开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
MENU.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：25k
源码类别：

Windows编程

开发平台：

Visual C++

MENU.C：源码内容
  2. /******************************************************************************
  3. *       This is a part of the Microsoft Source Code Samples. 
  4. *       Copyright (C) 1993-1997 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. ******************************************************************************/
  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. ****************************************************************************/
  33. #include "dlgedit.h"
  34. #include "dlgfuncs.h"
  35. #include "dlgextrn.h"
  36. #include "dialogs.h"
  38. #include <string.h>
  41. #define MM10PERINCH         254         // Tenths of a millimeter per inch.
  43. typedef struct {
  44.     WORD idm;
  45.     INT idbm;
  46.     HBITMAP hbm;
  47. } BITMAPMENU;
  50. STATICFN VOID CopyToClipboard(VOID);
  51. STATICFN BOOL DlgInClipboard(VOID);
  52. STATICFN VOID PasteFromClipboard(VOID);
  53. STATICFN INT GetHelpContext(INT idSubject, PHELPMAP phmap);
  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. };
  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. ************************************************************************/
  84. VOID DialogMenu(
  85.     INT cmd)
  86. {
  87.     /*
  88.      * Be sure any outstanding changes get applied without errors.
  89.      */
  90.     if (!StatusApplyChanges())
  91.         return;
  93.     switch (cmd) {
  95.         /*
  96.          * File menu ----------------------------------------------------
  97.          */
  99.         case MENU_NEWRES:
  100.             if (DoWeSave(FILE_INCLUDE) == IDCANCEL ||
  101.                     DoWeSave(FILE_RESOURCE) == IDCANCEL)
  102.                 break;
  104.             FreeInclude();
  105.             FreeRes();
  106.             AddNewDialog();
  107.             ShowFileStatus(TRUE);
  108.             break;
  110.         case MENU_OPEN:
  111.             if (DoWeSave(FILE_INCLUDE) == IDCANCEL ||
  112.                     DoWeSave(FILE_RESOURCE) == IDCANCEL)
  113.                 break;
  115.             Open(FILE_RESOURCE);
  117.             break;
  119.         case MENU_SAVE:
  120.             if (gfIncChged) {
  121.                 if (!Save(FILE_NOSHOW | FILE_INCLUDE))
  122.                     break;
  123.             }
  125.             if (gfResChged)
  126.                 Save(FILE_NOSHOW | FILE_RESOURCE);
  128.             break;
  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.             }
  139.             /*
  140.              * Save the resource file.
  141.              */
  142.             Save(FILE_NOSHOW | FILE_RESOURCE | FILE_SAVEAS);
  144.             break;
  146.         case MENU_NEWCUST:
  147.             DlgBox(DID_NEWCUST, (WNDPROC)NewCustDlgProc);
  148.             break;
  150.         case MENU_OPENCUST:
  151.             OpenCustomDialog();
  152.             break;
  154.         case MENU_REMCUST:
  155.             DlgBox(DID_REMCUST, (WNDPROC)RemCustDlgProc);
  156.             break;
  158.         case MENU_SETINCLUDE:
  159.             if (DoWeSave(FILE_INCLUDE) != IDCANCEL)
  160.                 Open(FILE_INCLUDE);
  162.             break;
  164.         case MENU_EXIT:
  165.             PostMessage(ghwndMain, WM_CLOSE, 0, 0L);
  166.             break;
  168.         /*
  169.          * Edit menu ----------------------------------------------------
  170.          */
  172.         case MENU_RESTOREDIALOG:
  173.             RestoreDialog();
  174.             break;
  176.         case MENU_CUT:
  177.         case MENU_COPY:
  178.             if (gfEditingDlg) {
  179.                 /*
  180.                  * Save current stuff in clipboard.
  181.                  */
  182.                 CopyToClipboard();
  184.                 /*
  185.                  * Clear the selection if they did a "cut" instead of
  186.                  * a "copy".
  187.                  */
  188.                 if (cmd == MENU_CUT)
  189.                     DeleteControl();
  190.             }
  192.             break;
  194.         case MENU_PASTE:
  195.             PasteFromClipboard();
  196.             break;
  198.         case MENU_DELETE:
  199.             DeleteControl();
  200.             break;
  202.         case MENU_DUPLICATE:
  203.             Duplicate();
  204.             break;
  206.         case MENU_SYMBOLS:
  207.             ViewInclude();
  208.             break;
  210.         case MENU_STYLES:
  211.             StylesDialog();
  212.             break;
  214.         case MENU_SIZETOTEXT:
  215.             SizeToText();
  216.             break;
  218.         case MENU_NEWDIALOG:
  219.             AddNewDialog();
  220.             break;
  222.         case MENU_SELECTDIALOG:
  223.             SelectDialogDialog();
  224.             break;
  226.         /*
  227.          * Arrange menu -------------------------------------------------
  228.          */
  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;
  239.         case MENU_SPACEVERT:
  240.         case MENU_SPACEHORZ:
  241.             ArrangeSpacing(cmd);
  242.             break;
  244.         case MENU_ARRSIZEWIDTH:
  245.         case MENU_ARRSIZEHEIGHT:
  246.             ArrangeSize(cmd);
  247.             break;
  249.         case MENU_ARRPUSHBOTTOM:
  250.         case MENU_ARRPUSHRIGHT:
  251.             ArrangePushButtons(cmd);
  252.             break;
  254.         case MENU_ORDERGROUP:
  255.             OrderGroupDialog();
  256.             break;
  258.         case MENU_ARRSETTINGS:
  259.             ArrangeSettingsDialog();
  260.             break;
  262.         /*
  263.          * Options menu -------------------------------------------------
  264.          */
  266.         case MENU_TESTMODE:
  267.             if (gfTestMode)
  268.                 DestroyTestDialog();
  269.             else
  270.                 CreateTestDialog();
  272.             break;
  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;
  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;
  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.             }
  304.             StatusSetEnable();
  305.             break;
  307.         case MENU_USENEWKEYWORDS:
  308.             /*
  309.              * Flip the flag.
  310.              */
  311.             gfUseNewKeywords = gfUseNewKeywords ? FALSE : TRUE;
  312.             break;
  314.         case MENU_SHOWTOOLBOX:
  315.             /*
  316.              * Toggle the state of the Toolbox.
  317.              */
  318.             gfShowToolbox = gfShowToolbox ? FALSE : TRUE;
  319.             ToolboxShow(gfShowToolbox);
  321.             break;
  323.         /*
  324.          * Help menu ----------------------------------------------------
  325.          */
  327.         case MENU_CONTENTS:
  328.             WinHelp(ghwndMain, gszHelpFile, HELP_CONTENTS, 0L);
  329.             break;
  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;
  340.         case MENU_ABOUT:
  341.             DlgBox(DID_ABOUT, (WNDPROC)AboutDlgProc);
  342.             break;
  344.         /*
  345.          * Hidden menu commands (accessed by accelerators) --------------
  346.          */
  348.         case MENU_HIDDEN_TOTOOLBOX:
  349.             if (ghwndToolbox && IsWindowVisible(ghwndToolbox))
  350.                 SetFocus(ghwndToolbox);
  352.             break;
  354.         case MENU_HIDDEN_TOPROPBAR:
  355.             SetFocus(hwndStatus);
  356.             break;
  357.     }
  358. }
  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. ************************************************************************/
  374. VOID LoadMenuBitmaps(
  375.     HMENU hMenu)
  376. {
  377.     INT i;
  379.     for (i = 0; i < sizeof(bmpmenuTable) / sizeof(BITMAPMENU); i++) {
  380.         bmpmenuTable[i].hbm =
  381.                 LoadBitmap(ghInst, MAKEINTRESOURCE(bmpmenuTable[i].idbm));
  383.         ModifyMenu(hMenu, bmpmenuTable[i].idm,
  384.                 MF_BYCOMMAND | MF_BITMAP, bmpmenuTable[i].idm,
  385.                 (LPTSTR)(DWORD)bmpmenuTable[i].hbm);
  386.     }
  387. }
  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. ************************************************************************/
  401. VOID FreeMenuBitmaps(VOID)
  402. {
  403.     INT i;
  405.     for (i = 0; i < sizeof(bmpmenuTable) / sizeof(BITMAPMENU); i++)
  406.         if (bmpmenuTable[i].hbm)
  407.             DeleteObject(bmpmenuTable[i].hbm);
  408. }
  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. ************************************************************************/
  423. VOID InitMenu(
  424.     HMENU hMenu)
  425. {
  426.     register INT i;
  427.     BOOL fEnable;
  428.     NPCTYPE npc;
  429.     HMENU hMenuArrange;
  431.     MyEnableMenuItem(hMenu, MENU_NEWRES, !gfTranslateMode);
  433.     MyEnableMenuItem(hMenu, MENU_SAVE,
  434.             (gfEditingDlg || gprlHead) && (gfResChged || gfIncChged));
  436.     MyEnableMenuItem(hMenu, MENU_SAVEAS, gfEditingDlg || gprlHead);
  438.     MyEnableMenuItem(hMenu, MENU_SETINCLUDE,
  439.             (gfEditingDlg || gprlHead) && !gfTranslateMode);
  441.     MyEnableMenuItem(hMenu, MENU_REMCUST, gpclHead);
  443.     MyEnableMenuItem(hMenu, MENU_RESTOREDIALOG, gfDlgChanged && gcd.prl);
  445.     MyEnableMenuItem(hMenu, MENU_CUT,
  446.             gnpcSel && gfEditingDlg && !gfTranslateMode);
  448.     MyEnableMenuItem(hMenu, MENU_COPY, gnpcSel && gfEditingDlg);
  450.     MyEnableMenuItem(hMenu, MENU_PASTE, !gfTranslateMode &&
  451.             IsClipboardFormatAvailable(fmtDlg) &&
  452.             (gfEditingDlg || DlgInClipboard()));
  454.     MyEnableMenuItem(hMenu, MENU_DELETE, gnpcSel && !gfTranslateMode);
  456.     MyEnableMenuItem(hMenu, MENU_DUPLICATE, gnpcSel && !gfTranslateMode);
  458.     MyEnableMenuItem(hMenu, MENU_SYMBOLS,
  459.             (gfEditingDlg || gprlHead) && !gfTranslateMode);
  461.     MyEnableMenuItem(hMenu, MENU_STYLES, gnpcSel && !gfTranslateMode);
  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.     }
  478.     MyEnableMenuItem(hMenu, MENU_SIZETOTEXT, fEnable);
  480.     MyEnableMenuItem(hMenu, MENU_NEWDIALOG, !gfTranslateMode);
  482.     MyEnableMenuItem(hMenu, MENU_SELECTDIALOG, gfEditingDlg || gprlHead);
  484.     hMenuArrange = GetSubMenu(hMenu, MENUPOS_ARRANGE);
  486.     MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGEALIGN, gcSelected > 1);
  488.     MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGESPACE, gcSelected > 1);
  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++;
  501.                 if (i > 1) {
  502.                     fEnable = TRUE;
  503.                     break;
  504.                 }
  505.             }
  506.         }
  507.     }
  509.     MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGESIZE, fEnable);
  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.     }
  538.     MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGEPUSH, fEnable);
  540.     MyEnableMenuItem(hMenu, MENU_ORDERGROUP,
  541.             npcHead && !gfTranslateMode && !gfTestMode && cWindows > 1);
  543.     MyEnableMenuItem(hMenu, MENU_TESTMODE, gfEditingDlg);
  544.     MyCheckMenuItem(hMenu, MENU_TESTMODE, gfTestMode);
  546.     MyEnableMenuItem(hMenu, MENU_HEXMODE, !gfTestMode);
  547.     MyCheckMenuItem(hMenu, MENU_HEXMODE, gfHexMode);
  549.     MyEnableMenuItem(hMenu, MENU_TRANSLATE, !gfTestMode);
  550.     MyCheckMenuItem(hMenu, MENU_TRANSLATE, gfTranslateMode);
  552.     MyEnableMenuItem(hMenu, MENU_USENEWKEYWORDS, !gfTestMode);
  553.     MyCheckMenuItem(hMenu, MENU_USENEWKEYWORDS, gfUseNewKeywords);
  555.     MyEnableMenuItem(hMenu, MENU_SHOWTOOLBOX, !gfTestMode && !gfTranslateMode);
  556.     MyCheckMenuItem(hMenu, MENU_SHOWTOOLBOX, gfShowToolbox);
  557. }
  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. ************************************************************************/
  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;
  582.     /*
  583.      * Store the current selection in a dialog resource.
  584.      */
  585.     if (!(pRes = AllocDialogResource(FALSE, TRUE)))
  586.         return;
  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.     }
  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);
  606.     /*
  607.      * Now place it in the clipboard.
  608.      */
  609.     if (OpenClipboard(ghwndMain)) {
  610.         EmptyClipboard();
  611.         SetClipboardData(fmtDlg, hResClip);
  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);
  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);
  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.                 }
  656.                 ReleaseDC(NULL, hdcSrc);
  657.             }
  659.             SetActiveWindow(ghwndMain);
  660.             SelectControl(gcd.npc, FALSE);
  661.         }
  663.         CloseClipboard();
  664.     }
  665.     else {
  666.         Message(MSG_NOCLIP);
  667.     }
  668. }
  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. ************************************************************************/
  681. STATICFN BOOL DlgInClipboard(VOID)
  682. {
  683.     HANDLE hClip;
  684.     PRES pRes;
  685.     PDIALOGBOXHEADER pdbh;
  686.     BOOL fDlgResFound = FALSE;
  688.     if (!OpenClipboard(ghwndMain))
  689.         return FALSE;
  691.     if (hClip = GetClipboardData(fmtDlg)) {
  692.         pRes = (PRES)GlobalLock(hClip);
  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;
  703.         GlobalUnlock(hClip);
  704.     }
  706.     CloseClipboard();
  708.     return fDlgResFound;
  709. }
  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. ************************************************************************/
  723. STATICFN VOID PasteFromClipboard(VOID)
  724. {
  725.     HANDLE hClip;
  726.     PRES pResClip;
  727.     PRES pResCopy;
  728.     INT cbRes;
  730.     if (!OpenClipboard(ghwndMain)) {
  731.         Message(MSG_NOCLIP);
  732.         return;
  733.     }
  735.     if (hClip = GetClipboardData(fmtDlg)) {
  736.         pResClip = (PRES)GlobalLock(hClip);
  737.         cbRes = ResourceSize(pResClip);
  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);
  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.         }
  755.         GlobalUnlock(hClip);
  756.     }
  758.     CloseClipboard();
  759. }
  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. ************************************************************************/
  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);
  784.         /*
  785.          * Tell Windows to swallow this message.
  786.          */
  787.         return 1;
  788.     }
  790.     return CallNextHookEx(ghhkMsgFilter, nCode, wParam, (LONG)lpMsg);
  791. }
  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. ************************************************************************/
  809. VOID ShowHelp(
  810.     BOOL fMenuHelp)
  811. {
  812.     INT nHelpContext = 0;
  813.     HWND hwndFocus;
  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.     }
  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. }
  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. ************************************************************************/
  860. STATICFN INT GetHelpContext(
  861.     INT idSubject,
  862.     PHELPMAP phmap)
  863. {
  864.     while (phmap->idSubject) {
  865.         if (phmap->idSubject == idSubject)
  866.             return phmap->HelpContext;
  868.         phmap++;
  869.     }
  871.     return 0;
  872. }