Return to menu.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / sdktools / dlgedit

Microsoft Windows NT Build 511 (SDK Final Release) 07-24-1993

/******************************************************************************\
*       This is a part of the Microsoft Source Code Samples. 
*       Copyright (C) 1993 Microsoft Corporation.
*       All rights reserved. 
*       This source code is only intended as a supplement to 
*       Microsoft Development Tools and/or WinHelp documentation.
*       See these sources for detailed information regarding the 
*       Microsoft samples programs.
\******************************************************************************/

/****************************** Module Header *******************************
* Module Name: menu.c
*
* Contains the main menu switching functions and the clipboard functions.
*
* Functions:
*   DialogMenu()
*   LoadMenuBitmaps()
*   FreeMenuBitmaps()
*   InitMenu()
*   MsgFilterHookFunc()
*   ShowHelp()
*   CopyToClipboard()
*   DlgInClipboard()
*   PasteFromClipboard()
*   GetHelpContext()
*
* Comments:
*
****************************************************************************/

#include "dlgedit.h"
#include "dlgfuncs.h"
#include "dlgextrn.h"
#include "dialogs.h"

#include <string.h>


#define MM10PERINCH         254         // Tenths of a millimeter per inch.

typedef struct {
    WORD idm;
    INT idbm;
    HBITMAP hbm;
} BITMAPMENU;


STATICFN VOID CopyToClipboard(VOID);
STATICFN BOOL DlgInClipboard(VOID);
STATICFN VOID PasteFromClipboard(VOID);
STATICFN INT GetHelpContext(INT idSubject, PHELPMAP phmap);


static BITMAPMENU bmpmenuTable[] = {
    {MENU_ALIGNLEFT,        IDBM_ALEFT,         NULL },
    {MENU_ALIGNVERT,        IDBM_AVERT,         NULL },
    {MENU_ALIGNRIGHT,       IDBM_ARIGHT,        NULL },
    {MENU_ALIGNTOP,         IDBM_ATOP,          NULL },
    {MENU_ALIGNHORZ,        IDBM_AHORZ,         NULL },
    {MENU_ALIGNBOTTOM,      IDBM_ABOTTOM,       NULL },
    {MENU_SPACEVERT,        IDBM_ASPCVERT,      NULL },
    {MENU_SPACEHORZ,        IDBM_ASPCHORZ,      NULL },
    {MENU_ARRSIZEWIDTH,     IDBM_ASZWIDTH,      NULL },
    {MENU_ARRSIZEHEIGHT,    IDBM_ASZHGHT,       NULL },
    {MENU_ARRPUSHBOTTOM,    IDBM_APBBOTTM,      NULL },
    {MENU_ARRPUSHRIGHT,     IDBM_APBRIGHT,      NULL }
};



/************************************************************************
* DialogMenu
*
* This is the main switching function to send menu commands to the
* appropriate function.
*
* Arguments:
*   INT - the menu command
*
************************************************************************/

