![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wxform.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / wxform|
Return to wxform.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / wxform |
1.1 ! root 1: /**************************************************************************\ ! 2: * wxform.c -- sample program demonstrating the new "World Transform." ! 3: * ! 4: * design: There are a few global handles or pointers in this application, ! 5: * and different routines to operate on them. The obvious case of this ! 6: * is the three window handles and their associated window procedures. ! 7: * There is also a unique pointer to a track object and a routine to ! 8: * operate on it (i.e. doTrackObject). All communication is accomplished ! 9: * by sending messages between these procedures. Each window procedure, ! 10: * and the track object procedure, operate on some set of messages which ! 11: * include some of the standard Windows messages, and also miscellaneous ! 12: * "WM_USER" messages (c.f. wxform.h). ! 13: \**************************************************************************/ ! 14: ! 15: #include <windows.h> ! 16: #include <string.h> ! 17: #include <stdio.h> ! 18: #include <math.h> ! 19: #include <limits.h> ! 20: #include "wxform.h" ! 21: ! 22: ! 23: ! 24: /**************************************************************************\ ! 25: * ! 26: * function: WinMain() ! 27: * ! 28: * input parameters: c.f. generic sample ! 29: * ! 30: \**************************************************************************/ ! 31: int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, ! 32: LPSTR lpCmdLine, int nCmdShow) ! 33: { ! 34: MSG msg; ! 35: HICON hicon; ! 36: ! 37: UNREFERENCED_PARAMETER( lpCmdLine ); ! 38: ! 39: ! 40: /* Check for previous instance. If none, then register class. */ ! 41: if (!hPrevInstance) { ! 42: WNDCLASS wc; ! 43: ! 44: wc.style = NULL; ! 45: wc.lpfnWndProc = (WNDPROC)MainWndProc; ! 46: ! 47: wc.cbClsExtra = 0; ! 48: wc.cbWndExtra = 0; ! 49: wc.hInstance = hInstance; ! 50: wc.hIcon = LoadIcon(hInstance, "TransformIcon"); ! 51: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 52: wc.hbrBackground = GetStockObject(LTGRAY_BRUSH); ! 53: wc.lpszMenuName = NULL; ! 54: wc.lpszClassName = "wxform"; ! 55: ! 56: if (!RegisterClass(&wc)) return (FALSE); ! 57: } /* class registered o.k. */ ! 58: ! 59: ! 60: /* Create the main window. Return false if CreateWindow() fails */ ! 61: hInst = hInstance; ! 62: ! 63: hwndMain = CreateWindow( ! 64: "wxform", ! 65: "World Transform Demonstration", ! 66: WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, ! 67: CW_USEDEFAULT, ! 68: CW_USEDEFAULT, ! 69: CW_USEDEFAULT, ! 70: CW_USEDEFAULT, ! 71: NULL, ! 72: NULL, ! 73: hInstance, ! 74: NULL); ! 75: ! 76: if (!hwndMain) return (FALSE); ! 77: ShowWindow(hwndMain, nCmdShow); ! 78: UpdateWindow(hwndMain); ! 79: ! 80: ! 81: /* create a new track object and paint it for the first time. */ ! 82: ptoRect = doTrackObject(NULL, TROB_NEW, hwndMain, 0); ! 83: doTrackObject(ptoRect, TROB_PAINT, hwndMain, 0); ! 84: ! 85: ! 86: /* load and display dialog for the world transform matrix. ! 87: * then fill its entry fields. Also, get the HICON from the ! 88: * main window and fill it into the dialog's class structure ! 89: * for this application. ! 90: */ ! 91: hwndTransform = CreateDialog(hInst, "TransformDlg", ! 92: hwndMain, (DLGPROC)TransformDlgProc); ! 93: hicon = (HICON) GetClassLong (hwndMain, GCL_HICON); ! 94: SetClassLong (hwndTransform, GCL_HICON, (LONG)hicon); ! 95: showTransform = TRUE; ! 96: SendMessage (hwndTransform, WM_PUTUPFLOATS, 0, (LONG) &ptoRect->xfmChange); ! 97: ! 98: /* load and display the dialog for the mouse position. ! 99: * minimize it initially. ! 100: */ ! 101: hwndMouse = CreateDialog(hInst, "MouseDlg", ! 102: hwndMain, (DLGPROC)MouseDlgProc); ! 103: ShowWindow (hwndMouse, SW_SHOWMINIMIZED); ! 104: showMouse = FALSE; ! 105: ! 106: ! 107: /* load and display the dialog with the direct manipulation help. ! 108: * minimize it initially. (Don't need a unique window procedure.) ! 109: */ ! 110: hwndHelp = CreateDialog(hInst, "helpDlg", hwndMain, NULL); ! 111: ShowWindow (hwndHelp, SW_SHOWMINIMIZED); ! 112: ! 113: ! 114: ! 115: /* Loop getting messages and dispatching them. */ ! 116: while (GetMessage(&msg,NULL, NULL, NULL)) { ! 117: if (!IsDialogMessage (hwndTransform, &msg)) ! 118: if (!IsDialogMessage (hwndMouse, &msg)) ! 119: if (!IsDialogMessage (hwndHelp, &msg)){ ! 120: TranslateMessage(&msg); ! 121: DispatchMessage(&msg); ! 122: } ! 123: } ! 124: return (msg.wParam); ! 125: } ! 126: ! 127: ! 128: ! 129: ! 130: ! 131: ! 132: ! 133: ! 134: ! 135: /**************************************************************************\ ! 136: * ! 137: * function: MainWndProc() ! 138: * ! 139: * input parameters: normal window procedure parameters. ! 140: * ! 141: * global variables: ! 142: * hwndTransform, ! 143: * hwndMouse - information dialog box window handles. ! 144: * showTransform, ! 145: * showMouse - Booleans recording the retore/minimize state of the dialogs. ! 146: * ptoRect - pointer to track object in middle of screen. ! 147: * ! 148: \**************************************************************************/ ! 149: LRESULT MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) ! 150: { ! 151: static HANDLE hPenGrid; ! 152: ! 153: switch (message) { ! 154: ! 155: /**********************************************************************\ ! 156: * WM_CREATE ! 157: * ! 158: * create a pen for later use. ! 159: \**********************************************************************/ ! 160: case WM_CREATE: ! 161: hPenGrid = CreatePen (PS_SOLID, 1, GRIDCOLOR); ! 162: break; ! 163: ! 164: ! 165: ! 166: /**********************************************************************\ ! 167: * WM_DESTROY ! 168: * ! 169: * Complement of WM_CREATE. send the track object the delete messages, ! 170: * then call PostQuitMessage. ! 171: \**********************************************************************/ ! 172: case WM_DESTROY: ! 173: DeleteObject(hPenGrid); ! 174: doTrackObject(ptoRect, TROB_DELETE, hwnd, lParam); ! 175: PostQuitMessage(0); ! 176: break; ! 177: ! 178: ! 179: ! 180: /**********************************************************************\ ! 181: * WM_SIZE ! 182: * ! 183: * Invalidate the whole window because we reset the origin on paint ! 184: * messages according to the size. Also, send the track object a ! 185: * message so that it will also change its HDC's viewport origin. ! 186: \**********************************************************************/ ! 187: case WM_SIZE: ! 188: InvalidateRect (hwnd, NULL, TRUE); ! 189: doTrackObject (ptoRect, TROB_CENTER, hwnd, lParam); ! 190: break; ! 191: ! 192: ! 193: ! 194: /**********************************************************************\ ! 195: * WM_PAINT ! 196: * ! 197: * First invalidate the whole window (forces the object to be painted ! 198: * fresh, and thus it won't XOR its old self out). Then draw the ! 199: * grid and finally draw the object. ! 200: \**********************************************************************/ ! 201: case WM_PAINT : { ! 202: PAINTSTRUCT ps; ! 203: HDC hdc; ! 204: RECT rect; ! 205: POINT point; ! 206: int i; ! 207: ! 208: InvalidateRect (hwnd, NULL, TRUE); ! 209: ! 210: hdc = BeginPaint(hwnd, &ps); ! 211: ! 212: CenterOrigin (hwnd, hdc); ! 213: GetClientRect (hwnd, &rect); ! 214: GetViewportOrgEx(hdc, &point); ! 215: OffsetRect(&rect, -point.x, -point.y ); ! 216: ! 217: ! 218: /* Draw vertical lines. Draw three at the origin. */ ! 219: SelectObject(hdc, hPenGrid); ! 220: for (i = 0; i<= rect.right; i+=TICKSPACE){ ! 221: MoveToEx (hdc, i, rect.top, NULL); ! 222: LineTo (hdc, i, rect.bottom); ! 223: MoveToEx (hdc, -i, rect.top, NULL); ! 224: LineTo (hdc, -i, rect.bottom); ! 225: } ! 226: MoveToEx (hdc, -1, rect.top, NULL); ! 227: LineTo (hdc, -1, rect.bottom); ! 228: MoveToEx (hdc, 1, rect.top, NULL); ! 229: LineTo (hdc, 1, rect.bottom); ! 230: ! 231: ! 232: /* Draw horizontal lines. Draw three at the origin. */ ! 233: for (i = 0; i<= rect.bottom; i+=TICKSPACE){ ! 234: MoveToEx (hdc, rect.left, i, NULL); ! 235: LineTo (hdc, rect.right, i); ! 236: MoveToEx (hdc, rect.left, -i, NULL); ! 237: LineTo (hdc, rect.right, -i); ! 238: } ! 239: MoveToEx (hdc, rect.left, -1, NULL); ! 240: LineTo (hdc, rect.right, -1); ! 241: MoveToEx (hdc, rect.left, 1, NULL); ! 242: LineTo (hdc, rect.right, 1); ! 243: ! 244: doTrackObject(ptoRect, TROB_PAINT, hwnd, lParam); ! 245: ! 246: EndPaint (hwnd, &ps); ! 247: } break; ! 248: ! 249: ! 250: ! 251: /**********************************************************************\ ! 252: * WM_LBUTTONDOWN & WM_RBUTTONDOWN ! 253: * On button down messages, hittest on the track object, and if ! 254: * it returns true, then send these messages to the track object. ! 255: \**********************************************************************/ ! 256: case WM_RBUTTONDOWN: ! 257: case WM_LBUTTONDOWN: ! 258: if (doTrackObject(ptoRect, TROB_HITTEST, hwnd, lParam)) ! 259: doTrackObject(ptoRect, message, hwnd, lParam); ! 260: break; ! 261: ! 262: ! 263: ! 264: /**********************************************************************\ ! 265: * WM_LBUTTONUP & WM_RBUTTONDOWN & MW_MOUSEMOVE ! 266: * If the track object is in a "tracking mode" then send it these messages. ! 267: * If the transform dialog is not minimized, fill it with numbers. ! 268: * If the mouse dialog is not minimized, fill it with numbers. ! 269: \**********************************************************************/ ! 270: case WM_RBUTTONUP: ! 271: case WM_LBUTTONUP: ! 272: case WM_MOUSEMOVE: ! 273: if (ptoRect->Mode) { ! 274: doTrackObject(ptoRect, message, hwnd, lParam); ! 275: if (showTransform) ! 276: SendMessage (hwndTransform, WM_PUTUPFLOATS, 0, ! 277: (LONG) &ptoRect->xfmChange); ! 278: } ! 279: ! 280: if (showMouse) ! 281: SendMessage (hwndMouse, WM_PUTUPFLOATS, (DWORD) hwnd, lParam); ! 282: ! 283: break; ! 284: ! 285: ! 286: default: ! 287: return (DefWindowProc(hwnd, message, wParam, lParam)); ! 288: } ! 289: return (NULL); ! 290: } ! 291: ! 292: ! 293: ! 294: ! 295: ! 296: ! 297: /**************************************************************************\ ! 298: * ! 299: * function: TransformDlgProc() ! 300: * ! 301: * input parameters: normal window procedure parameters. ! 302: * ! 303: * global variables: ! 304: * showTransform - TRUE if window is restored, FALSE if minimized. ! 305: * maintain the value in this routine for other windows' use. ! 306: * ptoRect - pointer to the track object. ! 307: * showMouse, hwndMain. ! 308: * ! 309: * nonstandard messages: ! 310: * WM_PUTUPFLOATS - fill the entry fields with the contents of an XFORM. ! 311: \**************************************************************************/ ! 312: LRESULT TransformDlgProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) ! 313: { ! 314: XFORM xform; ! 315: char buffer[MAXCHARS]; ! 316: ! 317: ! 318: switch (message) { ! 319: ! 320: ! 321: /**********************************************************************\ ! 322: * WM_INITDIALOG ! 323: * ! 324: * Fill the entry fields with sensible original values. ! 325: \**********************************************************************/ ! 326: case WM_INITDIALOG: ! 327: SetDlgItemText(hwnd, IDD_13, "0"); ! 328: SetDlgItemText(hwnd, IDD_23, "0"); ! 329: SetDlgItemText(hwnd, IDD_33, "1"); ! 330: return TRUE; ! 331: ! 332: ! 333: /******************************************************************\ ! 334: * WM_PUTUPFLOATS ! 335: * ! 336: * lParam - pointer to an XFORM structure. ! 337: * fill the entry fields with the XFORM values. ! 338: \******************************************************************/ ! 339: case WM_PUTUPFLOATS: { ! 340: PXFORM pxform; ! 341: pxform = (PXFORM) lParam; ! 342: ! 343: sprintf (buffer, FORMATFLOAT,pxform->eM11); ! 344: SetDlgItemText(hwnd, IDD_EM11, buffer); ! 345: sprintf (buffer, FORMATFLOAT,pxform->eM12); ! 346: SetDlgItemText(hwnd, IDD_EM12, buffer); ! 347: sprintf (buffer, FORMATFLOAT,pxform->eDx); ! 348: SetDlgItemText(hwnd, IDD_EDX, buffer); ! 349: ! 350: sprintf (buffer, FORMATFLOAT,pxform->eM21); ! 351: SetDlgItemText(hwnd, IDD_EM21, buffer); ! 352: sprintf (buffer, FORMATFLOAT,pxform->eM22); ! 353: SetDlgItemText(hwnd, IDD_EM22, buffer); ! 354: sprintf (buffer, FORMATFLOAT,pxform->eDy); ! 355: SetDlgItemText(hwnd, IDD_EDY, buffer); ! 356: ! 357: } return FALSE; ! 358: ! 359: ! 360: ! 361: /******************************************************************\ ! 362: * WM_SIZE ! 363: * ! 364: * toggle the global variable keeping track of the iconized state ! 365: * of this window. ! 366: \******************************************************************/ ! 367: case WM_SIZE : ! 368: if (wParam == SIZEICONIC) ! 369: showTransform = FALSE; ! 370: else { ! 371: showTransform = TRUE; ! 372: SendMessage (hwnd, WM_PUTUPFLOATS, 0, (LONG) &ptoRect->xfmChange); ! 373: } ! 374: return FALSE; ! 375: ! 376: ! 377: case WM_COMMAND: ! 378: /******************************************************************\ ! 379: * WM_COMMAND, IDD_SETXFORM ! 380: * ! 381: * take the values from the entry field, fill them into an XFORM ! 382: * structure and then send the track object the message to use ! 383: * these values. Finally, reformat and repaint the entry fields. ! 384: \******************************************************************/ ! 385: if (LOWORD(wParam) == IDD_SETXFORM) { ! 386: GetDlgItemText(hwnd, IDD_EM11, buffer, MAXCHARS); ! 387: xform.eM11 = (float) atof (buffer); ! 388: GetDlgItemText(hwnd, IDD_EM12, buffer, MAXCHARS); ! 389: xform.eM12 = (float) atof (buffer); ! 390: GetDlgItemText(hwnd, IDD_EDX, buffer, MAXCHARS); ! 391: xform.eDx = (float) atof (buffer); ! 392: ! 393: GetDlgItemText(hwnd, IDD_EM21, buffer, MAXCHARS); ! 394: xform.eM21 = (float) atof (buffer); ! 395: GetDlgItemText(hwnd, IDD_EM22, buffer, MAXCHARS); ! 396: xform.eM22 = (float) atof (buffer); ! 397: GetDlgItemText(hwnd, IDD_EDY, buffer, MAXCHARS); ! 398: xform.eDy = (float) atof (buffer); ! 399: ! 400: // HACK. The WM_SIZE here is used to flush the GDI buffer in order ! 401: // to eliminate a very strange bug whereby DPtoLP() doesn't work. ! 402: if (showMouse) SendMessage (hwndMain, WM_SIZE, NULL, NULL); ! 403: ! 404: ! 405: doTrackObject (ptoRect, TROB_SETXFORM, hwnd, (LONG) &xform); ! 406: SendMessage (hwnd, WM_PUTUPFLOATS, 0, (LONG) &xform); ! 407: ! 408: ! 409: /******************************************************************\ ! 410: * WM_COMMAND, IDD_IDENTITY ! 411: * ! 412: * fill a local XFORM structure with the identity matrix. Now ! 413: * send the track object the message to use these values. ! 414: * Finally, reformat and repaint the entry fields. ! 415: \******************************************************************/ ! 416: } else if (LOWORD(wParam) == IDD_IDENTITY) { ! 417: xform.eM11 = ! 418: xform.eM22 = (float) 1.0; ! 419: xform.eDx = ! 420: xform.eDy = ! 421: xform.eM12 = ! 422: xform.eM21 = (float) 0.0; ! 423: ! 424: // HACK. The WM_SIZE here is used to flush the GDI buffer in order ! 425: // to eliminate a very strange bug whereby DPtoLP() doesn't work. ! 426: if (showMouse) SendMessage (hwndMain, WM_SIZE, NULL, NULL); ! 427: ! 428: doTrackObject (ptoRect, TROB_SETXFORM, hwnd, (LONG) &xform); ! 429: SendMessage (hwnd, WM_PUTUPFLOATS, 0, (LONG) &xform); ! 430: } /* end WM_COMMAND */ ! 431: return FALSE; ! 432: ! 433: ! 434: } /* end switch */ ! 435: return FALSE; ! 436: } ! 437: ! 438: ! 439: ! 440: ! 441: ! 442: /**************************************************************************\ ! 443: * ! 444: * function: MouseDlgProc() ! 445: * ! 446: * input parameters: normal window procedure parameters. ! 447: * ! 448: * global variables: ! 449: * showMouse -- TRUE if window is restored, FALSE if minimized. ! 450: * maintain the value in this routine for other windows' use. ! 451: * ptoRect - pointer to the track object. Needed for DPtoLP() ! 452: * ! 453: * nonstandard messages: ! 454: * WM_PUTUPFLOATS - fill the entry fields with the mouse position. ! 455: * ! 456: \**************************************************************************/ ! 457: LRESULT MouseDlgProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) ! 458: { ! 459: char buffer[MAXCHARS]; ! 460: ! 461: switch (message) { ! 462: ! 463: /******************************************************************\ ! 464: * WM_PUTUPFLOATS ! 465: * ! 466: * wParam - contains the hwnd for the main window. ! 467: * lParam - contains the mouse position in device coordinates. ! 468: * (c.f. WM_MOUSEMOVE) ! 469: \******************************************************************/ ! 470: case WM_PUTUPFLOATS: { ! 471: POINT pScreen, pWorld; ! 472: HWND hwndMain; ! 473: ! 474: hwndMain = (HWND) wParam; ! 475: pScreen.x = pWorld.x = LOWORD(lParam); ! 476: pScreen.y = pWorld.y = HIWORD(lParam); ! 477: ! 478: sprintf (buffer, "%d", pScreen.x); ! 479: SetDlgItemText(hwnd, IDD_DEVICEX, buffer); ! 480: sprintf (buffer, "%d", pScreen.y); ! 481: SetDlgItemText(hwnd, IDD_DEVICEY, buffer); ! 482: ! 483: ClientToScreen (hwndMain, &pScreen); ! 484: sprintf (buffer, "%d", pScreen.x); ! 485: SetDlgItemText(hwnd, IDD_SCREENX, buffer); ! 486: sprintf (buffer, "%d", pScreen.y); ! 487: SetDlgItemText(hwnd, IDD_SCREENY, buffer); ! 488: ! 489: DPtoLP (ptoRect->hdc, &pWorld, 1); ! 490: sprintf (buffer, FORMATFLOAT, (float) pWorld.x); ! 491: SetDlgItemText(hwnd, IDD_WORLDX , buffer); ! 492: sprintf (buffer, FORMATFLOAT, (float) pWorld.y); ! 493: SetDlgItemText(hwnd, IDD_WORLDY , buffer); ! 494: ! 495: } return FALSE; ! 496: ! 497: ! 498: ! 499: /******************************************************************\ ! 500: * WM_SIZE ! 501: * ! 502: * toggle the global variable keeping track of the iconized state ! 503: * of this window. ! 504: \******************************************************************/ ! 505: case WM_SIZE : ! 506: if (wParam == SIZEICONIC) ! 507: showMouse = FALSE; ! 508: else ! 509: showMouse = TRUE; ! 510: return FALSE; ! 511: ! 512: } ! 513: return FALSE; ! 514: } ! 515: ! 516: ! 517: ! 518: ! 519: ! 520: ! 521: /**************************************************************************\ ! 522: * function: CenterOrigin() ! 523: * ! 524: * input parameters: ! 525: * hwnd - window with client we want the center of. ! 526: * hdc - device context which we set the Viewport origin of. ! 527: * ! 528: \**************************************************************************/ ! 529: VOID CenterOrigin (HWND hwnd, HDC hdc) ! 530: { ! 531: RECT rect; ! 532: POINT center; ! 533: ! 534: GetClientRect (hwnd, &rect); ! 535: center.x = rect.right / 2; ! 536: center.y = rect.bottom /2; ! 537: ! 538: SetViewportOrgEx (hdc, center.x, center.y, NULL); ! 539: return; ! 540: } ! 541: ! 542: ! 543: ! 544: ! 545: ! 546: ! 547: /**************************************************************************\ ! 548: * ! 549: * function: doTrackObject() ! 550: * ! 551: * input parameters: ! 552: * pto - pointer to a track object. ! 553: * msg - message selecting what action to take. Values may include WM_*'s ! 554: * (see case statements below for more information.) ! 555: * hwnd - Window handle for the window the track object exists within. ! 556: * lParam - Usually fourth param to window proc. varies based on msg. ! 557: * ! 558: * global variables: none. ! 559: * ! 560: * coordinate spaces: There are three coordinate spaces of interest here, ! 561: * and this routine is frequently switching between them... ! 562: * ! 563: * WORLD DEVICE SCREEN ! 564: * ! 565: * object coordinates input mouse pos used w/ SetCursorPos() ! 566: * (pto->rect) (lParam for WM_*) ! 567: * ! 568: * -----> LPtoDP() ----> ----> ClientToScreen() --> ! 569: * <----- DPtoLP() <---- <---- ScreenToClient() <-- ! 570: * ! 571: * in addition, the HDC has an offset origin. Device coordinates for the ! 572: * mouse (lParam) never take this into account, but it is necessary to ! 573: * translate them in order to get direct manipulation right. ! 574: * ! 575: \**************************************************************************/ ! 576: PTrackObject doTrackObject(PTrackObject pto, int msg, HWND hwnd, LONG lParam) ! 577: { ! 578: if ((pto == NULL) && (msg != TROB_NEW)) return NULL; ! 579: ! 580: switch (msg) { ! 581: ! 582: ! 583: /**********************************************************************\ ! 584: * TROB_NEW ! 585: * ! 586: * Allocate new PTrackObject structure. Fill in default values ! 587: * for the fields of the structure. Set up the HDC correctly. ! 588: * return - pointer to the new object. ! 589: \**********************************************************************/ ! 590: case TROB_NEW: { ! 591: PTrackObject pto; ! 592: ! 593: /* with LPTR returned value is a pointer. */ ! 594: pto = (PTrackObject) LocalAlloc (LPTR, sizeof (TrackObject)); ! 595: ! 596: /* initialize the HDC and other fields. */ ! 597: pto->hdc = GetDC(hwnd); ! 598: SetROP2(pto->hdc, R2_NOT); ! 599: SelectObject (pto->hdc, GetStockObject (NULL_BRUSH)); ! 600: SelectObject(pto->hdc, CreatePen (PS_SOLID, 2, (COLORREF) 0x01000009)); ! 601: pto->Mode = TMNONE; ! 602: doTrackObject (pto, TROB_CENTER, hwnd, lParam); ! 603: GetWorldTransform (pto->hdc, &(pto->xfmChange)); ! 604: ! 605: /* initialize the size. */ ! 606: pto->rect.top = pto->rect.left = 0; ! 607: pto->rect.bottom = pto->rect.right = TICKSPACE*5; ! 608: ! 609: return (pto); ! 610: } ! 611: ! 612: ! 613: /**********************************************************************\ ! 614: * TROB_DELETE ! 615: * ! 616: * Delete the pen that we created, release the DC, ! 617: * free up the memory allocated for the object. ! 618: \**********************************************************************/ ! 619: case TROB_DELETE: ! 620: DeleteObject (SelectObject (pto->hdc, GetStockObject (BLACK_PEN))); ! 621: doTrackObject (pto, TROB_PAINT, hwnd, lParam); ! 622: ReleaseDC (hwnd, pto->hdc); ! 623: LocalFree (LocalHandle ((LPSTR)pto)); ! 624: return NULL; ! 625: ! 626: ! 627: ! 628: /**********************************************************************\ ! 629: * TROB_CENTER ! 630: * ! 631: * Called in order to reset the view port origin in the track objects ! 632: * hdc whenever the client window changes size. This hdc is thus kept ! 633: * synchronized with the hdc that the axes are painted into. ! 634: \**********************************************************************/ ! 635: case TROB_CENTER: { ! 636: CenterOrigin (hwnd, pto->hdc); ! 637: return (pto); ! 638: } ! 639: ! 640: ! 641: ! 642: /**********************************************************************\ ! 643: * TROB_PAINT ! 644: * ! 645: * Paint the object into its hdc. Called half the time to erase ! 646: * the object, and half the time to redraw it. ! 647: \**********************************************************************/ ! 648: case TROB_PAINT: { ! 649: Rectangle (pto->hdc, pto->rect.left+1, pto->rect.top+1, ! 650: pto->rect.left+INC, pto->rect.top+INC); ! 651: ! 652: Rectangle (pto->hdc, pto->rect.left, pto->rect.top, ! 653: pto->rect.right, pto->rect.bottom); ! 654: } return NULL; ! 655: ! 656: ! 657: ! 658: /**********************************************************************\ ! 659: * TROB_SETXFORM ! 660: * ! 661: * lParam - pointer to the new transform. ! 662: * set the new transform into the HDC, then update xfmChange. ! 663: \**********************************************************************/ ! 664: case TROB_SETXFORM: { ! 665: doTrackObject (pto, TROB_PAINT, hwnd, lParam); ! 666: SetWorldTransform(pto->hdc, (PXFORM) lParam); ! 667: GetWorldTransform(pto->hdc, &pto->xfmChange); ! 668: doTrackObject (pto, TROB_PAINT, hwnd, lParam); ! 669: } return NULL; ! 670: ! 671: ! 672: ! 673: /**********************************************************************\ ! 674: * TROB_HITTEST ! 675: * ! 676: * Check the point sent in in the lParam to see if it lays within ! 677: * the bounds of the objects defining rectangle. ! 678: * return - pointer to the object iff the point is in rectangle, ! 679: * otherwise return NULL. ! 680: \**********************************************************************/ ! 681: case TROB_HITTEST:{ ! 682: POINT mouWorld; ! 683: mouWorld.x = LOWORD(lParam); ! 684: mouWorld.y = HIWORD(lParam); ! 685: ! 686: DPtoLP (pto->hdc, &mouWorld, 1); ! 687: ! 688: if (PtInRect (&pto->rect, mouWorld)) return pto; ! 689: else return NULL; ! 690: } ! 691: ! 692: ! 693: ! 694: /**********************************************************************\ ! 695: * WM_LBUTTONDOWN & WM_RBUTTONDOWN ! 696: * ! 697: * Capture the mouse, set the tracking mode depending on the mouse ! 698: * location in world coordinates, reset the mouse position. ! 699: * ! 700: \**********************************************************************/ ! 701: case WM_LBUTTONDOWN: ! 702: case WM_RBUTTONDOWN: { ! 703: POINT newmouScreen; ! 704: POINT mouWorld; ! 705: ! 706: mouWorld.x = LOWORD(lParam); ! 707: mouWorld.y = HIWORD(lParam); ! 708: DPtoLP (pto->hdc, &mouWorld, 1); ! 709: ! 710: /* upper left hand corner. right button is no-op. */ ! 711: if ((mouWorld.x <= (pto->rect.right / 2)) && ! 712: (mouWorld.y <= (pto->rect.bottom / 2))) { ! 713: if (msg == WM_RBUTTONDOWN) return NULL; ! 714: pto->Mode = TMMOVE; ! 715: newmouScreen.x = pto->rect.left; ! 716: newmouScreen.y = pto->rect.top; ! 717: ! 718: /* lower left hand corner */ ! 719: } else if ((mouWorld.x <= (pto->rect.right / 2)) && ! 720: (mouWorld.y > (pto->rect.bottom / 2))) { ! 721: ! 722: pto->Mode = (msg == WM_RBUTTONDOWN) ? TMSHEARY : TMSIZEY; ! 723: newmouScreen.x = pto->rect.left; ! 724: newmouScreen.y = pto->rect.bottom; ! 725: ! 726: /* upper right hand corner */ ! 727: } else if ((mouWorld.x > (pto->rect.right / 2)) && ! 728: (mouWorld.y <= (pto->rect.bottom / 2))) { ! 729: ! 730: pto->Mode = (msg == WM_RBUTTONDOWN) ? TMSHEARX : TMSIZEX; ! 731: newmouScreen.x = pto->rect.right; ! 732: newmouScreen.y = pto->rect.top; ! 733: ! 734: /* lower right hand corner */ ! 735: } else if ((mouWorld.x > (pto->rect.right / 2)) && ! 736: (mouWorld.y > (pto->rect.bottom / 2))) { ! 737: ! 738: pto->Mode = (msg == WM_RBUTTONDOWN) ? TMROTATE : TMSIZEXY; ! 739: newmouScreen.x = pto->rect.right; ! 740: newmouScreen.y = pto->rect.bottom; ! 741: } ! 742: ! 743: SetCapture(hwnd); ! 744: LPtoDP (pto->hdc, &newmouScreen, 1); ! 745: ClientToScreen (hwnd, &newmouScreen); ! 746: SetCursorPos (newmouScreen.x,newmouScreen.y); ! 747: ! 748: GetWorldTransform (pto->hdc, &pto->xfmDown); ! 749: } return NULL; ! 750: ! 751: ! 752: ! 753: /**********************************************************************\ ! 754: * WM_MOUSEMOVE ! 755: * ! 756: * this is where almost all of the interesting calculation is done. ! 757: * First clip the mouse location to be in client rectangle, then ! 758: * call MouseMove() to handle the different tracking modes. ! 759: \**********************************************************************/ ! 760: case WM_MOUSEMOVE: { ! 761: RECT rect; ! 762: GetClientRect (hwnd, &rect); ! 763: ! 764: if ((short) LOWORD(lParam) < (short)rect.left) ! 765: lParam = MAKELONG ((WORD)rect.left, HIWORD(lParam)); ! 766: ! 767: if (LOWORD(lParam) > (WORD)rect.right) ! 768: lParam = MAKELONG ((WORD)rect.right, HIWORD(lParam)); ! 769: ! 770: if ((short) HIWORD(lParam) < (short)rect.top) ! 771: lParam = MAKELONG (LOWORD(lParam), (WORD)rect.top); ! 772: ! 773: if (HIWORD(lParam) > (WORD)rect.bottom) ! 774: lParam = MAKELONG (LOWORD(lParam),(WORD)rect.bottom); ! 775: ! 776: MouseMove (pto, msg, hwnd, lParam); ! 777: ! 778: } return NULL; ! 779: ! 780: ! 781: ! 782: /**********************************************************************\ ! 783: * WM_RBUTTONUP & WM_LBUTTONUP ! 784: * ! 785: * simply release the mouse capture, and set the mode to TMNONE. ! 786: \**********************************************************************/ ! 787: case WM_RBUTTONUP: ! 788: case WM_LBUTTONUP: { ! 789: if (pto->Mode) { ! 790: ReleaseCapture(); ! 791: pto->Mode = TMNONE; ! 792: } ! 793: } return NULL; ! 794: ! 795: } /* end switch(msg) */ ! 796: } ! 797: ! 798: ! 799: ! 800: ! 801: ! 802: ! 803: /**************************************************************************\ ! 804: * function: MouseMove() ! 805: * ! 806: * input parameters: ! 807: * pto - pointer to a track object. ! 808: * msg - not used. ! 809: * hwnd - Window handle for the window the track object exists within. ! 810: * lParam - Usually fourth param to window proc. varies based on msg. ! 811: * ! 812: * The tracking behavior which the user observers when moving the mouse ! 813: * is based on the current tracking mode of the object. This is usually ! 814: * determined on the mouse down event (c.f. TM*). First erase the old ! 815: * object, then figure out the change to the transform matrix, finally ! 816: * change the world transform matrix and redraw the object. ! 817: * ! 818: * Tranform: ! 819: * ( eM11 eM12 0 ) ! 820: * ( eM21 eM22 0 ) ! 821: * ( eDx eDy 1 ) ! 822: * ! 823: * xDevice = (xWorld * eM11) + (yWorld * eM21) + eDx ! 824: * yDevice = (xWorld * eM12) + (yWorld * eM22) + eDy ! 825: * ! 826: * In this routine the Device (mouse location) and World (rectangle corner) ! 827: * points are known. Therefore, the two equations above are solved for ! 828: * the desired matrix entry value (e.g. eM11, 1M12, ... eDy). The tracking ! 829: * mode determines which one of these entries may be changed. E.g. scaling ! 830: * in X modifies eM11 while shearing in X modifies eM12. So rather than ! 831: * using the world transform to map from world to device points, we are ! 832: * back-computing the proper contents of the world transform. ! 833: * ! 834: \**************************************************************************/ ! 835: VOID MouseMove(PTrackObject pto, int msg, HWND hwnd, LONG lParam) ! 836: { ! 837: POINT mouWorld, mouDevice, orgDevice; ! 838: ! 839: UNREFERENCED_PARAMETER(msg); ! 840: ! 841: doTrackObject(pto, TROB_PAINT, hwnd, lParam); ! 842: mouDevice.x = mouWorld.x = LOWORD(lParam); ! 843: mouDevice.y = mouWorld.y = HIWORD(lParam); ! 844: ! 845: SetWorldTransform(pto->hdc, &pto->xfmDown); ! 846: DPtoLP (pto->hdc, &mouWorld, 1); ! 847: ! 848: /* offset the mouse device point for the viewport's origin. */ ! 849: GetViewportOrgEx (pto->hdc, &orgDevice); ! 850: mouDevice.x -= orgDevice.x; ! 851: mouDevice.y -= orgDevice.y; ! 852: ! 853: GetWorldTransform(pto->hdc, &pto->xfmChange); ! 854: ! 855: switch (pto->Mode) { ! 856: /*******************************************************\ ! 857: * ( 1 xShear 0 ) ! 858: * ( 0 1 0 ) ! 859: * ( 0 0 1 ) ! 860: * ! 861: * xWorld = rect.left == 0; ! 862: \*******************************************************/ ! 863: case TMSHEARX: { ! 864: pto->xfmChange.eM12 = (float) mouDevice.y; ! 865: pto->xfmChange.eM12 -=pto->xfmChange.eDy; ! 866: pto->xfmChange.eM12 /=(float) pto->rect.right ; ! 867: SetWorldTransform (pto->hdc, &pto->xfmChange); ! 868: } break; ! 869: ! 870: ! 871: /*******************************************************\ ! 872: * ( 1 0 0 ) ! 873: * ( yShear 1 0 ) ! 874: * ( 0 0 1 ) ! 875: * ! 876: * yWorld = rect.top == 0; ! 877: \*******************************************************/ ! 878: case TMSHEARY: { ! 879: pto->xfmChange.eM21 = (float) mouDevice.x; ! 880: pto->xfmChange.eM21 -=pto->xfmChange.eDx; ! 881: pto->xfmChange.eM21 /=(float) pto->rect.bottom ; ! 882: SetWorldTransform (pto->hdc, &pto->xfmChange); ! 883: ! 884: } break; ! 885: ! 886: ! 887: /*******************************************************\ ! 888: * ( cos(a) -sin(a) 0 ) ! 889: * ( sin(a) cos(a) 0 ) ! 890: * ( 0 0 1 ) ! 891: * ! 892: * a == rotation angle. Since mouse in in lower right, ! 893: * we need to shift this back 45 degrees (assuming that ! 894: * straight down is 0 degrees). Thus we actually compute ! 895: * cos(a) = cos(b - 45) = cos(b)sin(45) + cos(45)sin(45) ! 896: * where b is angle from the origin to the mouse (x,y) ! 897: * cos(45) = sin(45) ~= 0.707107 ! 898: * cos(b) = y/r sin(b) = x/r ! 899: * ! 900: \*******************************************************/ ! 901: case TMROTATE: { ! 902: float r; ! 903: ! 904: /* translate back to the origin. */ ! 905: pto->xfmChange.eDx = pto->xfmChange.eDy = (float)0.0; ! 906: SetWorldTransform (pto->hdc, &pto->xfmChange); ! 907: ! 908: /* rotate about the origin. */ ! 909: r = (float) sqrt( (double)(mouWorld.x * mouWorld.x) + ! 910: (double)(mouWorld.y * mouWorld.y)); ! 911: ! 912: pto->xfmChange.eM11 = (float) mouWorld.y / r; ! 913: pto->xfmChange.eM11 += (float) mouWorld.x / r; ! 914: pto->xfmChange.eM11 *= (float) 0.707107; ! 915: pto->xfmChange.eM22 = pto->xfmChange.eM11; ! 916: ! 917: pto->xfmChange.eM12 = (float) mouWorld.y / r; ! 918: pto->xfmChange.eM12 -= (float) mouWorld.x / r; ! 919: pto->xfmChange.eM12 *= (float) 0.707107; ! 920: pto->xfmChange.eM21 = -pto->xfmChange.eM12; ! 921: ! 922: pto->xfmChange.eDx = pto->xfmChange.eDy = (float)0.0; ! 923: ! 924: ModifyWorldTransform (pto->hdc, &pto->xfmChange, MWT_RIGHTMULTIPLY); ! 925: ! 926: /* translate back to the original offset. */ ! 927: pto->xfmChange.eM11 = ! 928: pto->xfmChange.eM22 = (float) 1.0; ! 929: pto->xfmChange.eM12 = ! 930: pto->xfmChange.eM21 = (float) 0.0; ! 931: ! 932: pto->xfmChange.eDx = pto->xfmDown.eDx; ! 933: pto->xfmChange.eDy = pto->xfmDown.eDy; ! 934: ModifyWorldTransform (pto->hdc, &pto->xfmChange, MWT_RIGHTMULTIPLY); ! 935: GetWorldTransform (pto->hdc, &pto->xfmChange); ! 936: } break; ! 937: ! 938: ! 939: /*******************************************************\ ! 940: * ( Size X 0 0 ) ! 941: * ( 0 Size Y 0 ) ! 942: * ( 0 0 1 ) ! 943: * ! 944: \*******************************************************/ ! 945: case TMSIZEXY: { ! 946: pto->xfmChange.eM11 = (float) mouDevice.x; ! 947: pto->xfmChange.eM11 -=pto->xfmChange.eDx; ! 948: pto->xfmChange.eM11 -=((float) pto->rect.bottom * pto->xfmChange.eM21); ! 949: pto->xfmChange.eM11 /=(float) pto->rect.right ; ! 950: ! 951: pto->xfmChange.eM22 = (float) mouDevice.y; ! 952: pto->xfmChange.eM22 -=pto->xfmChange.eDy; ! 953: pto->xfmChange.eM22 -=((float) pto->rect.right * pto->xfmChange.eM12); ! 954: pto->xfmChange.eM22 /=(float) pto->rect.bottom ; ! 955: SetWorldTransform (pto->hdc, &pto->xfmChange); ! 956: } break; ! 957: ! 958: ! 959: /*******************************************************\ ! 960: * ( Size X 0 0 ) ! 961: * ( 0 1 0 ) ! 962: * ( 0 0 1 ) ! 963: * ! 964: * yWorld = rect.top == 0; ! 965: \*******************************************************/ ! 966: case TMSIZEX: { ! 967: pto->xfmChange.eM11 = (float) mouDevice.x; ! 968: pto->xfmChange.eM11 -=pto->xfmChange.eDx; ! 969: pto->xfmChange.eM11 /=(float) pto->rect.right ; ! 970: SetWorldTransform (pto->hdc, &pto->xfmChange); ! 971: } break; ! 972: ! 973: ! 974: /*******************************************************\ ! 975: * ( 1 0 0 ) ! 976: * ( 0 Size Y 0 ) ! 977: * ( 0 0 1 ) ! 978: * ! 979: * xWorld = rect.left == 0; ! 980: \*******************************************************/ ! 981: case TMSIZEY: { ! 982: pto->xfmChange.eM22 = (float) mouDevice.y; ! 983: pto->xfmChange.eM22 -=pto->xfmChange.eDy; ! 984: pto->xfmChange.eM22 /=(float) pto->rect.bottom ; ! 985: SetWorldTransform (pto->hdc, &pto->xfmChange); ! 986: } break; ! 987: ! 988: ! 989: /*******************************************************\ ! 990: * ( 1 0 0 ) ! 991: * ( 0 1 0 ) ! 992: * ( Move x Move y 1 ) ! 993: * ! 994: * xWorld = rect.left == 0; ! 995: * yWorld = rect.top == 0; ! 996: \*******************************************************/ ! 997: case TMMOVE: { ! 998: pto->xfmChange.eDx = (float) mouDevice.x ; ! 999: pto->xfmChange.eDy = (float) mouDevice.y ; ! 1000: SetWorldTransform (pto->hdc, &pto->xfmChange); ! 1001: } break; ! 1002: } /* end switch */ ! 1003: ! 1004: doTrackObject(pto, TROB_PAINT, hwnd, lParam); ! 1005: ! 1006: return; ! 1007: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.