CICA 1993 August/CICA.cdr/unzipped/programr/makemdi2/frame.c

C/C++ Source or Header | 1992-11-25 | 30.3 KB | 1,110 lines

#define _FRAME_C
//-----------------------------------------------------------------
// APP.C - <description>
//
// MAKEMDI adaptation of Windows 3.1 SDK MAKEAPP system.
//
// MDI application design based on Chapter 7 of
// "Windows 3: A Developer's Guide" by Jeffrey Richter.
//
// Adaptation developed with permission of the author by
// John F. Holliday, Technisoft Corporation
// Telephone: [phone], CompuServe: 71271,634
//
// [DMM]    25-Nov-1992: Fixed crashing on exit
//            Also tabified file to tabsize of 4
//
//            David M. Miller, Business Visions, Inc.
//            Telephone: [phone]
//            CompuServe: 72676,327
//            internet: [e-mail]
//-----------------------------------------------------------------
#include "makemdi.h"


BOOL Frame_Initialize(APP * papp)
{
    WNDCLASS cls;

    cls.hCursor = LoadCursor(NULL, IDC_ARROW);
    cls.hIcon = LoadIcon(papp->hinst, MAKEINTRESOURCE(IDR_FRAMEICON));
    cls.lpszMenuName = MAKEINTRESOURCE(IDR_FRAMEMENU);
    cls.hInstance = papp->hinst;
    cls.lpszClassName = CLASS_FRAME;
    cls.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
    cls.lpfnWndProc = Frame_WndProc;
    cls.style = CS_HREDRAW | CS_VREDRAW;
    cls.cbWndExtra = sizeof(FRAME *);
    cls.cbClsExtra = 0;

    if (!RegisterClass(&cls))
        return FALSE;

    return TRUE;
}

void Frame_Terminate(APP * papp)
{
}

LRESULT CALLBACK _export Frame_WndProc(HWND hWnd,
                                       UINT msg,
                                       WPARAM wParam,
                                       LPARAM lParam)
{
    LRESULT lResult = 0;
    FRAME *pfrm = Frame_GetPtr(hWnd);

    if (pfrm == NULL) {
        if (msg == WM_NCCREATE) {
            pfrm = (FRAME *) LocalAlloc(LPTR, sizeof(FRAME));

            if (pfrm == NULL)
                return (LRESULT) FALSE;

            pfrm->hWnd = hWnd;
            Frame_SetPtr(hWnd, pfrm);
        }
        else
            return DefWindowProc(hWnd, msg, wParam, lParam);
    }

    if (msg == WM_NCDESTROY) {
        // [DMM] Added: save hwndClient before freeing pfrm
        HWND hWndClient = pfrm->hWndClient;

        if (pfrm->fpProcRibbon != NULL)
            FreeProcInstance((FARPROC) pfrm->fpProcRibbon);

        if (pfrm->hMenu != NULL)
            DestroyMenu(pfrm->hMenu);

        LocalFree((HLOCAL)OFFSETOF(pfrm));
        pfrm = NULL;
        Frame_SetPtr(hWnd, NULL);

        // [DMM] Added: execution ends here on NCDESTROY
        return DefFrameProc(hWnd, hWndClient, msg, wParam, lParam);
    }


    // Get the window handle of the active MDI child.
    // This is NULL if no MDI children exist.
    // Determine if the MDI child is maximized.

    if (IsWindow(pfrm->hWndClient))
        lResult = SendMessage(pfrm->hWndClient, WM_MDIGETACTIVE, 0, 0);

    pfrm->hWndActiveMDIChild = (HWND) LOWORD(lResult);
    pfrm->fMDIChildIsMaximized = HIWORD(lResult);


    switch (msg) {
        // Windows messages

        HANDLE_MSG(pfrm, WM_CREATE, Frame_OnCreate);
        HANDLE_MSG(pfrm, WM_DESTROY, Frame_OnDestroy);
        HANDLE_MSG(pfrm, WM_CLOSE, Frame_OnClose);
        HANDLE_MSG(pfrm, WM_QUERYENDSESSION, Frame_OnQueryEndSession);
        HANDLE_MSG(pfrm, WM_ENDSESSION, Frame_OnEndSession);
        HANDLE_MSG(pfrm, WM_PAINT, Frame_OnPaint);
        HANDLE_MSG(pfrm, WM_ERASEBKGND, Frame_OnEraseBkgnd);
        HANDLE_MSG(pfrm, WM_SIZE, Frame_OnSize);
        HANDLE_MSG(pfrm, WM_ACTIVATE, Frame_OnActivate);
        HANDLE_MSG(pfrm, WM_INITMENU, Frame_OnInitMenu);
        HANDLE_MSG(pfrm, WM_INITMENUPOPUP, Frame_OnInitMenuPopup);
        HANDLE_MSG(pfrm, WM_COMMAND, Frame_OnCommand);

        HANDLE_MSG(pfrm, WM_SYSCOMMAND, Frame_OnSysCommand);
        HANDLE_MSG(pfrm, WM_NCLBUTTONDBLCLK, Frame_OnNclButtonDown);
        HANDLE_MSG(pfrm, WM_MENUSELECT, Frame_OnMenuSelect);
        HANDLE_MSG(pfrm, WM_ENTERIDLE, Frame_OnEnterIdle);

        // Frame window specific messages

        HANDLE_MSG(pfrm, FW_MDICHILDDESTROY, Frame_OnMdiChildDestroy);
        HANDLE_MSG(pfrm, FW_GETSTATBARRECT, Frame_OnGetStatBarRect);
        HANDLE_MSG(pfrm, FW_DRAWSTATUSDIVIDE, Frame_OnDrawStatusDivide);
        HANDLE_MSG(pfrm, FW_RESIZEMDICLIENT, Frame_OnResizeMdiClient);
        HANDLE_MSG(pfrm, FW_SETMENUHELP, Frame_OnSetMenuHelp);
        HANDLE_MSG(pfrm, FW_GETMENUHELP, Frame_OnGetMenuHelp);

        // Application messages

        HANDLE_MSG(pfrm, AW_PAINTMENUHELP, Frame_OnPaintMenuHelp);

    default:
        return DefFrameProc(hWnd, pfrm->hWndClient, msg, wParam, lParam);
    }
}

