![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to edpline.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / pmsdk / samples / edpline|
Return to edpline.c CVS log | Up to [OS/2 SDKs] / pmsdk / samples / edpline |
1.1 ! root 1: /* ! 2: edpline.c -- polyline editor, for practice in mouse handling ! 3: Created by Microsoft Corporation, 1989 ! 4: */ ! 5: #define INCL_DOSMEMMGR ! 6: #define INCL_WINWINDOWMGR ! 7: #define INCL_WINMESSAGEMGR ! 8: #define INCL_WINSWITCHLIST ! 9: #define INCL_WINDIALOGS ! 10: #define INCL_GPIBITMAPS ! 11: #define INCL_GPIPRIMITIVES ! 12: #define INCL_WINMENUS ! 13: #define INCL_WININPUT ! 14: #define INCL_WINFRAMEMGR ! 15: #include <os2.h> ! 16: ! 17: #include <mt\stdio.h> ! 18: #include <mt\stdlib.h> ! 19: ! 20: #include "edpline.h" ! 21: ! 22: ! 23: ! 24: #define abs(x) (((x) > 0) ? (x) : -(x)) ! 25: #define PRIM_POLYLINE 0x0001 ! 26: #define PRIM_POLYFILLET 0x0002 ! 27: #define PRIM_POLYSPLINE 0x0004 ! 28: #define PRIM_POINTARC 0x0008 ! 29: ! 30: ! 31: /************************************************************************ ! 32: * ! 33: * Function declarations ! 34: * ! 35: ************************************************************************/ ! 36: ! 37: /* Private functions */ ! 38: ! 39: VOID cdecl main(VOID); ! 40: BOOL InitGlobals(VOID); ! 41: BOOL InitApp(VOID); ! 42: VOID Close(HWND); ! 43: VOID Command(HWND, USHORT); ! 44: VOID Paint(HPS, BOOL); ! 45: VOID MouseMove(HWND, MPARAM); ! 46: VOID ButtonUp(HWND, USHORT); ! 47: VOID ButtonDown(HWND, USHORT, MPARAM); ! 48: USHORT IsPtInList(PPOINTL); ! 49: USHORT AddPtToList(PPOINTL); ! 50: BOOL IsPtCloseToLine(PPOINTL, PPOINTL, PPOINTL); ! 51: VOID DrawPrimitive(HPS, USHORT); ! 52: VOID DrawPolyLine(HPS); ! 53: VOID DrawPolyFillet(HPS); ! 54: VOID DrawPolySpline(HPS); ! 55: VOID DrawPointArc(HPS); ! 56: VOID DrawControlPoints(HPS, LONG, PPOINTL); ! 57: VOID MyMessageBox(HWND, PSZ); ! 58: VOID SwapLong(PLONG, PLONG); ! 59: ! 60: /* Exported functions */ ! 61: ! 62: ULONG CALLBACK WndProc(HWND, USHORT, MPARAM, MPARAM); ! 63: MRESULT CALLBACK AboutDlgProc(HWND, USHORT, MPARAM, MPARAM); ! 64: ! 65: ! 66: ! 67: /************************************************************************ ! 68: * ! 69: * Global Variables ! 70: * ! 71: ************************************************************************/ ! 72: ! 73: typedef struct ! 74: { ! 75: HAB hab; ! 76: HMQ hMsgQ; ! 77: HWND hwndFrame; ! 78: HWND hwnd; ! 79: ! 80: ULONG flPrim; ! 81: BOOL fDisplayControlPoints; ! 82: LONG cptl; ! 83: PPOINTL pptl; ! 84: ! 85: USHORT usPtGrabbed; ! 86: BOOL fDragging; ! 87: ! 88: ULONG ulHitPrecision; ! 89: ! 90: } GLOBALDATA; ! 91: GLOBALDATA global; ! 92: ! 93: ! 94: ! 95: ! 96: /************************************************************************ ! 97: * ! 98: * main ! 99: * ! 100: * WinInitialize resizes our ring 2 stack, among other things, so ! 101: * we won't GP fault trying to do graphics. WinCreateMsgQueue defines ! 102: * us as a REAL PM app. (as well as the WINDOWAPI statement in the .DEF ! 103: * file...) Call a sub to register our window class and create a window. ! 104: * Loop over messages. Exit cleanly. ! 105: * ! 106: ************************************************************************/ ! 107: ! 108: VOID cdecl ! 109: main() ! 110: { ! 111: QMSG qMsg; ! 112: int iRet = 0; ! 113: ! 114: ! 115: global.hab = WinInitialize(NULL); ! 116: global.hMsgQ = WinCreateMsgQueue(global.hab, 0); ! 117: ! 118: if (InitApp()) ! 119: while (WinGetMsg( global.hab, (PQMSG)&qMsg, (HWND)NULL, 0, 0 )) ! 120: WinDispatchMsg( global.hab, (PQMSG)&qMsg ); ! 121: else ! 122: iRet = -1; ! 123: ! 124: WinDestroyWindow( global.hwndFrame ); ! 125: WinDestroyMsgQueue( global.hMsgQ ); ! 126: WinTerminate( global.hab ); ! 127: DosExit(EXIT_PROCESS, iRet); ! 128: } ! 129: ! 130: ! 131: ! 132: ! 133: /**************************************************************************** ! 134: * ! 135: * InitGlobals ! 136: * ! 137: * Initialize global variables. ! 138: * ! 139: ****************************************************************************/ ! 140: ! 141: BOOL ! 142: InitGlobals() ! 143: { ! 144: global.flPrim = PRIM_POLYLINE; ! 145: global.fDisplayControlPoints = TRUE; ! 146: ! 147: global.cptl = 0L; ! 148: global.pptl = NULL; ! 149: if (DosAllocSeg(CPTLMAX * sizeof(POINTL), ! 150: ((PUSHORT)&global.pptl)+1, 0)) ! 151: return FALSE; ! 152: ! 153: global.usPtGrabbed = -1; ! 154: global.fDragging = FALSE; ! 155: global.ulHitPrecision = 0L; ! 156: ! 157: return TRUE; ! 158: } ! 159: ! 160: ! 161: ! 162: ! 163: /**************************************************************************** ! 164: * ! 165: * InitApp ! 166: * ! 167: * Register application window class and creates standard window. ! 168: * ! 169: ****************************************************************************/ ! 170: ! 171: #define INIT_MENU_ITEM(val, var) \ ! 172: TOGGLE_MENU_ITEM(global.hwndFrame, (val), (var)) ! 173: ! 174: BOOL ! 175: InitApp() ! 176: { ! 177: char szTitle[24]; ! 178: ULONG ctldata; ! 179: PID pid; ! 180: TID tid; ! 181: HSWITCH hsw; ! 182: static SWCNTRL swctl = { 0, 0, 0, 0, 0, SWL_VISIBLE, ! 183: SWL_JUMPABLE, "Edit Polyline", 0 }; ! 184: ! 185: if (!InitGlobals()) ! 186: return FALSE; ! 187: ! 188: ! 189: /* Register Application Window Class */ ! 190: ! 191: WinLoadString( global.hab, NULL, IDS_TITLE, sizeof(szTitle), (PCH)szTitle ); ! 192: if ( !WinRegisterClass( global.hab, (PCH)szTitle, (PFNWP)WndProc, ! 193: CS_SIZEREDRAW, 0 )) ! 194: return FALSE; ! 195: ! 196: ! 197: ! 198: /* Create a window instance of class "PolyLine Editor" */ ! 199: ! 200: ctldata = FCF_STANDARD & ! 201: ~(ULONG)(FCF_ICON | FCF_ACCELTABLE | FCF_TASKLIST); ! 202: ! 203: if (global.hwndFrame = WinCreateStdWindow( ! 204: HWND_DESKTOP, /* specify desktop as parent window */ ! 205: WS_VISIBLE, /* window styles */ ! 206: &ctldata, /* frame creation flags */ ! 207: (PCH)szTitle, /* window class name */ ! 208: (PCH)szTitle, /* name appearing in window caption */ ! 209: 0L, /* */ ! 210: (HMODULE)NULL, /* use current executable module id */ ! 211: IDR_EDPLINE, /* menu id */ ! 212: (HWND FAR *)&global.hwnd /* window handle */ ! 213: )) ! 214: { ! 215: INIT_MENU_ITEM(IDM_CTLPOINTS, global.fDisplayControlPoints); ! 216: ! 217: if (global.flPrim & PRIM_POLYLINE) ! 218: CHECK_MENU_ITEM(global.hwndFrame, IDM_POLYLINE); ! 219: if (global.flPrim & PRIM_POLYFILLET) ! 220: CHECK_MENU_ITEM(global.hwndFrame, IDM_POLYFILLET); ! 221: if (global.flPrim & PRIM_POLYSPLINE) ! 222: CHECK_MENU_ITEM(global.hwndFrame, IDM_POLYSPLINE); ! 223: if (global.flPrim & PRIM_POINTARC) ! 224: CHECK_MENU_ITEM(global.hwndFrame, IDM_POINTARC); ! 225: ! 226: ! 227: /* Add ourselves to the switch list. */ ! 228: ! 229: WinQueryWindowProcess(global.hwndFrame, &pid, &tid); ! 230: swctl.hwnd = global.hwndFrame; ! 231: swctl.idProcess = pid; ! 232: hsw = WinAddSwitchEntry(&swctl); ! 233: ! 234: return TRUE; ! 235: } ! 236: return FALSE; ! 237: } ! 238: ! 239: ! 240: ! 241: ! 242: /************************************************************************ ! 243: * ! 244: * WndProc ! 245: * ! 246: * Process messages for the window class. ! 247: * ! 248: ************************************************************************/ ! 249: ! 250: ULONG CALLBACK ! 251: WndProc( hwnd, usMsg, mp1, mp2 ) ! 252: HWND hwnd; ! 253: USHORT usMsg; ! 254: MPARAM mp1; ! 255: MPARAM mp2; ! 256: { ! 257: HPS hps; ! 258: ! 259: ! 260: switch (usMsg) ! 261: { ! 262: case WM_CLOSE: ! 263: Close(hwnd); ! 264: break; ! 265: ! 266: case WM_COMMAND: ! 267: Command(hwnd, LOUSHORT(mp1)); ! 268: break; ! 269: ! 270: case WM_PAINT: ! 271: hps = WinBeginPaint(global.hwnd, NULL, NULL); ! 272: if (global.ulHitPrecision == 0L) ! 273: { ! 274: HDC hdc; ! 275: LONG cx; ! 276: ! 277: if (hdc = WinQueryWindowDC(global.hwnd)) { ! 278: DevQueryCaps(hdc, CAPS_MARKER_WIDTH, 1L, &cx); ! 279: global.ulHitPrecision = (cx >> 17) + 1L; ! 280: } else { ! 281: global.ulHitPrecision = 6L; ! 282: } ! 283: } ! 284: Paint(hps, TRUE); ! 285: WinEndPaint(hps); ! 286: break; ! 287: ! 288: case WM_BUTTON1DOWN: ! 289: case WM_BUTTON2DOWN: ! 290: ButtonDown(hwnd, usMsg, mp1); ! 291: break; ! 292: ! 293: case WM_BUTTON1UP: ! 294: case WM_BUTTON2UP: ! 295: ButtonUp(hwnd, usMsg); ! 296: break; ! 297: ! 298: case WM_MOUSEMOVE: ! 299: MouseMove(hwnd, mp1); ! 300: return( (ULONG)WinDefWindowProc(hwnd, usMsg, mp1, mp2)); ! 301: break; ! 302: ! 303: default: ! 304: return( (ULONG)WinDefWindowProc(hwnd, usMsg, mp1, mp2)); ! 305: break; ! 306: } ! 307: ! 308: return FALSE; ! 309: } ! 310: ! 311: ! 312: ! 313: ! 314: /************************************************************************ ! 315: * ! 316: * MouseMove ! 317: * ! 318: ************************************************************************/ ! 319: ! 320: VOID ! 321: MouseMove(hwnd, mp1) ! 322: HWND hwnd; ! 323: MPARAM mp1; ! 324: { ! 325: POINTL ptl; ! 326: HPS hps; ! 327: ! 328: if (hwnd == global.hwnd) ! 329: if (global.fDragging) ! 330: { ! 331: ptl.x = (LONG) LOUSHORT(mp1); ! 332: ptl.y = (LONG) HIUSHORT(mp1); ! 333: ! 334: if (global.usPtGrabbed != -1) ! 335: { ! 336: hps = WinGetPS(hwnd); ! 337: Paint(hps, FALSE); ! 338: ! 339: *(global.pptl+global.usPtGrabbed) = ptl; ! 340: ! 341: Paint(hps, FALSE); ! 342: WinReleasePS(hps); ! 343: } ! 344: } ! 345: } ! 346: ! 347: ! 348: ! 349: ! 350: /************************************************************************ ! 351: * ! 352: * ButtonUp ! 353: * ! 354: ************************************************************************/ ! 355: ! 356: VOID ! 357: ButtonUp(hwnd, usMsg) ! 358: HWND hwnd; ! 359: USHORT usMsg; ! 360: { ! 361: int i; ! 362: HPS hps; ! 363: ! 364: ! 365: if (hwnd == global.hwnd) ! 366: if (global.fDragging) ! 367: { ! 368: global.fDragging = FALSE; ! 369: if (global.usPtGrabbed != -1) ! 370: { ! 371: if (usMsg == WM_BUTTON2UP) ! 372: { ! 373: hps = WinGetPS(hwnd); ! 374: Paint(hps, FALSE); ! 375: ! 376: if ((i = global.usPtGrabbed) < (int) global.cptl-1) ! 377: while (i < (int) global.cptl-1) ! 378: { ! 379: global.pptl[i] = global.pptl[i+1]; ! 380: ++i; ! 381: } ! 382: ! 383: --global.cptl; ! 384: global.usPtGrabbed = -1; ! 385: ! 386: Paint(hps, FALSE); ! 387: WinReleasePS(hps); ! 388: } ! 389: else /* WM_BUTTON1UP */ ! 390: global.usPtGrabbed = -1; ! 391: } ! 392: } ! 393: } ! 394: ! 395: ! 396: ! 397: ! 398: /************************************************************************ ! 399: * ! 400: * ButtonDown ! 401: * ! 402: ************************************************************************/ ! 403: ! 404: VOID ! 405: ButtonDown(hwnd, usMsg, mp1) ! 406: HWND hwnd; ! 407: USHORT usMsg; ! 408: MPARAM mp1; ! 409: { ! 410: POINTL ptl; ! 411: HPS hps; ! 412: USHORT usNewPtGrabbed; ! 413: ! 414: ! 415: if (hwnd == global.hwnd) ! 416: if (!global.fDragging) ! 417: { ! 418: global.fDragging = TRUE; ! 419: ! 420: ptl.x = (LONG) LOUSHORT(mp1); ! 421: ptl.y = (LONG) HIUSHORT(mp1); ! 422: ! 423: if ((usNewPtGrabbed = IsPtInList(&ptl)) != -1) ! 424: global.usPtGrabbed = usNewPtGrabbed; ! 425: ! 426: if (usMsg == WM_BUTTON1DOWN) ! 427: { ! 428: hps = WinGetPS(hwnd); ! 429: Paint(hps, FALSE); ! 430: ! 431: if (usNewPtGrabbed == -1) ! 432: global.usPtGrabbed = AddPtToList(&ptl); ! 433: else ! 434: global.usPtGrabbed = usNewPtGrabbed; ! 435: ! 436: Paint(hps, FALSE); ! 437: WinReleasePS(hps); ! 438: ! 439: if (global.usPtGrabbed == -1) ! 440: MyMessageBox(global.hwnd, "Cannot add any more points."); ! 441: } ! 442: } ! 443: } ! 444: ! 445: ! 446: ! 447: ! 448: /************************************************************************ ! 449: * ! 450: * IsPtInList ! 451: * ! 452: ************************************************************************/ ! 453: ! 454: USHORT ! 455: IsPtInList(pptl) ! 456: PPOINTL pptl; ! 457: { ! 458: int i; ! 459: ! 460: ! 461: /* try to find pptl in the points we already have */ ! 462: for (i = 0; i < (int) global.cptl; ++i) ! 463: if (((abs(pptl->x - global.pptl[i].x)) ! 464: <= (LONG) global.ulHitPrecision) ! 465: && ((abs(pptl->y - global.pptl[i].y)) ! 466: <= (LONG) global.ulHitPrecision)) ! 467: return i; ! 468: ! 469: /* couldn't find it */ ! 470: return -1; ! 471: } ! 472: ! 473: ! 474: ! 475: ! 476: /************************************************************************ ! 477: * ! 478: * AddPtToList ! 479: * ! 480: ************************************************************************/ ! 481: ! 482: USHORT ! 483: AddPtToList(pptl) ! 484: PPOINTL pptl; ! 485: { ! 486: int i, j; ! 487: ! 488: if (global.cptl < CPTLMAX) ! 489: { ! 490: /* check for new points lying on a line segment */ ! 491: for (i = 0; i < (int) (global.cptl - 1L); ++i) ! 492: if (IsPtCloseToLine(&global.pptl[i], &global.pptl[i+1], pptl)) ! 493: { ! 494: for (j = (int) global.cptl; j > i+1; --j) ! 495: global.pptl[j] = global.pptl[j - 1]; ! 496: global.pptl[i+1] = *pptl; ! 497: ++global.cptl; ! 498: return i+1; ! 499: } ! 500: ! 501: /* append the point */ ! 502: ! 503: i = (int) global.cptl; ! 504: global.pptl[i] = *pptl; ! 505: ++global.cptl; ! 506: return i; ! 507: } ! 508: ! 509: return -1; ! 510: } ! 511: ! 512: ! 513: ! 514: ! 515: /************************************************************************ ! 516: * ! 517: * IsPtCloseToLine ! 518: * ! 519: ************************************************************************/ ! 520: ! 521: BOOL ! 522: IsPtCloseToLine(pptl1, pptl2, pptlTest) ! 523: PPOINTL pptl1; ! 524: PPOINTL pptl2; ! 525: PPOINTL pptlTest; ! 526: { ! 527: POINTL ptlLL, ptlUR; ! 528: LONG dx, dy, yIntercept, result; ! 529: ! 530: ! 531: /* find the bounding box of the line segment */ ! 532: ! 533: ptlLL = *pptl1; /* assume line goes lower left to upper right */ ! 534: ptlUR = *pptl2; ! 535: if (pptl1->x > pptl2->x) ! 536: SwapLong(&ptlLL.x, &ptlUR.x); ! 537: if (pptl1->y > pptl2->y) ! 538: SwapLong(&ptlLL.y, &ptlUR.y); ! 539: ! 540: ! 541: /* adjust the bounding box if it's too narrow */ ! 542: ! 543: dx = pptl2->x - pptl1->x; ! 544: if (abs(dx) <= (LONG) (global.ulHitPrecision >> 1)) ! 545: { ! 546: ptlLL.x -= (LONG) (global.ulHitPrecision >> 1); ! 547: ptlUR.x += (LONG) (global.ulHitPrecision >> 1); ! 548: } ! 549: dy = pptl2->y - pptl1->y; ! 550: if (abs(dy) <= (LONG) (global.ulHitPrecision >> 1)) ! 551: { ! 552: ptlLL.y -= (LONG) (global.ulHitPrecision >> 1); ! 553: ptlUR.y += (LONG) (global.ulHitPrecision >> 1); ! 554: } ! 555: ! 556: ! 557: /* see if the test point is in the bounding box of the line segment */ ! 558: ! 559: if ((pptlTest->x >= ptlLL.x) && ! 560: (pptlTest->x <= ptlUR.x) && ! 561: (pptlTest->y >= ptlLL.y) && ! 562: (pptlTest->y <= ptlUR.y)) ! 563: { ! 564: /* test for special cases */ ! 565: ! 566: if (dx == 0) ! 567: { ! 568: if (abs(pptlTest->x - pptl1->x) <= (LONG) global.ulHitPrecision) ! 569: return TRUE; ! 570: else ! 571: return FALSE; ! 572: } ! 573: ! 574: if (dy == 0) ! 575: { ! 576: if (abs(pptlTest->y - pptl1->y) <= (LONG) global.ulHitPrecision) ! 577: return TRUE; ! 578: else ! 579: return FALSE; ! 580: } ! 581: ! 582: ! 583: /* test for general case */ ! 584: ! 585: yIntercept = pptl1->y - (pptl1->x * dy) / dx; ! 586: ! 587: result = pptlTest->y - (pptlTest->x * dy / dx) - yIntercept; ! 588: if (abs(result) <= (LONG) global.ulHitPrecision) ! 589: return TRUE; ! 590: } ! 591: ! 592: return FALSE; ! 593: } ! 594: ! 595: ! 596: ! 597: ! 598: /************************************************************************ ! 599: * ! 600: * SwapLong ! 601: * ! 602: ************************************************************************/ ! 603: ! 604: VOID ! 605: SwapLong(pl1, pl2) ! 606: PLONG pl1, pl2; ! 607: { ! 608: LONG lTmp; ! 609: ! 610: lTmp = *pl1; ! 611: *pl1 = *pl2; ! 612: *pl2 = lTmp; ! 613: } ! 614: ! 615: ! 616: ! 617: ! 618: /************************************************************************ ! 619: * ! 620: * Close ! 621: * ! 622: ************************************************************************/ ! 623: ! 624: VOID ! 625: Close(hwnd) ! 626: HWND hwnd; ! 627: { ! 628: WinPostMsg(hwnd, WM_QUIT, 0L, 0L); ! 629: } ! 630: ! 631: ! 632: ! 633: ! 634: /************************************************************************ ! 635: * ! 636: * Command ! 637: * ! 638: * Dispatches menu commands to the proper handlers. ! 639: * ! 640: ************************************************************************/ ! 641: ! 642: #define UPDATE_MENU_BOOL(var, val) \ ! 643: { \ ! 644: TOGGLE_BOOL((var)); \ ! 645: TOGGLE_MENU_ITEM(global.hwndFrame, (val), (var)); \ ! 646: } ! 647: ! 648: #define UPDATE_MENU_LIST(var, val) \ ! 649: { \ ! 650: UNCHECK_MENU_ITEM(global.hwndFrame, (var)); \ ! 651: (var) = (val); \ ! 652: CHECK_MENU_ITEM(global.hwndFrame, (var)); \ ! 653: } ! 654: ! 655: VOID ! 656: Command(hwnd, id) ! 657: HWND hwnd; ! 658: USHORT id; ! 659: { ! 660: HPS hps; ! 661: BOOL fRedraw = FALSE; ! 662: int rc; ! 663: ! 664: switch (id) ! 665: { ! 666: case IDM_ABOUT: ! 667: rc = WinDlgBox(HWND_DESKTOP, hwnd, AboutDlgProc, NULL, IDD_ABOUT, NULL); ! 668: fRedraw = FALSE; ! 669: break; ! 670: ! 671: case IDM_NOPRIM: ! 672: global.flPrim = 0L; ! 673: TOGGLE_MENU_ITEM(global.hwndFrame, IDM_POLYLINE, 0); ! 674: TOGGLE_MENU_ITEM(global.hwndFrame, IDM_POLYFILLET, 0); ! 675: TOGGLE_MENU_ITEM(global.hwndFrame, IDM_POLYSPLINE, 0); ! 676: fRedraw = TRUE; ! 677: break; ! 678: ! 679: case IDM_POLYLINE: ! 680: global.flPrim ^= PRIM_POLYLINE; ! 681: TOGGLE_MENU_ITEM(global.hwndFrame, id, (global.flPrim & PRIM_POLYLINE)); ! 682: fRedraw = TRUE; ! 683: break; ! 684: ! 685: case IDM_POLYFILLET: ! 686: global.flPrim ^= PRIM_POLYFILLET; ! 687: TOGGLE_MENU_ITEM(global.hwndFrame, id, (global.flPrim & PRIM_POLYFILLET)); ! 688: fRedraw = TRUE; ! 689: break; ! 690: ! 691: case IDM_POLYSPLINE: ! 692: global.flPrim ^= PRIM_POLYSPLINE; ! 693: TOGGLE_MENU_ITEM(global.hwndFrame, id, (global.flPrim & PRIM_POLYSPLINE)); ! 694: fRedraw = TRUE; ! 695: break; ! 696: ! 697: case IDM_POINTARC: ! 698: global.flPrim ^= PRIM_POINTARC; ! 699: TOGGLE_MENU_ITEM(global.hwndFrame, id, (global.flPrim & PRIM_POINTARC)); ! 700: fRedraw = TRUE; ! 701: break; ! 702: ! 703: case IDM_CTLPOINTS: ! 704: UPDATE_MENU_BOOL(global.fDisplayControlPoints, IDM_CTLPOINTS); ! 705: fRedraw = TRUE; ! 706: break; ! 707: ! 708: case IDM_CLEARALL: ! 709: global.cptl = 0L; ! 710: fRedraw = TRUE; ! 711: break; ! 712: } ! 713: ! 714: if (fRedraw) ! 715: { ! 716: hps = WinGetPS(hwnd); ! 717: Paint(hps, TRUE); ! 718: WinReleasePS(hps); ! 719: } ! 720: } ! 721: ! 722: ! 723: ! 724: ! 725: /************************************************************************ ! 726: * ! 727: * Paint ! 728: * ! 729: ************************************************************************/ ! 730: ! 731: VOID ! 732: Paint(hps, fClearScreen) ! 733: HPS hps; ! 734: BOOL fClearScreen; ! 735: { ! 736: LINEBUNDLE lb; ! 737: RECTL rcl; ! 738: ! 739: ! 740: ! 741: if (fClearScreen) ! 742: { ! 743: /* clear the screen */ ! 744: WinQueryWindowRect(global.hwnd, &rcl); ! 745: GpiBitBlt(hps, NULL, 2L, (PPOINTL) &rcl, ROP_ONE, NULL); ! 746: } ! 747: ! 748: ! 749: if (global.cptl > 0L) ! 750: { ! 751: if (global.fDisplayControlPoints) ! 752: { ! 753: if (fClearScreen) ! 754: /* draw all the control points */ ! 755: DrawControlPoints(hps, global.cptl, global.pptl); ! 756: else if (global.usPtGrabbed != -1) ! 757: /* draw just the control point that moved */ ! 758: DrawControlPoints(hps, 1L, global.pptl+global.usPtGrabbed); ! 759: } ! 760: ! 761: /* set mix mode to xor */ ! 762: lb.usMixMode = FM_XOR; ! 763: GpiSetAttrs(hps, PRIM_LINE, LBB_MIX_MODE, 0L, &lb); ! 764: ! 765: /* draw the current primitives */ ! 766: ! 767: if (global.flPrim & PRIM_POLYLINE) ! 768: { ! 769: lb.lColor = CLR_BROWN; ! 770: GpiSetAttrs(hps, PRIM_LINE, LBB_COLOR, 0L, &lb); ! 771: DrawPrimitive(hps, IDM_POLYLINE); ! 772: } ! 773: ! 774: if (global.flPrim & PRIM_POLYFILLET) ! 775: { ! 776: lb.lColor = CLR_DARKCYAN; ! 777: GpiSetAttrs(hps, PRIM_LINE, LBB_COLOR, 0L, &lb); ! 778: DrawPrimitive(hps, IDM_POLYFILLET); ! 779: } ! 780: ! 781: if (global.flPrim & PRIM_POLYSPLINE) ! 782: { ! 783: lb.lColor = CLR_DARKPINK; ! 784: GpiSetAttrs(hps, PRIM_LINE, LBB_COLOR, 0L, &lb); ! 785: DrawPrimitive(hps, IDM_POLYSPLINE); ! 786: } ! 787: ! 788: if (global.flPrim & PRIM_POINTARC) ! 789: { ! 790: lb.lColor = CLR_BACKGROUND; ! 791: GpiSetAttrs(hps, PRIM_LINE, LBB_COLOR, 0L, &lb); ! 792: DrawPrimitive(hps, IDM_POINTARC); ! 793: } ! 794: } ! 795: } ! 796: ! 797: ! 798: ! 799: ! 800: /************************************************************************ ! 801: * ! 802: * DrawPrimitive ! 803: * ! 804: ************************************************************************/ ! 805: ! 806: VOID ! 807: DrawPrimitive(hps, usPrim) ! 808: HPS hps; ! 809: USHORT usPrim; ! 810: { ! 811: switch ( usPrim ) ! 812: { ! 813: case IDM_POLYLINE: ! 814: DrawPolyLine(hps); ! 815: break; ! 816: ! 817: case IDM_POLYFILLET: ! 818: DrawPolyFillet(hps); ! 819: break; ! 820: ! 821: case IDM_POLYSPLINE: ! 822: DrawPolySpline(hps); ! 823: break; ! 824: ! 825: case IDM_POINTARC: ! 826: DrawPointArc(hps); ! 827: break; ! 828: } ! 829: } ! 830: ! 831: ! 832: ! 833: ! 834: /************************************************************************ ! 835: * ! 836: * DrawPolyLine ! 837: * ! 838: ************************************************************************/ ! 839: ! 840: VOID ! 841: DrawPolyLine(hps) ! 842: HPS hps; ! 843: { ! 844: GpiSetCurrentPosition( hps, global.pptl ); ! 845: GpiPolyLine( hps, global.cptl-1L, global.pptl+1 ); ! 846: } ! 847: ! 848: ! 849: ! 850: ! 851: /************************************************************************ ! 852: * ! 853: * DrawPolyFillet ! 854: * ! 855: ************************************************************************/ ! 856: ! 857: VOID ! 858: DrawPolyFillet(hps) ! 859: HPS hps; ! 860: { ! 861: if (global.cptl > 2) ! 862: { ! 863: GpiSetCurrentPosition( hps, global.pptl ); ! 864: GpiPolyFillet( hps, global.cptl-1L, global.pptl+1 ); ! 865: } ! 866: } ! 867: ! 868: ! 869: ! 870: ! 871: /************************************************************************ ! 872: * ! 873: * DrawPolySpline ! 874: * ! 875: ************************************************************************/ ! 876: ! 877: VOID ! 878: DrawPolySpline(hps) ! 879: HPS hps; ! 880: { ! 881: USHORT cptSlack; /* # points in pptl not usable by PolySpline */ ! 882: ! 883: /* GpiPolySpline expects the number of points to be a ! 884: multiple of 3. If we have a non-multiple of three, ! 885: (excluding the first point, which we've used to set ! 886: the current position), only pass the largest multiple ! 887: of three, saving the rest for the next go-round. */ ! 888: ! 889: cptSlack = (int)((global.cptl-1L) % 3) + 1; ! 890: GpiSetCurrentPosition( hps, global.pptl ); ! 891: GpiPolySpline( hps, global.cptl-cptSlack, ! 892: global.pptl+1 ); ! 893: } ! 894: ! 895: ! 896: ! 897: ! 898: /************************************************************************ ! 899: * ! 900: * DrawPointArc ! 901: * ! 902: ************************************************************************/ ! 903: ! 904: VOID ! 905: DrawPointArc(hps) ! 906: HPS hps; ! 907: { ! 908: if (global.cptl >= 3L) ! 909: { ! 910: GpiSetCurrentPosition( hps, global.pptl ); ! 911: GpiPointArc( hps, global.pptl+1 ); ! 912: } ! 913: } ! 914: ! 915: ! 916: ! 917: ! 918: /************************************************************************ ! 919: * ! 920: * DrawControlPoints ! 921: * ! 922: ************************************************************************/ ! 923: ! 924: VOID ! 925: DrawControlPoints(hps, cptl, pptl) ! 926: HPS hps; ! 927: LONG cptl; ! 928: PPOINTL pptl; ! 929: { ! 930: MARKERBUNDLE mb; ! 931: ! 932: mb.lColor = CLR_TRUE; ! 933: mb.usMixMode = FM_XOR; ! 934: GpiSetAttrs(hps, PRIM_MARKER, MBB_COLOR | MBB_MIX_MODE, 0L, &mb); ! 935: ! 936: GpiPolyMarker(hps, cptl, pptl); ! 937: } ! 938: ! 939: ! 940: ! 941: ! 942: /************************************************************************ ! 943: * ! 944: * MyMessageBox ! 945: * ! 946: * Displays a message box with the given string. To simplify matters, ! 947: * the box will always have the same title ("PolyLine Editor"), will always ! 948: * have a single button ("Ok"), will always have an exclamation point ! 949: * icon, and will always be application modal. ! 950: * ! 951: ************************************************************************/ ! 952: ! 953: VOID ! 954: MyMessageBox(hWnd, sz) ! 955: HWND hWnd; ! 956: PSZ sz; ! 957: { ! 958: static char *szTitle = "PolyLine Editor"; ! 959: ! 960: WinMessageBox(HWND_DESKTOP, hWnd, sz, szTitle, NULL, ! 961: MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL); ! 962: } ! 963: ! 964: MRESULT CALLBACK AboutDlgProc(hDlg, msg, mp1, mp2) ! 965: /* ! 966: About... dialog procedure ! 967: */ ! 968: HWND hDlg; ! 969: USHORT msg; ! 970: MPARAM mp1; ! 971: MPARAM mp2; ! 972: { ! 973: switch(msg) { ! 974: case WM_COMMAND: ! 975: switch(COMMANDMSG(&msg)->cmd) { ! 976: case DID_OK: WinDismissDlg(hDlg, TRUE); break; ! 977: default: break; ! 978: } ! 979: default: return WinDefDlgProc(hDlg, msg, mp1, mp2); ! 980: } ! 981: return FALSE; ! 982: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.