![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gizmobar.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / gizmobar|
Return to gizmobar.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / gizmobar |
1.1 root 1: /*
2: * GIZMOBAR.C
3: * GizmoBar Version 1.00, March 1993
4: *
5: * Contains the main window procedure of the GizmoBar control
6: * that handles mouse logic and Windows messages.
7: *
8: * Copyright (c)1992 Microsoft Corporation, All Rights Reserved
9: *
10: * Kraig Brockschmidt, Software Design Engineer
11: * Microsoft Systems Developer Relations
12: *
13: * Internet : [email protected]
14: * Compuserve: >INTERNET:[email protected]
15: */
16:
17: #ifdef WIN32
18: #define _INC_OLE
19: #define __RPC_H__
20: #endif
21:
22:
23: #define STRICT
24: #include <windows.h>
25: #include "gizmoint.h"
26:
27:
28:
29: /*
30: * GizmoBarWndProc
31: *
32: * Purpose:
33: * Window Procedure for the GizmoBar custom control. Handles all
34: * messages like WM_PAINT just as a normal application window would.
35: * Any message not processed here should go to DefWindowProc.
36: *
37: * Parameters:
38: * Standard
39: *
40: * Return Value:
41: * Standard
42: */
43:
44: LRESULT FAR PASCAL GizmoBarWndProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
45: {
46: BOOL fSuccess;
47: BOOL fTemp;
48: LPCREATESTRUCT pCreate;
49: PGIZMOBAR pGB;
50: PGIZMO pGizmo;
51: RECT rc;
52: short x, y;
53: COLORREF cr;
54:
55: COMMANDPARAMS(wID, wCode, hWndMsg);
56:
57: //This will be valid for all messages except WM_NCCREATE
58: pGB=(PGIZMOBAR)GetWindowLong(hWnd, GBWL_STRUCTURE);
59:
60: //Pass control messages onto another function for processing.
61: if (iMsg >= WM_USER)
62: return GBMessageHandler(hWnd, iMsg, wParam, lParam, pGB);
63:
64: //Handle standard Windows messages.
65: switch (iMsg)
66: {
67: case WM_NCCREATE:
68: pCreate=(LPCREATESTRUCT)lParam;
69:
70: pGB=GizmoBarPAllocate((LPINT)&fSuccess, hWnd, pCreate->hInstance
71: , pCreate->hwndParent, pCreate->style, 0);
72:
73: if (!fSuccess)
74: {
75: GizmoBarPFree(pGB);
76: return -1L;
77: }
78: else
79: SetWindowLong(hWnd, GBWL_STRUCTURE, (LONG)pGB);
80:
81: return DefWindowProc(hWnd, iMsg, wParam, lParam);
82:
83:
84: case WM_DESTROY:
85: /*
86: * We want to clean up before DestroyWindow nukes all the
87: * children, so WM_DESTROY is a better to do it than
88: * WM_NCDESTROY.
89: */
90: GizmoBarPFree(pGB);
91: break;
92:
93:
94: case WM_ERASEBKGND:
95: /*
96: * Eat this message to avoid erasing portions that
97: * we are going to repaint in WM_PAINT. Part of a
98: * change-state-and-repaint strategy is to rely on
99: * WM_PAINT to do anything visual, which includes
100: * erasing invalid portions. Letting WM_ERASEBKGND
101: * erase the background is redundant.
102: */
103: return TRUE;
104:
105: #ifdef WIN32
106: case WM_CTLCOLORBTN:
107: case WM_CTLCOLORSTATIC:
108: #else
109: case WM_CTLCOLOR:
110: /*
111: * Change the color of static text on the GizmoBar.
112: */
113: if (HIWORD(lParam)==CTLCOLOR_STATIC || HIWORD(lParam)==CTLCOLOR_BTN)
114: #endif
115: {
116: cr=GetSysColor(COLOR_BTNFACE);
117: SetTextColor((HDC)wParam, GetSysColor(COLOR_BTNTEXT));
118: SetBkColor((HDC)wParam, cr);
119:
120: /*
121: * If the system colors have changed, then crFace will
122: * not be equal to COLOR_BTNFACE, so we reinitialize the
123: * background brush. This scheme handles system color
124: * changes appropriately without processing WM_WININICHANGE
125: * and without blindly creating a new brush on every
126: * WM_CTLCOLOR message.
127: */
128: if (cr!=pGB->crFace)
129: {
130: pGB->crFace=cr;
131:
132: if (NULL!=pGB->hBrFace)
133: DeleteObject(pGB->hBrFace);
134:
135: pGB->hBrFace=CreateSolidBrush(pGB->crFace);
136: }
137:
138: return (LONG)(UINT)pGB->hBrFace;
139: }
140:
141: return DefWindowProc(hWnd, iMsg, wParam, lParam);
142:
143:
144: case WM_PAINT:
145: GizmoBarPaint(hWnd, pGB);
146: break;
147:
148:
149: case WM_SETFONT:
150: /*
151: * wParam has the new font that we now send to all other
152: * windows controls in us. We control repaints here to
153: * prevent a lot of repainting for each control.
154: */
155: DefWindowProc(hWnd, WM_SETREDRAW, FALSE, 0L);
156: #ifdef WIN32
157: if ( (WPARAM)NULL != wParam)
158: #else
159: if ((WPARAM)NULL!=wParam && IsGDIObject((HFONT)wParam))
160: #endif
161: {
162: pGB->hFont=(HFONT)wParam;
163: GizmoPEnum(&pGB->pGizmos, FEnumChangeFont, (DWORD)(LPSTR)pGB);
164:
165: DefWindowProc(hWnd, WM_SETREDRAW, TRUE, 0L);
166: InvalidateRect(hWnd, NULL, FALSE);
167: UpdateWindow(hWnd);
168: }
169: break;
170:
171:
172: case WM_GETFONT:
173: return (LRESULT)(UINT)pGB->hFont;
174:
175:
176: case WM_ENABLE:
177: /*
178: * wParam has the new enable flag that we use to enable
179: * or disable ALL controls in us at one time. We also turn
180: * the redraw off to prevent a lot of flicker.
181: */
182: DefWindowProc(hWnd, WM_SETREDRAW, FALSE, 0L);
183:
184: pGB->fEnabled=(BOOL)wParam;
185: GizmoPEnum(&pGB->pGizmos, FEnumEnable, (DWORD)(LPSTR)pGB);
186:
187: DefWindowProc(hWnd, WM_SETREDRAW, TRUE, 0L);
188: InvalidateRect(hWnd, NULL, FALSE);
189: UpdateWindow(hWnd);
190: break;
191:
192:
193: case WM_CANCELMODE:
194: pGizmo=pGB->pGizmoTrack;
195:
196: pGB->fTracking=FALSE;
197: pGB->fMouseOut=FALSE;
198:
199: if (NULL!=pGizmo)
200: GizmoPStateSet(hWnd, pGizmo, COMMANDBUTTON_UP);
201:
202: ReleaseCapture();
203: break;
204:
205:
206: case WM_LBUTTONDBLCLK:
207: case WM_LBUTTONDOWN:
208: //Get the mouse coordinates.
209: x=LOWORD(lParam);
210: y=HIWORD(lParam);
211:
212:
213: /*
214: * See if we hit a command or attribute gizmo or not. Anything
215: * else that is a control will get the message instead of
216: * us anyway, so we don't have to check. FEnumHitTest also
217: * validates drawn gizmos, enabled, and visible, so we don't.
218: */
219: pGizmo=GizmoPEnum(&pGB->pGizmos, FEnumHitTest, lParam);
220:
221: if (NULL==pGizmo)
222: break; //Didn't hit one matching our needs.
223:
224: /*
225: * Inform the associate that a command was hit like a menu item.
226: */
227: if (NULL!=pGB->hWndAssociate)
228: {
229: if (pGizmo->fNotify)
230: SendMenuSelect(pGB->hWndAssociate, pGizmo->uID, 0, 0);
231: }
232:
233: /*
234: * We hit a button. If it's a command or attribute, then change
235: * the state and start tracking.
236: */
237: pGB->fTracking=TRUE;
238: pGB->pGizmoTrack=pGizmo;
239: pGB->fMouseOut=FALSE;
240: SetCapture(hWnd);
241:
242: pGizmo->uStateOrg=pGizmo->uState;
243: GizmoPStateSet(hWnd, pGizmo, ATTRIBUTEBUTTON_MOUSEDOWN);
244:
245: break;
246:
247:
248: case WM_MOUSEMOVE:
249: {
250: POINT point;
251: #ifdef WIN32
252: point.x = (LONG)(SHORT)LOWORD(lParam);
253: point.y = (LONG)(SHORT)HIWORD(lParam);
254: #else
255: point.x = LOWORD(lParam);
256: point.y = HIWORD(lParam);
257: #endif
258: if (!pGB->fTracking)
259: break;
260:
261: pGizmo=pGB->pGizmoTrack;
262: SetRect(&rc, pGizmo->x, pGizmo->y, pGizmo->x+pGizmo->dx, pGizmo->y+pGizmo->dy);
263:
264: fTemp=pGB->fMouseOut;
265: pGB->fMouseOut=!PtInRect(&rc, point);
266:
267: //If the mouse went out, change state to the original.
268: if (!fTemp && pGB->fMouseOut)
269: {
270: GizmoPStateSet(hWnd, pGizmo, pGizmo->uStateOrg);
271:
272: if (NULL!=pGB->hWndAssociate)
273: {
274: //Notify that we left the button
275: if (pGizmo->fNotify)
276: SendMenuSelect(pGB->hWndAssociate, 0x0000, 0xFFFF, 0);
277: }
278: }
279:
280: if (fTemp && !pGB->fMouseOut)
281: {
282: GizmoPStateSet(hWnd, pGizmo, ATTRIBUTEBUTTON_MOUSEDOWN);
283:
284: if (NULL!=pGB->hWndAssociate)
285: {
286: //Notify that we pressed down again
287: if (pGizmo->fNotify)
288: SendMenuSelect(pGB->hWndAssociate, pGizmo->uID, 0x0000, 0);
289: }
290: }
291:
292: break;
293: }
294:
295: case WM_LBUTTONUP:
296: if (!pGB->fTracking)
297: break;
298:
299: pGB->fTracking=FALSE;
300: pGizmo=pGB->pGizmoTrack;
301: ReleaseCapture();
302:
303:
304: /*
305: * Repaint if we were actually below the mouse when this
306: * occurred. For command buttons, pop the button up. For
307: * attributes, either toggle the state (inclusive buttons)
308: * or check the selected one (exclusive buttons).
309: */
310:
311: if (!pGB->fMouseOut)
312: {
313: //Command buttons always come up.
314: if (GIZMOTYPE_BUTTONCOMMAND==pGizmo->iType)
315: GizmoPStateSet(hWnd, pGizmo, COMMANDBUTTON_UP);
316:
317: //Attribute inclusive buttons toggle
318: if (GIZMOTYPE_BUTTONATTRIBUTEIN==pGizmo->iType)
319: GizmoPCheck(hWnd, pGizmo, !(BUTTONGROUP_DOWN & pGizmo->uStateOrg));
320:
321: //Attribure exclusive buttons are always checked.
322: if (GIZMOTYPE_BUTTONATTRIBUTEEX==pGizmo->iType)
323: GizmoPCheck(hWnd, pGizmo, TRUE);
324:
325: //Only send messages if notify is ON.
326: if (NULL!=pGB->hWndAssociate && pGizmo->fNotify)
327: {
328: SendMenuSelect(pGB->hWndAssociate, 0, 0xFFFF, 0);
329: SendCommand(pGB->hWndAssociate, pGizmo->uID, BN_CLICKED, hWnd);
330: }
331: }
332:
333: break;
334:
335:
336: case WM_COMMAND:
337: //Pass control messages on if the gizmo's notify is ON.
338: if (NULL!=pGB->hWndAssociate)
339: {
340: pGizmo=PGizmoFromHwndID(hWnd, wID);
341:
342: if (NULL!=pGizmo)
343: {
344: if (pGizmo->fNotify)
345: SendMessage(pGB->hWndAssociate, iMsg, wParam, lParam);
346: }
347: }
348: break;
349:
350: default:
351: return DefWindowProc(hWnd, iMsg, wParam, lParam);
352: }
353:
354: return 0L;
355: }
356:
357:
358:
359:
360:
361: /*
362: * FEnumChangeFont
363: *
364: * Purpose:
365: * Enumeration callback for all the gizmos we know about in order to
366: * send a new font to them that's stored in PGIZMOBAR in dw.
367: *
368: * Parameters:
369: * pGizmo PGIZMO to draw.
370: * iGizmo UINT index on the GizmoBar of this gizmo.
371: * dw DWORD extra data passed to GizmoPEnum, in our case
372: * the GizmoBar's pGB.
373: *
374: * Return Value:
375: * BOOL TRUE to continue the enumeration, FALSE otherwise.
376: */
377:
378: BOOL FAR PASCAL FEnumChangeFont(PGIZMO pGizmo, UINT iGizmo, DWORD dw)
379: {
380: PGIZMOBAR pGB=(PGIZMOBAR)dw;
381:
382: //We only need to change fonts in windowed controls using WM_SETFONT
383: if (NULL!=pGizmo->hWnd)
384: SendMessage(pGizmo->hWnd, WM_SETFONT, (WPARAM)pGB->hFont, 1L);
385:
386: return TRUE;
387: }
388:
389:
390:
391:
392:
393:
394: /*
395: * FEnumEnable
396: *
397: * Purpose:
398: * Enumeration callback for all the gizmos we know about in order to
399: * enable or disable them from the WM_ENABLE message.
400: *
401: * Parameters:
402: * pGizmo PGIZMO to draw.
403: * iGizmo UINT index on the GizmoBar of this gizmo.
404: * dw DWORD extra data passed to GizmoPEnum, in our case
405: * the GizmoBar's pGB.
406: *
407: * Return Value:
408: * BOOL TRUE to continue the enumeration, FALSE otherwise.
409: */
410:
411: BOOL FAR PASCAL FEnumEnable(PGIZMO pGizmo, UINT iGizmo, DWORD dw)
412: {
413: PGIZMOBAR pGB=(PGIZMOBAR)dw;
414: BOOL fEnable=pGB->fEnabled;
415:
416: //NOTE: This code is duplicated in GBGizmoEnable in API.C
417: if (NULL!=pGizmo->hWnd)
418: EnableWindow(pGizmo->hWnd, fEnable);
419: else
420: {
421: //If we're not down, command and attribute buttons act the same.
422: if (!(BUTTONGROUP_DOWN & pGizmo->uState))
423: {
424: GizmoPStateSet(pGB->hWnd, pGizmo
425: , fEnable ? COMMANDBUTTON_UP : COMMANDBUTTON_DISABLED);
426: }
427: else
428: {
429: //Attribute buttons are a little more sensitive with DOWNDISABLED
430: GizmoPStateSet(pGB->hWnd, pGizmo
431: , fEnable ? ATTRIBUTEBUTTON_DOWN : ATTRIBUTEBUTTON_DOWNDISABLED);
432: }
433: }
434:
435: return TRUE;
436: }
437:
438:
439:
440:
441:
442:
443:
444: /*
445: * FEnumHitTest
446: *
447: * Purpose:
448: * Enumeration callback for all the gizmos we know about in order to
449: * hit-test them.
450: *
451: * Parameters:
452: * pGizmo PGIZMO to draw.
453: * iGizmo UINT index on the GizmoBar of this gizmo.
454: * dw DWORD extra data passed to GizmoPEnum, in our case
455: * the hDC on which to draw.
456: *
457: * Return Value:
458: * BOOL TRUE to continue the enumeration, FALSE otherwise.
459: */
460:
461: BOOL FAR PASCAL FEnumHitTest(PGIZMO pGizmo, UINT iGizmo, DWORD dw)
462: {
463: RECT rc;
464: POINT point;
465: #ifdef WIN32
466: point.x = (LONG)(SHORT)LOWORD(dw);
467: point.y = (LONG)(SHORT)HIWORD(dw);
468: #else
469: point.x = LOWORD(dw);
470: point.y = HIWORD(dw);
471: #endif
472:
473:
474: //Hit tests have to happen on visible, enabled, and drawn controls only.
475: if (GIZMOTYPE_DRAWN & pGizmo->iType
476: && !pGizmo->fHidden && !(BUTTONGROUP_DISABLED & pGizmo->uState))
477: {
478: SetRect(&rc, pGizmo->x, pGizmo->y, pGizmo->x+pGizmo->dx, pGizmo->y+pGizmo->dy);
479:
480: //Stop enumeration if we have a hit.
481: return !PtInRect(&rc, point);
482: }
483:
484: return TRUE;
485: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.