DEMO8_1.C
上传用户:cncajx
上传日期:2007-01-03
资源大小:190k
文件大小:8k
源码类别:

GDI/图象编程

开发平台:

Visual C++

  1.   1 /****************************************************************/
  2.   2 /*         Demo8_1   ---  Print Test                            */
  3.   3 /****************************************************************/
  4.   4 
  5.   5 #include <windows.h>
  6.   6 #include "demo8_1.h"
  7.   7 
  8.   8 
  9.   9 int  PASCAL  WinMain(HANDLE, HANDLE, LPSTR, int);
  10.  10 long FAR PASCAL MainWndProc(HWND, unsigned, WORD, LONG);
  11.  11 
  12.  12 void DrawGraph(HDC, BOOL);
  13.  13 void DrawPencil(HDC);
  14.  14 void DrawLine(HDC, BOOL);
  15.  15 
  16.  16 void PrintGraph(HWND);
  17.  17 
  18.  18 
  19.  19 int   ToolID = IDM_PENCIL;
  20.  20 POINT OrgPoint;
  21.  21 POINT PrePoint;
  22.  22 POINT CurPoint;
  23.  23 
  24.  24 int CX, CY;
  25.  25 
  26.  26 /****************************************************************/
  27.  27 /*                      WinMain()                               */
  28.  28 /****************************************************************/
  29.  29 
  30.  30 int PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance,
  31.  31                    LPSTR lpszCmdLine, int nCmdShow)
  32.  32 {
  33.  33    WNDCLASS wclass;
  34.  34    MSG      msg;
  35.  35    HWND     hWnd;
  36.  36    char     szName[] = "Demo8_1";
  37.  37 
  38.  38    if (!hPrevInstance)
  39.  39     {
  40.  40         wclass.style         = CS_HREDRAW | CS_VREDRAW;
  41.  41         wclass.lpfnWndProc   = MainWndProc;
  42.  42         wclass.cbClsExtra    = 0;
  43.  43         wclass.cbWndExtra    = 0;
  44.  44         wclass.hInstance     = hInstance;
  45.  45         wclass.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
  46.  46         wclass.hCursor       = LoadCursor(NULL, IDC_ARROW);
  47.  47         wclass.hbrBackground = GetStockObject(WHITE_BRUSH);
  48.  48         wclass.lpszMenuName  = szName;
  49.  49         wclass.lpszClassName = szName;
  50.  50 
  51.  51         if (!RegisterClass (&wclass))
  52.  52            return (FALSE);
  53.  53     }
  54.  54 
  55.  55     hWnd = CreateWindow(
  56.  56                 szName,
  57.  57                 "Print Test" ,
  58.  58                 WS_OVERLAPPEDWINDOW,
  59.  59                 CW_USEDEFAULT,
  60.  60                 CW_USEDEFAULT,
  61.  61                 CW_USEDEFAULT,
  62.  62                 CW_USEDEFAULT,
  63.  63                 NULL,
  64.  64                 NULL,
  65.  65                 hInstance,
  66.  66                 NULL );
  67.  67 
  68.  68     if (!hWnd)
  69.  69         return (FALSE);
  70.  70 
  71.  71     ShowWindow(hWnd, nCmdShow);
  72.  72     UpdateWindow(hWnd);
  73.  73 
  74.  74     while (GetMessage(&msg, NULL, NULL,NULL))
  75.  75        {
  76.  76            TranslateMessage(&msg);
  77.  77            DispatchMessage(&msg);
  78.  78        }
  79.  79     return (msg.wParam);
  80.  80 }
  81.  81 
  82.  82 
  83.  83 
  84.  84 /****************************************************************/
  85.  85 /*                      MainWndProc()                           */
  86.  86 /****************************************************************/
  87.  87 
  88.  88 long FAR PASCAL MainWndProc(HWND hWnd, unsigned message,
  89.  89                             WORD wParam, LONG lParam)
  90.  90 {
  91.  91    HDC           hDC;
  92.  92    HMENU         hMenu;
  93.  93    static BOOL   bLBDown;
  94.  94 
  95.  95    switch (message)
  96.  96     {
  97.  97       case WM_CREATE :
  98.  98                 hMenu = GetMenu(hWnd);
  99.  99                 CheckMenuItem(hMenu, IDM_PENCIL,
  100. 100                               MF_CHECKED);
  101. 101                 return (0);
  102. 102 
  103. 103       case WM_COMMAND :
  104. 104                 hMenu = GetMenu(hWnd);
  105. 105                 switch (wParam)
  106. 106                   {
  107. 107                     case IDM_PENCIL :
  108. 108                     case IDM_LINE :
  109. 109 
  110. 110                          if (ToolID == wParam)
  111. 111                             return (0);
  112. 112 
  113. 113                          CheckMenuItem(hMenu, ToolID,
  114. 114                                         MF_UNCHECKED);
  115. 115                          ToolID = wParam;
  116. 116                          CheckMenuItem(hMenu, ToolID,
  117. 117                                         MF_CHECKED);
  118. 118                          break;
  119. 119 
  120. 120                     case IDM_CLEAR :
  121. 121                          InvalidateRect(hWnd, NULL, TRUE);
  122. 122                          break;
  123. 123 
  124. 124                     case IDM_PRINT :
  125. 125                          PrintGraph(hWnd);
  126. 126                          break;
  127. 127 
  128. 128                     case IDM_QUIT :
  129. 129                          DestroyWindow(hWnd);
  130. 130                          break;
  131. 131                   }
  132. 132                 return (0);
  133. 133 
  134. 134       case WM_SIZE :
  135. 135                 CX = LOWORD(lParam);
  136. 136                 CY = HIWORD(lParam);
  137. 137                 return (0);
  138. 138 
  139. 139       case WM_LBUTTONDOWN :
  140. 140                 SetCapture(hWnd);
  141. 141                 bLBDown = TRUE;
  142. 142 
  143. 143                 OrgPoint = MAKEPOINT(lParam);
  144. 144                 CurPoint = PrePoint = OrgPoint;
  145. 145 
  146. 146                 return (0);
  147. 147 
  148. 148       case WM_LBUTTONUP :
  149. 149                 bLBDown = FALSE;
  150. 150                 ReleaseCapture();
  151. 151 
  152. 152                 hDC = GetDC(hWnd);
  153. 153                 DrawGraph(hDC, TRUE);
  154. 154                 ReleaseDC(hWnd, hDC);
  155. 155 
  156. 156                 return (0);
  157. 157 
  158. 158       case WM_MOUSEMOVE :
  159. 159                 if (bLBDown)
  160. 160                   {
  161. 161                     PrePoint = CurPoint;
  162. 162                     CurPoint = MAKEPOINT(lParam);
  163. 163 
  164. 164                     hDC = GetDC(hWnd);
  165. 165                     DrawGraph(hDC, FALSE);
  166. 166                     ReleaseDC(hWnd, hDC);
  167. 167                   }
  168. 168                 return (0);
  169. 169 
  170. 170       case WM_DESTROY :
  171. 171                 PostQuitMessage(0);
  172. 172                 return (0);
  173. 173 
  174. 174       default :
  175. 175          return(DefWindowProc(hWnd, message, wParam, lParam));
  176. 176     }
  177. 177 }
  178. 178 
  179. 179 
  180. 180 
  181. 181 void DrawGraph(HDC hDC, BOOL bSure)
  182. 182 {
  183. 183    switch (ToolID)
  184. 184     {
  185. 185       case IDM_PENCIL :
  186. 186               DrawPencil(hDC);
  187. 187               break;
  188. 188 
  189. 189       case IDM_LINE :
  190. 190               DrawLine(hDC, bSure);
  191. 191               break;
  192. 192     }
  193. 193 }
  194. 194 
  195. 195 
  196. 196 
  197. 197 void DrawPencil(HDC hDC)
  198. 198 {
  199. 199    MoveTo(hDC, PrePoint.x, PrePoint.y);
  200. 200    LineTo(hDC, CurPoint.x, CurPoint.y);
  201. 201 }
  202. 202 
  203. 203 
  204. 204 
  205. 205 void DrawLine(HDC hDC, BOOL bSure)
  206. 206 {
  207. 207    int  nDrawMode;
  208. 208 
  209. 209    if (! bSure)
  210. 210      {
  211. 211        nDrawMode = SetROP2(hDC, R2_NOT);
  212. 212 
  213. 213        MoveTo(hDC, OrgPoint.x, OrgPoint.y);
  214. 214        LineTo(hDC, PrePoint.x, PrePoint.y);
  215. 215 
  216. 216        MoveTo(hDC, OrgPoint.x, OrgPoint.y);
  217. 217        LineTo(hDC, CurPoint.x, CurPoint.y);
  218. 218 
  219. 219        SetROP2(hDC, nDrawMode);
  220. 220      }
  221. 221    else
  222. 222      {
  223. 223        MoveTo(hDC, OrgPoint.x, OrgPoint.y);
  224. 224        LineTo(hDC, CurPoint.x, CurPoint.y);
  225. 225      }
  226. 226 }
  227. 227 
  228. 228 
  229. 229 
  230. 230 HDC CreateDC_Printer()
  231. 231 {
  232. 232    HDC  hPrnDC;
  233. 233    char szProfile[70];
  234. 234    char *szDriver, *szDevice, *szOutput;
  235. 235 
  236. 236    GetProfileString("windows", "device", "", szProfile, 70);
  237. 237 
  238. 238    szDevice = (char *) strtok(szProfile, ",");
  239. 239    szDriver = (char *) strtok(NULL,     ",");
  240. 240    szOutput = (char *) strtok(NULL,     ",");
  241. 241 
  242. 242    if (szDevice && szDriver && szOutput)
  243. 243     {
  244. 244       hPrnDC = CreateDC(szDriver, szDevice, szOutput, NULL);
  245. 245       return (hPrnDC);
  246. 246     }
  247. 247 
  248. 248    return (NULL);
  249. 249 }
  250. 250 
  251. 251 
  252. 252 
  253. 253 void PrintGraph(HWND hWnd)
  254. 254 {
  255. 255    HDC      hDC, hMemDC;
  256. 256    HDC      hPrnDC;
  257. 257    HBITMAP  hBitmap;
  258. 258    BOOL     bPrinted = TRUE;
  259. 259    char     szName[] = "Demo8_1 -- Print test";
  260. 260 
  261. 261    hPrnDC = CreateDC_Printer();
  262. 262    if (hPrnDC == NULL)
  263. 263      {
  264. 264        MessageBox(hWnd, "Printer Error", NULL,
  265. 265                   MB_OK | MB_ICONHAND);
  266. 266        return ;
  267. 267      }
  268. 268 
  269. 269    hDC = GetDC(hWnd);
  270. 270    hMemDC = CreateCompatibleDC(hDC);
  271. 271    hBitmap = CreateCompatibleBitmap(hDC, CX, CY);
  272. 272 
  273. 273    SelectObject(hMemDC, hBitmap);
  274. 274    BitBlt(hMemDC, 0, 0, CX, CY, hDC, 0, 0, SRCCOPY);
  275. 275    ReleaseDC(hWnd, hDC);
  276. 276 
  277. 277    if (Escape(hPrnDC, STARTDOC,
  278. 278               strlen(szName), szName, NULL) > 0)
  279. 279      {
  280. 280        BitBlt(hPrnDC, 0, 0, CX, CY, hMemDC, 0, 0, SRCCOPY);
  281. 281 
  282. 282        if (Escape(hPrnDC, NEWFRAME, 0, NULL, NULL) > 0)
  283. 283          Escape(hPrnDC, ENDDOC, 0, NULL, NULL);
  284. 284        else
  285. 285          bPrinted = FALSE;
  286. 286      }
  287. 287    else
  288. 288      bPrinted = FALSE;
  289. 289 
  290. 290    if (! bPrinted)
  291. 291      MessageBox(hWnd, "Print Error", NULL,
  292. 292                 MB_OK | MB_ICONHAND);
  293. 293 
  294. 294    DeleteDC(hPrnDC);
  295. 295    DeleteDC(hMemDC);
  296. 296    DeleteObject(hBitmap);
  297. 297 }