HWND Frame_CreateWindow(LPCSTR lpszText,
                        int x,
                        int y,
                        int cx,
                        int cy,
                        HINSTANCE hinst)
{
    return CreateWindowEx(0L,
                          CLASS_FRAME,
                          lpszText,
            WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                          x, y, cx, cy,
                          NULL,
                          NULL,
                          hinst,
                          NULL);
}

//-Message handlers------------------------------------------------

BOOL Frame_OnCreate(FRAME * pfrm, CREATESTRUCT FAR * lpCreateStruct)
{
    CLIENTCREATESTRUCT ccs;

    pfrm->hMenu = LoadMenu(lpCreateStruct->hInstance,
                           MAKEINTRESOURCE(IDR_FRAMEMENU));

    pfrm->fStatusBarOn = TRUE;

    // Create the MDICLIENT window as a child of the frame.

    ccs.hWindowMenu = GetSubMenu(GetMenu(pfrm->hWnd), 1);
    ccs.idFirstChild = CMD_WINDOWCHILD;

    pfrm->hWndClient = CreateWindow("MDIClient", "",
                        WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL |
                                    WS_VISIBLE | WS_CLIPSIBLINGS, 0, 0, 0, 0,
                                  pfrm->hWnd, NULL, lpCreateStruct->hInstance,
                                    (LPSTR) (LPCLIENTCREATESTRUCT) & ccs);

    // Create the Ribbon dialog box with Frame as owner.

    pfrm->fpProcRibbon = (DLGPROC) MakeProcInstance((FARPROC) Ribbon_DlgProc, g_app.hinst);

    pfrm->hdlgRibbon = CreateDialog(g_app.hinst,
                                    MAKEINTRESOURCE(DLG_RIBBON), pfrm->hWnd,
                                    pfrm->fpProcRibbon);

    if (pfrm->hdlgRibbon == NULL) {
        FreeProcInstance((FARPROC) pfrm->fpProcRibbon);
        return (0);
    }

    return pfrm->hWndClient != NULL;
}

void Frame_OnDestroy(FRAME * pfrm)
{
    PostQuitMessage(0);
}

void Frame_OnClose(FRAME * pfrm)
{
    // Before closing the application, ask the MDI children if it
    // is ok?

    if ((BOOL) SendMessage(pfrm->hWnd, WM_QUERYENDSESSION, 0, 0)) {
        SendMessage(pfrm->hWnd, WM_ENDSESSION, TRUE, 0);
        DefFrameProc(pfrm->hWnd, pfrm->hWndClient, WM_CLOSE, 0, 0L);
    }
}

BOOL Frame_OnQueryEndSession(FRAME * pfrm)
{
    BOOL            bResult = TRUE;
    HWND            hWndChild;

    // Get the handle of the first MDI Child.

    hWndChild = GetWindow(pfrm->hWndClient, GW_CHILD);

    if (hWndChild != NULL) {
        // Ask each child if it is OK to terminate.

        do {
            // Do not ask caption bars of iconic MDI Children.

            if (GetWindow(hWndChild, GW_OWNER) != NULL)
                continue;

            bResult = FORWARD_WM_QUERYENDSESSION(hWndChild, SendMessage);

            // If the MDI Child says that it is NOT OK, don't ask the
            // rest of the MDI Children.

            if (bResult == FALSE)
                break;
        }
        while ((hWndChild = GetWindow(hWndChild, GW_HWNDNEXT)) != NULL);


        // If any MDI Child said NO, tell the other children that
        // the session is NOT being terminated.

        if (bResult == FALSE) {
            HWND            hWndTemp = hWndChild;

            hWndChild = GetWindow(pfrm->hWndClient, GW_CHILD);

            do {
                // If this child is the one that said NO, stop.

                if (hWndTemp == hWndChild)
                    break;

                // Do not send to caption bars of iconic MDI Children.

                if (GetWindow(hWndChild, GW_OWNER) != NULL)
                    continue;

                // Tell child we are not ending the session (wParam is FALSE).

                SendMessage(hWndChild, WM_ENDSESSION, FALSE, 0);
            }
            while ((hWndChild = GetWindow(hWndChild, GW_HWNDNEXT)) != NULL);
        }

    }

    return bResult;
}