VOID DialogMenu(
    INT cmd)
{
    /*
     * Be sure any outstanding changes get applied without errors.
     */
    if (!StatusApplyChanges())
        return;

    switch (cmd) {

        /*
         * File menu ----------------------------------------------------
         */

        case MENU_NEWRES:
            if (DoWeSave(FILE_INCLUDE) == IDCANCEL ||
                    DoWeSave(FILE_RESOURCE) == IDCANCEL)
                break;

            FreeInclude();
            FreeRes();
            AddNewDialog();
            ShowFileStatus(TRUE);
            break;

        case MENU_OPEN:
            if (DoWeSave(FILE_INCLUDE) == IDCANCEL ||
                    DoWeSave(FILE_RESOURCE) == IDCANCEL)
                break;

            Open(FILE_RESOURCE);

            break;

        case MENU_SAVE:
            if (gfIncChged) {
                if (!Save(FILE_NOSHOW | FILE_INCLUDE))
                    break;
            }

            if (gfResChged)
                Save(FILE_NOSHOW | FILE_RESOURCE);

            break;

        case MENU_SAVEAS:
            /*
             * Save the include file, but only if there is one.
             */
            if (pszIncludeFile || plInclude) {
                if (!Save(FILE_NOSHOW | FILE_INCLUDE | FILE_SAVEAS))
                    break;
            }

            /*
             * Save the resource file.
             */
            Save(FILE_NOSHOW | FILE_RESOURCE | FILE_SAVEAS);

            break;

        case MENU_NEWCUST:
            DlgBox(DID_NEWCUST, (WNDPROC)NewCustDlgProc);
            break;

        case MENU_OPENCUST:
            OpenCustomDialog();
            break;

        case MENU_REMCUST:
            DlgBox(DID_REMCUST, (WNDPROC)RemCustDlgProc);
            break;

        case MENU_SETINCLUDE:
            if (DoWeSave(FILE_INCLUDE) != IDCANCEL)
                Open(FILE_INCLUDE);

            break;

        case MENU_EXIT:
            PostMessage(ghwndMain, WM_CLOSE, 0, 0L);
            break;

        /*
         * Edit menu ----------------------------------------------------
         */

        case MENU_RESTOREDIALOG:
            RestoreDialog();
            break;

        case MENU_CUT:
        case MENU_COPY:
            if (gfEditingDlg) {
                /*
                 * Save current stuff in clipboard.
                 */
                CopyToClipboard();

                /*
                 * Clear the selection if they did a "cut" instead of
                 * a "copy".
                 */
                if (cmd == MENU_CUT)
                    DeleteControl();
            }

            break;

        case MENU_PASTE:
            PasteFromClipboard();
            break;

        case MENU_DELETE:
            DeleteControl();
            break;

        case MENU_DUPLICATE:
            Duplicate();
            break;

        case MENU_SYMBOLS:
            ViewInclude();
            break;

        case MENU_STYLES:
            StylesDialog();
            break;

        case MENU_SIZETOTEXT:
            SizeToText();
            break;

        case MENU_NEWDIALOG:
            AddNewDialog();
            break;

        case MENU_SELECTDIALOG:
            SelectDialogDialog();
            break;

        /*
         * Arrange menu -------------------------------------------------
         */

        case MENU_ALIGNLEFT:
        case MENU_ALIGNVERT:
        case MENU_ALIGNRIGHT:
        case MENU_ALIGNTOP:
        case MENU_ALIGNHORZ:
        case MENU_ALIGNBOTTOM:
            AlignControls(cmd);
            break;

        case MENU_SPACEVERT:
        case MENU_SPACEHORZ:
            ArrangeSpacing(cmd);
            break;

        case MENU_ARRSIZEWIDTH:
        case MENU_ARRSIZEHEIGHT:
            ArrangeSize(cmd);
            break;

        case MENU_ARRPUSHBOTTOM:
        case MENU_ARRPUSHRIGHT:
            ArrangePushButtons(cmd);
            break;

        case MENU_ORDERGROUP:
            OrderGroupDialog();
            break;

        case MENU_ARRSETTINGS:
            ArrangeSettingsDialog();
            break;

        /*
         * Options menu -------------------------------------------------
         */

        case MENU_TESTMODE:
            if (gfTestMode)
                DestroyTestDialog();
            else
                CreateTestDialog();

            break;

        case MENU_HEXMODE:
            /*
             * Flip the flag, and update the status display so that
             * the id value will be displayed in the new format.
             */
            gfHexMode = gfHexMode ? FALSE : TRUE;
            StatusUpdate();
            break;

        case MENU_TRANSLATE:
            /*
             * Flip the flag, and set the enable state of the fields
             * in the status window.  Changing the translate mode can
             * effect whether they are allowed to change ids of controls.
             */
            gfTranslateMode = gfTranslateMode ? FALSE : TRUE;

            /*
             * If they turned on Translate mode, reset the tool and
             * hide the Toolbox.  Otherwise, show the toolbox if they
             * want it shown.
             */
            if (gfTranslateMode) {
                ToolboxShow(FALSE);
                ToolboxSelectTool(W_NOTHING, FALSE);
            }
            else if (gfShowToolbox) {
                ToolboxShow(TRUE);
            }

            StatusSetEnable();
            break;

        case MENU_USENEWKEYWORDS:
            /*
             * Flip the flag.
             */
            gfUseNewKeywords = gfUseNewKeywords ? FALSE : TRUE;
            break;

        case MENU_SHOWTOOLBOX:
            /*
             * Toggle the state of the Toolbox.
             */
            gfShowToolbox = gfShowToolbox ? FALSE : TRUE;
            ToolboxShow(gfShowToolbox);

            break;

        /*
         * Help menu ----------------------------------------------------
         */

        case MENU_CONTENTS:
            WinHelp(ghwndMain, gszHelpFile, HELP_CONTENTS, 0L);
            break;

        case MENU_SEARCH:
            /*
             * Tell winhelp to be sure this app's help file is current,
             * then invoke a search with an empty starting key.
             */
            WinHelp(ghwndMain, gszHelpFile, HELP_FORCEFILE, 0);
            WinHelp(ghwndMain, gszHelpFile, HELP_PARTIALKEY, (DWORD)szEmpty);
            break;

        case MENU_ABOUT:
            DlgBox(DID_ABOUT, (WNDPROC)AboutDlgProc);
            break;

        /*
         * Hidden menu commands (accessed by accelerators) --------------
         */

        case MENU_HIDDEN_TOTOOLBOX:
            if (ghwndToolbox && IsWindowVisible(ghwndToolbox))
                SetFocus(ghwndToolbox);

            break;

        case MENU_HIDDEN_TOPROPBAR:
            SetFocus(hwndStatus);
            break;
    }
}



