![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to menu.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 menu.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: menu.c
14: *
15: * Contains the main menu switching functions and the clipboard functions.
16: *
17: * Functions:
18: * DialogMenu()
19: * LoadMenuBitmaps()
20: * FreeMenuBitmaps()
21: * InitMenu()
22: * MsgFilterHookFunc()
23: * ShowHelp()
24: * CopyToClipboard()
25: * DlgInClipboard()
26: * PasteFromClipboard()
27: * GetHelpContext()
28: *
29: * Comments:
30: *
31: ****************************************************************************/
32:
33: #include "dlgedit.h"
34: #include "dlgfuncs.h"
35: #include "dlgextrn.h"
36: #include "dialogs.h"
37:
38: #include <string.h>
39:
40:
41: #define MM10PERINCH 254 // Tenths of a millimeter per inch.
42:
43: typedef struct {
44: WORD idm;
45: INT idbm;
46: HBITMAP hbm;
47: } BITMAPMENU;
48:
49:
50: STATICFN VOID CopyToClipboard(VOID);
51: STATICFN BOOL DlgInClipboard(VOID);
52: STATICFN VOID PasteFromClipboard(VOID);
53: STATICFN INT GetHelpContext(INT idSubject, PHELPMAP phmap);
54:
55:
56: static BITMAPMENU bmpmenuTable[] = {
57: {MENU_ALIGNLEFT, IDBM_ALEFT, NULL },
58: {MENU_ALIGNVERT, IDBM_AVERT, NULL },
59: {MENU_ALIGNRIGHT, IDBM_ARIGHT, NULL },
60: {MENU_ALIGNTOP, IDBM_ATOP, NULL },
61: {MENU_ALIGNHORZ, IDBM_AHORZ, NULL },
62: {MENU_ALIGNBOTTOM, IDBM_ABOTTOM, NULL },
63: {MENU_SPACEVERT, IDBM_ASPCVERT, NULL },
64: {MENU_SPACEHORZ, IDBM_ASPCHORZ, NULL },
65: {MENU_ARRSIZEWIDTH, IDBM_ASZWIDTH, NULL },
66: {MENU_ARRSIZEHEIGHT, IDBM_ASZHGHT, NULL },
67: {MENU_ARRPUSHBOTTOM, IDBM_APBBOTTM, NULL },
68: {MENU_ARRPUSHRIGHT, IDBM_APBRIGHT, NULL }
69: };
70:
71:
72:
73: /************************************************************************
74: * DialogMenu
75: *
76: * This is the main switching function to send menu commands to the
77: * appropriate function.
78: *
79: * Arguments:
80: * INT - the menu command
81: *
82: ************************************************************************/
83:
84: VOID DialogMenu(
85: INT cmd)
86: {
87: /*
88: * Be sure any outstanding changes get applied without errors.
89: */
90: if (!StatusApplyChanges())
91: return;
92:
93: switch (cmd) {
94:
95: /*
96: * File menu ----------------------------------------------------
97: */
98:
99: case MENU_NEWRES:
100: if (DoWeSave(FILE_INCLUDE) == IDCANCEL ||
101: DoWeSave(FILE_RESOURCE) == IDCANCEL)
102: break;
103:
104: FreeInclude();
105: FreeRes();
106: AddNewDialog();
107: ShowFileStatus(TRUE);
108: break;
109:
110: case MENU_OPEN:
111: if (DoWeSave(FILE_INCLUDE) == IDCANCEL ||
112: DoWeSave(FILE_RESOURCE) == IDCANCEL)
113: break;
114:
115: Open(FILE_RESOURCE);
116:
117: break;
118:
119: case MENU_SAVE:
120: if (gfIncChged) {
121: if (!Save(FILE_NOSHOW | FILE_INCLUDE))
122: break;
123: }
124:
125: if (gfResChged)
126: Save(FILE_NOSHOW | FILE_RESOURCE);
127:
128: break;
129:
130: case MENU_SAVEAS:
131: /*
132: * Save the include file, but only if there is one.
133: */
134: if (pszIncludeFile || plInclude) {
135: if (!Save(FILE_NOSHOW | FILE_INCLUDE | FILE_SAVEAS))
136: break;
137: }
138:
139: /*
140: * Save the resource file.
141: */
142: Save(FILE_NOSHOW | FILE_RESOURCE | FILE_SAVEAS);
143:
144: break;
145:
146: case MENU_NEWCUST:
147: DlgBox(DID_NEWCUST, (WNDPROC)NewCustDlgProc);
148: break;
149:
150: case MENU_OPENCUST:
151: OpenCustomDialog();
152: break;
153:
154: case MENU_REMCUST:
155: DlgBox(DID_REMCUST, (WNDPROC)RemCustDlgProc);
156: break;
157:
158: case MENU_SETINCLUDE:
159: if (DoWeSave(FILE_INCLUDE) != IDCANCEL)
160: Open(FILE_INCLUDE);
161:
162: break;
163:
164: case MENU_EXIT:
165: PostMessage(ghwndMain, WM_CLOSE, 0, 0L);
166: break;
167:
168: /*
169: * Edit menu ----------------------------------------------------
170: */
171:
172: case MENU_RESTOREDIALOG:
173: RestoreDialog();
174: break;
175:
176: case MENU_CUT:
177: case MENU_COPY:
178: if (gfEditingDlg) {
179: /*
180: * Save current stuff in clipboard.
181: */
182: CopyToClipboard();
183:
184: /*
185: * Clear the selection if they did a "cut" instead of
186: * a "copy".
187: */
188: if (cmd == MENU_CUT)
189: DeleteControl();
190: }
191:
192: break;
193:
194: case MENU_PASTE:
195: PasteFromClipboard();
196: break;
197:
198: case MENU_DELETE:
199: DeleteControl();
200: break;
201:
202: case MENU_DUPLICATE:
203: Duplicate();
204: break;
205:
206: case MENU_SYMBOLS:
207: ViewInclude();
208: break;
209:
210: case MENU_STYLES:
211: StylesDialog();
212: break;
213:
214: case MENU_SIZETOTEXT:
215: SizeToText();
216: break;
217:
218: case MENU_NEWDIALOG:
219: AddNewDialog();
220: break;
221:
222: case MENU_SELECTDIALOG:
223: SelectDialogDialog();
224: break;
225:
226: /*
227: * Arrange menu -------------------------------------------------
228: */
229:
230: case MENU_ALIGNLEFT:
231: case MENU_ALIGNVERT:
232: case MENU_ALIGNRIGHT:
233: case MENU_ALIGNTOP:
234: case MENU_ALIGNHORZ:
235: case MENU_ALIGNBOTTOM:
236: AlignControls(cmd);
237: break;
238:
239: case MENU_SPACEVERT:
240: case MENU_SPACEHORZ:
241: ArrangeSpacing(cmd);
242: break;
243:
244: case MENU_ARRSIZEWIDTH:
245: case MENU_ARRSIZEHEIGHT:
246: ArrangeSize(cmd);
247: break;
248:
249: case MENU_ARRPUSHBOTTOM:
250: case MENU_ARRPUSHRIGHT:
251: ArrangePushButtons(cmd);
252: break;
253:
254: case MENU_ORDERGROUP:
255: OrderGroupDialog();
256: break;
257:
258: case MENU_ARRSETTINGS:
259: ArrangeSettingsDialog();
260: break;
261:
262: /*
263: * Options menu -------------------------------------------------
264: */
265:
266: case MENU_TESTMODE:
267: if (gfTestMode)
268: DestroyTestDialog();
269: else
270: CreateTestDialog();
271:
272: break;
273:
274: case MENU_HEXMODE:
275: /*
276: * Flip the flag, and update the status display so that
277: * the id value will be displayed in the new format.
278: */
279: gfHexMode = gfHexMode ? FALSE : TRUE;
280: StatusUpdate();
281: break;
282:
283: case MENU_TRANSLATE:
284: /*
285: * Flip the flag, and set the enable state of the fields
286: * in the status window. Changing the translate mode can
287: * effect whether they are allowed to change ids of controls.
288: */
289: gfTranslateMode = gfTranslateMode ? FALSE : TRUE;
290:
291: /*
292: * If they turned on Translate mode, reset the tool and
293: * hide the Toolbox. Otherwise, show the toolbox if they
294: * want it shown.
295: */
296: if (gfTranslateMode) {
297: ToolboxShow(FALSE);
298: ToolboxSelectTool(W_NOTHING, FALSE);
299: }
300: else if (gfShowToolbox) {
301: ToolboxShow(TRUE);
302: }
303:
304: StatusSetEnable();
305: break;
306:
307: case MENU_USENEWKEYWORDS:
308: /*
309: * Flip the flag.
310: */
311: gfUseNewKeywords = gfUseNewKeywords ? FALSE : TRUE;
312: break;
313:
314: case MENU_SHOWTOOLBOX:
315: /*
316: * Toggle the state of the Toolbox.
317: */
318: gfShowToolbox = gfShowToolbox ? FALSE : TRUE;
319: ToolboxShow(gfShowToolbox);
320:
321: break;
322:
323: /*
324: * Help menu ----------------------------------------------------
325: */
326:
327: case MENU_CONTENTS:
328: WinHelp(ghwndMain, gszHelpFile, HELP_CONTENTS, 0L);
329: break;
330:
331: case MENU_SEARCH:
332: /*
333: * Tell winhelp to be sure this app's help file is current,
334: * then invoke a search with an empty starting key.
335: */
336: WinHelp(ghwndMain, gszHelpFile, HELP_FORCEFILE, 0);
337: WinHelp(ghwndMain, gszHelpFile, HELP_PARTIALKEY, (DWORD)szEmpty);
338: break;
339:
340: case MENU_ABOUT:
341: DlgBox(DID_ABOUT, (WNDPROC)AboutDlgProc);
342: break;
343:
344: /*
345: * Hidden menu commands (accessed by accelerators) --------------
346: */
347:
348: case MENU_HIDDEN_TOTOOLBOX:
349: if (ghwndToolbox && IsWindowVisible(ghwndToolbox))
350: SetFocus(ghwndToolbox);
351:
352: break;
353:
354: case MENU_HIDDEN_TOPROPBAR:
355: SetFocus(hwndStatus);
356: break;
357: }
358: }
359:
360:
361:
362: /************************************************************************
363: * LoadMenuBitmaps
364: *
365: * This function loads and inserts the menu items that are bitmaps.
366: * This has to be done at runtime because windows does not have a
367: * way to specify bitmap menu items in the rc file.
368: *
369: * Arguments:
370: * HMENU hMenu - The menu handle.
371: *
372: ************************************************************************/
373:
374: VOID LoadMenuBitmaps(
375: HMENU hMenu)
376: {
377: INT i;
378:
379: for (i = 0; i < sizeof(bmpmenuTable) / sizeof(BITMAPMENU); i++) {
380: bmpmenuTable[i].hbm =
381: LoadBitmap(ghInst, MAKEINTRESOURCE(bmpmenuTable[i].idbm));
382:
383: ModifyMenu(hMenu, bmpmenuTable[i].idm,
384: MF_BYCOMMAND | MF_BITMAP, bmpmenuTable[i].idm,
385: (LPTSTR)(DWORD)bmpmenuTable[i].hbm);
386: }
387: }
388:
389:
390:
391: /************************************************************************
392: * FreeMenuBitmaps
393: *
394: * This function frees the menu bitmaps that were loaded by
395: * LoadMenuBitmaps. This function should be called only when
396: * the application is exiting, because it frees the bitmaps
397: * without removing them from the menu first.
398: *
399: ************************************************************************/
400:
401: VOID FreeMenuBitmaps(VOID)
402: {
403: INT i;
404:
405: for (i = 0; i < sizeof(bmpmenuTable) / sizeof(BITMAPMENU); i++)
406: if (bmpmenuTable[i].hbm)
407: DeleteObject(bmpmenuTable[i].hbm);
408: }
409:
410:
411:
412: /************************************************************************
413: * InitMenu
414: *
415: * This function grays/enables and checks/unchecks the menu items
416: * appropriately for the given state.
417: *
418: * Arguments:
419: * HMENU hMenu - The menu handle.
420: *
421: ************************************************************************/
422:
423: VOID InitMenu(
424: HMENU hMenu)
425: {
426: register INT i;
427: BOOL fEnable;
428: NPCTYPE npc;
429: HMENU hMenuArrange;
430:
431: MyEnableMenuItem(hMenu, MENU_NEWRES, !gfTranslateMode);
432:
433: MyEnableMenuItem(hMenu, MENU_SAVE,
434: (gfEditingDlg || gprlHead) && (gfResChged || gfIncChged));
435:
436: MyEnableMenuItem(hMenu, MENU_SAVEAS, gfEditingDlg || gprlHead);
437:
438: MyEnableMenuItem(hMenu, MENU_SETINCLUDE,
439: (gfEditingDlg || gprlHead) && !gfTranslateMode);
440:
441: MyEnableMenuItem(hMenu, MENU_REMCUST, gpclHead);
442:
443: MyEnableMenuItem(hMenu, MENU_RESTOREDIALOG, gfDlgChanged && gcd.prl);
444:
445: MyEnableMenuItem(hMenu, MENU_CUT,
446: gnpcSel && gfEditingDlg && !gfTranslateMode);
447:
448: MyEnableMenuItem(hMenu, MENU_COPY, gnpcSel && gfEditingDlg);
449:
450: MyEnableMenuItem(hMenu, MENU_PASTE, !gfTranslateMode &&
451: IsClipboardFormatAvailable(fmtDlg) &&
452: (gfEditingDlg || DlgInClipboard()));
453:
454: MyEnableMenuItem(hMenu, MENU_DELETE, gnpcSel && !gfTranslateMode);
455:
456: MyEnableMenuItem(hMenu, MENU_DUPLICATE, gnpcSel && !gfTranslateMode);
457:
458: MyEnableMenuItem(hMenu, MENU_SYMBOLS,
459: (gfEditingDlg || gprlHead) && !gfTranslateMode);
460:
461: MyEnableMenuItem(hMenu, MENU_STYLES, gnpcSel && !gfTranslateMode);
462:
463: /*
464: * For the "Size to text" menu command to be enabled, there
465: * must be at least one control selected, and one of the
466: * controls selected has to be able to be sized to its text.
467: */
468: fEnable = FALSE;
469: if (gcSelected) {
470: for (npc = npcHead; npc; npc = npc->npcNext) {
471: if (npc->fSelected && npc->pwcd->fSizeToText) {
472: fEnable = TRUE;
473: break;
474: }
475: }
476: }
477:
478: MyEnableMenuItem(hMenu, MENU_SIZETOTEXT, fEnable);
479:
480: MyEnableMenuItem(hMenu, MENU_NEWDIALOG, !gfTranslateMode);
481:
482: MyEnableMenuItem(hMenu, MENU_SELECTDIALOG, gfEditingDlg || gprlHead);
483:
484: hMenuArrange = GetSubMenu(hMenu, MENUPOS_ARRANGE);
485:
486: MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGEALIGN, gcSelected > 1);
487:
488: MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGESPACE, gcSelected > 1);
489:
490: /*
491: * For the "Same size" menu option to be enabled, there
492: * must be more than one control selected, and they
493: * must be sizeable controls.
494: */
495: fEnable = FALSE;
496: if (gcSelected > 1) {
497: for (i = 0, npc = npcHead; npc; npc = npc->npcNext) {
498: if (npc->fSelected && npc->pwcd->fSizeable) {
499: i++;
500:
501: if (i > 1) {
502: fEnable = TRUE;
503: break;
504: }
505: }
506: }
507: }
508:
509: MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGESIZE, fEnable);
510:
511: /*
512: * For the Arrange/Push buttons menu item to be enabled,
513: * there must be a dialog up and it must have at least one
514: * push button. In addition, if there are control(s) other
515: * than the dialog selected, at least one of the selected
516: * controls must be a push button.
517: */
518: fEnable = FALSE;
519: if (gfEditingDlg || gprlHead) {
520: if (!gcSelected || gfDlgSelected) {
521: for (npc = npcHead; npc; npc = npc->npcNext) {
522: if (npc->pwcd->iType == W_PUSHBUTTON) {
523: fEnable = TRUE;
524: break;
525: }
526: }
527: }
528: else {
529: for (npc = npcHead; npc; npc = npc->npcNext) {
530: if (npc->pwcd->iType == W_PUSHBUTTON && npc->fSelected) {
531: fEnable = TRUE;
532: break;
533: }
534: }
535: }
536: }
537:
538: MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGEPUSH, fEnable);
539:
540: MyEnableMenuItem(hMenu, MENU_ORDERGROUP,
541: npcHead && !gfTranslateMode && !gfTestMode && cWindows > 1);
542:
543: MyEnableMenuItem(hMenu, MENU_TESTMODE, gfEditingDlg);
544: MyCheckMenuItem(hMenu, MENU_TESTMODE, gfTestMode);
545:
546: MyEnableMenuItem(hMenu, MENU_HEXMODE, !gfTestMode);
547: MyCheckMenuItem(hMenu, MENU_HEXMODE, gfHexMode);
548:
549: MyEnableMenuItem(hMenu, MENU_TRANSLATE, !gfTestMode);
550: MyCheckMenuItem(hMenu, MENU_TRANSLATE, gfTranslateMode);
551:
552: MyEnableMenuItem(hMenu, MENU_USENEWKEYWORDS, !gfTestMode);
553: MyCheckMenuItem(hMenu, MENU_USENEWKEYWORDS, gfUseNewKeywords);
554:
555: MyEnableMenuItem(hMenu, MENU_SHOWTOOLBOX, !gfTestMode && !gfTranslateMode);
556: MyCheckMenuItem(hMenu, MENU_SHOWTOOLBOX, gfShowToolbox);
557: }
558:
559:
560:
561: /************************************************************************
562: * CopyToClipboard
563: *
564: * Puts the current dialog and a bitmap image of it into the clipboard.
565: * Gives a dialog box resource to the Clipboard.
566: * Gives a bit map to the clipboard.
567: * Clears everything else out of clipboard.
568: *
569: ************************************************************************/
570:
571: STATICFN VOID CopyToClipboard(VOID)
572: {
573: INT cbRes;
574: HANDLE hResClip;
575: PRES lpRes;
576: PRES pRes;
577: HDC hdcSrc;
578: HDC hdcDst;
579: RECT rc;
580: HBITMAP hbm;
581:
582: /*
583: * Store the current selection in a dialog resource.
584: */
585: if (!(pRes = AllocDialogResource(FALSE, TRUE)))
586: return;
587:
588: /*
589: * Allocate global memory for it.
590: */
591: cbRes = ResourceSize(pRes);
592: if (!cbRes || !(hResClip = GlobalAlloc(GHND | GMEM_DDESHARE, cbRes))) {
593: MyFree(pRes);
594: Message(MSG_OUTOFMEMORY);
595: return;
596: }
597:
598: /*
599: * Copy it to the global memory.
600: */
601: lpRes = (PRES)GlobalLock(hResClip);
602: memcpy(lpRes, pRes, cbRes);
603: GlobalUnlock(hResClip);
604: MyFree(pRes);
605:
606: /*
607: * Now place it in the clipboard.
608: */
609: if (OpenClipboard(ghwndMain)) {
610: EmptyClipboard();
611: SetClipboardData(fmtDlg, hResClip);
612:
613: /*
614: * If the dialog is selected, place a bitmap image of it
615: * in the clipboard also. The drag handles will be removed
616: * first and the dialog will be activated so that the
617: * image looks proper.
618: */
619: if (gfDlgSelected) {
620: CancelSelection(FALSE);
621: SetActiveWindow(gcd.npc->hwnd);
622: UpdateWindow(gcd.npc->hwnd);
623:
624: if (hdcSrc = GetDC(NULL)) {
625: GetWindowRect(gcd.npc->hwnd, &rc);
626: if (hbm = CreateCompatibleBitmap(hdcSrc,
627: rc.right - rc.left, rc.bottom - rc.top)) {
628: if (hdcDst = CreateCompatibleDC(hdcSrc)) {
629: /*
630: * Calculate the dimensions of the bitmap and
631: * convert them to tenths of a millimeter for
632: * setting the size with the SetBitmapDimensionEx
633: * call. This allows programs like WinWord to
634: * retrieve the bitmap and know what size to
635: * display it as.
636: */
637: SetBitmapDimensionEx(hbm,
638: ((rc.right - rc.left) * MM10PERINCH) /
639: GetDeviceCaps(hdcSrc, LOGPIXELSX),
640: ((rc.bottom - rc.top) * MM10PERINCH) /
641: GetDeviceCaps(hdcSrc, LOGPIXELSY),
642: NULL);
643:
644: SelectObject(hdcDst, hbm);
645: BitBlt(hdcDst, 0, 0,
646: rc.right - rc.left, rc.bottom - rc.top,
647: hdcSrc, rc.left, rc.top, SRCCOPY);
648: DeleteDC(hdcDst);
649: SetClipboardData(CF_BITMAP, hbm);
650: }
651: else {
652: DeleteObject(hbm);
653: }
654: }
655:
656: ReleaseDC(NULL, hdcSrc);
657: }
658:
659: SetActiveWindow(ghwndMain);
660: SelectControl(gcd.npc, FALSE);
661: }
662:
663: CloseClipboard();
664: }
665: else {
666: Message(MSG_NOCLIP);
667: }
668: }
669:
670:
671:
672: /************************************************************************
673: * DlgInClipboard
674: *
675: * This function returns TRUE if there is data in the clipboard in the
676: * dialog format, and this data is for a complete dialog, not just for
677: * a group of controls.
678: *
679: ************************************************************************/
680:
681: STATICFN BOOL DlgInClipboard(VOID)
682: {
683: HANDLE hClip;
684: PRES pRes;
685: PDIALOGBOXHEADER pdbh;
686: BOOL fDlgResFound = FALSE;
687:
688: if (!OpenClipboard(ghwndMain))
689: return FALSE;
690:
691: if (hClip = GetClipboardData(fmtDlg)) {
692: pRes = (PRES)GlobalLock(hClip);
693:
694: /*
695: * If cx is CONTROLS_ONLY, then we know that we only
696: * want to copy the controls in the template, not the
697: * entire dialog plus controls.
698: */
699: pdbh = (PDIALOGBOXHEADER)SkipResHeader(pRes);
700: if (pdbh->cx != CONTROLS_ONLY)
701: fDlgResFound = TRUE;
702:
703: GlobalUnlock(hClip);
704: }
705:
706: CloseClipboard();
707:
708: return fDlgResFound;
709: }
710:
711:
712:
713: /************************************************************************
714: * PasteFromClipboard
715: *
716: * This routine pastes any data from the clipboard into the current
717: * resource file. If the data represents a complete dialog, a new dialog
718: * is added. If it represents some controls, the operation to drop them
719: * into the current dialog is begun.
720: *
721: ************************************************************************/
722:
723: STATICFN VOID PasteFromClipboard(VOID)
724: {
725: HANDLE hClip;
726: PRES pResClip;
727: PRES pResCopy;
728: INT cbRes;
729:
730: if (!OpenClipboard(ghwndMain)) {
731: Message(MSG_NOCLIP);
732: return;
733: }
734:
735: if (hClip = GetClipboardData(fmtDlg)) {
736: pResClip = (PRES)GlobalLock(hClip);
737: cbRes = ResourceSize(pResClip);
738:
739: /*
740: * Make a copy of the clipboard data. This needs to be done
741: * because we may need to drag the new controls for a while,
742: * and it is rude to leave the clipboard open that long.
743: */
744: if (pResCopy = (PRES)MyAlloc(cbRes)) {
745: memcpy((PBYTE)pResCopy, (PBYTE)pResClip, cbRes);
746:
747: /*
748: * Now duplicate the dialog or controls in the clipboard.
749: * The pResCopy buffer does NOT need to be freed here, because
750: * it will be freed after the drag operation is complete.
751: */
752: MakeCopyFromRes(pResCopy);
753: }
754:
755: GlobalUnlock(hClip);
756: }
757:
758: CloseClipboard();
759: }
760:
761:
762:
763: /************************************************************************
764: * MsgFilterHookFunc
765: *
766: * This is the exported message filter function that is hooked into
767: * the message stream for detecting the pressing of the F1 key, at
768: * which time it calls up the appropriate help.
769: *
770: ************************************************************************/
771:
772: BOOL APIENTRY MsgFilterHookFunc(
773: INT nCode,
774: WPARAM wParam,
775: LPMSG lpMsg)
776: {
777: if ((nCode == MSGF_MENU || nCode == MSGF_DIALOGBOX) &&
778: (lpMsg->message == WM_KEYDOWN && lpMsg->wParam == VK_F1)) {
779: /*
780: * Display help.
781: */
782: ShowHelp((nCode == MSGF_MENU) ? TRUE : FALSE);
783:
784: /*
785: * Tell Windows to swallow this message.
786: */
787: return 1;
788: }
789:
790: return CallNextHookEx(ghhkMsgFilter, nCode, wParam, (LONG)lpMsg);
791: }
792:
793:
794:
795: /************************************************************************
796: * ShowHelp
797: *
798: * This function is called when the user has requested help. It will
799: * look at the menu state (if fMenuHelp is TRUE) or which dialog
800: * is currently up to determine the help topic, then it calls WinHelp.
801: *
802: * Arguments:
803: * BOOL fMenuHelp - TRUE if this help is for a menu (help was requested
804: * in the menu modal loop). If FALSE, general help
805: * or help for a dialog is assumed.
806: *
807: ************************************************************************/
808:
809: VOID ShowHelp(
810: BOOL fMenuHelp)
811: {
812: INT nHelpContext = 0;
813: HWND hwndFocus;
814:
815: if (fMenuHelp) {
816: nHelpContext = GetHelpContext(gMenuSelected, gahmapMenu);
817: }
818: else {
819: /*
820: * Look for help for the current dialog.
821: */
822: if (gidCurrentDlg) {
823: nHelpContext = GetHelpContext(gidCurrentDlg, gahmapDialog);
824: }
825: else {
826: /*
827: * There is no current dialog. Is the window with the
828: * focus a control on the Properties Bar?
829: */
830: if ((hwndFocus = GetFocus()) && IsChild(hwndStatus, hwndFocus))
831: nHelpContext = GetHelpContext(DID_STATUS, gahmapDialog);
832: }
833: }
834:
835: /*
836: * If there is help context, display it. Otherwise display
837: * the Contents screen.
838: */
839: if (nHelpContext)
840: WinHelp(ghwndMain, gszHelpFile, HELP_CONTEXT, nHelpContext);
841: else
842: WinHelp(ghwndMain, gszHelpFile, HELP_CONTENTS, 0L);
843: }
844:
845:
846:
847: /************************************************************************
848: * GetHelpContext
849: *
850: * This function takes a subject and returns its matching help
851: * context id from the given HELPMAP table.
852: *
853: * Arguments:
854: * INT idSubject - ID of the subject to find the help context for.
855: * PHELPMAP phmap - The help map table. It is assumed that the
856: * last entry in the table has a NULL subject id.
857: *
858: ************************************************************************/
859:
860: STATICFN INT GetHelpContext(
861: INT idSubject,
862: PHELPMAP phmap)
863: {
864: while (phmap->idSubject) {
865: if (phmap->idSubject == idSubject)
866: return phmap->HelpContext;
867:
868: phmap++;
869: }
870:
871: return 0;
872: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.