void Frame_OnEndSession(FRAME * pfrm, BOOL fEnding)
{
    HWND            hWndChild;

    // Get handle of first MDI Child window.

    hWndChild = GetWindow(pfrm->hWndClient, GW_CHILD);

    // If no MDI Children exist, we are done.

    if (hWndChild != NULL) {
        // Tell each MDI Child whether or not the session is ending.

        do {
            // Do not send to caption bars of iconic MDI Children.

            if (GetWindow(hWndChild, GW_OWNER) != NULL)
                continue;

            FORWARD_WM_ENDSESSION(hWndChild, fEnding, SendMessage);
        }
        while ((hWndChild = GetWindow(hWndChild, GW_HWNDNEXT)) != NULL);
    }
}

void Frame_OnPaint(FRAME * pfrm)
{
    PAINTSTRUCT        ps;

    // Since the only visible portion of the Frame's client area is
    // the status bar when it is ON, this must mean that the status
    // bar needs to be repainted.

    // Set up the device context.

    BeginPaint(pfrm->hWnd, &ps);

    SendMessage(pfrm->hWnd, FW_GETSTATBARRECT, 0, (LPARAM)((LPRECT)&ps.rcPaint));
    SetBkMode(ps.hdc, TRANSPARENT);

    // If an MDI Child exists, the status bar must be updated by it.

    if (pfrm->hWndActiveMDIChild) {
        SendMessage(   pfrm->hWndActiveMDIChild,
                       AC_PAINTSTATBAR,
                       (WPARAM) ps.hdc,
                       (LPARAM)((LPPAINTSTRUCT)&ps));
    }
    else {
        // No MDI Child exists, the Frame can do whatever it wants here.

        ps.rcPaint.top += (int) SendMessage(pfrm->hWnd, FW_DRAWSTATUSDIVIDE, 0,
                                            (LPARAM)((LPPAINTSTRUCT)&ps));

        LoadString(g_app.hinst, IDS_FRAMESTATUSBAR, g_app.szBuf, sizeof(g_app.szBuf));
        TextOut(ps.hdc, 0, ps.rcPaint.top, g_app.szBuf, lstrlen(g_app.szBuf));
    }

    EndPaint(pfrm->hWnd, &ps);
}

BOOL Frame_OnEraseBkgnd(FRAME * pfrm, HDC hdc)
{
    return FORWARD_WM_ERASEBKGND(pfrm->hWnd, hdc, DefWindowProc);
}

void Frame_OnSize(FRAME * pfrm, UINT state, int cx, int cy)
//-----------------------------------------------------------------
// Force MDICHILD window to be resized.
//-----------------------------------------------------------------
{
    SendMessage(pfrm->hWnd, FW_RESIZEMDICLIENT, 0, 0);
}

void Frame_OnActivate(FRAME * pfrm, UINT state, HWND hWndActDeact, BOOL fMinimized)
{
    switch (state) {
    case WA_INACTIVE:
        break;

    case WA_ACTIVE:
        SetFocus(pfrm->hWndClient);
        break;

    case WA_CLICKACTIVE:
        break;
    }
}

void Frame_OnInitMenu(FRAME * pfrm, HMENU hMenu)
//-----------------------------------------------------------------
// The user has entered the menu system, set any options.
//-----------------------------------------------------------------
{
    CheckMenuItem(hMenu, CMD_OPTIONSSTATUS, MF_BYCOMMAND |
            (pfrm->fStatusBarOn ? MF_CHECKED : MF_UNCHECKED));

    CheckMenuItem(hMenu, CMD_OPTIONSRIBBON, MF_BYCOMMAND |
            (IsWindowVisible(pfrm->hdlgRibbon) ? MF_CHECKED : MF_UNCHECKED));
}

void Frame_OnInitMenuPopup(FRAME * pfrm, HMENU hMenu, int item, BOOL fSystemMenu)
{
}