/************************************************************************
* LoadMenuBitmaps
*
* This function loads and inserts the menu items that are bitmaps.
* This has to be done at runtime because windows does not have a
* way to specify bitmap menu items in the rc file.
*
* Arguments:
*   HMENU hMenu - The menu handle.
*
************************************************************************/

VOID LoadMenuBitmaps(
    HMENU hMenu)
{
    INT i;

    for (i = 0; i < sizeof(bmpmenuTable) / sizeof(BITMAPMENU); i++) {
        bmpmenuTable[i].hbm =
                LoadBitmap(ghInst, MAKEINTRESOURCE(bmpmenuTable[i].idbm));

        ModifyMenu(hMenu, bmpmenuTable[i].idm,
                MF_BYCOMMAND | MF_BITMAP, bmpmenuTable[i].idm,
                (LPTSTR)(DWORD)bmpmenuTable[i].hbm);
    }
}



/************************************************************************
* FreeMenuBitmaps
*
* This function frees the menu bitmaps that were loaded by
* LoadMenuBitmaps.  This function should be called only when
* the application is exiting, because it frees the bitmaps
* without removing them from the menu first.
*
************************************************************************/

VOID FreeMenuBitmaps(VOID)
{
    INT i;

    for (i = 0; i < sizeof(bmpmenuTable) / sizeof(BITMAPMENU); i++)
        if (bmpmenuTable[i].hbm)
            DeleteObject(bmpmenuTable[i].hbm);
}



/************************************************************************
* InitMenu
*
* This function grays/enables and checks/unchecks the menu items
* appropriately for the given state.
*
* Arguments:
*   HMENU hMenu - The menu handle.
*
************************************************************************/

