![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to drag.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / dlgedit|
Return to drag.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / dlgedit |
1.1 root 1:
2: /******************************************************************************\
3: * This is a part of the Microsoft Source Code Samples.
4: * Copyright (C) 1993 Microsoft Corporation.
5: * All rights reserved.
6: * This source code is only intended as a supplement to
7: * Microsoft Development Tools and/or WinHelp documentation.
8: * See these sources for detailed information regarding the
9: * Microsoft samples programs.
10: \******************************************************************************/
11:
12: /****************************** Module Header *******************************
13: * Module Name: drag.c
14: *
15: * Contains routines for dragging and sizing controls.
16: *
17: * Functions:
18: * ShowTrackRect()
19: * HideTrackRect()
20: * FitRectToBounds()
21: * GetOverHang()
22: * GridizeRect()
23: * SizeDragToControl()
24: * DragWndProc()
25: * DrawHandles()
26: * HandleHitTest()
27: * CtrlButtonDown()
28: * DragNewBegin()
29: * CtrlMouseMove()
30: * PreDragTimeout()
31: * DragCancel()
32: * CtrlButtonUp()
33: * DragEnd()
34: * CalcCursorOffset()
35: * InitTracking()
36: * DrawTrackRect()
37: * CancelTracking()
38: * AtOrAbove()
39: * AtOrBelow()
40: * PaintUnderDrag()
41: * MouseToDragRect()
42: * MouseToDU()
43: * DragBegin()
44: * CtrlHitTest()
45: * DragBegin2()
46: *
47: * Comments:
48: *
49: ****************************************************************************/
50:
51: #include "dlgedit.h"
52: #include "dlgfuncs.h"
53: #include "dlgextrn.h"
54:
55: #include <stdlib.h>
56:
57: STATICFN VOID CalcCursorOffset(POINT *ppt);
58: STATICFN VOID InitTracking(VOID);
59: STATICFN VOID DrawTrackRect(PRECT prc, BOOL fDialog, BOOL fDraw);
60: STATICFN VOID CancelTracking(VOID);
61: STATICFN INT AtOrAbove(INT nStart, INT nGrid);
62: STATICFN INT AtOrBelow(INT nStart, INT nGrid);
63: STATICFN VOID PaintUnderDrag(HWND hwndDrag);
64: STATICFN VOID MouseToDragRect(INT x, INT y, PRECT prc);
65: STATICFN VOID MouseToDU(PPOINT ppt);
66: STATICFN VOID DragBegin(HWND hwnd, INT x, INT y, BOOL fHandleWindow);
67: STATICFN HWND CtrlHitTest(HWND hwnd, PPOINT ppt);
68: STATICFN VOID DragBegin2(PPOINT ppt);
69:
70: /*
71: * This contains the initial location of the mouse when going into
72: * pre-drag mode. If the mouse pointer is moved too FAR away from
73: * this point, we will start the drag operation, even if the pre-drag
74: * timer has not elapsed yet.
75: */
76: static POINT gptPreDragStart;
77:
78:
79:
80: /************************************************************************
81: * CalcCursorOffset
82: *
83: * This routine updates the gptCursorOffset point. This is used during
84: * dragging operations. It contains the offset from the mouse pointer
85: * at the time a dragging operation is begun and the upper left corner
86: * of the dragging rectangle. This value is needed for determining
87: * where mouse events are occuring in relation to where the drag was
88: * initially begun from.
89: *
90: * Arguments:
91: * POINT - offset where the mouse pointer began drag.
92: *
93: ************************************************************************/
94:
95: STATICFN VOID CalcCursorOffset(
96: POINT *ppt)
97: {
98: RECT rc;
99: POINT pt;
100:
101: if (gfDlgSelected) {
102: gptCursorOffset = *ppt;
103: }
104: else {
105: rc = grcSelected;
106: pt = *ppt;
107: DUToWinRect(&rc);
108:
109: ClientToScreen(gnpcSel->hwnd, &pt);
110: ScreenToClient(gcd.npc->hwnd, &pt);
111:
112: gptCursorOffset.x = pt.x - rc.left;
113: gptCursorOffset.y = pt.y - rc.top;
114: }
115: }
116:
117:
118:
119: /************************************************************************
120: * InitTracking
121: *
122: * This function initializes a tracking operation. The pointer is
123: * changed to be the system "move" pointer if we are moving the
124: * control (not sizing it).
125: *
126: ************************************************************************/
127:
128: STATICFN VOID InitTracking(VOID)
129: {
130: if (gfDlgSelected)
131: ghDCTrack = CreateDC(L"DISPLAY", NULL, NULL, NULL);
132: else
133: ghDCTrack = GetDC(gcd.npc->hwnd);
134:
135: SetROP2(ghDCTrack, R2_NOT);
136: }
137:
138:
139:
140: /************************************************************************
141: * DrawTrackRect
142: *
143: * This routine draws the drag rectangle. It is assumed that the window
144: * has been locked for update appropriately or this could leave garbage
145: * around. The rectangle given is in dialog units, and is converted
146: * to window coordinates using different rules based on the value of
147: * fDialog. After this routine has been called to set the rectangle,
148: * the HideTrackRect and ShowTrackRect functions can be called to
149: * temporarily hide the track rectangle, but this routine must be called
150: * again every time that the tracking rectangle is to be changed.
151: *
152: * Arguments:
153: * PRECT prc - Drag rectangle to draw (in dialog units).
154: * BOOL fDialog - TRUE if the control being dragged is the dialog.
155: * BOOL fDraw - If TRUE, the rectangle will be drawn. Having this
156: * FALSE is useful to just initialize the state globals,
157: * but defer the drawing of the rectangle until the mouse
158: * is moved from its starting point.
159: *
160: ************************************************************************/
161:
162: STATICFN VOID DrawTrackRect(
163: PRECT prc,
164: BOOL fDialog,
165: BOOL fDraw)
166: {
167: HideTrackRect();
168:
169: grcTrackWin = grcTrackDU = *prc;
170: DUToWinRect(&grcTrackWin);
171:
172: if (fDialog) {
173: AdjustWindowRectEx(&grcTrackWin, gcd.npc->flStyle, FALSE,
174: (gcd.npc->flStyle & DS_MODALFRAME) ?
175: gcd.npc->flExtStyle | WS_EX_DLGMODALFRAME :
176: gcd.npc->flExtStyle);
177: ClientToScreenRect(ghwndSubClient, &grcTrackWin);
178: }
179:
180: if (fDraw)
181: ShowTrackRect();
182: }
183:
184:
185:
186: /************************************************************************
187: * ShowTrackRect
188: *
189: * This routine shows the current tracking rectangle.
190: *
191: ************************************************************************/
192:
193: VOID ShowTrackRect(VOID)
194: {
195: if (!gfTrackRectShown) {
196: MyFrameRect(ghDCTrack, &grcTrackWin, DSTINVERT);
197: gfTrackRectShown = TRUE;
198: }
199: }
200:
201:
202:
203: /************************************************************************
204: * HideTrackRect
205: *
206: * This routine hides the current tracking rectangle.
207: *
208: ************************************************************************/
209:
210: VOID HideTrackRect(VOID)
211: {
212: if (gfTrackRectShown) {
213: MyFrameRect(ghDCTrack, &grcTrackWin, DSTINVERT);
214: gfTrackRectShown = FALSE;
215: }
216: }
217:
218:
219:
220: /************************************************************************
221: * CancelTracking
222: *
223: * This routine is used to cancel the display of the tracking rectangle.
224: * It is basically the opposite of InitTracking.
225: *
226: ************************************************************************/
227:
228: STATICFN VOID CancelTracking(VOID)
229: {
230: if (gfTrackRectShown) {
231: HideTrackRect();
232:
233: if (gfDlgSelected)
234: DeleteDC(ghDCTrack);
235: else
236: ReleaseDC(gcd.npc->hwnd, ghDCTrack);
237: }
238: }
239:
240:
241:
242: /************************************************************************
243: * FitRectToBounds
244: *
245: * This routine fits the given rectangle to the appropriate boundary.
246: * If fDialog is FALSE, the rectangle is a control and it must fall
247: * entirely within the area of the current dialog being edited. If the
248: * rectangle is adjusted to fit, the moved edge(s) will be aligned on
249: * a grid boundary. The wHandleHit parameter is used to tell this routine
250: * what edges are allowed to move, in other words, what edges are
251: * "anchored" down and what edges are being tracked.
252: *
253: * Arguments:
254: * PRECT prc - Rectangle to be adjusted to the allowed size.
255: * INT nOverHang - How much the control can hang below the dialog.
256: * This is primarily for the combobox listboxes.
257: * INT HandleHit - One of the DRAG_* constants.
258: * BOOL fDialog - TRUE if the rectangle is for a dialog.
259: *
260: ************************************************************************/
261:
262: VOID FitRectToBounds(
263: PRECT prc,
264: INT nOverHang,
265: INT HandleHit,
266: BOOL fDialog)
267: {
268: INT cxDlg;
269: INT cyDlg;
270: INT dx;
271: INT dy;
272:
273: /*
274: * Are we just moving the control (not sizing)?
275: */
276: if (HandleHit == DRAG_CENTER) {
277: /*
278: * We only do range checking if it is a control (not on the dialog).
279: */
280: if (!fDialog) {
281: dx = prc->right - prc->left;
282: dy = prc->bottom - prc->top;
283: cxDlg = gcd.npc->rc.right - gcd.npc->rc.left;
284: cyDlg = gcd.npc->rc.bottom - gcd.npc->rc.top + nOverHang;
285:
286: if (prc->right > cxDlg) {
287: prc->left = AtOrBelow(cxDlg - dx, gcxGrid);
288: prc->right = prc->left + dx;
289: }
290:
291: if (prc->left < 0) {
292: prc->left = 0;
293: prc->right = prc->left + dx;
294: }
295:
296: if (prc->bottom > cyDlg) {
297: prc->top = AtOrBelow(cyDlg - dy, gcyGrid);
298: prc->bottom = prc->top + dy;
299: }
300:
301: if (prc->top < 0) {
302: prc->top = 0;
303: prc->bottom = prc->top + dy;
304: }
305: }
306:
307: return;
308: }
309:
310: if (fDialog) {
311: /*
312: * When dealing with the dialog, we want to take into account
313: * the controls so that the dialog is never sized to hide a
314: * control. This routine assumes that grcMinDialog has already
315: * been set to enclose the controls. If the dialog has no
316: * controls, this rectangle is not used, but the dialog's size
317: * is still limited so that it never goes negative.
318: */
319: /*
320: * First deal with the x coordinates.
321: */
322: switch (HandleHit) {
323: case DRAG_LEFTBOTTOM:
324: case DRAG_LEFT:
325: case DRAG_LEFTTOP:
326: if (npcHead) {
327: if (prc->left > grcMinDialog.left)
328: prc->left = AtOrBelow(grcMinDialog.left, gcxGrid);
329: }
330: else {
331: if (prc->left > prc->right)
332: prc->left = AtOrBelow(prc->right, gcxGrid);
333: }
334:
335: break;
336:
337: case DRAG_RIGHTBOTTOM:
338: case DRAG_RIGHT:
339: case DRAG_RIGHTTOP:
340: if (npcHead) {
341: if (prc->right < grcMinDialog.right)
342: prc->right = AtOrAbove(grcMinDialog.right, gcxGrid);
343: }
344: else {
345: if (prc->right < prc->left)
346: prc->right = AtOrAbove(prc->left, gcxGrid);
347: }
348:
349: break;
350: }
351:
352: /*
353: * Now deal with the y coordinates.
354: */
355: switch (HandleHit) {
356: case DRAG_LEFTBOTTOM:
357: case DRAG_BOTTOM:
358: case DRAG_RIGHTBOTTOM:
359: if (npcHead) {
360: if (prc->bottom < grcMinDialog.bottom)
361: prc->bottom = AtOrAbove(grcMinDialog.bottom, gcyGrid);
362: }
363: else {
364: if (prc->bottom < prc->top)
365: prc->bottom = AtOrAbove(prc->top, gcyGrid);
366: }
367:
368: break;
369:
370: case DRAG_LEFTTOP:
371: case DRAG_TOP:
372: case DRAG_RIGHTTOP:
373: if (npcHead) {
374: if (prc->top > grcMinDialog.top)
375: prc->top = AtOrBelow(grcMinDialog.top, gcyGrid);
376: }
377: else {
378: if (prc->top > prc->bottom)
379: prc->top = AtOrBelow(prc->bottom, gcyGrid);
380: }
381:
382: break;
383: }
384: }
385: else {
386: /*
387: * First deal with the x coordinates.
388: */
389: switch (HandleHit) {
390: case DRAG_LEFTBOTTOM:
391: case DRAG_LEFT:
392: case DRAG_LEFTTOP:
393: if (prc->left > prc->right)
394: prc->left = AtOrBelow(prc->right, gcxGrid);
395:
396: if (prc->left == prc->right)
397: prc->left -= gcxGrid;
398:
399: if (prc->left < 0)
400: prc->left = 0;
401:
402: break;
403:
404: case DRAG_RIGHTBOTTOM:
405: case DRAG_RIGHT:
406: case DRAG_RIGHTTOP:
407: cxDlg = gcd.npc->rc.right - gcd.npc->rc.left;
408: if (prc->right > cxDlg)
409: prc->right = AtOrBelow(cxDlg, gcxGrid);
410:
411: if (prc->right < prc->left)
412: prc->right = AtOrAbove(prc->left, gcxGrid);
413:
414: if (prc->right == prc->left)
415: prc->right += gcxGrid;
416:
417: break;
418: }
419:
420: /*
421: * Now deal with the y coordinates.
422: */
423: switch (HandleHit) {
424: case DRAG_LEFTTOP:
425: case DRAG_TOP:
426: case DRAG_RIGHTTOP:
427: if (prc->top > prc->bottom)
428: prc->top = AtOrBelow(prc->bottom, gcyGrid);
429:
430: if (prc->top == prc->bottom)
431: prc->top -= gcyGrid;
432:
433: if (prc->top < 0)
434: prc->top = 0;
435:
436: break;
437:
438: case DRAG_LEFTBOTTOM:
439: case DRAG_BOTTOM:
440: case DRAG_RIGHTBOTTOM:
441: cyDlg = gcd.npc->rc.bottom - gcd.npc->rc.top;
442:
443: /*
444: * Note that if there is an overhang allowed, then
445: * we do not limit how FAR down the bottom of the
446: * control can be.
447: */
448: if (prc->bottom > cyDlg && !nOverHang)
449: prc->bottom = AtOrBelow(cyDlg, gcyGrid);
450:
451: if (prc->bottom < prc->top)
452: prc->bottom = AtOrAbove(prc->top, gcyGrid);
453:
454: if (prc->bottom == prc->top)
455: prc->bottom += gcyGrid;
456:
457: break;
458: }
459: }
460: }
461:
462:
463:
464: /************************************************************************
465: * AtOrAbove
466: *
467: * This routine takes a number, and returns the closest number that
468: * is equal to or above that number and is an integral of the given
469: * grid value.
470: *
471: * Arguments:
472: * INT nStart - Starting number (can be negative).
473: * INT nGrid - Grid value.
474: *
475: ************************************************************************/
476:
477: STATICFN INT AtOrAbove(
478: INT nStart,
479: INT nGrid)
480: {
481: register INT nAbove;
482:
483: nAbove = (nStart / nGrid) * nGrid;
484:
485: if (nStart > 0 && nStart != nAbove)
486: nAbove += nGrid;
487:
488: return nAbove;
489: }
490:
491:
492:
493: /************************************************************************
494: * AtOrBelow
495: *
496: * This routine takes a number, and returns the closest number that
497: * is equal to or below that number and is an integral of the given
498: * grid value.
499: *
500: * Arguments:
501: * INT nStart - Starting number (can be negative).
502: * INT nGrid - Grid value.
503: *
504: ************************************************************************/
505:
506: STATICFN INT AtOrBelow(
507: INT nStart,
508: INT nGrid)
509: {
510: register INT nBelow;
511:
512: nBelow = (nStart / nGrid) * nGrid;
513:
514: if (nStart < 0 && nStart != nBelow)
515: nBelow -= nGrid;
516:
517: return nBelow;
518: }
519:
520:
521:
522: /************************************************************************
523: * GetOverHang
524: *
525: * This function returns the height that the control can overhang the
526: * bottom of the dialog. This is currently only meaningful for comboboxes.
527: * If the control is not a combobox, zero is returned.
528: *
529: * Arguments:
530: * INT iType - Type of control (W_* constant).
531: * INT cy - Height of the control (in DU's).
532: *
533: ************************************************************************/
534:
535: INT GetOverHang(
536: INT iType,
537: INT cy)
538: {
539: if (iType != W_COMBOBOX)
540: return 0;
541:
542: return max(cy - COMBOEDITHEIGHT, 0);
543: }
544:
545:
546:
547: /************************************************************************
548: * GridizeRect
549: *
550: * This function "gridizes" coordinates in a rectangle. The current
551: * grid values are used. The fsGrid flag can contain OR'd together
552: * GRIDIZE_* values that specify which points to apply the gridding to.
553: * Upon return, all coordinates specified will have been rounded to the
554: * nearest grid boundary.
555: *
556: * If GRIDIZE_SAMESIZE is specified, the size of the control will be
557: * kept the same. This overrides the GRIDIZE_RIGHT and GRIDIZE_BOTTOM
558: * flags. In other words, any delta applied to left or top will
559: * be added to right and bottom to retain the original size of the
560: * rectangle.
561: *
562: * Arguments:
563: * PRECT prc - Rectangle to adjust to the current grid.
564: * INT fGridFlags - GRIDIZE_* flags. Specifies which points to gridize.
565: *
566: ************************************************************************/
567:
568: VOID GridizeRect(
569: PRECT prc,
570: INT fGridFlags)
571: {
572: register INT nTemp;
573: INT leftOld = prc->left;
574: INT topOld = prc->top;
575:
576: if (fGridFlags & GRIDIZE_LEFT) {
577: nTemp = AtOrBelow(prc->left, gcxGrid);
578:
579: if (prc->left - nTemp > gcxGrid / 2)
580: nTemp += gcxGrid;
581:
582: prc->left = nTemp;
583: }
584:
585: if (fGridFlags & GRIDIZE_TOP) {
586: nTemp = AtOrBelow(prc->top, gcyGrid);
587:
588: if (prc->top - nTemp > gcyGrid / 2)
589: nTemp += gcyGrid;
590:
591: prc->top = nTemp;
592: }
593:
594: /*
595: * Do they want to retain the same size of the rectangle?
596: */
597: if (fGridFlags & GRIDIZE_SAMESIZE) {
598: /*
599: * Shift the right coordinate over by the delta that
600: * was applied to the left.
601: */
602: prc->right += prc->left - leftOld;
603: prc->bottom += prc->top - topOld;
604: }
605: else {
606: if (fGridFlags & GRIDIZE_RIGHT) {
607: nTemp = AtOrBelow(prc->right, gcxGrid);
608:
609: if (prc->right - nTemp > gcxGrid / 2)
610: nTemp += gcxGrid;
611:
612: prc->right = nTemp;
613: }
614:
615: if (fGridFlags & GRIDIZE_BOTTOM) {
616: nTemp = AtOrBelow(prc->bottom, gcyGrid);
617:
618: if (prc->bottom - nTemp > gcyGrid / 2)
619: nTemp += gcyGrid;
620:
621: prc->bottom = nTemp;
622: }
623: }
624: }
625:
626:
627:
628: /************************************************************************
629: * SizeDragToControl
630: *
631: * This routine sizes and positions the drag window associated with a
632: * control, based on the current size and position of the control.
633: *
634: * It takes into account the different origin that controls and dialogs
635: * have, and sizes the drag window to fit around the control properly.
636: * The Z order of the drag window is NOT changed.
637: *
638: * This routine should only be called for controls, not the dialog.
639: *
640: * Arguments:
641: * NPCTYPE npc - Control whose drag window needs to be sized.
642: *
643: ************************************************************************/
644:
645: VOID SizeDragToControl(
646: NPCTYPE npc)
647: {
648: RECT rc;
649:
650: rc = npc->rc;
651: DUToWinRect(&rc);
652:
653: InflateRect(&rc, CHANDLESIZE / 2, CHANDLESIZE / 2);
654:
655: SetWindowPos(npc->hwndDrag, NULL, rc.left, rc.top,
656: rc.right - rc.left, rc.bottom - rc.top,
657: SWP_NOACTIVATE | SWP_NOZORDER);
658: }
659:
660:
661:
662: /************************************************************************
663: * DragWndProc
664: *
665: * This is the window procedure for the "drag" class. This window
666: * is placed behind a control and is what the user grabs to size a
667: * window with the mouse.
668: *
669: ************************************************************************/
670:
671: WINDOWPROC DragWndProc(
672: HWND hwnd,
673: UINT msg,
674: WPARAM wParam,
675: LPARAM lParam)
676: {
677: POINT pt;
678:
679: switch (msg) {
680: case WM_PAINT:
681: {
682: PAINTSTRUCT ps;
683: HDC hDC;
684:
685: PaintUnderDrag(hwnd);
686:
687: hDC = BeginPaint(hwnd, &ps);
688: DrawHandles(hwnd, hDC,
689: (gnpcSel && hwnd == gnpcSel->hwndDrag) ? TRUE : FALSE);
690: EndPaint(hwnd, &ps);
691: }
692:
693: break;
694:
695: case WM_NCHITTEST:
696: ((pt).x = ((*((POINTS *)&(lParam)))).x, (pt).y = ((*((POINTS *)&(lParam)))).y);
697: ScreenToClient(hwnd, &pt);
698:
699: if (HandleHitTest(hwnd, pt.x, pt.y) == DRAG_CENTER)
700: return HTTRANSPARENT;
701: else
702: return HTCLIENT;
703:
704: case WM_SETCURSOR:
705: /*
706: * Defeat the system changing cursors on us. We do it based
707: * on our own hit testing.
708: */
709: break;
710:
711: case WM_LBUTTONDOWN:
712: ((pt).x = ((*((POINTS *)&(lParam)))).x, (pt).y = ((*((POINTS *)&(lParam)))).y);
713: CtrlButtonDown(hwnd, pt.x, pt.y, TRUE);
714: break;
715:
716: case WM_MOUSEMOVE:
717: ((pt).x = ((*((POINTS *)&(lParam)))).x, (pt).y = ((*((POINTS *)&(lParam)))).y);
718: CtrlMouseMove(hwnd, TRUE, pt.x, pt.y);
719: break;
720:
721: case WM_LBUTTONUP:
722: ((pt).x = ((*((POINTS *)&(lParam)))).x, (pt).y = ((*((POINTS *)&(lParam)))).y);
723: CtrlButtonUp(pt.x, pt.y);
724: break;
725:
726: case WM_RBUTTONDOWN:
727: case WM_MBUTTONDOWN:
728: case WM_LBUTTONDBLCLK:
729: case WM_RBUTTONDBLCLK:
730: case WM_MBUTTONDBLCLK:
731: /*
732: * Prevents calling SetFocus when the middle or right
733: * mouse buttons are pressed (or doubleclicked).
734: */
735: break;
736:
737: case WM_NCCALCSIZE:
738: /*
739: * The client area is the entire control.
740: */
741: break;
742:
743: case WM_DESTROY:
744: /*
745: * When destroying the drag window, we must be sure and
746: * remove the properties associated with it.
747: */
748: UNSETPCINTOHWND(hwnd);
749: break;
750:
751: default:
752: return DefWindowProc(hwnd, msg, wParam, lParam);
753: }
754:
755: return 0L;
756: }
757:
758:
759:
760: /************************************************************************
761: * DrawHandles
762: *
763: * This routine draws the drag handles for a drag window. The handles
764: * will be solid (filled) if fCurrentSelection is TRUE, or hollow if it
765: * is FALSE.
766: *
767: * Arguments:
768: * HWND hwnd - Drag window handle.
769: * HDC hDC - DC to use to draw in this window.
770: * BOOL fCurrentSelection - TRUE if this control is the "current"
771: * selection.
772: *
773: ************************************************************************/
774:
775: VOID DrawHandles(
776: HWND hwnd,
777: HDC hDC,
778: BOOL fCurrentSelection)
779: {
780: RECT rc;
781: INT xMid;
782: INT yMid;
783: INT x2;
784: INT y2;
785: HBITMAP hbmOld;
786:
787: GetWindowRect(hwnd, &rc);
788: OffsetRect(&rc, -rc.left, -rc.top);
789:
790: /*
791: * Precalculate some points.
792: */
793: xMid = ((rc.right + 1) / 2) - (CHANDLESIZE / 2);
794: yMid = ((rc.bottom + 1) / 2) - (CHANDLESIZE / 2);
795: x2 = rc.right - CHANDLESIZE;
796: y2 = rc.bottom - CHANDLESIZE;
797:
798: /*
799: * Draw a solid box if this is the currently selected
800: * control, otherwise draw a hollow box.
801: */
802: if (fCurrentSelection)
803: hbmOld = SelectObject(ghDCMem, ghbmDragHandle);
804: else
805: hbmOld = SelectObject(ghDCMem, ghbmDragHandle2);
806:
807: BitBlt(hDC, 0, 0, CHANDLESIZE, CHANDLESIZE,
808: ghDCMem, 0, 0, SRCCOPY);
809: BitBlt(hDC, xMid, 0, CHANDLESIZE, CHANDLESIZE,
810: ghDCMem, 0, 0, SRCCOPY);
811: BitBlt(hDC, x2, 0, CHANDLESIZE, CHANDLESIZE,
812: ghDCMem, 0, 0, SRCCOPY);
813: BitBlt(hDC, x2, yMid, CHANDLESIZE, CHANDLESIZE,
814: ghDCMem, 0, 0, SRCCOPY);
815: BitBlt(hDC, x2, y2, CHANDLESIZE, CHANDLESIZE,
816: ghDCMem, 0, 0, SRCCOPY);
817: BitBlt(hDC, xMid, y2, CHANDLESIZE, CHANDLESIZE,
818: ghDCMem, 0, 0, SRCCOPY);
819: BitBlt(hDC, 0, y2, CHANDLESIZE, CHANDLESIZE,
820: ghDCMem, 0, 0, SRCCOPY);
821: BitBlt(hDC, 0, yMid, CHANDLESIZE, CHANDLESIZE,
822: ghDCMem, 0, 0, SRCCOPY);
823:
824: SelectObject(ghDCMem, hbmOld);
825: }
826:
827:
828:
829: /************************************************************************
830: * PaintUnderDrag
831: *
832: * This function is used during a paint operation for a visible drag
833: * window. It checks underneath the area to update and forces any
834: * windows down there to paint themselves, in such an order as to cause
835: * the last one painted to be the visually top window. This is necessary
836: * to implement the drag windows as "transparent" windows. After this
837: * routine finishes, the caller can paint the "handles". The caller must
838: * call this routine before calling BeginPaint, or the update area
839: * will be null and nothing will get painted.
840: *
841: * It is assumed that the drag windows are for controls, not for the
842: * dialog.
843: *
844: * Arguments:
845: * HWND hwndDrag - Drag window to paint under.
846: *
847: ************************************************************************/
848:
849: STATICFN VOID PaintUnderDrag(
850: HWND hwndDrag)
851: {
852: RECT rc;
853: RECT rcInt;
854: RECT rcUpdate;
855: HWND hwnd;
856: HWND hwndControl;
857: NPCTYPE npc;
858:
859: /*
860: * Get our corresponding control window.
861: */
862: hwndControl = (PCFROMHWND(hwndDrag))->hwnd;
863:
864: /*
865: * Get the update rectangle and convert to screen coords.
866: */
867: GetUpdateRect(hwndDrag, &rcUpdate, TRUE);
868: ClientToScreenRect(hwndDrag, &rcUpdate);
869:
870: /*
871: * Start enumerating windows.
872: */
873: hwnd = hwndDrag;
874: while (hwnd = GetWindow(hwnd, GW_HWNDNEXT)) {
875: /*
876: * Skip invisible drag windows.
877: */
878: if (IsWindowVisible(hwnd)) {
879: /*
880: * Does the window rectangle intersect the update rectangle?
881: */
882: GetWindowRect(hwnd, &rc);
883: if (IntersectRect(&rcInt, &rc, &rcUpdate)) {
884: npc = PCFROMHWND(hwnd);
885:
886: if (npc->hwndDrag == hwnd || !npc->fSelected) {
887: ScreenToClientRect(hwnd, &rcInt);
888: InvalidateRect(hwnd, &rcInt, TRUE);
889: UpdateWindow(hwnd);
890: }
891:
892: if (npc->hwndDrag == hwnd)
893: break;
894: }
895: }
896: }
897:
898: /*
899: * Finally, paint the control associated with this drag window.
900: */
901: InvalidateRect(hwndControl, NULL, TRUE);
902: UpdateWindow(hwndControl);
903: }
904:
905:
906:
907: /************************************************************************
908: * HandleHitTest
909: *
910: * This routine takes a point from a mouse button press on a drag window
911: * and returns which "handle" was hit, if any.
912: *
913: * The coordinates are given in zero based coordinates of the drag
914: * window.
915: *
916: * Arguments:
917: * HWND hwnd - Drag window handle the x,y point is relative to.
918: * INT x - Mouse X location (in the drag's client coordinates).
919: * INT y - Mouse Y location (in the drag's client coordinates).
920: *
921: * Returns:
922: * One of the DRAG_* constants. If no handle was hit, the
923: * return will be DRAG_CENTER.
924: *
925: ************************************************************************/
926:
927: INT HandleHitTest(
928: HWND hwnd,
929: INT x,
930: INT y)
931: {
932: RECT rc;
933: INT xMidStart;
934: INT yMidStart;
935:
936: /*
937: * If there are multiple controls selected, or if the control
938: * type does not allow sizing, defeat the ability to size
939: * with the handles by returning DRAG_CENTER.
940: */
941: if (gcSelected > 1 || !(PCFROMHWND(hwnd))->pwcd->fSizeable)
942: return DRAG_CENTER;
943:
944: /*
945: * Get the window rectangle and cause it to be zero-origined.
946: */
947: GetWindowRect(hwnd, &rc);
948: OffsetRect(&rc, -rc.left, -rc.top);
949:
950: /*
951: * Calculate the starting points for the handles
952: * that are not on a corner.
953: */
954: xMidStart = ((rc.right + 1) / 2) - (CHANDLESIZE / 2);
955: yMidStart = ((rc.bottom + 1) / 2) - (CHANDLESIZE / 2);
956:
957: if (x < CHANDLESIZE) {
958: if (y < CHANDLESIZE)
959: return DRAG_LEFTTOP;
960: else if (y > rc.bottom - CHANDLESIZE)
961: return DRAG_LEFTBOTTOM;
962: else if (y >= yMidStart && y < yMidStart + CHANDLESIZE)
963: return DRAG_LEFT;
964: }
965: else if (x > rc.right - CHANDLESIZE) {
966: if (y < CHANDLESIZE)
967: return DRAG_RIGHTTOP;
968: else if (y > rc.bottom - CHANDLESIZE)
969: return DRAG_RIGHTBOTTOM;
970: else if (y >= yMidStart && y < yMidStart + CHANDLESIZE)
971: return DRAG_RIGHT;
972: }
973: else if (x >= xMidStart && x < xMidStart + CHANDLESIZE) {
974: if (y < CHANDLESIZE)
975: return DRAG_TOP;
976: else if (y > rc.bottom - CHANDLESIZE)
977: return DRAG_BOTTOM;
978: }
979:
980: return DRAG_CENTER;
981: }
982:
983:
984:
985: /************************************************************************
986: * MouseToDragRect
987: *
988: * This routine takes the mouse pointer coordinates from a mouse message
989: * and produces a rectangle that contains the coordinates that the drag
990: * rectangle should be displayed as. This is for tracking (moving/sizing)
991: * operations. It relies on a number of globals to have been set up
992: * prior to the call with such things as the current control, type of
993: * drag, old location of the control, offset of the original mouse press
994: * from the origin of the control, etc.
995: *
996: * The returned rectangle is pegged to the boundaries of the dialog (if it
997: * is for a control), and is aligned to the current grid units. It is in
998: * dialog units relative to the appropriate point based on whether it is
999: * for a control or the dialog, and must be converted to window points
1000: * before the actual drag rectangle can be drawn on the screen.
1001: *
1002: * Arguments:
1003: * INT x - Mouse X location (in window coordinates).
1004: * INT y - Mouse Y location (in window coordinates).
1005: * PRECT prc - Rectangle to return the appropriate drag rectangle
1006: * in.
1007: *
1008: ************************************************************************/
1009:
1010: STATICFN VOID MouseToDragRect(
1011: INT x,
1012: INT y,
1013: PRECT prc)
1014: {
1015: POINT pt;
1016: INT fGridFlags;
1017:
1018: pt.x = x;
1019: pt.y = y;
1020: MouseToDU(&pt);
1021:
1022: switch (gHandleHit) {
1023: case DRAG_LEFTBOTTOM:
1024: SetRect(prc, pt.x, grcSelected.top, grcSelected.right,
1025: (grcSelected.bottom - grcSelected.top) + pt.y);
1026: fGridFlags = GRIDIZE_LEFT | GRIDIZE_BOTTOM;
1027: break;
1028:
1029: case DRAG_BOTTOM:
1030: SetRect(prc, grcSelected.left, grcSelected.top,
1031: grcSelected.right,
1032: (grcSelected.bottom - grcSelected.top) + pt.y);
1033: fGridFlags = GRIDIZE_BOTTOM;
1034: break;
1035:
1036: case DRAG_RIGHTBOTTOM:
1037: SetRect(prc, grcSelected.left, grcSelected.top,
1038: (grcSelected.right - grcSelected.left) + pt.x,
1039: (grcSelected.bottom - grcSelected.top) + pt.y);
1040: fGridFlags = GRIDIZE_BOTTOM | GRIDIZE_RIGHT;
1041: break;
1042:
1043: case DRAG_RIGHT:
1044: SetRect(prc, grcSelected.left, grcSelected.top,
1045: (grcSelected.right - grcSelected.left) + pt.x,
1046: grcSelected.bottom);
1047: fGridFlags = GRIDIZE_RIGHT;
1048: break;
1049:
1050: case DRAG_RIGHTTOP:
1051: SetRect(prc, grcSelected.left, pt.y,
1052: (grcSelected.right - grcSelected.left) + pt.x,
1053: grcSelected.bottom);
1054: fGridFlags = GRIDIZE_RIGHT | GRIDIZE_TOP;
1055: break;
1056:
1057: case DRAG_TOP:
1058: SetRect(prc, grcSelected.left, pt.y,
1059: grcSelected.right, grcSelected.bottom);
1060: fGridFlags = GRIDIZE_TOP;
1061: break;
1062:
1063: case DRAG_LEFTTOP:
1064: SetRect(prc, pt.x, pt.y, grcSelected.right, grcSelected.bottom);
1065: fGridFlags = GRIDIZE_LEFT | GRIDIZE_TOP;
1066: break;
1067:
1068: case DRAG_LEFT:
1069: SetRect(prc, pt.x, grcSelected.top,
1070: grcSelected.right, grcSelected.bottom);
1071: fGridFlags = GRIDIZE_LEFT;
1072: break;
1073:
1074: case DRAG_CENTER:
1075: SetRect(prc, pt.x, pt.y,
1076: (grcSelected.right - grcSelected.left) + pt.x,
1077: (grcSelected.bottom - grcSelected.top) + pt.y);
1078: fGridFlags = GRIDIZE_LEFT | GRIDIZE_TOP | GRIDIZE_SAMESIZE;
1079: break;
1080: }
1081:
1082: GridizeRect(prc, fGridFlags);
1083: FitRectToBounds(prc, gnOverHang, gHandleHit, gfDlgSelected);
1084: }
1085:
1086:
1087:
1088: /************************************************************************
1089: * MouseToDU
1090: *
1091: * This routine converts the point at ppt from window coordinates
1092: * for the current control into the closest Dialog Unit point.
1093: *
1094: * This routine normally assumes that the point is relative to the selected
1095: * control, and will convert the point into DU's. The current control
1096: * can either be the current dialog or one of its child controls.
1097: * The DU's returned will be appropriate for the type of control. If
1098: * it is the dialog, they will be relative to the apps client area.
1099: * If it is a control, they will be relative to the "client" area of
1100: * the current dialog.
1101: *
1102: * If there is no current selection (such as when dropping a new control),
1103: * the point is assumed to already be relative to the dialog and it will
1104: * will not be mapped. This only applies when called with a point for a
1105: * control, not a dialog.
1106: *
1107: * Arguments:
1108: * PPOINT ppt - Point to convert.
1109: *
1110: ************************************************************************/
1111:
1112: STATICFN VOID MouseToDU(
1113: PPOINT ppt)
1114: {
1115: if (gfDlgSelected) {
1116: /*
1117: * Map the points from the dialog to the app client.
1118: */
1119: ClientToScreen(gcd.npc->hwnd, ppt);
1120: ScreenToClient(ghwndSubClient, ppt);
1121:
1122: /*
1123: * Subtract the cursor offset.
1124: */
1125: ppt->x -= gptCursorOffset.x;
1126: ppt->y -= gptCursorOffset.y;
1127: }
1128: else {
1129: /*
1130: * Map the points from the control to the dialog window,
1131: * but only if there is a current selection. There will
1132: * not be a current selection when dropping a new control,
1133: * and the point must already be relative to the dialog!
1134: */
1135: if (gnpcSel) {
1136: ClientToScreen(gnpcSel->hwnd, ppt);
1137: ScreenToClient(gcd.npc->hwnd, ppt);
1138: }
1139:
1140: /*
1141: * Subtract the cursor offset, then the dialogs frame
1142: * controls offset.
1143: */
1144: ppt->x -= gptCursorOffset.x;
1145: ppt->y -= gptCursorOffset.y;
1146: }
1147:
1148: /*
1149: * Convert this position to dialog units.
1150: */
1151: WinToDUPoint(ppt);
1152: }
1153:
1154:
1155:
1156: /************************************************************************
1157: * CtrlButtonDown
1158: *
1159: * This routine is called by the control and drag window procs when
1160: * the left mouse button is pressed. It checks for the Ctrl modifier key
1161: * then passes control on to the appropriate routine.
1162: *
1163: * When hwnd is the dialog itself, fHandleWindow must be TRUE, even
1164: * if a handle was not hit, because of the special-case code that must
1165: * be done for the dialog (it doesn't have a separate drag window).
1166: *
1167: * Arguments:
1168: * HWND hwnd - Window handle, can be a drag window or control.
1169: * INT x - X mouse location (window coordinates).
1170: * INT y - Y mouse location (window coordinates).
1171: * BOOL fHandleWindow - TRUE if a handle was clicked on, or FALSE if the
1172: * body of a control was clicked on.
1173: *
1174: ************************************************************************/
1175:
1176: VOID CtrlButtonDown(
1177: HWND hwnd,
1178: INT x,
1179: INT y,
1180: BOOL fHandleWindow)
1181: {
1182: POINT pt;
1183: HWND hwndHit;
1184: INT nOverHang;
1185:
1186: /*
1187: * Discard all mouse messages during certain operations.
1188: */
1189: if (gfDisabled)
1190: return;
1191:
1192: /*
1193: * Also, be sure any outstanding changes get applied
1194: * without errors.
1195: */
1196: if (!StatusApplyChanges())
1197: return;
1198:
1199: if (gCurTool != W_NOTHING) {
1200: nOverHang = GetOverHang(gpwcdCurTool->iType, gpwcdCurTool->cyDefault);
1201: DragNewBegin(gpwcdCurTool->cxDefault,
1202: gpwcdCurTool->cyDefault, nOverHang);
1203: }
1204: else {
1205: /*
1206: * If the Control key is down, duplicate the control, unless
1207: * it is the dialog (mouse duplicate of the dialog is not
1208: * supported).
1209: */
1210: if ((GetKeyState(VK_CONTROL) & 0x8000) &&
1211: (PCFROMHWND(hwnd))->pwcd->iType != W_DIALOG) {
1212: /*
1213: * First, figure out which control was hit and select it.
1214: */
1215: if (fHandleWindow) {
1216: hwndHit = hwnd;
1217: }
1218: else {
1219: pt.x = x;
1220: pt.y = y;
1221: hwndHit = CtrlHitTest(hwnd, &pt);
1222: }
1223:
1224: SelectControl(PCFROMHWND(hwndHit), TRUE);
1225:
1226: /*
1227: * If there is still a selection, begin dragging a copy
1228: * of it. The check here is necessary because the prior
1229: * call to SelectControl can unselect the last selected
1230: * control if the Shift key was held down.
1231: */
1232: if (gcSelected)
1233: Duplicate();
1234: }
1235: else {
1236: /*
1237: * Start a drag operation. This can be either moving or sizing
1238: * the control, depending on fHandleWindow and where the mouse
1239: * click is at.
1240: */
1241: DragBegin(hwnd, x, y, fHandleWindow);
1242: }
1243: }
1244: }
1245:
1246:
1247:
1248: /************************************************************************
1249: * DragNewBegin
1250: *
1251: * This routine begins a drag operation when dropping a new control, or
1252: * group of controls. It is NOT used when dragging existing controls.
1253: *
1254: * Arguments:
1255: * INT cx - Width of the new control.
1256: * INT cy - Height of the new control.
1257: * INT nOverHang - How much the control can overhang the dialog bottom.
1258: *
1259: ************************************************************************/
1260:
1261: VOID DragNewBegin(
1262: INT cx,
1263: INT cy,
1264: INT nOverHang)
1265: {
1266: POINTS mpt;
1267: POINT pt;
1268: DWORD dwPos;
1269:
1270: /*
1271: * Always be sure the focus is where we want it, not on something
1272: * like the status ribbon or "Esc" won't work to cancel the tracking.
1273: */
1274: SetFocus(ghwndMain);
1275:
1276: /*
1277: * Cancel any current selection, and set some state globals.
1278: */
1279: CancelSelection(TRUE);
1280: gHandleHit = DRAG_CENTER;
1281: gState = STATE_DRAGGINGNEW;
1282: SetCursor(hcurMove);
1283:
1284: /*
1285: * The cursor offset is set to be located in the middle of the
1286: * new control. This causes the pointer to be initially located
1287: * exactly in the center.
1288: */
1289: gptCursorOffset.x = cx;
1290: gptCursorOffset.y = cy;
1291: DUToWinPoint(&gptCursorOffset);
1292: gptCursorOffset.x /= 2;
1293: gptCursorOffset.y /= 2;
1294:
1295: /*
1296: * Set a global with the overhang. This is used all during the
1297: * drag operation we are starting.
1298: */
1299: gnOverHang = nOverHang;
1300:
1301: /*
1302: * Now we make up a dummy rectangle for the new control. We start
1303: * it at (0,0) with a size of cx and cy. The point where the mouse
1304: * was when the command was done is obtained and mapped to the dialog
1305: * (it is assumed that only controls will be done here, not a dialog).
1306: * The new control rectangle is then converted to be at this location,
1307: * it is gridized, the tracking rectangle is shown and we are off.
1308: */
1309: SetRect(&grcSelected, 0, 0, cx, cy);
1310: dwPos = GetMessagePos();
1311: mpt = (*((POINTS *)&(dwPos)));
1312: ((pt).x = (mpt).x, (pt).y = (mpt).y);
1313: ScreenToClient(gcd.npc->hwnd, &pt);
1314: MouseToDragRect(pt.x, pt.y, &grcSelected);
1315: InitTracking();
1316: DrawTrackRect(&grcSelected, FALSE, TRUE);
1317:
1318: /*
1319: * Display the initial coordinates.
1320: */
1321: StatusSetCoords(&grcSelected);
1322:
1323: /*
1324: * The mouse messages will come through the dialog subclass proc for
1325: * these kinds of operations.
1326: */
1327: SetCapture(gcd.npc->hwnd);
1328: }
1329:
1330:
1331:
1332: /************************************************************************
1333: * DragBegin
1334: *
1335: * This routine begins a drag operation for either moving a control or
1336: * sizing it. The tracking rectangle is not actually drawn until the
1337: * mouse moves by a grid unit, however.
1338: *
1339: * To begin a drag on the dialog itself, fHandleWindow must be TRUE, even
1340: * if a handle was not hit, because of the special-case code that must
1341: * be done for the dialog (it doesn't have a separate drag window).
1342: *
1343: * Arguments:
1344: * HWND hwnd - Window handle, can be a drag window or control.
1345: * INT x - Starting X mouse location (window coordinates).
1346: * INT y - Starting Y mouse location (window coordinates).
1347: * BOOL fHandleWindow - TRUE if the drag is happening because a drag
1348: * handle was clicked on, or FALSE if the drag is
1349: * happening because the body of a control is
1350: * clicked on.
1351: *
1352: *
1353: ************************************************************************/
1354:
1355: STATICFN VOID DragBegin(
1356: HWND hwnd,
1357: INT x,
1358: INT y,
1359: BOOL fHandleWindow)
1360: {
1361: NPCTYPE npcT;
1362: HWND hwndHit;
1363: POINT pt;
1364: NPCTYPE npc;
1365: BOOL fPrevSelect = FALSE;
1366: INT nBottom;
1367:
1368: /*
1369: * Always be sure the focus is where we want it, not on something
1370: * like the status ribbon or "Esc" won't work to cancel the tracking.
1371: */
1372: SetFocus(ghwndMain);
1373:
1374: pt.x = x;
1375: pt.y = y;
1376:
1377: /*
1378: * Is this drag happening because a drag handle was clicked on?
1379: */
1380: if (fHandleWindow) {
1381: /*
1382: * Find out which handle was clicked on. It is assumed that
1383: * hwnd is a drag window.
1384: */
1385: gHandleHit = HandleHitTest(hwnd, pt.x, pt.y);
1386: hwndHit = hwnd;
1387: }
1388: else {
1389: /*
1390: * The body of a control was clicked on. Set a global to say
1391: * that we are moving a control, then find out which control
1392: * was hit (with our own hit testing).
1393: */
1394: gHandleHit = DRAG_CENTER;
1395: hwndHit = CtrlHitTest(hwnd, &pt);
1396: }
1397:
1398: /*
1399: * Find out if the control clicked on was the currently selected
1400: * control already.
1401: */
1402: npc = PCFROMHWND(hwndHit);
1403: if (npc == gnpcSel)
1404: fPrevSelect = TRUE;
1405:
1406: /*
1407: * Select the control. This can return FALSE if the control is
1408: * unselected (shift key is down and the control is already selected).
1409: */
1410: if (!SelectControl(npc, TRUE))
1411: return;
1412:
1413: /*
1414: * If the dialog is selected, we make a rectangle that encloses all
1415: * the controls. This will be used to limit the size that the dialog
1416: * can be sized to so that it cannot cover any existing controls.
1417: */
1418: if (gfDlgSelected) {
1419: /*
1420: * Seed the rectangle with impossible values.
1421: */
1422: SetRect(&grcMinDialog, 32000, 32000, -32000, -32000);
1423:
1424: /*
1425: * Loop through all the controls, expanding the rectangle to
1426: * fit around all the controls.
1427: */
1428: for (npcT = npcHead; npcT; npcT = npcT->npcNext) {
1429: if (npcT->rc.left < grcMinDialog.left)
1430: grcMinDialog.left = npcT->rc.left;
1431:
1432: if (npcT->rc.right > grcMinDialog.right)
1433: grcMinDialog.right = npcT->rc.right;
1434:
1435: if (npcT->rc.top < grcMinDialog.top)
1436: grcMinDialog.top = npcT->rc.top;
1437:
1438: /*
1439: * When calculating the bottom boundary of the controls,
1440: * make the rectangle shorter by the ovehang amount. This
1441: * allows the dialog to be sized up so that it covers
1442: * parts of controls with overhang (comboboxes).
1443: */
1444: nBottom = npcT->rc.bottom - GetOverHang(npcT->pwcd->iType,
1445: npcT->rc.bottom - npcT->rc.top);
1446: if (nBottom > grcMinDialog.bottom)
1447: grcMinDialog.bottom = nBottom;
1448: }
1449:
1450: OffsetRect(&grcMinDialog, gcd.npc->rc.left, gcd.npc->rc.top);
1451: }
1452:
1453: /*
1454: * If the control clicked on was already the anchor, go right into
1455: * dragging mode. If it was not, go into pre-drag mode, which will
1456: * defer the calculation of offsets, etc., until after a certain
1457: * small amount of time so the mouse can be "debounced".
1458: */
1459: if (fPrevSelect) {
1460: DragBegin2(&pt);
1461: }
1462: else {
1463: gState = STATE_PREDRAG;
1464:
1465: /*
1466: * Save the point in a global. If the mouse pointer is moved
1467: * too FAR away from this point, we will start the drag operation
1468: * even if the pre-drag time has not elapsed yet.
1469: */
1470: gptPreDragStart = pt;
1471:
1472: /*
1473: * Start the pre-drag timer.
1474: */
1475: SetTimer(hwndHit, TID_PREDRAG, gmsecPreDrag, NULL);
1476: }
1477:
1478: /*
1479: * The mouse messages from now on will go to the window clicked on,
1480: * either the drag window or the control window.
1481: */
1482: SetCapture(hwndHit);
1483: }
1484:
1485:
1486:
1487: /************************************************************************
1488: * DragBegin2
1489: *
1490: * This routine continues the initiation of a drag operation started
1491: * by DragBegin. It is separate because it calculates offsets based
1492: * on where the mouse pointer is, and these calculations can be deferred
1493: * until a later time than when DragBegin was called so that the mouse
1494: * can be "debounced".
1495: *
1496: * Arguments:
1497: * POINT ppt - Starting mouse location (window coordinates).
1498: *
1499: ************************************************************************/
1500:
1501: STATICFN VOID DragBegin2(
1502: PPOINT ppt)
1503: {
1504: gState = STATE_DRAGGING;
1505:
1506: /*
1507: * Set the pointer to the "move" pointer if we are moving.
1508: * Otherwise, the pointer should already be set to the proper
1509: * sizing pointer.
1510: */
1511: if (gHandleHit == DRAG_CENTER)
1512: SetCursor(hcurMove);
1513:
1514: /*
1515: * Save away the initial offset of the cursor.
1516: */
1517: CalcCursorOffset(ppt);
1518:
1519: /*
1520: * Initialize the track rectangle. Note we are calling DrawTrackRect
1521: * with FALSE.
1522: */
1523: DrawTrackRect(&grcSelected, gfDlgSelected, FALSE);
1524: }
1525:
1526:
1527:
1528: /****************************************************************************
1529: * CtrlHitTest
1530: *
1531: * This routine walks the list of controls and determines which one is
1532: * "hit" by this point. If a hit is found, the point is also converted
1533: * to coordinates for the hit window.
1534: *
1535: * There is a special case when hitting controls over a groupbox.
1536: * Controls within a groupbox will always be hit instead of the
1537: * groupbox itself.
1538: *
1539: * Arguments:
1540: * HWND hwnd - Window handle the coordinates are relative to.
1541: * PPOINT ppt - Window point where the click occurred (window coords).
1542: *
1543: * Returns:
1544: * The hwnd of the "hit" control will be returned. If no control was hit,
1545: * the hwnd that was passed in is returned.
1546: *
1547: ****************************************************************************/
1548:
1549: STATICFN HWND CtrlHitTest(
1550: HWND hwnd,
1551: PPOINT ppt)
1552: {
1553: NPCTYPE npc;
1554: RECT rc;
1555: HWND hwndHit = (HWND)NULL;
1556: BOOL fGroupHit = FALSE;
1557:
1558: for (npc = npcHead; npc; npc = npc->npcNext) {
1559: GetWindowRect(npc->hwnd, &rc);
1560: ScreenToClientRect(npc->hwnd, &rc);
1561: MyMapWindowRect(npc->hwnd, hwnd, &rc);
1562:
1563: /*
1564: * Is this a hit, and was there either no control hit as
1565: * yet, or this control is not a groupbox, or the control
1566: * that was previously hit was a groupbox also?
1567: */
1568: if (PtInRect(&rc, *ppt) &&
1569: (!hwndHit || npc->pwcd->iType != W_GROUPBOX || fGroupHit)) {
1570: hwndHit = npc->hwnd;
1571: if (npc->pwcd->iType == W_GROUPBOX)
1572: fGroupHit = TRUE;
1573: else
1574: fGroupHit = FALSE;
1575: }
1576: }
1577:
1578: if (hwndHit) {
1579: MapWindowPoint(hwnd, hwndHit, ppt);
1580: return hwndHit;
1581: }
1582: else {
1583: return hwnd;
1584: }
1585: }
1586:
1587:
1588:
1589: /****************************************************************************
1590: * PreDragTimeout
1591: *
1592: * This function handles the WM_TIMER message from the control window
1593: * proc. It is used so that the dragging of a newly selected control
1594: * can be deferred for a small period of time to "debounce" the mouse.
1595: *
1596: * This function is also called if the mouse is moved too much during the
1597: * debounce time, effectively cutting the debounce time short.
1598: *
1599: * Arguments:
1600: * HWND hwnd - Window handle the timer came from.
1601: * BOOL fTimedOut - TRUE if the predrag is ending because the timer
1602: * expired. FALSE if the predrag is ending because
1603: * the mouse was moved too FAR.
1604: *
1605: ****************************************************************************/
1606:
1607: VOID PreDragTimeout(
1608: HWND hwnd,
1609: BOOL fTimedOut)
1610: {
1611: POINT pt;
1612:
1613: /*
1614: * The debounce time is over and the mouse button is still
1615: * down. Get the current mouse pointer location and go into
1616: * drag mode.
1617: */
1618: if (gState == STATE_PREDRAG) {
1619: /*
1620: * If we timed out (the mouse was not moved a large distance),
1621: * eat any small movement that may have been done during the
1622: * predrag time by setting the mouse cursor back to the location
1623: * that it started at. Note that we do not do this if the mouse
1624: * was moved a large distance, because the efect would be
1625: * noticeable for that case, and we want the control to be
1626: * moved then anyways.
1627: */
1628: if (fTimedOut) {
1629: pt = gptPreDragStart;
1630: ClientToScreen(hwnd, &pt);
1631: SetCursorPos(pt.x, pt.y);
1632: }
1633:
1634: DragBegin2(&gptPreDragStart);
1635: }
1636:
1637: KillTimer(hwnd, TID_PREDRAG);
1638: }
1639:
1640:
1641:
1642: /************************************************************************
1643: * CtrlMouseMove
1644: *
1645: * This routine handles the mouse move messages for controls, the dialog,
1646: * drag windows and when dropping a new control.
1647: *
1648: * During a drag operation, the tracking rectangle will be adjusted.
1649: * If there is not a drag operation is effect, the mouse cursor will
1650: * be changed to a sizing pointer if it is over a drag handle. If not
1651: * over a drag handle, the pointer will be changed back to the arrow.
1652: *
1653: * Arguments:
1654: * HWND hwnd - Window handle the x and y are relative to.
1655: * BOOL fDragWindow - TRUE if hwnd is a drag window.
1656: * INT x - X location of the mouse movement (window coords).
1657: * INT y - Y location of the mouse movement (window coords).
1658: *
1659: ************************************************************************/
1660:
1661: VOID CtrlMouseMove(
1662: HWND hwnd,
1663: BOOL fDragWindow,
1664: INT x,
1665: INT y)
1666: {
1667: RECT rc;
1668: RECT rc2;
1669: HCURSOR hcur = NULL;
1670:
1671: /*
1672: * Discard all mouse messages during certain operations
1673: * (but still set the pointer properly).
1674: */
1675: if (gfDisabled) {
1676: SetCursor(hcurArrow);
1677: return;
1678: }
1679:
1680: switch (gState) {
1681: case STATE_PREDRAG:
1682: /*
1683: * If the mouse was moved too FAR, consider the
1684: * pre-drag time elapsed and go into drag mode.
1685: */
1686: if (abs(gptPreDragStart.x - x) > gcxPreDragMax ||
1687: abs(gptPreDragStart.y - y) > gcyPreDragMax)
1688: PreDragTimeout(hwnd, FALSE);
1689:
1690: break;
1691:
1692: case STATE_DRAGGING:
1693: case STATE_DRAGGINGNEW:
1694: MouseToDragRect(x, y, &rc);
1695:
1696: if (!EqualRect(&rc, &grcTrackDU)) {
1697: /*
1698: * If the tracking rectangle is not shown, this means that
1699: * this is the first significant mouse move since the start
1700: * of a drag operation, and we need to lock the window, get
1701: * our clip DC, etc.
1702: */
1703: if (!gfTrackRectShown)
1704: InitTracking();
1705:
1706: DrawTrackRect(&rc, gfDlgSelected, TRUE);
1707:
1708: if (gcSelected > 1) {
1709: /*
1710: * Since there are multiple controls selected,
1711: * rc will be the rectangle that surrounds them
1712: * all. We really want to just show the anchor
1713: * controls new position, so we have to do a
1714: * little math to calculate and display it.
1715: */
1716: rc2 = gnpcSel->rc;
1717: OffsetRect(&rc2, rc.left - grcSelected.left,
1718: rc.top - grcSelected.top);
1719: StatusSetCoords(&rc2);
1720: }
1721: else {
1722: /*
1723: * Either a single control is being dragged or
1724: * a new control is being dropped.
1725: */
1726: StatusSetCoords(&rc);
1727: }
1728: }
1729:
1730: break;
1731:
1732: case STATE_SELECTING:
1733: OutlineSelectDraw(x, y);
1734: break;
1735:
1736: default:
1737: /*
1738: * Is there a tool selected?
1739: */
1740: if (gCurTool != W_NOTHING) {
1741: hcur = hcurDropTool;
1742: }
1743: else {
1744: /*
1745: * If hwnd is a drag window, see if the pointer is over
1746: * over any of the handles and change it to one of the
1747: * sizing pointers if necessary. Otherwise set the pointer
1748: * to the default arrow pointer.
1749: */
1750: if (fDragWindow) {
1751: switch (HandleHitTest(hwnd, x, y)) {
1752: case DRAG_LEFTBOTTOM:
1753: case DRAG_RIGHTTOP:
1754: hcur = hcurSizeNESW;
1755: break;
1756:
1757: case DRAG_LEFTTOP:
1758: case DRAG_RIGHTBOTTOM:
1759: hcur = hcurSizeNWSE;
1760: break;
1761:
1762: case DRAG_BOTTOM:
1763: case DRAG_TOP:
1764: hcur = hcurSizeNS;
1765: break;
1766:
1767: case DRAG_RIGHT:
1768: case DRAG_LEFT:
1769: hcur = hcurSizeWE;
1770: break;
1771:
1772: case DRAG_CENTER:
1773: default:
1774: hcur = hcurArrow;
1775: break;
1776: }
1777: }
1778: else {
1779: hcur = hcurArrow;
1780: }
1781: }
1782:
1783: break;
1784: }
1785:
1786: if (hcur)
1787: SetCursor(hcur);
1788: }
1789:
1790:
1791:
1792: /************************************************************************
1793: * DragCancel
1794: *
1795: * This function cancels any drag operation in effect. It handles
1796: * such things as erasing any visible tracking rectangle, freeing any
1797: * "copy" data, setting globals and updating the status display. It
1798: * can be used no matter how the drag operation was started.
1799: *
1800: ************************************************************************/
1801:
1802: VOID DragCancel(VOID)
1803: {
1804: HWND hwnd;
1805:
1806: switch (gState) {
1807: case STATE_PREDRAG:
1808: /*
1809: * Stop the timer. Note that this assumes the timer
1810: * was attached to the capture window. This should
1811: * be safe (see the associated SetTimer).
1812: */
1813: if (hwnd = GetCapture())
1814: KillTimer(hwnd, TID_PREDRAG);
1815:
1816: break;
1817:
1818: case STATE_DRAGGING:
1819: case STATE_DRAGGINGNEW:
1820: CancelTracking();
1821:
1822: if (gpResCopy) {
1823: MyFree(gpResCopy);
1824: gpResCopy = NULL;
1825: }
1826:
1827: break;
1828: }
1829:
1830: gState = STATE_NORMAL;
1831: ReleaseCapture();
1832: SetCursor(hcurArrow);
1833:
1834: StatusUpdate();
1835: StatusSetEnable();
1836: }
1837:
1838:
1839:
1840: /************************************************************************
1841: * CtrlButtonUp
1842: *
1843: * This function is called when the left mouse button is released. Depending
1844: * on the mode, it will complete the operation started when the button
1845: * was pressed down.
1846: *
1847: * Arguments:
1848: * INT x - Mouse X location (in window coords).
1849: * INT y - Mouse Y location (in window coords).
1850: *
1851: ************************************************************************/
1852:
1853: VOID CtrlButtonUp(
1854: INT x,
1855: INT y)
1856: {
1857: /*
1858: * Discard all mouse messages during certain operations.
1859: */
1860: if (gfDisabled)
1861: return;
1862:
1863: switch (gState) {
1864: case STATE_PREDRAG:
1865: /*
1866: * They released the mouse button during the debounce time,
1867: * so cancel the drag.
1868: */
1869: DragCancel();
1870: break;
1871:
1872: case STATE_DRAGGING:
1873: case STATE_DRAGGINGNEW:
1874: DragEnd(x, y);
1875: break;
1876:
1877: case STATE_SELECTING:
1878: OutlineSelectEnd(x, y);
1879: break;
1880:
1881: default:
1882: break;
1883: }
1884: }
1885:
1886:
1887:
1888: /************************************************************************
1889: * DragEnd
1890: *
1891: * This function completes all kinds of drag operations. If dragging a
1892: * new control, it will be dropped at the specified location. If dragging
1893: * an existing control, it will be positioned to the given location.
1894: *
1895: * Arguments:
1896: * INT x - X location the control ended up at (in window coords).
1897: * INT y - Y location the control ended up at (in window coords).
1898: *
1899: ************************************************************************/
1900:
1901: VOID DragEnd(
1902: INT x,
1903: INT y)
1904: {
1905: PDIALOGBOXHEADER pdbh;
1906: PCONTROLDATA pcd;
1907: INT cControls;
1908: RECT rc;
1909: INT i;
1910: INT cx;
1911: INT cy;
1912:
1913: CancelTracking();
1914: MouseToDragRect(x, y, &rc);
1915:
1916: if (gState == STATE_DRAGGING) {
1917: PositionControl(&rc);
1918: }
1919: else {
1920: if (gpResCopy) {
1921: pdbh = (PDIALOGBOXHEADER)SkipResHeader(gpResCopy);
1922: cControls = (INT)pdbh->NumberOfItems;
1923: pcd = SkipDialogBoxHeader(pdbh);
1924: cx = rc.left - grcCopy.left;
1925: cy = rc.top - grcCopy.top;
1926:
1927: /*
1928: * Loop through all the controls, adjusting their position
1929: * according to where the drag rectangle ended up.
1930: */
1931: for (i = 0; i < cControls; i++) {
1932: /*
1933: * Add cx and cy to the resource's x and y fields.
1934: */
1935: pcd->x += (WORD)cx;
1936: pcd->y += (WORD)cy;
1937:
1938: pcd = SkipControlData(pcd);
1939: }
1940:
1941: /*
1942: * Now we go and create all the controls, adding them to
1943: * the current dialog. It is assumed that the image in
1944: * gpResCopy specifies controls to add, and not a dialog
1945: * to create!
1946: */
1947: if (ResToDialog(gpResCopy, FALSE)) {
1948: gfResChged = gfDlgChanged = TRUE;
1949: ShowFileStatus(FALSE);
1950: }
1951:
1952: MyFree(gpResCopy);
1953: gpResCopy = NULL;
1954:
1955: StatusUpdate();
1956: StatusSetEnable();
1957: }
1958: else {
1959: /*
1960: * Drop the new control.
1961: */
1962: DropControl(gpwcdCurTool, &rc);
1963:
1964: if (!gfToolLocked)
1965: ToolboxSelectTool(W_NOTHING, FALSE);
1966: }
1967: }
1968:
1969: gState = STATE_NORMAL;
1970: ReleaseCapture();
1971: SetCursor(hcurArrow);
1972: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.