void Frame_OnCommand(FRAME * pfrm, int id, HWND hWndCtl, UINT code)
{
    BOOL            fCallDefProc = FALSE;
    WORD            wTemp;

    // If a child is being activated via the "Window" menu, let
    // the DefFrameProc handle it.

    if (id >= CMD_WINDOWCHILD)
        fCallDefProc = TRUE;
    else
        switch (id) {
        case CMD_FILEOPENSHEET:
            // Get the # of sheets already created and increment by 1.

            wTemp = pfrm->wNumSheets + 1;
            pfrm->wNumSheets = wTemp;

            // The sheet's caption should display the sheet number.

            wsprintf(g_app.szBuf, "Sheet%d", wTemp);

            // Create the MDI Child window.

            Frame_CreateMDIChild(CLASS_SHEET, g_app.szBuf, 0,
                   CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
                                 pfrm->hWndClient, g_app.hinst, 0);

            // Make sure the ribbon is enabled when any children exist.

            EnableWindow(pfrm->hdlgRibbon, TRUE);
            break;

        case CMD_FILEOPENCHART:
            // Get the # of charts already created and increment by 1.

            wTemp = pfrm->wNumCharts + 1;
            pfrm->wNumCharts = wTemp;

            // The chart's caption should display the chart number.

            wsprintf(g_app.szBuf, "Chart%d", wTemp);

            // Create the MDI Child window.

            Frame_CreateMDIChild(CLASS_CHART, g_app.szBuf, 0,
                   CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
                                 pfrm->hWndClient, g_app.hinst, 0);

            // Make sure the ribbon is enabled when any children exist.

            EnableWindow(pfrm->hdlgRibbon, TRUE);
            break;

        case CMD_OPTIONSSTATUS:
            // Toggle the status of the status bar, resize the MDICLIENT.

            pfrm->fStatusBarOn = !pfrm->fStatusBarOn;
            SendMessage(pfrm->hWnd, FW_RESIZEMDICLIENT, 0, 0);
            break;

        case CMD_OPTIONSRIBBON:
            // Toggle the status of the ribbon, resize the MDICLIENT.

            ShowWindow(pfrm->hdlgRibbon,
                       IsWindowVisible(pfrm->hdlgRibbon) ? SW_HIDE : SW_SHOW);

            SendMessage(pfrm->hWnd, FW_RESIZEMDICLIENT, 0, 0);
            break;

        case CMD_EXIT:
            SendMessage(pfrm->hWnd, WM_CLOSE, 0, 0L);
            break;

        case CMD_HELPINDEX:
        case CMD_HELPKEYBOARD:
        case CMD_HELPCOMMANDS:
        case CMD_HELPPROCEDURES:
        case CMD_HELPUSINGHELP:
            MessageBox(pfrm->hWnd, "Option not implemented.", g_app.szName, MB_OK);
            break;

            // case CMD_ABOUT:
            // {
            // FARPROC    fpProc;
            // fpProc = MakeProcInstance(AboutProc, g_app.hinst);
            // DialogBox(g_app.hinst, "About", pfrm->hWnd, fpProc);
            // FreeProcInstance(fpProc);
            // break;
            // }

        case CMD_WINDOWTILEVERT:
            // Call our own function to perform vertical tiling.

            Frame_TileVertically(pfrm->hWndClient);
            break;

        case CMD_WINDOWTILEHORIZ:
            // Let the MDICLIENT window do the repositioning.

            SendMessage(pfrm->hWndClient, WM_MDITILE, 0, 0);
            break;

        case CMD_WINDOWCASCADE:
            // Let the MDICLIENT window do the repositioning.

            SendMessage(pfrm->hWndClient, WM_MDICASCADE, 0, 0);
            break;

        case CMD_WINDOWARRANGEICONS:
            // Let the MDICLIENT window do the repositioning.

            SendMessage(pfrm->hWndClient, WM_MDIICONARRANGE, 0, 0);
            break;

        default:
            // Menu options not processed by the Frame window must
            // be passed to the MDI Children for processing.

            FORWARD_WM_COMMAND(pfrm->hWndActiveMDIChild,
                               id, hWndCtl, code,
                               SendMessage);
            break;
        }

    if (fCallDefProc)
        DefFrameProc(pfrm->hWnd,
                     pfrm->hWndClient, WM_COMMAND,
                     (WPARAM) id, MAKELPARAM(hWndCtl, code));
}

void Frame_OnSysCommand(FRAME * pfrm, WORD cmd, int x, int y)
//-----------------------------------------------------------------
// Set focus to frame window.  This causes any comboboxes
// in the ribbon to be closed.
//-----------------------------------------------------------------
{
    SetFocus(pfrm->hWnd);
    DefFrameProc(pfrm->hWnd,
                 pfrm->hWndClient, WM_SYSCOMMAND,
                 (WPARAM) cmd,
                 MAKELPARAM(x, y));
}