VOID InitMenu(
    HMENU hMenu)
{
    register INT i;
    BOOL fEnable;
    NPCTYPE npc;
    HMENU hMenuArrange;

    MyEnableMenuItem(hMenu, MENU_NEWRES, !gfTranslateMode);

    MyEnableMenuItem(hMenu, MENU_SAVE,
            (gfEditingDlg || gprlHead) && (gfResChged || gfIncChged));

    MyEnableMenuItem(hMenu, MENU_SAVEAS, gfEditingDlg || gprlHead);

    MyEnableMenuItem(hMenu, MENU_SETINCLUDE,
            (gfEditingDlg || gprlHead) && !gfTranslateMode);

    MyEnableMenuItem(hMenu, MENU_REMCUST, gpclHead);

    MyEnableMenuItem(hMenu, MENU_RESTOREDIALOG, gfDlgChanged && gcd.prl);

    MyEnableMenuItem(hMenu, MENU_CUT,
            gnpcSel && gfEditingDlg && !gfTranslateMode);

    MyEnableMenuItem(hMenu, MENU_COPY, gnpcSel && gfEditingDlg);

    MyEnableMenuItem(hMenu, MENU_PASTE, !gfTranslateMode &&
            IsClipboardFormatAvailable(fmtDlg) &&
            (gfEditingDlg || DlgInClipboard()));

    MyEnableMenuItem(hMenu, MENU_DELETE, gnpcSel && !gfTranslateMode);

    MyEnableMenuItem(hMenu, MENU_DUPLICATE, gnpcSel && !gfTranslateMode);

    MyEnableMenuItem(hMenu, MENU_SYMBOLS,
            (gfEditingDlg || gprlHead) && !gfTranslateMode);

    MyEnableMenuItem(hMenu, MENU_STYLES, gnpcSel && !gfTranslateMode);

    /*
     * For the "Size to text" menu command to be enabled, there
     * must be at least one control selected, and one of the
     * controls selected has to be able to be sized to its text.
     */
    fEnable = FALSE;
    if (gcSelected) {
        for (npc = npcHead; npc; npc = npc->npcNext) {
            if (npc->fSelected && npc->pwcd->fSizeToText) {
                fEnable = TRUE;
                break;
            }
        }
    }

    MyEnableMenuItem(hMenu, MENU_SIZETOTEXT, fEnable);

    MyEnableMenuItem(hMenu, MENU_NEWDIALOG, !gfTranslateMode);

    MyEnableMenuItem(hMenu, MENU_SELECTDIALOG, gfEditingDlg || gprlHead);

    hMenuArrange = GetSubMenu(hMenu, MENUPOS_ARRANGE);

    MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGEALIGN, gcSelected > 1);

    MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGESPACE, gcSelected > 1);

    /*
     * For the "Same size" menu option to be enabled, there
     * must be more than one control selected, and they
     * must be sizeable controls.
     */
    fEnable = FALSE;
    if (gcSelected > 1) {
        for (i = 0, npc = npcHead; npc; npc = npc->npcNext) {
            if (npc->fSelected && npc->pwcd->fSizeable) {
                i++;

                if (i > 1) {
                    fEnable = TRUE;
                    break;
                }
            }
        }
    }

    MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGESIZE, fEnable);

    /*
     * For the Arrange/Push buttons menu item to be enabled,
     * there must be a dialog up and it must have at least one
     * push button.  In addition, if there are control(s) other
     * than the dialog selected, at least one of the selected
     * controls must be a push button.
     */
    fEnable = FALSE;
    if (gfEditingDlg || gprlHead) {
        if (!gcSelected || gfDlgSelected) {
            for (npc = npcHead; npc; npc = npc->npcNext) {
                if (npc->pwcd->iType == W_PUSHBUTTON) {
                    fEnable = TRUE;
                    break;
                }
            }
        }
        else {
            for (npc = npcHead; npc; npc = npc->npcNext) {
                if (npc->pwcd->iType == W_PUSHBUTTON && npc->fSelected) {
                    fEnable = TRUE;
                    break;
                }
            }
        }
    }

    MyEnableMenuItemByPos(hMenuArrange, MENUPOS_ARRANGEPUSH, fEnable);

    MyEnableMenuItem(hMenu, MENU_ORDERGROUP,
            npcHead && !gfTranslateMode && !gfTestMode && cWindows > 1);

    MyEnableMenuItem(hMenu, MENU_TESTMODE, gfEditingDlg);
    MyCheckMenuItem(hMenu, MENU_TESTMODE, gfTestMode);

    MyEnableMenuItem(hMenu, MENU_HEXMODE, !gfTestMode);
    MyCheckMenuItem(hMenu, MENU_HEXMODE, gfHexMode);

    MyEnableMenuItem(hMenu, MENU_TRANSLATE, !gfTestMode);
    MyCheckMenuItem(hMenu, MENU_TRANSLATE, gfTranslateMode);

    MyEnableMenuItem(hMenu, MENU_USENEWKEYWORDS, !gfTestMode);
    MyCheckMenuItem(hMenu, MENU_USENEWKEYWORDS, gfUseNewKeywords);

    MyEnableMenuItem(hMenu, MENU_SHOWTOOLBOX, !gfTestMode && !gfTranslateMode);
    MyCheckMenuItem(hMenu, MENU_SHOWTOOLBOX, gfShowToolbox);
}



/************************************************************************
* CopyToClipboard
*
* Puts the current dialog and a bitmap image of it into the clipboard.
* Gives a dialog box resource to the Clipboard.
* Gives a bit map to the clipboard.
* Clears everything else out of clipboard.
*
************************************************************************/

