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

GDI/图象编程

开发平台:

Visual C++

  1.   1 /****************************************************************/
  2.   2 /*         Demo4_2   ---  Pencil & Line                         */
  3.   3 /****************************************************************/
  4.   4 
  5.   5 #include <windows.h>
  6.   6 #include "demo4_2.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 
  13.  13 void DrawGraph(HDC, BOOL);
  14.  14 void DrawPencil(HDC);
  15.  15 void DrawLine(HDC, BOOL);
  16.  16 
  17.  17 
  18.  18 int   ToolID  = IDM_PENCIL;
  19.  19 int   ColorID = IDM_RED;
  20.  20 int   StyleID = IDM_SOLID;
  21.  21 int   WidthID = IDM_W1;
  22.  22 POINT OrgPoint;
  23.  23 POINT PrePoint;
  24.  24 POINT CurPoint;
  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[] = "Demo4_2";
  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                 "Pencil & Line V.2" ,
  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    int           i;
  95.  95 
  96.  96 
  97.  97    switch (message)
  98.  98     {
  99.  99       case WM_CREATE :
  100. 100                 hMenu = GetMenu(hWnd);
  101. 101                 CheckMenuItem(hMenu, IDM_PENCIL, MF_CHECKED);
  102. 102                 CheckMenuItem(hMenu, IDM_RED, MF_CHECKED);
  103. 103                 CheckMenuItem(hMenu, IDM_SOLID, MF_CHECKED);
  104. 104                 CheckMenuItem(hMenu, IDM_W1, MF_CHECKED);
  105. 105                 return (0);
  106. 106 
  107. 107       case WM_COMMAND :
  108. 108                 hMenu = GetMenu(hWnd);
  109. 109                 switch (wParam)
  110. 110                   {
  111. 111                     case IDM_PENCIL :
  112. 112                     case IDM_LINE :
  113. 113 
  114. 114                          if (ToolID == wParam)
  115. 115                             return (0);
  116. 116 
  117. 117                          CheckMenuItem(hMenu, ToolID,
  118. 118                                         MF_UNCHECKED);
  119. 119                          ToolID = wParam;
  120. 120                          CheckMenuItem(hMenu, ToolID,
  121. 121                                         MF_CHECKED);
  122. 122                          break;
  123. 123 
  124. 124                     case IDM_RED :
  125. 125                     case IDM_GREEN :
  126. 126                     case IDM_BLUE :
  127. 127                     case IDM_YELLOW :
  128. 128                     case IDM_CYAN :
  129. 129                     case IDM_MAGENTA :
  130. 130                     case IDM_WHITE :
  131. 131                     case IDM_GRAY :
  132. 132                     case IDM_BLACK :
  133. 133 
  134. 134                          if (ColorID == wParam)
  135. 135                             return (0);
  136. 136 
  137. 137                          CheckMenuItem(hMenu, ColorID,
  138. 138                                         MF_UNCHECKED);
  139. 139                          ColorID = wParam;
  140. 140                          CheckMenuItem(hMenu, ColorID,
  141. 141                                         MF_CHECKED);
  142. 142                          break;
  143. 143 
  144. 144                     case IDM_SOLID :
  145. 145                     case IDM_DASH :
  146. 146                     case IDM_DOT :
  147. 147                     case IDM_DASHDOT :
  148. 148                     case IDM_DASHDOTDOT :
  149. 149 
  150. 150                          if (StyleID == wParam)
  151. 151                             return (0);
  152. 152 
  153. 153                          CheckMenuItem(hMenu, StyleID,
  154. 154                                         MF_UNCHECKED);
  155. 155                          StyleID = wParam;
  156. 156                          CheckMenuItem(hMenu, StyleID,
  157. 157                                         MF_CHECKED);
  158. 158                          break;
  159. 159 
  160. 160                     case IDM_W1 :
  161. 161                     case IDM_W3 :
  162. 162                     case IDM_W5 :
  163. 163                     case IDM_W7 :
  164. 164                     case IDM_W9 :
  165. 165 
  166. 166                          if (WidthID == wParam)
  167. 167                             return (0);
  168. 168 
  169. 169                          if (wParam != IDM_W1)
  170. 170                            {
  171. 171                             SendMessage(hWnd, WM_COMMAND,
  172. 172                                         IDM_SOLID, 0);
  173. 173                             for (i=1; i<5; i++)
  174. 174                               EnableMenuItem(hMenu,
  175. 175                                  IDM_SOLID+i, MF_GRAYED);
  176. 176                            }
  177. 177                          else
  178. 178                            {
  179. 179                             for (i=1; i<5; i++)
  180. 180                               EnableMenuItem(hMenu,
  181. 181                                  IDM_SOLID+i, MF_ENABLED);
  182. 182                            }
  183. 183 
  184. 184                          CheckMenuItem(hMenu, WidthID,
  185. 185                                         MF_UNCHECKED);
  186. 186                          WidthID = wParam;
  187. 187                          CheckMenuItem(hMenu, WidthID,
  188. 188                                         MF_CHECKED);
  189. 189                          break;
  190. 190 
  191. 191                     case IDM_CLEAR :
  192. 192                          InvalidateRect(hWnd, NULL, TRUE);
  193. 193                          break;
  194. 194 
  195. 195                     case IDM_QUIT :
  196. 196                          DestroyWindow(hWnd);
  197. 197                          break;
  198. 198                   }
  199. 199                 return (0);
  200. 200 
  201. 201       case WM_LBUTTONDOWN :
  202. 202                 SetCapture(hWnd);
  203. 203                 bLBDown = TRUE;
  204. 204 
  205. 205                 OrgPoint = MAKEPOINT(lParam);
  206. 206                 CurPoint = PrePoint = OrgPoint;
  207. 207 
  208. 208                 return (0);
  209. 209 
  210. 210       case WM_LBUTTONUP :
  211. 211                 bLBDown = FALSE;
  212. 212                 ReleaseCapture();
  213. 213 
  214. 214                 hDC = GetDC(hWnd);
  215. 215                 DrawGraph(hDC, TRUE);
  216. 216                 ReleaseDC(hWnd, hDC);
  217. 217 
  218. 218                 return (0);
  219. 219 
  220. 220       case WM_MOUSEMOVE :
  221. 221                 if (bLBDown)
  222. 222                   {
  223. 223                     PrePoint = CurPoint;
  224. 224                     CurPoint = MAKEPOINT(lParam);
  225. 225 
  226. 226                     hDC = GetDC(hWnd);
  227. 227                     DrawGraph(hDC, FALSE);
  228. 228                     ReleaseDC(hWnd, hDC);
  229. 229                   }
  230. 230                 return (0);
  231. 231 
  232. 232       case WM_DESTROY :
  233. 233                 PostQuitMessage(0);
  234. 234                 return (0);
  235. 235 
  236. 236       default :
  237. 237          return(DefWindowProc(hWnd, message, wParam, lParam));
  238. 238     }
  239. 239 }
  240. 240 
  241. 241 
  242. 242 
  243. 243 COLORREF MakeRgbColor()
  244. 244 {
  245. 245    COLORREF crColor;
  246. 246 
  247. 247    switch (ColorID)
  248. 248     {
  249. 249       case IDM_RED :
  250. 250                 crColor = RGB(255, 0, 0);
  251. 251                 break;
  252. 252 
  253. 253       case IDM_GREEN :
  254. 254                 crColor = RGB(0, 255, 0);
  255. 255                 break;
  256. 256 
  257. 257       case IDM_BLUE :
  258. 258                 crColor = RGB(0, 0, 255);
  259. 259                 break;
  260. 260 
  261. 261       case IDM_YELLOW :
  262. 262                 crColor = RGB(255, 255, 0);
  263. 263                 break;
  264. 264 
  265. 265       case IDM_CYAN :
  266. 266                 crColor = RGB(0, 255, 255);
  267. 267                 break;
  268. 268 
  269. 269       case IDM_MAGENTA :
  270. 270                 crColor = RGB(255, 0, 255);
  271. 271                 break;
  272. 272 
  273. 273       case IDM_WHITE :
  274. 274                 crColor = RGB(255, 255, 255);
  275. 275                 break;
  276. 276 
  277. 277       case IDM_GRAY :
  278. 278                 crColor = RGB(150, 150, 150);
  279. 279                 break;
  280. 280 
  281. 281       case IDM_BLACK :
  282. 282                 crColor = RGB(0, 0, 0);
  283. 283                 break;
  284. 284     }
  285. 285 
  286. 286    return (crColor);
  287. 287 }
  288. 288 
  289. 289 
  290. 290 
  291. 291 HPEN CreateColorPen()
  292. 292 {
  293. 293    HPEN     hPen;
  294. 294    int      nStyle;
  295. 295    int      nWidth;
  296. 296    COLORREF crColor;
  297. 297 
  298. 298    nStyle  = StyleID - IDM_SOLID;
  299. 299    nWidth  = 2*(WidthID - IDM_W1) + 1;
  300. 300    crColor = MakeRgbColor();
  301. 301 
  302. 302    hPen = CreatePen(nStyle, nWidth, crColor);
  303. 303    return (hPen);
  304. 304 }
  305. 305 
  306. 306 
  307. 307 
  308. 308 void DrawGraph(HDC hDC, BOOL bSure)
  309. 309 {
  310. 310    HPEN  hPen, hPrePen;
  311. 311 
  312. 312    if (ToolID==IDM_PENCIL || bSure)
  313. 313      {
  314. 314        hPen = CreateColorPen();
  315. 315        hPrePen = SelectObject(hDC, hPen);
  316. 316      }
  317. 317 
  318. 318    switch (ToolID)
  319. 319      {
  320. 320        case IDM_PENCIL :
  321. 321               DrawPencil(hDC);
  322. 322               break;
  323. 323 
  324. 324        case IDM_LINE :
  325. 325               DrawLine(hDC, bSure);
  326. 326               break;
  327. 327      }
  328. 328 
  329. 329    if (ToolID==IDM_PENCIL || bSure)
  330. 330      {
  331. 331        SelectObject(hDC, hPrePen);
  332. 332        DeleteObject(hPen);
  333. 333      }
  334. 334 }
  335. 335 
  336. 336 
  337. 337 
  338. 338 void DrawPencil(HDC hDC)
  339. 339 {
  340. 340    MoveTo(hDC, PrePoint.x, PrePoint.y);
  341. 341    LineTo(hDC, CurPoint.x, CurPoint.y);
  342. 342 }
  343. 343 
  344. 344 
  345. 345 
  346. 346 void DrawLine(HDC hDC, BOOL bSure)
  347. 347 {
  348. 348    int  nDrawMode;
  349. 349 
  350. 350    if (! bSure)
  351. 351      {
  352. 352        nDrawMode = SetROP2(hDC, R2_NOT);
  353. 353 
  354. 354        MoveTo(hDC, OrgPoint.x, OrgPoint.y);
  355. 355        LineTo(hDC, PrePoint.x, PrePoint.y);
  356. 356 
  357. 357        MoveTo(hDC, OrgPoint.x, OrgPoint.y);
  358. 358        LineTo(hDC, CurPoint.x, CurPoint.y);
  359. 359 
  360. 360        SetROP2(hDC, nDrawMode);
  361. 361      }
  362. 362    else
  363. 363      {
  364. 364        MoveTo(hDC, OrgPoint.x, OrgPoint.y);
  365. 365        LineTo(hDC, CurPoint.x, CurPoint.y);
  366. 366      }
  367. 367 }