void Frame_OnNclButtonDown(FRAME * pfrm, BOOL fDoubleClick, int x, int y, UINT codeHitTest)
//-----------------------------------------------------------------
// Code to allow double-clicking the MDI Child's system menu
// to close the MDI Child window.
//-----------------------------------------------------------------
{
    RECT            rc;
    BITMAP            Bitmap;
    HBITMAP            hBitmap;
    DWORD            dwResult;
    LPARAM            lParam;
    BOOL            fCallDefProc = TRUE;


    if (fDoubleClick && (codeHitTest == HTMENU)) {
        // If the active child is not maximized, nothing to do.

        dwResult = SendMessage(pfrm->hWndClient, WM_MDIGETACTIVE, 0, 0);

        if (HIWORD(dwResult) == 1) {
            // Get position and dimensions of the MDI Child's system menu in
            // the Frame's menu bar.

            // Get position and dimensions of the Frame window.

            GetWindowRect(pfrm->hWnd, &rc);

            // Get handle to the CLOSE BOX bitmaps.

            hBitmap = LoadBitmap(NULL, MAKEINTRESOURCE(OBM_CLOSE));

            // Get dimensions of the bitmaps.

            GetObject(hBitmap, sizeof(BITMAP), (LPSTR) (LPBITMAP) & Bitmap);
            DeleteBitmap(hBitmap);

            // Adjust the rectangle.

            rc.top += GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFRAME);
            rc.bottom = rc.top + Bitmap.bmHeight;
            rc.left += GetSystemMetrics(SM_CXFRAME);

            // The close bitmap includes the Application and MDI Child CLOSE
            // boxes.  So we only want half of the bitmap's width.

            rc.right = rc.left + Bitmap.bmWidth / 2;

            // If the mouse cursor is within this rectangle, tell the
            // MDI Child window to close.

            lParam = MAKELPARAM(x, y);
            if (PtInRect(&rc, MAKEPOINT(lParam))) {
                SendMessage((HWND) LOWORD(dwResult),
                            WM_SYSCOMMAND, SC_CLOSE, lParam);
                fCallDefProc = FALSE;
            }
        }
    }

    if (fCallDefProc)
        DefFrameProc(pfrm->hWnd,
                     pfrm->hWndClient,
                     (fDoubleClick) ? WM_NCLBUTTONDBLCLK : WM_NCLBUTTONDOWN,
                     (WPARAM) (UINT) codeHitTest,
                     MAKELPARAM(x, y));
}

void Frame_OnMenuSelect(FRAME * pfrm, HMENU hMenu, int item, HMENU hMenuPopup, UINT flags)
//-----------------------------------------------------------------
// The user has highlighted a menu item.
//-----------------------------------------------------------------
{
    WORD            wTemp;

    if (flags == -1 && (hMenu == (HMENU) 0)) {
        // User has stopped using the menu system.

        SendMessage(pfrm->hWnd, FW_SETMENUHELP, 0, 0);
        return;
    }

    // If wTemp == 0, at end of switch, MDI Child handled the message.

    wTemp = 0;

    switch (flags & (MF_POPUP | MF_SYSMENU)) {
    case 0:
        // item is a menu item ID NOT on the app's system menu.

        if (pfrm->hWndActiveMDIChild != NULL) {
            // An MDI Child exists.

            if (pfrm->fMDIChildIsMaximized) {
                // If menu item from the MDI Child's system menu, set
                // the MF_SYSMENU bit in the lParam parameter.

                HMENU            hTemp = GetSubMenu(GetMenu(pfrm->hWnd), 0);

                if ((int) GetMenuState(hTemp, item, MF_BYCOMMAND) != -1)
                    flags |= MF_SYSMENU;
            }

            // Make active MDI Child think that it received the
            // WM_MENUSELECT message.

            FORWARD_WM_MENUSELECT(
                                     pfrm->hWndActiveMDIChild,
                                     hMenu, item, hMenuPopup,
                                     flags,
                                     SendMessage);

            wTemp = 0;                    // MDI Child handled the message.
            break;
        }

        wTemp = IDS_FRAMEMENUID + item;
        break;

    case MF_POPUP:

        if (pfrm->hWndActiveMDIChild != NULL) {
            // An MDI Child exists.

            if (pfrm->fMDIChildIsMaximized) {
                // If popup menu is first top-level menu, it is the
                // MDI Child's system menu, set the MF_SYSMENU flag.

                if (hMenuPopup == GetSubMenu(GetMenu(pfrm->hWnd), 0))
                    flags |= MF_SYSMENU;
            }

            // Make active MDI Child think that it received the
            // WM_MENUSELECT message.

            FORWARD_WM_MENUSELECT(
                                     pfrm->hWndActiveMDIChild,
                                     hMenu, item, hMenuPopup,
                                     flags,
                                     SendMessage);

            wTemp = 0;                    // MDI Child handled the message.
            break;
        }

        // Calculate the index of the top-level menu.

        hMenu = GetMenu(pfrm->hWnd);
        wTemp = GetMenuItemCount(hMenu);

        while (wTemp--)
            if (GetSubMenu(hMenu, wTemp) == hMenuPopup)
                break;

        wTemp += IDS_FRAMEPOPUPID + 1;    // Jump over system menu.
        break;

    case MF_SYSMENU:
        // item is menu item ID from system menu.
        wTemp = IDS_FRAMEMENUID + ((item & 0x0FFF) >> 4);
        break;

    case MF_POPUP | MF_SYSMENU:
        // item is handle to app's sys menu.
        wTemp = IDS_FRAMEPOPUPID;
        break;
    }

    // If message handled by MDI Child, nothing more to do.

    if (wTemp != 0) {
        // Tell the Frame that the Frame window should display the
        // help text and the identifier for the help text.

        SendMessage(pfrm->hWnd, FW_SETMENUHELP,
                    (WPARAM) pfrm->hWnd, (LPARAM) wTemp);
    }
}