STATICFN VOID CopyToClipboard(VOID)
{
    INT cbRes;
    HANDLE hResClip;
    PRES lpRes;
    PRES pRes;
    HDC hdcSrc;
    HDC hdcDst;
    RECT rc;
    HBITMAP hbm;

    /*
     * Store the current selection in a dialog resource.
     */
    if (!(pRes = AllocDialogResource(FALSE, TRUE)))
        return;

    /*
     * Allocate global memory for it.
     */
    cbRes = ResourceSize(pRes);
    if (!cbRes || !(hResClip = GlobalAlloc(GHND | GMEM_DDESHARE, cbRes))) {
        MyFree(pRes);
        Message(MSG_OUTOFMEMORY);
        return;
    }

    /*
     * Copy it to the global memory.
     */
    lpRes = (PRES)GlobalLock(hResClip);
    memcpy(lpRes, pRes, cbRes);
    GlobalUnlock(hResClip);
    MyFree(pRes);

    /*
     * Now place it in the clipboard.
     */
    if (OpenClipboard(ghwndMain)) {
        EmptyClipboard();
        SetClipboardData(fmtDlg, hResClip);

        /*
         * If the dialog is selected, place a bitmap image of it
         * in the clipboard also.  The drag handles will be removed
         * first and the dialog will be activated so that the
         * image looks proper.
         */
        if (gfDlgSelected) {
            CancelSelection(FALSE);
            SetActiveWindow(gcd.npc->hwnd);
            UpdateWindow(gcd.npc->hwnd);

            if (hdcSrc = GetDC(NULL)) {
                GetWindowRect(gcd.npc->hwnd, &rc);
                if (hbm = CreateCompatibleBitmap(hdcSrc,
                        rc.right - rc.left, rc.bottom - rc.top)) {
                    if (hdcDst = CreateCompatibleDC(hdcSrc)) {
                        /*
                         * Calculate the dimensions of the bitmap and
                         * convert them to tenths of a millimeter for
                         * setting the size with the SetBitmapDimensionEx
                         * call.  This allows programs like WinWord to
                         * retrieve the bitmap and know what size to
                         * display it as.
                         */
                        SetBitmapDimensionEx(hbm,
                                ((rc.right - rc.left) * MM10PERINCH) /
                                GetDeviceCaps(hdcSrc, LOGPIXELSX),
                                ((rc.bottom - rc.top) * MM10PERINCH) /
                                GetDeviceCaps(hdcSrc, LOGPIXELSY),
                                NULL);

                        SelectObject(hdcDst, hbm);
                        BitBlt(hdcDst, 0, 0,
                                rc.right - rc.left, rc.bottom - rc.top,
                                hdcSrc, rc.left, rc.top, SRCCOPY);
                        DeleteDC(hdcDst);
                        SetClipboardData(CF_BITMAP, hbm);
                    }
                    else {
                        DeleteObject(hbm);
                    }
                }

                ReleaseDC(NULL, hdcSrc);
            }

            SetActiveWindow(ghwndMain);
            SelectControl(gcd.npc, FALSE);
        }

        CloseClipboard();
    }
    else {
        Message(MSG_NOCLIP);
    }
}



/************************************************************************
* DlgInClipboard
*
* This function returns TRUE if there is data in the clipboard in the
* dialog format, and this data is for a complete dialog, not just for
* a group of controls.
*
************************************************************************/

STATICFN BOOL DlgInClipboard(VOID)
{
    HANDLE hClip;
    PRES pRes;
    PDIALOGBOXHEADER pdbh;
    BOOL fDlgResFound = FALSE;

    if (!OpenClipboard(ghwndMain))
        return FALSE;

    if (hClip = GetClipboardData(fmtDlg)) {
        pRes = (PRES)GlobalLock(hClip);

        /*
         * If cx is CONTROLS_ONLY, then we know that we only
         * want to copy the controls in the template, not the
         * entire dialog plus controls.
         */
        pdbh = (PDIALOGBOXHEADER)SkipResHeader(pRes);
        if (pdbh->cx != CONTROLS_ONLY)
            fDlgResFound = TRUE;

        GlobalUnlock(hClip);
    }

    CloseClipboard();

    return fDlgResFound;
}



