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

GDI/图象编程

开发平台:

Visual C++

  1.   1 /****************************************************************/
  2.   2 /*         Demo5_3   ---  Moving Region                         */
  3.   3 /****************************************************************/
  4.   4 
  5.   5 #include <windows.h>
  6.   6 #include "Demo5_3.h"
  7.   7 
  8.   8 int  PASCAL  WinMain(HANDLE, HANDLE, LPSTR, int);
  9.   9 long FAR PASCAL MainWndProc(HWND, unsigned, WORD, LONG);
  10.  10 
  11.  11 void MakeScreenBitmap(HDC);
  12.  12 void DrawRegion(HDC, int, int, int, int, int);
  13.  13 void GetViewSize(POINT *);
  14.  14 void Run(HWND);
  15.  15 
  16.  16 
  17.  17 HDC     hMemDC;
  18.  18 HBITMAP hBitmap;
  19.  19 HRGN    hPreRgn;
  20.  20 
  21.  21 int     MemX, MemY;
  22.  22 int     RegionTypeID = IDM_CIRCLE;
  23.  23 int     ViewSizeID = IDM_75;
  24.  24 
  25.  25 /****************************************************************/
  26.  26 /*                      WinMain()                               */
  27.  27 /****************************************************************/
  28.  28 
  29.  29 int PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance,
  30.  30                    LPSTR lpszCmdLine, int nCmdShow)
  31.  31 {
  32.  32    WNDCLASS wclass;
  33.  33    MSG      msg;
  34.  34    HWND     hWnd;
  35.  35    char     szName[] = "Demo5_3";
  36.  36 
  37.  37    if (!hPrevInstance)
  38.  38     {
  39.  39         wclass.style         = CS_HREDRAW | CS_VREDRAW;
  40.  40         wclass.lpfnWndProc   = MainWndProc;
  41.  41         wclass.cbClsExtra    = 0;
  42.  42         wclass.cbWndExtra    = 0;
  43.  43         wclass.hInstance     = hInstance;
  44.  44         wclass.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
  45.  45         wclass.hCursor       = LoadCursor(NULL, IDC_ARROW);
  46.  46         wclass.hbrBackground = GetStockObject(WHITE_BRUSH);
  47.  47         wclass.lpszMenuName  = szName;
  48.  48         wclass.lpszClassName = szName;
  49.  49 
  50.  50         if (!RegisterClass (&wclass))
  51.  51            return (FALSE);
  52.  52     }
  53.  53 
  54.  54     hWnd = CreateWindow(
  55.  55                 szName,
  56.  56                 "Moving Region" ,
  57.  57                 WS_OVERLAPPEDWINDOW,
  58.  58                 CW_USEDEFAULT,
  59.  59                 CW_USEDEFAULT,
  60.  60                 CW_USEDEFAULT,
  61.  61                 CW_USEDEFAULT,
  62.  62                 NULL,
  63.  63                 NULL,
  64.  64                 hInstance,
  65.  65                 NULL );
  66.  66 
  67.  67     if (!hWnd)
  68.  68         return (FALSE);
  69.  69 
  70.  70     ShowWindow(hWnd, nCmdShow);
  71.  71     UpdateWindow(hWnd);
  72.  72 
  73.  73     while (GetMessage(&msg, NULL, NULL,NULL))
  74.  74        {
  75.  75            TranslateMessage(&msg);
  76.  76            DispatchMessage(&msg);
  77.  77        }
  78.  78     return (msg.wParam);
  79.  79 }
  80.  80 
  81.  81 
  82.  82 
  83.  83 /****************************************************************/
  84.  84 /*                      MainWndProc()                           */
  85.  85 /****************************************************************/
  86.  86 
  87.  87 long FAR PASCAL MainWndProc(HWND hWnd, unsigned message,
  88.  88                             WORD wParam, LONG lParam)
  89.  89 {
  90.  90    HMENU           hMenu;
  91.  91 
  92.  92    switch (message)
  93.  93     {
  94.  94       case WM_CREATE :
  95.  95                 hMenu = GetMenu(hWnd);
  96.  96                 CheckMenuItem(hMenu, RegionTypeID,
  97.  97                               MF_CHECKED);
  98.  98                 CheckMenuItem(hMenu, ViewSizeID,
  99.  99                               MF_CHECKED);
  100. 100                 return (0);
  101. 101 
  102. 102       case WM_COMMAND :
  103. 103                 switch (wParam)
  104. 104                   {
  105. 105                     case IDM_CIRCLE :
  106. 106                     case IDM_SQUARE :
  107. 107 
  108. 108                          hMenu = GetMenu(hWnd);
  109. 109                          if (RegionTypeID == wParam)
  110. 110                             break;
  111. 111 
  112. 112                          CheckMenuItem(hMenu, RegionTypeID,
  113. 113                                         MF_UNCHECKED);
  114. 114                          RegionTypeID = wParam;
  115. 115                          CheckMenuItem(hMenu, RegionTypeID,
  116. 116                                         MF_CHECKED);
  117. 117                          break;
  118. 118 
  119. 119                     case IDM_50 :
  120. 120                     case IDM_75 :
  121. 121                     case IDM_100 :
  122. 122                     case IDM_150 :
  123. 123 
  124. 124                          hMenu = GetMenu(hWnd);
  125. 125                          if (ViewSizeID == wParam)
  126. 126                             break;
  127. 127 
  128. 128                          CheckMenuItem(hMenu, ViewSizeID,
  129. 129                                         MF_UNCHECKED);
  130. 130                          ViewSizeID = wParam;
  131. 131                          CheckMenuItem(hMenu, ViewSizeID,
  132. 132                                         MF_CHECKED);
  133. 133                          break;
  134. 134 
  135. 135                     case IDM_RUN :
  136. 136                          Run(hWnd);
  137. 137                          break;
  138. 138 
  139. 139                     case IDM_EXIT :
  140. 140                          DestroyWindow(hWnd);
  141. 141                          break;
  142. 142                   }
  143. 143                 return (0);
  144. 144 
  145. 145       case WM_DESTROY :
  146. 146                 PostQuitMessage(0);
  147. 147                 return (0);
  148. 148     }
  149. 149 
  150. 150   return(DefWindowProc(hWnd, message, wParam, lParam));
  151. 151 }
  152. 152 
  153. 153 
  154. 154 void MakeScreenBitmap(HDC hDC)
  155. 155 {
  156. 156    hMemDC = CreateCompatibleDC(hDC);
  157. 157 
  158. 158    MemX = GetSystemMetrics(SM_CXSCREEN);
  159. 159    MemY = GetSystemMetrics(SM_CYSCREEN);
  160. 160 
  161. 161    hBitmap = CreateCompatibleBitmap(hDC, MemX, MemY);
  162. 162    SelectObject(hMemDC, hBitmap);
  163. 163 
  164. 164    BitBlt(hMemDC, 0, 0, MemX, MemY, hDC, 0, 0, SRCCOPY);
  165. 165    PatBlt(hDC, 0, 0, MemX, MemY, BLACKNESS);
  166. 166 }
  167. 167 
  168. 168 
  169. 169 void DrawRegion(HDC hDC, int MX, int MY,
  170. 170                 int Width, int Height, int bFirst)
  171. 171 {
  172. 172    HRGN    hRgn, hDstRgn;
  173. 173    static  int PreMX, PreMY;
  174. 174 
  175. 175    switch (RegionTypeID)
  176. 176     {
  177. 177       case IDM_CIRCLE :
  178. 178              hRgn = CreateEllipticRgn(
  179. 179                             MX-Width/2, MY-Height/2,
  180. 180                             MX+Width/2, MY+Height/2);
  181. 181              break;
  182. 182       case IDM_SQUARE :
  183. 183              hRgn = CreateRectRgn(
  184. 184                             MX-Width/2, MY-Height/2,
  185. 185                             MX+Width/2, MY+Height/2);
  186. 186              break;
  187. 187     }
  188. 188 
  189. 189    SelectObject(hDC, hRgn);
  190. 190    BitBlt(hDC, MX-Width/2, MY-Height/2,
  191. 191           Width, Height,
  192. 192           hMemDC, MX-Width/2, MY-Height/2,
  193. 193           SRCCOPY);
  194. 194 
  195. 195    if (! bFirst)
  196. 196      {
  197. 197        hDstRgn = CreateRectRgn(0, 0, 1, 1);
  198. 198        CombineRgn(hDstRgn, hPreRgn, hRgn, RGN_DIFF);
  199. 199 
  200. 200        SelectObject(hDC, hDstRgn);
  201. 201        PatBlt(hDC, PreMX-Width/2, PreMY-Height/2,
  202. 202                    Width, Height, BLACKNESS);
  203. 203        SelectObject(hDC, hRgn);
  204. 204 
  205. 205        DeleteObject(hDstRgn);
  206. 206        DeleteObject(hPreRgn);
  207. 207      }
  208. 208 
  209. 209    hPreRgn = hRgn;
  210. 210 
  211. 211    PreMX = MX;
  212. 212    PreMY = MY;
  213. 213 
  214. 214    bFirst = FALSE;
  215. 215 }
  216. 216 
  217. 217 
  218. 218 void GetViewSize(POINT *lpSize)
  219. 219 {
  220. 220    switch (ViewSizeID)
  221. 221     {
  222. 222       case IDM_50 :
  223. 223                 lpSize->x = 50;
  224. 224                 break;
  225. 225 
  226. 226       case IDM_75 :
  227. 227                 lpSize->x = 75;
  228. 228                 break;
  229. 229 
  230. 230       case IDM_100 :
  231. 231                 lpSize->x = 100;
  232. 232                 break;
  233. 233 
  234. 234       case IDM_150 :
  235. 235                 lpSize->x = 150;
  236. 236                 break;
  237. 237     }
  238. 238 
  239. 239    lpSize->y = -lpSize->x;
  240. 240 }
  241. 241 
  242. 242 
  243. 243 void Run(HWND hWnd)
  244. 244 {
  245. 245    int     KeyState;
  246. 246    HDC     hDC;
  247. 247    HRGN    hScrRgn;
  248. 248    POINT   Pt, ptSize;
  249. 249 
  250. 250    SetCapture(hWnd);
  251. 251    ShowCursor(FALSE);
  252. 252 
  253. 253    hDC = CreateDC("DISPLAY", NULL, NULL, NULL);
  254. 254    MakeScreenBitmap(hDC);
  255. 255 
  256. 256    GetViewSize(&ptSize);
  257. 257    SetMapMode(hDC, MM_LOENGLISH);
  258. 258    LPtoDP(hDC, &ptSize, 1);
  259. 259    SetMapMode(hDC, MM_TEXT);
  260. 260 
  261. 261    GetCursorPos(&Pt);
  262. 262    DrawRegion(hDC, Pt.x, Pt.y, ptSize.x, ptSize.y, 1);
  263. 263 
  264. 264    for (;;)
  265. 265     {
  266. 266       KeyState = GetAsyncKeyState(VK_SPACE);
  267. 267       if (KeyState & 0x8000)
  268. 268         break;
  269. 269 
  270. 270       GetCursorPos(&Pt);
  271. 271       DrawRegion(hDC, Pt.x, Pt.y, ptSize.x, ptSize.y, 0);
  272. 272     }
  273. 273 
  274. 274    hScrRgn = CreateRectRgn(0, 0, MemX, MemY);
  275. 275    SelectObject(hDC, hScrRgn);
  276. 276    BitBlt(hDC, 0, 0, MemX, MemY, hMemDC, 0, 0, SRCCOPY);
  277. 277 
  278. 278    DeleteDC(hMemDC);
  279. 279    DeleteObject(hBitmap);
  280. 280    DeleteObject(hPreRgn);
  281. 281    DeleteObject(hScrRgn);
  282. 282 
  283. 283    DeleteDC(hDC);
  284. 284 
  285. 285    ReleaseCapture();
  286. 286    ShowCursor(TRUE);
  287. 287 }