void Frame_OnEnterIdle(FRAME * pfrm, WORD source, HWND hWndSource)
{
    RECT            rc;
    PAINTSTRUCT        ps;

    if (source == MSGF_MENU) {
        // User has stopped scrolling through menu items.

        // If Menu help already displayed, nothing more to do.
        // This is signaled by hWndMenu help being -1.

        if (pfrm->hWndMenuHelp != (HWND) - 1) {
            // Display new menu help, invalidate the status bar.

            SendMessage(pfrm->hWnd, FW_GETSTATBARRECT, 0, (LPARAM)((LPRECT)&rc));
            InvalidateRect(pfrm->hWnd, &rc, TRUE);

            // BeginPaint is OK because an invalid rectangle must exist because
            // of the call to InvalidateRect above.     This causes the background
            // for the Frame's client area to be drawn correctly.

            BeginPaint(pfrm->hWnd, &ps);

            // Set up the device context.

            SetBkMode(ps.hdc, TRANSPARENT);

            // Send message to window that last received a WM_MENUSELECT
            // message to tell it to paint the status bar with the
            // appropriate menu help text.

            SendMessage(pfrm->hWndMenuHelp, AW_PAINTMENUHELP, 0,
                        (LPARAM)((LPPAINTSTRUCT)&ps));

            EndPaint(pfrm->hWnd, &ps);

            // Set flag notifying this message that the most recently selected
            // menu item has had its help text painted.     This stops unsightly
            // screen flicker.

            pfrm->hWndMenuHelp = (HWND) - 1;
        }
    }
}


void Frame_OnMdiChildDestroy(FRAME * pfrm)
//-----------------------------------------------------------------
// Message is posted by an MDI Child just before it is destroyed.
//-----------------------------------------------------------------
{
    // If another MDI Child exists, nothing to do.

    if (pfrm->hWndActiveMDIChild != NULL)
        return;

    // Set the menu bar and accelerator table to the Frame's defaults.

    Frame_ChangeMDIMenu(   pfrm->hWnd,
                           pfrm->hWndClient,
                           pfrm->hMenu,
                           CMD_WINDOWTILEVERT);

    g_app.hAccelTable = NULL;

    // Force the status bar to be updated.

    InvalidateRect(pfrm->hWnd, NULL, TRUE);

    // Disable the Ribbon.

    EnableWindow(pfrm->hdlgRibbon, FALSE);
}

void Frame_OnGetStatBarRect(FRAME * pfrm, LPRECT lpRect)
{
    // Get the client area of the Frame window.

    GetClientRect(pfrm->hWnd, lpRect);

    // If the status bar is OFF, set the status bar to have no height.

    if (pfrm->fStatusBarOn) {
        // Change the dimensions so that the status bar is the height of
        // one line of text plus a small border.

        HDC                hdc;
        TEXTMETRIC        tm;

        hdc = GetDC(pfrm->hWnd);
        GetTextMetrics(hdc, &tm);
        ReleaseDC(pfrm->hWnd, hdc);

        lpRect->top = lpRect->bottom - tm.tmHeight -
                GetSystemMetrics(SM_CYBORDER);
    }
    else
        lpRect->top = lpRect->bottom;
}

void Frame_OnDrawStatusDivide(FRAME * pfrm, LPPAINTSTRUCT ps)
{
    HPEN            hPen;
    DWORD            dwResult = GetSystemMetrics(SM_CYBORDER);

    // Draw a line separating the status bar from the MDICLIENT window.

    hPen = CreatePen(PS_SOLID, (int) dwResult, RGB(0, 0, 0));
    hPen = SelectPen(ps->hdc, hPen);

    MoveTo(ps->hdc, 0, ps->rcPaint.top);
    LineTo(ps->hdc, ps->rcPaint.right, ps->rcPaint.top);
    DeletePen(SelectPen(ps->hdc, hPen));
}