/************************************************************************
* PasteFromClipboard
*
* This routine pastes any data from the clipboard into the current
* resource file.  If the data represents a complete dialog, a new dialog
* is added.  If it represents some controls, the operation to drop them
* into the current dialog is begun.
*
************************************************************************/

STATICFN VOID PasteFromClipboard(VOID)
{
    HANDLE hClip;
    PRES pResClip;
    PRES pResCopy;
    INT cbRes;

    if (!OpenClipboard(ghwndMain)) {
        Message(MSG_NOCLIP);
        return;
    }

    if (hClip = GetClipboardData(fmtDlg)) {
        pResClip = (PRES)GlobalLock(hClip);
        cbRes = ResourceSize(pResClip);

        /*
         * Make a copy of the clipboard data.  This needs to be done
         * because we may need to drag the new controls for a while,
         * and it is rude to leave the clipboard open that long.
         */
        if (pResCopy = (PRES)MyAlloc(cbRes)) {
            memcpy((PBYTE)pResCopy, (PBYTE)pResClip, cbRes);

            /*
             * Now duplicate the dialog or controls in the clipboard.
             * The pResCopy buffer does NOT need to be freed here, because
             * it will be freed after the drag operation is complete.
             */
            MakeCopyFromRes(pResCopy);
        }

        GlobalUnlock(hClip);
    }

    CloseClipboard();
}



/************************************************************************
* MsgFilterHookFunc
*
* This is the exported message filter function that is hooked into
* the message stream for detecting the pressing of the F1 key, at
* which time it calls up the appropriate help.
*
************************************************************************/

BOOL APIENTRY MsgFilterHookFunc(
    INT nCode,
    WPARAM wParam,
    LPMSG lpMsg)
{
    if ((nCode == MSGF_MENU || nCode == MSGF_DIALOGBOX) &&
            (lpMsg->message == WM_KEYDOWN && lpMsg->wParam == VK_F1)) {
        /*
         * Display help.
         */
        ShowHelp((nCode == MSGF_MENU) ? TRUE : FALSE);

        /*
         * Tell Windows to swallow this message.
         */
        return 1;
    }

    return CallNextHookEx(ghhkMsgFilter, nCode, wParam, (LONG)lpMsg);
}



/************************************************************************
* ShowHelp
*
* This function is called when the user has requested help.  It will
* look at the menu state (if fMenuHelp is TRUE) or which dialog
* is currently up to determine the help topic, then it calls WinHelp.
*
* Arguments:
*   BOOL fMenuHelp - TRUE if this help is for a menu (help was requested
*                    in the menu modal loop).  If FALSE, general help
*                    or help for a dialog is assumed.
*
************************************************************************/

VOID ShowHelp(
    BOOL fMenuHelp)
{
    INT nHelpContext = 0;
    HWND hwndFocus;

    if (fMenuHelp) {
        nHelpContext = GetHelpContext(gMenuSelected, gahmapMenu);
    }
    else {
        /*
         * Look for help for the current dialog.
         */
        if (gidCurrentDlg) {
            nHelpContext = GetHelpContext(gidCurrentDlg, gahmapDialog);
        }
        else {
            /*
             * There is no current dialog.  Is the window with the
             * focus a control on the Properties Bar?
             */
            if ((hwndFocus = GetFocus()) && IsChild(hwndStatus, hwndFocus))
                nHelpContext = GetHelpContext(DID_STATUS, gahmapDialog);
        }
    }

    /*
     * If there is help context, display it.  Otherwise display
     * the Contents screen.
     */
    if (nHelpContext)
        WinHelp(ghwndMain, gszHelpFile, HELP_CONTEXT, nHelpContext);
    else
        WinHelp(ghwndMain, gszHelpFile, HELP_CONTENTS, 0L);
}



/************************************************************************
* GetHelpContext
*
* This function takes a subject and returns its matching help
* context id from the given HELPMAP table.
*
* Arguments:
*   INT idSubject   - ID of the subject to find the help context for.
*   PHELPMAP phmap  - The help map table.  It is assumed that the
*                     last entry in the table has a NULL subject id.
*
************************************************************************/

STATICFN INT GetHelpContext(
    INT idSubject,
    PHELPMAP phmap)
{
    while (phmap->idSubject) {
        if (phmap->idSubject == idSubject)
            return phmap->HelpContext;

        phmap++;
    }

    return 0;
}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.