![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to regions.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / q_a / samples / regions|
Return to regions.c CVS log | Up to [WindowsNT SDKs] / q_a / samples / regions |
1.1 ! root 1: /************************************************************************\ ! 2: * ! 3: * PROGRAM: Regions.c ! 4: * ! 5: * PURPOSE: To demonstrate the region APIs in Win32, namely: ! 6: * ! 7: * CombineRgn() ! 8: * CreateEllipticRgn() ! 9: * CreateEllipticRgnIndirect() ! 10: * CreatePolygonRgn() ! 11: * CreatePolyPolygonRgn() ! 12: * CreateRectRgn() ! 13: * FillRgn() ! 14: * #ifdef NOTIMPLEMENTED FrameRgn() #endif ! 15: * GetRgnBox() ! 16: * InvertRgn() ! 17: * OffsetRgn() ! 18: * PaintRgn() ! 19: * PtInRegion() ! 20: * RectInRegion() ! 21: * SetRectRgn() ! 22: * ! 23: * The EqualRgn() API is *not* called in this program. ! 24: * ! 25: * FUNCTIONS: ! 26: * WinMain() - initialization, create window, msg loop ! 27: * MainWndProc() - processes main window msgs ! 28: * AboutDlgProc() - processes About dialog box msgs ! 29: * RgnBoxDlgProc() - processes RgnBox dialog box msgs ! 30: * MyCreateRgn() - calls any one of Create*Rgn*() APIs ! 31: * MyCombineRgn() - calls CombineRgn() API ! 32: * TrackRect() - creates\draws\deletes a tracking rectangle ! 33: * (for use with RectInRegion menu item.) ! 34: * Reset() - enables\disables menu items, modifies ! 35: * global vars (rgnArray[], currRgn). ! 36: * ! 37: * COMMENTS: This program allows a user to create the different kinds ! 38: * of regions available in Win32, and to perform the various ! 39: * operations on them. All operations are immediately ! 40: * reflected on the screen. The order in which the regions ! 41: * are created determines the order in which they are drawn, ! 42: * as well as which operation affects which region(s); for ! 43: * example, the last region created will be drawn on top of ! 44: * the others, and the operations in "Options" menu will ! 45: * affect this region. When two regions are combined the ! 46: * second region will be destroyed. ! 47: * ! 48: \************************************************************************/ ! 49: ! 50: #include <windows.h> ! 51: #include "regions.h" ! 52: ! 53: ! 54: ! 55: /************************************************************************\ ! 56: * ! 57: * FUNCTION: WinMain (standard WinMain INPUTS/RETURNS) ! 58: * ! 59: * GLOBAL VARS: hInst - Handle of program instance ! 60: * ! 61: \************************************************************************/ ! 62: ! 63: int APIENTRY WinMain (HANDLE hInstance, HANDLE hPrevInstance, ! 64: LPSTR lpCmdLine, int nCmdShow) ! 65: { HWND hWnd; ! 66: MSG msg; ! 67: ! 68: if (!hPrevInstance) ! 69: { PWNDCLASS pWndClass; ! 70: ! 71: pWndClass = (PWNDCLASS) LocalAlloc (LPTR, sizeof(WNDCLASS)); ! 72: if(!pWndClass) ! 73: { MessageBox (NULL, "REGIONS: LocalAlloc() failed", NULL, MB_OK | ! 74: MB_ICONHAND); ! 75: return(FALSE); ! 76: } ! 77: ! 78: pWndClass->hCursor = LoadCursor (NULL, IDC_ARROW); ! 79: pWndClass->hIcon = LoadIcon(NULL, IDI_APPLICATION); ! 80: pWndClass->lpszMenuName = (LPSTR) "Menu"; ! 81: pWndClass->lpszClassName = (LPSTR) "Main"; ! 82: pWndClass->hbrBackground = GetStockObject (DKGRAY_BRUSH); ! 83: pWndClass->hInstance = hInstance; ! 84: pWndClass->style = NULL; ! 85: pWndClass->lpfnWndProc = (WNDPROC)MainWndProc; ! 86: ! 87: if (!RegisterClass (pWndClass)) ! 88: { MessageBox (NULL, "REGIONS: RegisterClass() failed", NULL, MB_OK | ! 89: MB_ICONHAND); ! 90: return(FALSE); ! 91: } ! 92: ! 93: LocalFree (LocalHandle ((LPSTR)pWndClass)); ! 94: } ! 95: hInst = hInstance; ! 96: hWnd = CreateWindow ("Main", "Regions API Sample", ! 97: WS_OVERLAPPED | WS_CAPTION | ! 98: WS_SYSMENU | WS_MINIMIZEBOX, ! 99: CW_USEDEFAULT, CW_USEDEFAULT, ! 100: 220, 280, NULL, NULL, hInstance, NULL); ! 101: if (!hWnd) ! 102: return (NULL); ! 103: ! 104: ShowWindow(hWnd, nCmdShow); ! 105: UpdateWindow(hWnd); ! 106: ! 107: while (GetMessage(&msg, NULL, NULL, NULL)) ! 108: { TranslateMessage(&msg); ! 109: DispatchMessage(&msg); ! 110: } ! 111: return (msg.wParam); ! 112: UNREFERENCED_PARAMETER(lpCmdLine); ! 113: } ! 114: ! 115: ! 116: ! 117: /************************************************************************\ ! 118: * ! 119: * FUNCTION: MainWndProc (standard window procedure INPUTS/RETURNS) ! 120: * ! 121: * GLOBAL VARS: hInst - Handle of program instance ! 122: * rgnArray - Array of RGNSTRUCTs describing regions user has ! 123: * created ! 124: * currRgn - Index (in rgnArray) of most recently created ! 125: * region. If -1 then no regions created. Otherwise, ! 126: * values range from 0 to MAXRGNSTRUCTS - 1. ! 127: * hMenu - Handle of main window's menu. ! 128: * ! 129: * LOCAL VARS: rect - Scratch rectangle used in various places. ! 130: * ptr - Pointer to a TRACKRECTSTRUCT (used for ! 131: * tracking rectangle). ! 132: * i - For-loop variable. ! 133: * hdc - Scratch HDC used in various places. ! 134: * lButtonFlag - Tells what to do when left mouse button goes ! 135: * down (eg. nothing, check point in region, ! 136: * check rect in region). ! 137: * bOffsetRgnFlag - A BOOL which tells whether to offset up ! 138: * and left or down and right. ! 139: * ! 140: \************************************************************************/ ! 141: ! 142: LONG APIENTRY MainWndProc (HWND hWnd, UINT message, UINT wParam, ! 143: LONG lParam) ! 144: { static RECT rect; ! 145: static PTRACKRECTSTRUCT ptr; ! 146: static BOOL bOffsetRgnFlag = FALSE; ! 147: static WORD lButtonFlag = 0; ! 148: int i; ! 149: HDC hdc; ! 150: ! 151: switch (message) ! 152: { case WM_CREATE: ! 153: hMenu = GetMenu (hWnd); ! 154: currRgn = -1; ! 155: Reset (RESET_ALL); ! 156: break; ! 157: ! 158: case WM_COMMAND: ! 159: switch (LOWORD(wParam)) ! 160: { case IDM_ERASE: ! 161: Reset (RESET_ALL); ! 162: InvalidateRect (hWnd, NULL, TRUE); ! 163: break; ! 164: ! 165: case IDM_OFFSETRGN: ! 166: ! 167: /**************************************************************\ ! 168: * Offset rgnArray[currRgn].hrgn either down & right, or up & ! 169: * left (depending on bOffsetRgnFlag). Toggle bOffsetRgnFlag. ! 170: \**************************************************************/ ! 171: ! 172: if (bOffsetRgnFlag) ! 173: OffsetRgn (rgnArray[currRgn].hrgn, 15, 10); ! 174: else ! 175: OffsetRgn (rgnArray[currRgn].hrgn, -15, -10); ! 176: bOffsetRgnFlag = ~bOffsetRgnFlag; ! 177: InvalidateRect (hWnd, NULL, TRUE); ! 178: ! 179: break; ! 180: ! 181: case IDM_INVERTRGN: ! 182: hdc = GetDC (hWnd); ! 183: InvertRgn (hdc, rgnArray[currRgn].hrgn); ! 184: ReleaseDC (hWnd, hdc); ! 185: break; ! 186: ! 187: #ifdef NOTIMPLEMENTED ! 188: ! 189: case IDM_FRAMERGN: ! 190: hdc = GetDC (hWnd); ! 191: ! 192: FrameRgn (hdc, rgnArray[currRgn].hrgn, ! 193: GetStockObject (WHITE_BRUSH), 2, 2); ! 194: ReleaseDC (hWnd, hdc); ! 195: break; ! 196: #endif ! 197: ! 198: case IDM_PTINRGN: ! 199: ! 200: /**************************************************************\ ! 201: * Uncheck "RectInRgn" menu item, toggle "PtInRgn" menu item, ! 202: * toggle lButtonFlag ! 203: \**************************************************************/ ! 204: ! 205: if (lButtonFlag == IDM_RECTINRGN) ! 206: CheckMenuItem (GetSubMenu (hMenu, 0), IDM_RECTINRGN, ! 207: MF_UNCHECKED | MF_BYCOMMAND); ! 208: if (lButtonFlag == IDM_PTINRGN) { ! 209: CheckMenuItem (GetSubMenu (hMenu, 0), IDM_PTINRGN, ! 210: MF_UNCHECKED | MF_BYCOMMAND); ! 211: lButtonFlag = 0; ! 212: } ! 213: else { ! 214: CheckMenuItem (GetSubMenu (hMenu, 0), IDM_PTINRGN, ! 215: MF_CHECKED | MF_BYCOMMAND); ! 216: lButtonFlag = IDM_PTINRGN; ! 217: } ! 218: break; ! 219: ! 220: case IDM_RECTINRGN: ! 221: ! 222: /**************************************************************\ ! 223: * Uncheck "PtInRgn" menu item, toggle "RectInRgn" menu item, ! 224: * toggle lButtonFlag ! 225: \**************************************************************/ ! 226: ! 227: if (lButtonFlag == IDM_PTINRGN) ! 228: CheckMenuItem (GetSubMenu (hMenu, 0), IDM_PTINRGN, ! 229: MF_UNCHECKED | MF_BYCOMMAND); ! 230: if (lButtonFlag == IDM_RECTINRGN) { ! 231: CheckMenuItem (GetSubMenu (hMenu, 0), IDM_RECTINRGN, ! 232: MF_UNCHECKED | MF_BYCOMMAND); ! 233: lButtonFlag = 0; ! 234: } ! 235: else { ! 236: CheckMenuItem (GetSubMenu (hMenu, 0), IDM_RECTINRGN, ! 237: MF_CHECKED | MF_BYCOMMAND); ! 238: lButtonFlag = IDM_RECTINRGN; ! 239: } ! 240: break; ! 241: ! 242: case IDM_SETRECTRGN: ! 243: ! 244: /**************************************************************\ ! 245: * Reset rgnArray[currRgn].hrgn to be the rectangle which ! 246: * currently bounds it. ! 247: \**************************************************************/ ! 248: ! 249: GetRgnBox (rgnArray[currRgn].hrgn, &rect); ! 250: SetRectRgn (rgnArray[currRgn].hrgn, (int) rect.left, ! 251: (int) rect.top, (int) rect.right, ! 252: (int) rect.bottom); ! 253: InvalidateRect (hWnd, NULL, TRUE); ! 254: break; ! 255: ! 256: case IDM_GETRGNBOX: /* put up dlg which call GetRgnBox */ ! 257: DialogBox (hInst, "RgnBox", hWnd, (DLGPROC)RgnBoxDlgProc); ! 258: break; ! 259: ! 260: case IDM_ELLIPSE: /* create an elliptic rgn */ ! 261: MyCreateRgn (ELLIPTIC_RGN); ! 262: InvalidateRect (hWnd, NULL, TRUE); ! 263: break; ! 264: ! 265: case IDM_POLYPOLYGON: /* create a polyPolygon rgn */ ! 266: MyCreateRgn (POLYPOLYGON_RGN); ! 267: InvalidateRect (hWnd, NULL, TRUE); ! 268: break; ! 269: ! 270: case IDM_RECT: /* create a rectangular rgn */ ! 271: MyCreateRgn (RECT_RGN); ! 272: InvalidateRect (hWnd, NULL, TRUE); ! 273: break; ! 274: ! 275: case IDM_AND: /* combine previous 2 rgns */ ! 276: MyCombineRgn (RGN_AND); ! 277: InvalidateRect (hWnd, NULL, TRUE); ! 278: break; ! 279: ! 280: case IDM_COPY: /* combine previous 2 rgns */ ! 281: MyCombineRgn (RGN_COPY); ! 282: InvalidateRect (hWnd, NULL, TRUE); ! 283: break; ! 284: ! 285: case IDM_DIFF: /* combine previous 2 rgns */ ! 286: MyCombineRgn (RGN_DIFF); ! 287: InvalidateRect (hWnd, NULL, TRUE); ! 288: break; ! 289: ! 290: case IDM_OR: /* combine previous 2 rgns */ ! 291: MyCombineRgn (RGN_OR); ! 292: InvalidateRect (hWnd, NULL, TRUE); ! 293: break; ! 294: ! 295: case IDM_XOR: /* combine previous 2 rgns */ ! 296: MyCombineRgn (RGN_XOR); ! 297: InvalidateRect (hWnd, NULL, TRUE); ! 298: break; ! 299: ! 300: case IDM_ABOUT: /* put up About dialog box */ ! 301: DialogBox (hInst, "AboutBox", hWnd, (DLGPROC)AboutDlgProc); ! 302: break; ! 303: } ! 304: return (NULL); ! 305: ! 306: case WM_LBUTTONDOWN: ! 307: { ! 308: /******************************************************************\ ! 309: * if the "PtInRgn" menu item is checked, then see if the point at ! 310: * which this event happened is within currRgn, MessageBeep if so. ! 311: * ! 312: * else if the "RectInRgn" menu items are checked, then start ! 313: * tracking rectangle mode ! 314: \******************************************************************/ ! 315: ! 316: if (lButtonFlag == IDM_PTINRGN) ! 317: { if (currRgn > -1) ! 318: if (PtInRegion (rgnArray[currRgn].hrgn, (int) LOWORD(lParam), ! 319: (int) HIWORD(lParam))) ! 320: MessageBeep (0); ! 321: } ! 322: else if (lButtonFlag == IDM_RECTINRGN) ! 323: if ((ptr = TrackRect (NULL, TRECT_NEW, hWnd, lParam)) == NULL) ! 324: ! 325: /****************************************************************\ ! 326: * If TrackRect failed to LocalAlloc, then disable the ! 327: * IDM_RECTINRGN opion. ! 328: \****************************************************************/ ! 329: ! 330: EnableMenuItem (GetSubMenu (hMenu, 0), IDM_RECTINRGN, ! 331: MF_DISABLED | MF_GRAYED | MF_BYCOMMAND); ! 332: ! 333: return (NULL); ! 334: } ! 335: case WM_MOUSEMOVE: ! 336: ! 337: /******************************************************************\ ! 338: * if in tracking rectangle mode call TrackRect ! 339: \******************************************************************/ ! 340: ! 341: if (lButtonFlag == IDM_RECTINRGN && GetCapture () == hWnd) ! 342: TrackRect (ptr, TRECT_PAINT, hWnd, lParam); ! 343: return (NULL); ! 344: ! 345: case WM_LBUTTONUP: ! 346: ! 347: /******************************************************************\ ! 348: * if in tracking rectangle mode call TrackRect, check out the final ! 349: * rectangle, and see if it intersects currRgn ! 350: \******************************************************************/ ! 351: ! 352: if (lButtonFlag == IDM_RECTINRGN && GetCapture () == hWnd) ! 353: { ! 354: /****************************************************************\ ! 355: * call TrackRect with TRECT_PAINT so it updates the rectangle ! 356: * for the last time, then again with TRECT_DELETE so it frees ! 357: * up the TRACKRECTSTRUCT it allocated ! 358: \****************************************************************/ ! 359: ! 360: TrackRect (ptr, TRECT_PAINT, hWnd, lParam); ! 361: rect = ptr->trackRect; ! 362: TrackRect (ptr, TRECT_DELETE, hWnd, lParam); ! 363: if (RectInRegion (rgnArray[currRgn].hrgn, &rect)) ! 364: MessageBeep (0); ! 365: } ! 366: return (NULL); ! 367: ! 368: case WM_PAINT: { ! 369: PAINTSTRUCT ps; ! 370: COLORREF crColor; ! 371: HBRUSH hBrush; ! 372: ! 373: hdc = BeginPaint (hWnd, &ps); ! 374: ! 375: /******************************************************************\ ! 376: * For each rgn we created determine appropriate color & draw it ! 377: \******************************************************************/ ! 378: ! 379: for (i = 0; i <= currRgn; i++) ! 380: { if (rgnArray[i].hrgn != NULL) ! 381: { crColor = 0x000000; ! 382: if (rgnArray[i].type & ELLIPTIC_RGN) /* add some red */ ! 383: crColor |= 0x0000ff; ! 384: if (rgnArray[i].type & POLYPOLYGON_RGN) /* add some green */ ! 385: crColor |= 0x00ff00; ! 386: if (rgnArray[i].type & RECT_RGN) /* add some blue */ ! 387: crColor |= 0xff0000; ! 388: hBrush = CreateSolidBrush (crColor); ! 389: ! 390: /**************************************************************\ ! 391: * Alternately, the following would work: ! 392: * SelectObject (hdc, hBrush); ! 393: * FillRgn (hdc, rgnArray[i].hrgn); ! 394: \**************************************************************/ ! 395: ! 396: FillRgn (hdc, rgnArray[i].hrgn, hBrush); ! 397: DeleteObject (hBrush); ! 398: } ! 399: } ! 400: EndPaint (hWnd, &ps); ! 401: return (NULL); ! 402: } ! 403: case WM_DESTROY: ! 404: ! 405: PostQuitMessage(NULL); ! 406: return (NULL); ! 407: } ! 408: return (DefWindowProc(hWnd, message, wParam, lParam)); ! 409: } ! 410: ! 411: ! 412: ! 413: /************************************************************************\ ! 414: * ! 415: * FUNCTION: AboutDlgProc (standard dialog procedure INPUTS/RETURNS) ! 416: * ! 417: * COMMENTS: Displays "about" message ! 418: * ! 419: \************************************************************************/ ! 420: ! 421: BOOL APIENTRY AboutDlgProc (HWND hDlg, UINT message, UINT wParam, ! 422: LONG lParam) ! 423: { switch (message) ! 424: { case WM_INITDIALOG: ! 425: ! 426: return (TRUE); ! 427: ! 428: case WM_COMMAND: ! 429: ! 430: if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) ! 431: { EndDialog(hDlg, TRUE); ! 432: return (TRUE); ! 433: } ! 434: return (TRUE); ! 435: } ! 436: return (FALSE); ! 437: UNREFERENCED_PARAMETER(lParam); ! 438: } ! 439: ! 440: ! 441: ! 442: /************************************************************************\ ! 443: * ! 444: * FUNCTION: RgnBoxDlgProc (standard dialog procedure INPUTS/RETURNS) ! 445: * ! 446: * GLOBAL VARS: rgnArray - Array of RGNSTRUCTs describing regions user has ! 447: * created ! 448: * currRgn - Index (in rgnArray) of most recently created ! 449: * region. If -1 then no regions created. Other- ! 450: * wise, values range from 0 to MAXRGNSTRUCTS - 1. ! 451: * ! 452: * COMMENTS: Displays bounding rectangle of most recently created ! 453: * region. ! 454: * ! 455: \************************************************************************/ ! 456: ! 457: BOOL APIENTRY RgnBoxDlgProc (HWND hDlg, UINT message, UINT wParam, ! 458: LONG lParam) ! 459: { ! 460: switch (message) ! 461: { case WM_INITDIALOG: ! 462: { RECT rect; ! 463: char buf[15]; ! 464: ! 465: /******************************************************************\ ! 466: * get the bounding rect of currRgn, fill in the dlg controls ! 467: * with text string describing the bounding rect. ! 468: \******************************************************************/ ! 469: ! 470: if (GetRgnBox (rgnArray[currRgn].hrgn, &rect) == SIMPLEREGION) ! 471: SetDlgItemText (hDlg, 102, "SIMPLEREGION"); ! 472: else ! 473: SetDlgItemText (hDlg, 102, "COMPLEXREGION"); ! 474: ! 475: wsprintf (buf, "%ld", rect.left); ! 476: SetDlgItemText (hDlg, 107, buf); ! 477: wsprintf (buf, "%ld", rect.top); ! 478: SetDlgItemText (hDlg, 108, buf); ! 479: wsprintf (buf, "%ld", rect.right); ! 480: SetDlgItemText (hDlg, 109, buf); ! 481: wsprintf (buf, "%ld", rect.bottom); ! 482: SetDlgItemText (hDlg, 110, buf); ! 483: ! 484: return (TRUE); ! 485: } ! 486: case WM_COMMAND: ! 487: ! 488: if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) ! 489: { EndDialog(hDlg, TRUE); ! 490: return (TRUE); ! 491: } ! 492: return (TRUE); ! 493: } ! 494: return (FALSE); ! 495: UNREFERENCED_PARAMETER(lParam); ! 496: } ! 497: ! 498: ! 499: ! 500: /************************************************************************\ ! 501: * ! 502: * FUNCTION: MyCreateRgn ! 503: * ! 504: * INPUTS: rgnStyle - The type of region to create (ELLIPTIC_RGN, ! 505: * POLYPOLYGON_RGN, RECT_RGN) ! 506: * ! 507: * GLOBAL VARS: rgnArray - Array of RGNSTRUCTs describing regions ! 508: * user has created. ! 509: * currRgn - Index (in rgnArray) of most recently ! 510: * created region. If -1 then no regions ! 511: * created. Otherwise, values range from ! 512: * 0 to MAXRGNSTRUCTS-1. ! 513: * hMenu - Handle of main window's menu. ! 514: * ellipseRect - Rectangle bounding elliptical region. ! 515: * polyPolygonPoints - The points for the polyPolygon region. ! 516: * polyPolygonCounts - The count of points for each polygon ! 517: * in the polyPolygon region. ! 518: * rectRect - The points for the rectangular region. ! 519: * ! 520: * COMMENTS: Creates a region (based on rgnStyle), increments currRgn, ! 521: * and fills in rgnArray[currRgn]. ! 522: * ! 523: \************************************************************************/ ! 524: ! 525: void MyCreateRgn (WORD rgnStyle) ! 526: { if (++currRgn == 0) /* if this is 1st rgn enable options menu */ ! 527: Reset (ENABLE_OPTIONS); ! 528: else if (currRgn == 1) /* if this is 2nd rgn enable combine menu */ ! 529: Reset (ENABLE_COMBINERGN); ! 530: rgnArray[currRgn].type = rgnStyle; ! 531: ! 532: switch (rgnStyle) ! 533: { case ELLIPTIC_RGN: ! 534: ! 535: /******************************************************************\ ! 536: * The following will also work here: ! 537: * CreateEllipticRgn ((int) ellipseRect.left, ! 538: * (int) ellipseRect.top, ! 539: * (int) ellipseRect.right, ! 540: * (int) ellipseRect.bottom); ! 541: \******************************************************************/ ! 542: ! 543: rgnArray[currRgn].hrgn = CreateEllipticRgnIndirect (&ellipseRect); ! 544: ! 545: EnableMenuItem (GetSubMenu (hMenu, 1), IDM_ELLIPSE, ! 546: MF_GRAYED | MF_DISABLED | MF_BYCOMMAND); ! 547: break; ! 548: ! 549: case POLYPOLYGON_RGN: ! 550: ! 551: /******************************************************************\ ! 552: * Alternately, several calls to CreatePolygonRgn could be made. ! 553: \******************************************************************/ ! 554: ! 555: rgnArray[currRgn].hrgn = CreatePolyPolygonRgn (polyPolygonPoints, ! 556: polyPolygonCounts, ! 557: POLYPOLYGONCOUNT, ! 558: WINDING); ! 559: EnableMenuItem (GetSubMenu (hMenu, 1), IDM_POLYPOLYGON, ! 560: MF_GRAYED | MF_DISABLED | MF_BYCOMMAND); ! 561: break; ! 562: ! 563: case RECT_RGN: ! 564: ! 565: /******************************************************************\ ! 566: * Alternately, a call to CreatePolygonRgn could be made. ! 567: \******************************************************************/ ! 568: ! 569: rgnArray[currRgn].hrgn = CreateRectRgn (rectRect.left, ! 570: rectRect.top, ! 571: rectRect.right, ! 572: rectRect.bottom); ! 573: ! 574: EnableMenuItem (GetSubMenu (hMenu, 1), IDM_RECT, ! 575: MF_GRAYED | MF_DISABLED | MF_BYCOMMAND); ! 576: break; ! 577: } ! 578: } ! 579: ! 580: ! 581: ! 582: /************************************************************************\ ! 583: * ! 584: * FUNCTION: MyCombineRgn ! 585: * ! 586: * INPUTS: fnCombineMode- Operation to perform on the two regions ! 587: * (RGN_AND, RGN_COPY, RGN_DIFF, RGN_OR, ! 588: * RGN_XOR) ! 589: * ! 590: * GLOBAL VARS: rgnArray- Array of RGNSTRUCTs describing regions user has ! 591: * created ! 592: * currRgn - Index (in rgnArray) of most recently created ! 593: * region. If -1 then no regions created. Otherwise, ! 594: * values range from 0 to MAXRGNSTRUCTS - 1. ! 595: * ! 596: * COMMENTS: Combines the two regions rgnArray[currRgn-1] and ! 597: * rgnArray[currRgn] using fnCombineMode, placing the ! 598: * results in rgnArray[currRgn-1]. Destroys rgnArray[currRgn] ! 599: * and decrements currRgn. ! 600: * ! 601: \************************************************************************/ ! 602: ! 603: void MyCombineRgn (int fnCombineMode) ! 604: { ! 605: if (currRgn >= 1) /* only if two or more regions have been created */ ! 606: { CombineRgn (rgnArray[currRgn-1].hrgn, rgnArray[currRgn-1].hrgn, ! 607: rgnArray[currRgn].hrgn, fnCombineMode); ! 608: ! 609: rgnArray[currRgn-1].type |= rgnArray[currRgn].type; ! 610: ! 611: /* Delete the second of the two regions after combining */ ! 612: ! 613: DeleteObject (rgnArray[currRgn--].hrgn); ! 614: ! 615: if (currRgn == 0) ! 616: Reset (DISABLE_COMBINERGN); ! 617: } ! 618: } ! 619: ! 620: ! 621: ! 622: /************************************************************************\ ! 623: * ! 624: * FUNCTION: Reset ! 625: * ! 626: * INPUTS: action - Describes which reset action to take, eg. which ! 627: * menus to enable/disable etc... ! 628: * ! 629: * GLOBAL VARS: rgnArray - Array of RGNSTRUCTs describing regions user has ! 630: * created ! 631: * currRgn - Index (in rgnArray) of most recently created ! 632: * region. If -1 then no regions created. Other- ! 633: * wise, values range from 0 to MAXRGNSTRUCTS - 1. ! 634: * hMenu - Handle of main window's menu. ! 635: * ! 636: * COMMENTS: Sets appropriate menu states and deletes old regions ! 637: * according to "action" parameter. ! 638: * ! 639: \************************************************************************/ ! 640: ! 641: void Reset (WORD action) ! 642: { UINT i; ! 643: ! 644: switch (action) ! 645: { case RESET_ALL: ! 646: if (currRgn > 0) ! 647: for (i = 0; i <= (UINT) currRgn; i++) ! 648: DeleteObject (rgnArray[i].hrgn); ! 649: currRgn = -1; ! 650: for (i = IDM_ERASE; i <= IDM_GETRGNBOX; i++) ! 651: EnableMenuItem (GetSubMenu (hMenu, 0), i, MF_DISABLED | MF_GRAYED ! 652: | MF_BYCOMMAND); ! 653: for (i = IDM_ELLIPSE; i <= IDM_RECT; i++) ! 654: EnableMenuItem (GetSubMenu (hMenu, 1), i, MF_ENABLED | ! 655: MF_BYCOMMAND); ! 656: for (i = IDM_AND; i <= IDM_XOR; i++) ! 657: EnableMenuItem (GetSubMenu (hMenu, 2), i, MF_DISABLED | MF_GRAYED ! 658: | MF_BYCOMMAND); ! 659: break; ! 660: ! 661: case ENABLE_OPTIONS: ! 662: for (i = IDM_ERASE; i <= IDM_GETRGNBOX; i++) ! 663: EnableMenuItem (GetSubMenu (hMenu, 0), i, MF_ENABLED | ! 664: MF_BYCOMMAND); ! 665: break; ! 666: ! 667: case ENABLE_COMBINERGN: ! 668: for (i = IDM_AND; i <= IDM_XOR; i++) ! 669: EnableMenuItem (GetSubMenu (hMenu, 2), i, MF_ENABLED | ! 670: MF_BYCOMMAND); ! 671: break; ! 672: ! 673: case DISABLE_COMBINERGN: ! 674: for (i = IDM_AND; i <= IDM_XOR; i++) ! 675: EnableMenuItem (GetSubMenu (hMenu, 2), i, MF_DISABLED | MF_GRAYED ! 676: | MF_BYCOMMAND); ! 677: break; ! 678: } ! 679: } ! 680: ! 681: ! 682: /************************************************************************\ ! 683: * ! 684: * FUNCTION: TrackRect() ! 685: * ! 686: * INPUTS: ptr - Pointer to a PTRACKRECTSTRUCT. ! 687: * action - Message selecting what action to take. ! 688: * hWnd - Window handle for the window the track rect ! 689: * exists within. ! 690: * lParam - Fourth param to window proc (as with WM_MOUSEMOVE, ! 691: * WM_LBUTTONDOWN, WM_LBUTTONUP...) desribing ! 692: * event location. ! 693: * ! 694: * RETURNS: A pointer to a new TRACKRECTSTRUCT if msg == TRECT_NEW, ! 695: * NULL if msg != NEW ! 696: * ! 697: * COMMENTS: This function provides tracking rectangle functionality. ! 698: * ! 699: \************************************************************************/ ! 700: ! 701: PTRACKRECTSTRUCT TrackRect (PTRACKRECTSTRUCT ptr, int action, HWND hWnd, ! 702: LONG lParam) ! 703: { if ((ptr == NULL) && (action != TRECT_NEW)) return NULL; ! 704: ! 705: switch (action) ! 706: { ! 707: /********************************************************************\ ! 708: * TRECT_NEW: Allocate new PTRACKRECTSTRUCT. Fill in initial values ! 709: * for the fields of the structure. Set up the HDC ! 710: * correctly. ! 711: * ! 712: * return - pointer to the new object. ! 713: \********************************************************************/ ! 714: ! 715: case TRECT_NEW: ! 716: { PTRACKRECTSTRUCT ptr; ! 717: ! 718: if ((ptr = LocalAlloc (LPTR, sizeof (TRACKRECTSTRUCT))) == NULL) ! 719: { MessageBox (hWnd, "REGIONS: LocalAlloc() failed", "Err!", ! 720: MB_OK | MB_ICONEXCLAMATION); ! 721: return NULL; ! 722: } ! 723: ! 724: /* initialize the HDC and other fields. */ ! 725: ptr->hdc = GetDC(hWnd); ! 726: SetROP2(ptr->hdc, R2_NOT); ! 727: SelectObject (ptr->hdc, GetStockObject (NULL_BRUSH)); ! 728: SelectObject (ptr->hdc, CreatePen (PS_SOLID, 2, ! 729: (COLORREF) 0x01000009)); ! 730: ! 731: /* initialize the size. */ ! 732: ptr->trackRect.left = ptr->trackRect.right = ! 733: (LONG) (ptr->xOrigin = LOWORD (lParam)); ! 734: ptr->trackRect.top = ptr->trackRect.bottom = ! 735: (LONG) (ptr->yOrigin = HIWORD (lParam)); ! 736: ! 737: SetCapture (hWnd); ! 738: GetClientRect (hWnd, &(ptr->clientRect)); ! 739: return (ptr); ! 740: } ! 741: ! 742: /********************************************************************\ ! 743: * TRECT_DELETE: Free up the memory allocated for the tracking rect. ! 744: * Also, erase the last rectangle we drew. ! 745: \********************************************************************/ ! 746: ! 747: case TRECT_DELETE: ! 748: Rectangle (ptr->hdc, (int) ptr->trackRect.left, ! 749: (int) ptr->trackRect.top, ! 750: (int) ptr->trackRect.right, ! 751: (int) ptr->trackRect.bottom); ! 752: ReleaseDC (hWnd, ptr->hdc); ! 753: LocalFree (LocalHandle ((LPSTR)ptr)); ! 754: ReleaseCapture (); ! 755: return NULL; ! 756: ! 757: /********************************************************************\ ! 758: * TRECT_PAINT: Draw the tracking rectangle (involves erasing last ! 759: * rectangle at old coordinates, and drawing new rect ! 760: * at new coordinates). ! 761: \********************************************************************/ ! 762: ! 763: case TRECT_PAINT: ! 764: ! 765: /******************************************************************\ ! 766: * Remove the last rectangle we painted by painting over it again ! 767: \******************************************************************/ ! 768: ! 769: Rectangle (ptr->hdc, (int) ptr->trackRect.left, ! 770: (int) ptr->trackRect.top, ! 771: (int) ptr->trackRect.right, ! 772: (int) ptr->trackRect.bottom); ! 773: ! 774: /******************************************************************\ ! 775: * We want to restrict our Rectangle() calls to paint within the ! 776: * client area, so do a bounds check on lParam and reset any ! 777: * values which fall outside the client area (eg. <1, ! 778: * >clientRect.left, >clientRect.top). ! 779: \******************************************************************/ ! 780: ! 781: if ((SHORT)LOWORD(lParam) < 1) ! 782: lParam &= 0xffff0000; ! 783: else if (LOWORD(lParam) > (WORD) (ptr->clientRect.right- 1)) ! 784: lParam = MAKELONG ((WORD) ptr->clientRect.right - 1, ! 785: HIWORD(lParam)); ! 786: ! 787: if ((SHORT)HIWORD(lParam) < 1) ! 788: lParam &= 0x0000ffff; ! 789: else if (HIWORD(lParam) > (WORD) (ptr->clientRect.bottom - 1)) ! 790: lParam = MAKELONG (LOWORD(lParam), ! 791: (WORD) ptr->clientRect.bottom - 1); ! 792: ! 793: ptr->trackRect.left = (LONG) (ptr->xOrigin > LOWORD(lParam) ! 794: ? LOWORD(lParam) : ptr->xOrigin); ! 795: ptr->trackRect.right = (LONG) (ptr->xOrigin > LOWORD(lParam) ! 796: ? ptr->xOrigin : LOWORD(lParam)); ! 797: ptr->trackRect.top = (LONG) (ptr->yOrigin > HIWORD(lParam) ! 798: ? HIWORD(lParam) : ptr->yOrigin); ! 799: ptr->trackRect.bottom = (LONG) (ptr->yOrigin > HIWORD(lParam) ! 800: ? ptr->yOrigin : HIWORD(lParam)); ! 801: ! 802: /******************************************************************\ ! 803: * Redraw the tracking rectangle ! 804: \******************************************************************/ ! 805: ! 806: Rectangle (ptr->hdc, (int) ptr->trackRect.left, ! 807: (int) ptr->trackRect.top, ! 808: (int) ptr->trackRect.right, ! 809: (int) ptr->trackRect.bottom); ! 810: return NULL; ! 811: } ! 812: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.