void Frame_OnResizeMdiClient(FRAME * pfrm)
{
    RECT            rc, rcTemp;

    // Sent when the Frame window is resized or when the status bar
    // and ribbon are toggled.

    GetClientRect(pfrm->hWnd, &rc);

    if (IsWindow(pfrm->hdlgRibbon) && IsWindowVisible(pfrm->hdlgRibbon)) {
        // Ribbon is displayed, adjust rectangle.

        GetClientRect(pfrm->hdlgRibbon, &rcTemp);
        rc.top += rcTemp.bottom;
        rc.bottom -= rcTemp.bottom;
    }

    // Get the dimensions of the status bar rectangle and adjust the
    // dimensions of the MDICLIENT window.

    SendMessage(pfrm->hWnd, FW_GETSTATBARRECT, 0, (LPARAM)((LPRECT)&rcTemp));
    rc.bottom -= rcTemp.bottom - rcTemp.top;
    MoveWindow(pfrm->hWndClient, 0, rc.top, rc.right, rc.bottom, TRUE);
}

void Frame_OnSetMenuHelp(FRAME * pfrm, HWND hWndMenuHelp, DWORD dwMenuHelp)
//-----------------------------------------------------------------
// Called by the Frame and MDI Children whenever a
// WM_MENUSELECT message is received.
//-----------------------------------------------------------------
{
    // Save the handle of the window sending the message.

    pfrm->hWndMenuHelp = hWndMenuHelp;

    // Save the menu help code that the window sent too.

    pfrm->dwMenuHelp = dwMenuHelp;

    // When the Frame or MDI Child receive a WM_MENUSELECT message
    // specifying that the menu system is closed
    // (dwMenuHelp == MAKELONG(-1, 0)), the menu help should disappear and
    // be replaced by the proper information on the status bar.

    if (hWndMenuHelp == NULL) {
        RECT            rc;

        SendMessage(pfrm->hWnd, FW_GETSTATBARRECT, 0, (LPARAM)((LPRECT)&rc));

        // Force status bar to be updated.

        InvalidateRect(pfrm->hWnd, &rc, TRUE);
    }
}

DWORD Frame_OnGetMenuHelp(FRAME * pfrm)
//-----------------------------------------------------------------
// Sent by the Frame or MDI Child when they
// receive a AW_PAINTMENUHELP message.
//-----------------------------------------------------------------
{
    return pfrm->dwMenuHelp;
}

void Frame_OnPaintMenuHelp(FRAME * pfrm, LPPAINTSTRUCT psStatus)
//-----------------------------------------------------------------
// Message sent from Frame window to notify Frame that it should
// paint the status bar text for the last highlighted menu item.
//-----------------------------------------------------------------
{
    LRESULT            lResult;

    // Ask the Frame window what the last selected menu ID was.
    // This value was sent to the frame by this window during the
    // processing for the WM_MENUSELECT message.

    lResult = SendMessage(pfrm->hWnd, FW_GETMENUHELP, 0, 0);

    // Draw the horizontal dividing line separating the Status bar
    // from the MDICLIENT window.

    psStatus->rcPaint.top += (int)
            SendMessage(pfrm->hWnd, FW_DRAWSTATUSDIVIDE, 0, (LPARAM) psStatus);

    // Construct the string that is to be displayed.

    LoadString(g_app.hinst, LOWORD(lResult), g_app.szBuf, sizeof(g_app.szBuf));

    // Paint the menu help text in the status bar.

    TextOut(psStatus->hdc, 0, psStatus->rcPaint.top, g_app.szBuf, lstrlen(g_app.szBuf));
}

//-Utility routines------------------------------------------------

HWND WINAPI Frame_CreateMDIChild(LPSTR szClassName,
                                 LPSTR szWindowName,
                                 DWORD dwStyle,
                                 short x,
                                 short y,
                                 short nWidth,
                                 short nHeight,
                                 HWND hWndMDIClient,
                                 HANDLE hInstance,
                                 LONG lParam)
{
    MDICREATESTRUCT cs;
    HWND            hWndChild;

    cs.szClass = szClassName;
    cs.szTitle = szWindowName;
    cs.hOwner = hInstance;
    cs.x = x;
    cs.y = y;
    cs.cx = nWidth;
    cs.cy = nHeight;
    cs.style = dwStyle;
    cs.lParam = lParam;

    hWndChild = (HWND) SendMessage(hWndMDIClient, WM_MDICREATE,
            0, (LPARAM)((LPMDICREATESTRUCT)&cs));
    return (hWndChild);
}

// Function to change the menu in the Frame window whenever a
// new MDI Child becomes active.

void WINAPI Frame_ChangeMDIMenu(HWND hWndFrame,
                                HWND hWndClient,
                                HMENU hMenuNew,
                                WORD wMenuID)
{
    WORD            wCount;
    HMENU            hSubMenu = 0;

    // Get number of top-level menu items in the menu used by the window
    // being activated.

    wCount = GetMenuItemCount(hMenuNew);

    // Locate the POPUP menu that contains the menu option with the
    // 'wMenuID' identifier in it.    This must be an identifier for an option
    // in the new menu's "Window" popup menu.

    while (wCount) {
        hSubMenu = GetSubMenu(hMenuNew, wCount - 1);
        if ((int) GetMenuState(hSubMenu, wMenuID, MF_BYCOMMAND) != -1)
            break;
        wCount--;
    }

    // Tell the MDICLIENT window to setup the new menu.

    SendMessage(hWndClient, WM_MDISETMENU, 0, MAKELONG(hMenuNew, hSubMenu));
    DrawMenuBar(hWndFrame);
}

void WINAPI Frame_TileVertically(HWND hWndMDIClient)
{
    int    nNumWndsOnRow, nOpenMDIChildren = 0, nTopOfBottomIconRow = 0;
    int    nCrntCol, nColWidth, nCrntRow, nNumRows, nRowHeight, nMinWndHeight;
    HWND            hWndChild;
    HANDLE            hWinPosInfo;
    RECT            rc;
    POINT            Point;
    DWORD            dwChildInfo;

    // Assume that scrollbars will be off after windows are tiled.
    // By forcing them off now, GetClientRect will return the correct size.

    ShowScrollBar(hWndMDIClient, SB_BOTH, 0);

    // The WM_MDICASCADE and WM_MDITILE messages cause the icons to be
    // arranged.  So we will too.  In fact, this is necessary to locate
    // the top of the bottom icon row in the next step of this function.

    SendMessage(hWndMDIClient, WM_MDIICONARRANGE, 0, 0);

    // Get handle to first MDI Child window.

    hWndChild = GetWindow(hWndMDIClient, GW_CHILD);

    do {
        if (IsIconic(hWndChild) && GetWindow(hWndChild, GW_OWNER) == NULL) {
            // Window is iconic and window is NOT an icon's caption.

            // Get client area of the icon window.

            GetWindowRect(hWndChild, &rc);

            // rc.top is in screen coordinates.

            nTopOfBottomIconRow = max(nTopOfBottomIconRow, rc.top);
        }

        if (!IsIconic(hWndChild) && GetWindow(hWndChild, GW_OWNER) == NULL)
            ++nOpenMDIChildren;

    }
    while ((hWndChild = GetWindow(hWndChild, GW_HWNDNEXT)) != NULL);


    // All MDI Children are icons, no tiling is necessary.

    if (nOpenMDIChildren == 0)
        return;


    // Find height of usable client area for tiling.

    GetClientRect(hWndMDIClient, &rc);

    if (nTopOfBottomIconRow) {
        // At least one MDI Child is iconic.

        // Convert coordinates from screen to client.

        Point.x = 0;
        Point.y = nTopOfBottomIconRow;
        ScreenToClient(hWndMDIClient, &Point);

        // Point.y is top of bottom icon row in client coordinates.

        rc.bottom = Point.y;
    }


    // Restore the active MDI child if it's maximized

    dwChildInfo = SendMessage(hWndMDIClient, WM_MDIGETACTIVE, 0, 0);

    if (HIWORD(dwChildInfo) == 1)
        ShowWindow((HWND) LOWORD(dwChildInfo), SW_RESTORE);

    // Calculate the minimum desired height of each MDI Child.

    nMinWndHeight = max(1, rc.bottom / (5 * GetSystemMetrics(SM_CYCAPTION)));

    // Calculate the number of rows that will be tiled.

    nNumRows = min(nOpenMDIChildren, nMinWndHeight);

    // Calculate the height of each row.

    nRowHeight = rc.bottom / nNumRows;

    // Get the handle to the first MDI Child window.

    hWndChild = GetWindow(hWndMDIClient, GW_CHILD);

    // Prime the storage of positioning information.

    hWinPosInfo = BeginDeferWindowPos(nOpenMDIChildren);

    // Execute the loop for each row.

    for (nCrntRow = 0; nCrntRow < nNumRows; nCrntRow++) {
        // Calculate the number of MDI Children that will appear on this row.

        nNumWndsOnRow = nOpenMDIChildren / nNumRows +
                ((nOpenMDIChildren % nNumRows > (nNumRows - (nCrntRow + 1))) ? 1 : 0);

        // Calculate the width of each of these children.

        nColWidth = rc.right / nNumWndsOnRow;

        // Fill each column with an MDI Child window.

        for (nCrntCol = 0; nCrntCol < nNumWndsOnRow;) {
            if (!IsIconic(hWndChild) && GetWindow(hWndChild, GW_OWNER) == NULL) {
                // Child is NOT iconic and not an icon's caption bar.

                // Tell windows what the new position and dimensions of this
                // MDI Child should be.

                hWinPosInfo = DeferWindowPos(hWinPosInfo, hWndChild, NULL,
                       nCrntCol * nColWidth, nCrntRow * nRowHeight, nColWidth,
                                   nRowHeight, SWP_NOACTIVATE | SWP_NOZORDER);

                // Go to the next column.

                nCrntCol++;
            }

            // Get handle to the next MDI Child window.

            hWndChild = GetWindow(hWndChild, GW_HWNDNEXT);
        }
    }

    // All of the positioning has been set.     Now, tell Windows to update
    // all of the windows at once.

    EndDeferWindowPos(hWinPosInfo);
}