opendoors/ODFrame.c

/* OpenDoors Online Software Programming Toolkit
 * (C) Copyright 1991 - 1999 by Brian Pirie.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 *        File: ODFrame.c
 *
 * Description: Implements the OpenDoors frame window which provides the
 *              menu, toolbar, and status bar. The frame window's client
 *              area contains the display window which shows the door's
 *              output as the remote user would see it. This file should
 *              not be built into non-Windows versions of OpenDoors.
 *
 *   Revisions: Date          Ver   Who  Change
 *              ---------------------------------------------------------------
 *              Aug 20, 1995  6.00  BP   Created.
 *              Dec 20, 1995  6.00  BP   Remember toolbar & statusbar settings.
 *              Dec 22, 1995  6.00  BP   Added od_connect_speed.
 *              Jan 20, 1996  6.00  BP   Made ODFrameCenter...() shared.
 *              Jan 21, 1996  6.00  BP   Added ODScrnShowMessage() and related.
 *              Feb 17, 1996  6.00  BP   Add ...Accelerator() return value.
 *              Feb 17, 1996  6.00  BP   Pass WM_MENUSELECT to DefWindowProc().
 *              Feb 19, 1996  6.00  BP   Changed version number to 6.00.
 *              Feb 21, 1996  6.00  BP   Fixed user keyboard off command.
 *              Feb 22, 1996  6.00  BP   Allow escape to close Help About box.
 *              Feb 23, 1996  6.00  BP   Properly update when toolbar turned on
 *              Mar 03, 1996  6.10  BP   Begin version 6.10.
 *              Mar 14, 1996  6.10  BP   Added configuration menu option.
 *              Aug 10, 2003  6.23  SH   *nix support
 */

#define BUILDING_OPENDOORS

#include <stdio.h>

#include "windows.h"
#include "commctrl.h"

#include "OpenDoor.h"
#include "ODRes.h"
#include "ODFrame.h"
#include "ODGen.h"
#include "ODScrn.h"
#include "ODKrnl.h"

#ifdef ODPLAT_WIN32

/* Frame window information structure. */
typedef struct
{
   HINSTANCE hInstance;
   BOOL bToolbarOn;
   HWND hwndToolbar;
   BOOL bStatusBarOn;
   HWND hwndStatusBar;
   HWND hwndTimeEdit;
   HWND hwndTimeUpDown;
   BOOL bWantsChatIndicator;
   HACCEL hacclFrameCommands;
   HWND hwndMessageWindow;
   char *pszCurrentMessage;
   int nCurrentMessageFlags;
} tODFrameWindowInfo;

/* Toolbar button information. */
TBBUTTON atbButtons[] =
{
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {0,   ID_DOOR_CHATMODE,          TBSTATE_ENABLED,  TBSTYLE_BUTTON, 0, 0},
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {1,   ID_DOOR_USERKEYBOARDOFF,   TBSTATE_ENABLED,  TBSTYLE_BUTTON, 0, 0},
   {2,   ID_DOOR_SYSOPNEXT,         TBSTATE_ENABLED,  TBSTYLE_BUTTON, 0, 0},
   {0,   0,                         TBSTATE_ENABLED,  TBSTYLE_SEP,    0, 0},
   {3,   ID_DOOR_HANGUP,            TBSTATE_ENABLED,  TBSTYLE_BUTTON, 0, 0},
   {4,   ID_DOOR_LOCKOUT,           TBSTATE_ENABLED,  TBSTYLE_BUTTON, 0, 0},
   {5,   ID_DOOR_EXIT,              TBSTATE_ENABLED,  TBSTYLE_BUTTON, 0, 0},
};

/* Other toolbar settings. */
#define NUM_TOOLBAR_BITMAPS   6
#define MIN_TIME              0
#define MAX_TIME              1440

/* Pointer to default edit box window procedure. */
WNDPROC pfnDefEditProc = NULL;
WNDPROC pfnDefToolbarProc = NULL;

/* Global frame window handle. */
static HWND hwndCurrentFrame;

/* Status bar settings. */
#define NUM_STATUS_PARTS      2
#define NODE_PART_WIDTH       65

/* Child window IDs. */
#define ID_TOOLBAR            1000
#define ID_TIME_EDIT          1001
#define ID_TIME_UPDOWN        1002
#define ID_STATUSBAR          1003


/* Private function prototypes. */
static HWND ODFrameCreateToolbar(HWND hwndParent, HANDLE hInstance,
   tODFrameWindowInfo *pWindowInfo);
static void ODFrameDestroyToolbar(HWND hwndToolbar,
   tODFrameWindowInfo *pWindowInfo);
static HWND ODFrameCreateStatusBar(HWND hwndParent, HANDLE hInstance);
static void ODFrameSetMainStatusText(HWND hwndStatusBar);
static void ODFrameDestroyStatusBar(HWND hwndStatusBar);
static void ODFrameSizeStatusBar(HWND hwndStatusBar);
LRESULT CALLBACK ODFrameWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
   LPARAM lParam);
LRESULT CALLBACK ODFrameToolbarProc(HWND hwnd, UINT uMsg, WPARAM wParam,
   LPARAM lParam);
static void ODFrameUpdateTimeLeft(tODFrameWindowInfo *pWindowInfo);
LRESULT CALLBACK ODFrameTimeEditProc(HWND hwnd, UINT uMsg, WPARAM wParam,
   LPARAM lParam);
BOOL CALLBACK ODFrameAboutDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,
   LPARAM lParam);
static HWND ODFrameCreateWindow(HANDLE hInstance);
static void ODFrameDestroyWindow(HWND hwndFrame);
static void ODFrameMessageLoop(HANDLE hInstance, HWND hwndFrame);
DWORD OD_THREAD_FUNC ODFrameThreadProc(void *pParam);
BOOL CALLBACK ODFrameMessageDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,
   LPARAM lParam);


/* ----------------------------------------------------------------------------
 * ODFrameCreateWindow()                               *** PRIVATE FUNCTION ***
 *
 * Creates the OpenDoors frame window and its children.
 *
 * Parameters: hInstance   - Handle to application instance.
 *
 *     Return: A handle to the newly created window, or NULL on failure.
 */
static HWND ODFrameCreateWindow(HANDLE hInstance)
{
   HWND hwndFrameWindow = NULL;
   WNDCLASS wcFrameWindow;
   tODFrameWindowInfo *pWindowInfo = NULL;
   tODThreadHandle hScreenThread;
   HKEY hOpenDoorsKey;
   DWORD cbData;

   /* Register the main frame window's window class. */
   memset(&wcFrameWindow, 0, sizeof(wcFrameWindow));
   wcFrameWindow.style = CS_HREDRAW | CS_VREDRAW;
   wcFrameWindow.lpfnWndProc = ODFrameWindowProc;
   wcFrameWindow.cbClsExtra = 0;
   wcFrameWindow.cbWndExtra = 0;
   wcFrameWindow.hInstance = hInstance;
   if(od_control.od_app_icon != NULL)
   {
      wcFrameWindow.hIcon = od_control.od_app_icon;
   }
   else
   {
      wcFrameWindow.hIcon
         = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_OPENDOORS));
   }
   wcFrameWindow.hCursor = LoadCursor(NULL, IDC_ARROW);
   wcFrameWindow.hbrBackground = NULL;
   wcFrameWindow.lpszMenuName = MAKEINTRESOURCE(IDR_FRAME_MENU);
   wcFrameWindow.lpszClassName = "ODFrame";

   RegisterClass(&wcFrameWindow);

   /* Setup window information structure. */
   pWindowInfo = malloc(sizeof(tODFrameWindowInfo));
   if(!pWindowInfo)
   {
      return(NULL);
   }
   pWindowInfo->hInstance = hInstance;
   pWindowInfo->hwndTimeEdit = NULL;
   pWindowInfo->hwndTimeUpDown = NULL;
   pWindowInfo->bWantsChatIndicator = FALSE;
   pWindowInfo->hwndMessageWindow = NULL;

   /* Determine whether or not the toolbar and status bar are on. */
   RegCreateKey(HKEY_CURRENT_USER, "Software\\Pirie\\OpenDoors",
      &hOpenDoorsKey);

   cbData = sizeof(pWindowInfo->bToolbarOn);
   if(RegQueryValueEx(hOpenDoorsKey, "ToolBarOn", NULL, NULL, 
      (LPBYTE)&pWindowInfo->bToolbarOn,
      &cbData) != ERROR_SUCCESS)
   {
      pWindowInfo->bToolbarOn = TRUE;
      RegSetValueEx(hOpenDoorsKey, "ToolBarOn", 0, REG_DWORD,
         (LPBYTE)&pWindowInfo->bToolbarOn,
         sizeof(pWindowInfo->bToolbarOn));
   }

   cbData = sizeof(pWindowInfo->bStatusBarOn);
   if(RegQueryValueEx(hOpenDoorsKey, "StatusBarOn", NULL, NULL, 
      (LPBYTE)&pWindowInfo->bStatusBarOn,
      &cbData) != ERROR_SUCCESS)
   {
      pWindowInfo->bStatusBarOn = TRUE;
      RegSetValueEx(hOpenDoorsKey, "StatusBarOn", 0, REG_DWORD,
         (LPBYTE)&pWindowInfo->bStatusBarOn,
         sizeof(pWindowInfo->bStatusBarOn));
   }

   RegCloseKey(hOpenDoorsKey);

   /* Create the main frame window. */
   if((hwndFrameWindow = CreateWindowEx(
      0L,
      wcFrameWindow.lpszClassName,
      od_control.od_prog_name,
      WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_BORDER | WS_MINIMIZEBOX,
      CW_USEDEFAULT,
      0,
      0,
      0,
      NULL,
      NULL,
      hInstance,
      pWindowInfo)) == NULL)
   {
      /* On window creation failure, return NULL. */
      return(NULL);
   }

   /* Load accelerator table for the  frame window. */
   pWindowInfo->hacclFrameCommands
      = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_FRAME));

   /* Create the OpenDoors toolbar. On failure, we will continue anyhow. */
   if(pWindowInfo->bToolbarOn)
   {
      pWindowInfo->hwndToolbar =
         ODFrameCreateToolbar(hwndFrameWindow, hInstance, pWindowInfo);
   }

   /* Create the status bar. On failure, we will continue anyhow. */
   if(pWindowInfo->bStatusBarOn)
   {
      pWindowInfo->hwndStatusBar =
         ODFrameCreateStatusBar(hwndFrameWindow, hInstance);
   }

   /* Updates state of the window from whether or not the user has */
   /* requested a chat with the sysop.                             */
   ODFrameUpdateWantChat();

   /* Create the local screen window, which occupies the remaining */
   /* client area of the frame window.                             */
   ODScrnStartWindow(hInstance, &hScreenThread, hwndFrameWindow);

   return(hwndFrameWindow);
}


/* ----------------------------------------------------------------------------
 * ODFrameCreateToolbar()                              *** PRIVATE FUNCTION ***
 *
 * Creates the OpenDoors toolbar.
 *
 * Parameters: hwndParent  - Handle to the parent window.
 *
 *             hInstance   - Handle to the executable file's module instance.
 *
 *             pWindowInfo - Pointer to frame window information structure.
 *
 *     Return: A handle to the toolbar on success, or NULL on failure.
 */
static HWND ODFrameCreateToolbar(HWND hwndParent, HANDLE hInstance,
   tODFrameWindowInfo *pWindowInfo)
{
   HWND hwndToolbar = NULL;
   HWND hwndTimeEdit = NULL;
   HWND hwndTimeUpDown = NULL;
   HWND hwndToolTip;
   BOOL bSuccess = FALSE;

   ASSERT(hwndParent != NULL);
   ASSERT(hInstance != NULL);
   ASSERT(pWindowInfo != NULL);

   /* First, attempt to create the toolbar window. */
   hwndToolbar = CreateToolbarEx(hwndParent,
      WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS,
      ID_TOOLBAR, NUM_TOOLBAR_BITMAPS, hInstance, IDB_TOOLBAR,
      atbButtons, DIM(atbButtons), 0, 0, 0, 0, sizeof(TBBUTTON));

   if(hwndToolbar == NULL)
   {
      goto CleanUp;
   }

   /* Change the window proc for the toolbar window to our own, keeping a */
   /* pointer to the original window proc.                                */
   pfnDefToolbarProc = (WNDPROC)GetWindowLong(hwndToolbar, GWL_WNDPROC);
   SetWindowLong(hwndToolbar, GWL_WNDPROC, (LONG)ODFrameToolbarProc);

   /* Next, create an edit control on the toolbar, to allow the user's */
   /* time remaining online to be adjusted.                            */
   hwndTimeEdit = CreateWindowEx(WS_EX_STATICEDGE, "EDIT", "",
      WS_CHILD | WS_BORDER | WS_VISIBLE | ES_LEFT,
      0, 0, 70, 22, hwndToolbar, (HMENU)ID_TIME_EDIT, hInstance, NULL);

   if(hwndTimeEdit == NULL)
   {
      goto CleanUp;
   }

   /* Now that the edit window has the appropriate parent, we set its */
   /* position accordingly. */
   SetWindowPos(hwndTimeEdit, NULL, 2, 2, 0, 0,
      SWP_NOZORDER | SWP_NOSIZE);

   /* Set font of the edit control to be the standard non-bold font. */
   SendMessage(hwndTimeEdit, WM_SETFONT,
      (WPARAM)GetStockObject(DEFAULT_GUI_FONT), MAKELPARAM(FALSE, 0));

   /* Change the window proc for the edit window to our own, keeping a */
   /* pointer to the original window proc. */
   pfnDefEditProc = (WNDPROC)GetWindowLong(hwndTimeEdit, GWL_WNDPROC);
   SetWindowLong(hwndTimeEdit, GWL_WNDPROC, (LONG)ODFrameTimeEditProc);

   /* Add the time edit control to the tooltip control. */

   /* Obtain a handle to the toolbar's tooltip control. */
   hwndToolTip = (HWND)SendMessage(hwndToolbar, TB_GETTOOLTIPS, 0, 0);
   if(hwndToolTip)
   {
      TOOLINFO ToolInfo;

      /* Fill TOOLINFO structure. */
      ToolInfo.cbSize = sizeof(ToolInfo);
      ToolInfo.uFlags = TTF_IDISHWND | TTF_CENTERTIP;
      ToolInfo.lpszText = "User's Time Remaining";
      ToolInfo.hwnd = hwndParent;
      ToolInfo.uId = (UINT)hwndTimeEdit;
      ToolInfo.hinst = hInstance;

      /* Setup tooltips for the time edit box. */
      SendMessage(hwndToolTip, TTM_ADDTOOL, 0, (LPARAM)&ToolInfo);
   }

   /* Now, we create an up-down control to buddy with the edit control. */
   hwndTimeUpDown = CreateWindowEx(0L, UPDOWN_CLASS, "",
      WS_CHILD | WS_BORDER | WS_VISIBLE | UDS_ARROWKEYS |
      UDS_ALIGNRIGHT, 0, 0, 8, 8,
         hwndToolbar, (HMENU)ID_TIME_UPDOWN, hInstance, NULL);

   if(hwndTimeUpDown == NULL)
   {
      goto CleanUp;
   }

   /* Set the up-down control's buddy control to be the edit control that */
   /* we just created.                                                    */
   SendMessage(hwndTimeUpDown, UDM_SETBUDDY, (LONG)hwndTimeEdit, 0L);

   /* Set the valid range of values for the edit control. */
   SendMessage(hwndTimeUpDown, UDM_SETRANGE, 0L, MAKELONG(MAX_TIME, MIN_TIME));

   /* Store handles to time limit edit and up-down controls. */
   pWindowInfo->hwndTimeEdit = hwndTimeEdit;
   pWindowInfo->hwndTimeUpDown = hwndTimeUpDown;

   /* Next, we set the default text for the edit control. */
   ODFrameUpdateTimeLeft(pWindowInfo);

   /* Return with success. */
   bSuccess = TRUE;

CleanUp:
   if(!bSuccess)
   {
      /* On failure, free any allocated resources. */
      if(hwndTimeUpDown != NULL)
      {
         DestroyWindow(hwndTimeUpDown);
      }
      if(hwndTimeEdit != NULL)
      {
         DestroyWindow(hwndTimeUpDown);
      }
      if(hwndToolbar != NULL)
      {
         DestroyWindow(hwndToolbar);
         hwndToolbar = NULL;
      }
   }

   /* Return handle to newly created toolbar, or NULL on failure. */
   return(hwndToolbar);
}


/* ----------------------------------------------------------------------------
 * ODFrameDestroyToolbar()                             *** PRIVATE FUNCTION ***
 *
 * Destroys the OpenDoors toolbar.
 *
 * Parameters: hwndToolbar - Handle to previously created toolbar.
 *
 *             pWindowInfo - Pointer to frame window information structure.
 *
 *     Return: void.
 */
static void ODFrameDestroyToolbar(HWND hwndToolbar,
   tODFrameWindowInfo *pWindowInfo)
{
   ASSERT(hwndToolbar != NULL);
   ASSERT(pWindowInfo != NULL);

   /* Destroy the time up-down control, and NULL its handle in the frame */
   /* window information structure.                                      */
   DestroyWindow(pWindowInfo->hwndTimeUpDown);
   pWindowInfo->hwndTimeUpDown = NULL;

   /* Destroy the time edit control, and NULL its handle in the frame window */
   /* information structure.                                                 */
   DestroyWindow(pWindowInfo->hwndTimeEdit);
   pWindowInfo->hwndTimeEdit = NULL;

   /* Now, destroy the toolbar itself. */
   DestroyWindow(hwndToolbar);
}


/* ----------------------------------------------------------------------------
 * ODFrameCreateStatusBar()                            *** PRIVATE FUNCTION ***
 *
 * Creates the OpenDoors status bar.
 *
 * Parameters: hwndParent  - Handle to the parent window.
 *
 *             hInstance   - Handle to the executable file's module instance.
 *
 *     Return: A handle to the status bar on success, or NULL on failure.
 */
static HWND ODFrameCreateStatusBar(HWND hwndParent, HANDLE hInstance)
{
   HWND hwndStatusBar = NULL;
   char szStatusText[20];

   ASSERT(hwndParent != NULL);

   /* Create the status bar window. */
   hwndStatusBar = CreateWindowEx(0L, STATUSCLASSNAME, "",
      WS_CHILD | WS_VISIBLE, 0, 0, 0, 0,
      hwndParent, (HMENU)ID_STATUSBAR, hInstance, NULL);

   if(hwndStatusBar == NULL)
   {
      return(NULL);
   }

   /* Set the size of the status bar parts from the size of the frame */
   /* window.                                                         */
   ODFrameSizeStatusBar(hwndStatusBar);

   /* Add the user's name, location and connection info string. */
   ODFrameSetMainStatusText(hwndStatusBar);

   /* Add the node number string. */
   sprintf(szStatusText, "Node %d", od_control.od_node);
   SendMessage(hwndStatusBar, SB_SETTEXT, (WPARAM)1, (LPARAM)szStatusText);

   return(hwndStatusBar);
}


/* ----------------------------------------------------------------------------
 * ODFrameSetMainStatusText()                          *** PRIVATE FUNCTION ***
 *
 * Updates the text that is displayed in the main pane of the status bar.
 *
 * Parameters: hwndStatusBar - Handle to the status bar.
 *
 *     Return: void.
 */
static void ODFrameSetMainStatusText(HWND hwndStatusBar)
{
   char szStatusText[160];

   ASSERT(hwndStatusBar != NULL);

   /* Generate base status bar text, with the user's name, location and */
   /* connection information.                                           */
   if(od_control.baud == 0)
   {
      sprintf(szStatusText, "%s of %s in local mode",
         od_control.user_name,
         od_control.user_location);
   }
   else
   {
      sprintf(szStatusText, "%s of %s at %ldbps",
         od_control.user_name,
         od_control.user_location,
         od_control.od_connect_speed);
   }

   /* If the user has paged the sysop, then include reason for chat if */
   /* it is available.                                                 */
   if(od_control.user_wantchat && strlen(od_control.user_reasonforchat) > 0)
   {
      strcat(szStatusText, " (Reason for chat: \"");
      strcat(szStatusText, od_control.user_reasonforchat);
      strcat(szStatusText, "\")");
   }

   /* Update status bar text in the main status bar pane with the newly */
   /* generated string.                                                 */
   SendMessage(hwndStatusBar, SB_SETTEXT, (WPARAM)0, (LPARAM)szStatusText);
}


/* ----------------------------------------------------------------------------
 * ODFrameDestroyStatusBar()                           *** PRIVATE FUNCTION ***
 *
 * Destroys the OpenDoors status bar.
 *
 * Parameters: hwndStatusBar    - Handle to previously created status bar.
 *
 *     Return: void.
 */
static void ODFrameDestroyStatusBar(HWND hwndStatusBar)
{
   DestroyWindow(hwndStatusBar);
}


/* ----------------------------------------------------------------------------
 * ODFrameSizeStatusBar()                              *** PRIVATE FUNCTION ***
 *
 * Creates the OpenDoors status bar.
 *
 * Parameters: hwndStatusBar  - Handle to existing status bar window.
 *
 *     Return: void.
 */
static void ODFrameSizeStatusBar(HWND hwndStatusBar)
{
   int anWidths[NUM_STATUS_PARTS];
   int nStatusWidth;
   RECT rcStatusBar;

   /* Determine the total width of the status bar. */
   GetWindowRect(hwndStatusBar, &rcStatusBar);
   nStatusWidth = rcStatusBar.right - rcStatusBar.left;

   /* Calculate the width of the parts from the total width. */
   anWidths[0] = nStatusWidth - NODE_PART_WIDTH;
   anWidths[1] = -1;

   /* Update the status bar part settings. */
   SendMessage(hwndStatusBar, SB_SETPARTS, NUM_STATUS_PARTS,
      (LPARAM)anWidths);
}


/* ----------------------------------------------------------------------------
 * ODFrameGetUsedClientAtTop()
 *
 * Determines height in pixels of the space used at the top of the
 * frame window's client area, by the toolbar, etc.
 *
 * Parameters: hwndFrame - Handle to the OpenDoors frame window.
 *
 *     Return: The height of the used space, in pixels.
 */
INT ODFrameGetUsedClientAtTop(HWND hwndFrame)
{
   tODFrameWindowInfo *pWindowInfo;
   RECT rcWindow;

   pWindowInfo = (tODFrameWindowInfo *)GetWindowLong(hwndFrame, GWL_USERDATA);

   if(!pWindowInfo->bToolbarOn) return(0);

   GetWindowRect(pWindowInfo->hwndToolbar, &rcWindow);

   return(rcWindow.bottom - rcWindow.top - 2);
}


/* ----------------------------------------------------------------------------
 * ODFrameGetUsedClientAtBottom()
 *
 * Determines height in pixels of the space used at the bottom of the
 * frame window's client area, by the status bar, etc.
 *
 * Parameters: hwndFrame - Handle to the OpenDoors frame window.
 *
 *     Return: The height of the used space, in pixels.
 */
INT ODFrameGetUsedClientAtBottom(HWND hwndFrame)
{
   tODFrameWindowInfo *pWindowInfo;
   RECT rcWindow;

   pWindowInfo = (tODFrameWindowInfo *)GetWindowLong(hwndFrame, GWL_USERDATA);

   if(!pWindowInfo->bStatusBarOn) return(0);

   GetWindowRect(pWindowInfo->hwndStatusBar, &rcWindow);

   return(rcWindow.bottom - rcWindow.top - 1);
}


/* ----------------------------------------------------------------------------
 * ODFrameWindowProc()                                 *** PRIVATE FUNCTION ***
 *
 * The OpenDoors frame window proceedure.
 *
 * Parameters: hwnd   - Handle to the OpenDoors frame window.
 *
 *             uMsg   - Specifies the message.
 *
 *             wParam - Specifies additional message information. The content
 *                      of this parameter depends on the value of the uMsg
 *                      parameter.
 *
 *             lParam - Specifies additional message information. The content
 *                      of this parameter depends on the value of the uMsg
 *                      parameter.
 *
 *     Return: The return value is the result of the message processing and
 *             depends on the message.
 */
LRESULT CALLBACK ODFrameWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
   LPARAM lParam)
{
   tODFrameWindowInfo *pWindowInfo;

   pWindowInfo = (tODFrameWindowInfo *)GetWindowLong(hwnd, GWL_USERDATA);

   switch(uMsg)
   {
      case WM_CREATE:
      {
         /* At window creation time, store a pointer to the window */
         /* information structure in window's user data.           */
         CREATESTRUCT *pCreateStruct = (CREATESTRUCT *)lParam;
         pWindowInfo = (tODFrameWindowInfo *)pCreateStruct->lpCreateParams;
         SetWindowLong(hwnd, GWL_USERDATA, (LONG)pWindowInfo);

         /* Update the enabled and checked states of frame window commands. */
         ODFrameUpdateCmdUI();

         /* If the client has not provided a help callback function, then */
         /* remove the Contents item from the help menu.                  */
         if(od_control.od_help_callback == NULL)
         {
            RemoveMenu(GetMenu(hwnd), ID_HELP_CONTENTS, MF_BYCOMMAND);
         }

         if(od_control.od_config_callback == NULL)
         {
            RemoveMenu(GetMenu(hwnd), ID_DOOR_CONFIG, MF_BYCOMMAND);
         }
         break;
      }

      case WM_CLOSE:
         /* If door exit has been chosen, confirm with local user. */
         if(MessageBox(hwnd,
            "You are about to terminate this session and return the user to the BBS.\nDo you wish to proceed?",
            od_control.od_prog_name,
            MB_ICONQUESTION | MB_YESNO) == IDYES)
         {
            /* Normal door exit (drop to BBS) is implemented by the */
            /* WM_DESTROY handler.                                  */
            ODFrameDestroyWindow(hwnd);
         }
         break;

      case WM_DESTROY:
         /* If toolbar is on, then it must be destroyed when the frame */
         /* window is destroyed.                                       */
         if(pWindowInfo->bToolbarOn)
         {
            ODFrameDestroyToolbar(GetDlgItem(hwnd, ID_TOOLBAR), pWindowInfo);
         }

         /* If status bar is on, then it must be destroyed when the frame */
         /* window is destroyed.                                          */
         if(pWindowInfo->bStatusBarOn)
         {
            ODFrameDestroyStatusBar(GetDlgItem(hwnd, ID_STATUSBAR));
         }

         /* Now, force OpenDoors to shutdown. */
         ODKrnlForceOpenDoorsShutdown(ERRORLEVEL_DROPTOBBS);

         /* When the frame window is destroyed, it is the window proc's   */
         /* responsiblity to deallocate the window information structure. */
         free(pWindowInfo);
         SetWindowLong(hwnd, GWL_USERDATA, (LONG)NULL);

         /* Reset current frame window handle. */
         hwndCurrentFrame = NULL;
         break;

      case WM_SETFOCUS:
         /* Whenver input focus is set to the frame window, pass the input */
         /* focus on to the screen window, which fills most of our client  */
         /* area.                                                          */
         ODScrnSetFocusToWindow();
         break;

      case WM_TIMER:
         /* If the window flash timer has elapsed, then flash the window. */
         FlashWindow(hwnd, TRUE);
         break;

      case WM_COMMAND:
         /* An OpenDoors-defined command has been selected, so switch on */
         /* the command ID.                                              */
         switch(LOWORD(wParam))
         {
            case ID_HELP_ABOUT:
               /* Display the OpenDoors default about box. */
               DialogBox(pWindowInfo->hInstance, MAKEINTRESOURCE(IDD_ABOUT),
                  hwnd, ODFrameAboutDlgProc);
               break;

            case ID_HELP_CONTENTS:
               /* Call the client's help callback function, if one was */
               /* provided.                                            */
               if(od_control.od_help_callback != NULL)
               {
                  (*od_control.od_help_callback)();
               }
               break;

            case ID_DOOR_CONFIG:
               if(od_control.od_config_callback != NULL)
               {
                  (*od_control.od_config_callback)();
               }
               break;

            case ID_DOOR_EXIT:
               /* On request for normal door exit (drop to BBS), just send  */
               /* a close message to this window. This will prompt to       */
               /* confirm exit, and then shutdown OpenDoors if appropriate. */
               PostMessage(hwnd, WM_CLOSE, 0, 0L);
               break;

            case ID_DOOR_CHATMODE:
               /* If chat mode is currently active, then end it. */
               if(od_control.od_chat_active)
               {
                  ODKrnlEndChatMode();
               }
               /* If chat mode is not currently active, then start it. */
               else
               {
                  ODKrnlStartChatThread(TRUE);
               }
               break;

            case ID_DOOR_USERKEYBOARDOFF:
               /* If user keyboard off command has been chosen, then toggle */
               /* keyboard off mode on or off.                              */
               od_control.od_user_keyboard_on
                  = !od_control.od_user_keyboard_on;

               /* Update the keyboard off menu item and toolbar button. */
               CheckMenuItem(GetMenu(hwnd), ID_DOOR_USERKEYBOARDOFF,
                  MF_BYCOMMAND | (od_control.od_user_keyboard_on
                  ? MF_UNCHECKED : MF_CHECKED));
               SendMessage(GetDlgItem(hwnd, ID_TOOLBAR), TB_CHECKBUTTON,
                  ID_DOOR_USERKEYBOARDOFF,
                  MAKELONG(!od_control.od_user_keyboard_on, 0));
               break;

            case ID_DOOR_SYSOPNEXT:
               /* If sysop next command has been chosen, then toggle the */
               /* sysop next flag on or off.                             */
               od_control.sysop_next = !od_control.sysop_next;

               /* Update the sysop next menu item and toolbar button. */
               CheckMenuItem(GetMenu(hwnd), ID_DOOR_SYSOPNEXT, MF_BYCOMMAND |
                  (od_control.sysop_next ? MF_CHECKED : MF_UNCHECKED));
               SendMessage(GetDlgItem(hwnd, ID_TOOLBAR), TB_CHECKBUTTON,
                  ID_DOOR_SYSOPNEXT, MAKELONG(od_control.sysop_next, 0));
               break;

            case ID_DOOR_HANGUP:
               /* If hangup command has been chosen, then confirm with the */
               /* local user.                                              */
               if(MessageBox(hwnd,
                  "You are about to disconnect this user. Do you wish to proceed?",
                  od_control.od_prog_name,
                  MB_ICONQUESTION | MB_YESNO) == IDYES)
               {
                  ODKrnlForceOpenDoorsShutdown(ERRORLEVEL_HANGUP);
               }
               break;

            case ID_DOOR_LOCKOUT:
               /* If lockout command has been chosen, the confirm with the */
               /* local user.                                              */
               if(MessageBox(hwnd,
                  "You are about to lock out this user. Do you wish to proceed?",
                  od_control.od_prog_name,
                  MB_ICONQUESTION | MB_YESNO) == IDYES)
               {
                  /* Set the user's access security level to 0. */
                  od_control.user_security = 0;

                  ODKrnlForceOpenDoorsShutdown(ERRORLEVEL_HANGUP);
               }
               break;

            case ID_VIEW_TOOL_BAR:
            {
               HKEY hOpenDoorsKey;

               /* If toolbar on/off command has been chosen ... */
               if(pWindowInfo->bToolbarOn)
               {
                  /* If the toolbar is on, then turn it off. */
                  ODFrameDestroyToolbar(GetDlgItem(hwnd, ID_TOOLBAR),
                     pWindowInfo);
                  pWindowInfo->bToolbarOn = FALSE;
                  CheckMenuItem(GetMenu(hwnd), ID_VIEW_TOOL_BAR,
                     MF_BYCOMMAND | MF_UNCHECKED);
               }
               else
               {
                  /* If the toolbar is off, then turn it on. */
                  pWindowInfo->hwndToolbar = ODFrameCreateToolbar(hwnd,
                     pWindowInfo->hInstance, pWindowInfo);
                  pWindowInfo->bToolbarOn = TRUE;
                  CheckMenuItem(GetMenu(hwnd), ID_VIEW_TOOL_BAR,
                     MF_BYCOMMAND | MF_CHECKED);
                  ODFrameUpdateCmdUI();
               }

               /* Adjust window sizes accordingly. */
               ODScrnAdjustWindows();

               /* Update the toolbar setting in the registry. */
               RegCreateKey(HKEY_CURRENT_USER, "Software\\Pirie\\OpenDoors",
                  &hOpenDoorsKey);
               RegSetValueEx(hOpenDoorsKey, "ToolBarOn", 0, REG_DWORD,
                  (LPBYTE)&pWindowInfo->bToolbarOn,
                  sizeof(pWindowInfo->bToolbarOn));
               RegCloseKey(hOpenDoorsKey);
               break;
            }

            case ID_VIEW_STAT_BAR:
            {
               HKEY hOpenDoorsKey;

               /* If the status bar on/off command has been chosen ... */
               if(pWindowInfo->bStatusBarOn)
               {
                  /* If the status bar is on, then turn it off. */
                  pWindowInfo->bStatusBarOn = FALSE;
                  CheckMenuItem(GetMenu(hwnd), ID_VIEW_STAT_BAR,
                     MF_BYCOMMAND | MF_UNCHECKED);
                  ODFrameDestroyStatusBar(GetDlgItem(hwnd, ID_STATUSBAR));
               }
               else
               {
                  /* If the status bar is off, then turn it on. */
                  pWindowInfo->bStatusBarOn = TRUE;
                  CheckMenuItem(GetMenu(hwnd), ID_VIEW_STAT_BAR,
                     MF_BYCOMMAND | MF_CHECKED);
                  pWindowInfo->hwndStatusBar =
                     ODFrameCreateStatusBar(hwnd, pWindowInfo->hInstance);
               }

               /* Adjust window sizes accordingly. */
               ODScrnAdjustWindows();

               /* Update the status bar setting in the registry. */
               RegCreateKey(HKEY_CURRENT_USER, "Software\\Pirie\\OpenDoors",
                  &hOpenDoorsKey);
               RegSetValueEx(hOpenDoorsKey, "StatusBarOn", 0, REG_DWORD,
                  (LPBYTE)&pWindowInfo->bStatusBarOn,
                  sizeof(pWindowInfo->bStatusBarOn));
               RegCloseKey(hOpenDoorsKey);
               break;
            }

            case ID_USER_ADDONEMINUTE:
               /* If add one minute command has been chosen, then        */
               /* increment the user's time, up to the maximum allowable */
               /* time.                                                  */
               if(od_control.user_timelimit < MAX_TIME)
               {
                  od_control.user_timelimit++;
                  ODFrameUpdateTimeLeft(pWindowInfo);
               }
               break;

            case ID_USER_ADDFIVEMINUTES:
               /* If add five minutes command has been chosen, then */
               /* adjust the user's time accordingly.               */
               od_control.user_timelimit =
                  MIN(od_control.user_timelimit + 5, MAX_TIME);
               ODFrameUpdateTimeLeft(pWindowInfo);
               break;

            case ID_USER_SUBTRACTONEMINUTE:
               /* If subtract one minute command has been chosen, then */
               /* adjust the user's time accordingly.                  */
               if(od_control.user_timelimit > MIN_TIME)
               {
                  od_control.user_timelimit--;
                  ODFrameUpdateTimeLeft(pWindowInfo);
               }
               break;

            case ID_USER_SUBTRACTFIVEMINUTES:
               /* If the subtract five mintues command has been chosen, */
               /* then adjust the user's time accordingly.              */
               od_control.user_timelimit =
                  MAX(od_control.user_timelimit - 5, MIN_TIME);
               ODFrameUpdateTimeLeft(pWindowInfo);
               break;

            case ID_USER_INACTIVITYTIMER:
               /* If the user inactivity timer command has been chosen, */
               /* then toggle the timer on or off.                      */
               od_control.od_disable_inactivity =
                  !od_control.od_disable_inactivity;
               CheckMenuItem(GetMenu(hwnd), ID_USER_INACTIVITYTIMER,
                  MF_BYCOMMAND | (od_control.od_disable_inactivity ?
                  MF_UNCHECKED : MF_CHECKED));
               break;

            case ID_TIME_EDIT:
            {
               /* If the user's time remaining has been directly edited, */
               /* then adjust the time limit accordingly.                */
               if(HIWORD(wParam) == EN_CHANGE)
               {
                  char szTimeText[40];
                  GetWindowText((HWND)lParam, szTimeText, sizeof(szTimeText));
                  od_control.user_timelimit = atoi(szTimeText);

                  /* Do not allow the time limit to fall outside of the */
                  /* valid range.                                       */
                  od_control.user_timelimit =
                     MAX(MIN_TIME, od_control.user_timelimit);
                  od_control.user_timelimit =
                     MIN(MAX_TIME, od_control.user_timelimit);

                  /* Update the position of the up-down control. */
                  SendMessage(pWindowInfo->hwndTimeUpDown, UDM_SETPOS, 0,
                     (LPARAM)MAKELONG(od_control.user_timelimit, 0));
               }
            }

            default:
               return(TRUE);
         }
         return(FALSE);

      case WM_NOTIFY:
         /* A control parent notification message has been sent. */
         switch(((LPNMHDR)lParam)->code)
         {
            case TTN_NEEDTEXT:
            {
               /* This is the message from the tool tip control, requesting */
               /* the appropriate string to display for the current toolbar */
               /* item.                                                     */
               LPTOOLTIPTEXT lpToolTipText = (LPTOOLTIPTEXT)lParam;
               switch(lpToolTipText->hdr.idFrom)
               {
                  case ID_DOOR_EXIT:
                     lpToolTipText->lpszText = "Exit To BBS";
                     break;
                  case ID_DOOR_CHATMODE:
                     lpToolTipText->lpszText = "Chat Mode";
                     break;
                  case ID_DOOR_USERKEYBOARDOFF:
                     lpToolTipText->lpszText = "User Keyboard Off";
                     break;
                  case ID_DOOR_SYSOPNEXT:
                     lpToolTipText->lpszText = "Sysop Next";
                     break;
                  case ID_DOOR_HANGUP:
                     lpToolTipText->lpszText = "Hangup";
                     break;
                  case ID_DOOR_LOCKOUT:
                     lpToolTipText->lpszText = "Lockout";
                     break;
               }
               break;
            }
         }
         break;

      case WM_VSCROLL:
         /* A scrolling action has taken place. */

         /* If it is the time limit up-down control that has scrolled. */
         if((HWND)lParam == pWindowInfo->hwndTimeUpDown)
         {
            int nPos = HIWORD(wParam);

            /* Adjust the user's time limit. */
            od_control.user_timelimit = MAX(MIN(nPos, MAX_TIME), MIN_TIME);

            /* Update the time left displayed in the edit box. */
            ODFrameUpdateTimeLeft(pWindowInfo);
         }
         break;

      case WM_SIZE:
         /* The OpenDoors frame window has been resized, so its contents */
         /* must now be resized accordingly.                             */

         /* Pass the message on to the status bar window, so that it will */
         /* automatically adjust its own position and overall size.       */
         SendMessage(GetDlgItem(hwnd, ID_STATUSBAR), WM_SIZE, wParam, lParam);

         /* Now, adjust the size of each part of the status bar. */
         ODFrameSizeStatusBar(GetDlgItem(hwnd, ID_STATUSBAR));

         /* Pass the message on to the toolbar, so that it will resize */
         /* iteself.                                                   */
         SendMessage(GetDlgItem(hwnd, ID_TOOLBAR), WM_SIZE, wParam, lParam);
         break;

      case WM_MENUSELECT:
         /* If the user has selected an item on the menu, then we should */
         /* update the status bar accordingly.                           */
         if(HIWORD(wParam) == 0xFFFF)
         {
            /* If menu is being exited, then turn off the status bar simple */
            /* mode.                                                        */
            HWND hwndStatusBar = GetDlgItem(hwnd, ID_STATUSBAR);

            SendMessage(hwndStatusBar, SB_SIMPLE, (WPARAM)FALSE, 0L);
         }
         else
         {
            char szCommandString[160] = "";
            HWND hwndStatusBar = GetDlgItem(hwnd, ID_STATUSBAR);

            /* A new menu item is being selected. */

            /* If this item is on the system menu, then provide the strings */
            /* for any of those menu items.                                 */
            if(HIWORD(wParam) & MF_SYSMENU)
            {
               switch(LOWORD(wParam))
               {
                  case SC_SIZE:
                     strcpy(szCommandString,
                        "Resizes this window.");
                     break;
                  case SC_MOVE:
                     strcpy(szCommandString,
                        "Moves this window.");
                     break;
                  case SC_MINIMIZE:
                     strcpy(szCommandString,
                        "Collapses this window to an icon.");
                     break;
                  case SC_MAXIMIZE:
                     strcpy(szCommandString,
                        "Expands this window to fill the screen.");
                     break;
                  case SC_CLOSE:
                     strcpy(szCommandString,
                        "Closes this window, and returns the user to the BBS.");
                     break;
                  case SC_RESTORE:
                     strcpy(szCommandString,
                        "Restores this window to normal size.");
                     break;
                  case SC_TASKLIST:
                     strcpy(szCommandString,
                        "");
                     break;
               }
            }
            else
            {
               /* If this item is on the window menu provided by OpenDoors, */
               /* then load the status bar string for this command ID.      */
               LoadString(pWindowInfo->hInstance, LOWORD(wParam),
                  szCommandString, sizeof(szCommandString));
            }

            /* Switch the status bar into simple (single-paned) mode. */
            SendMessage(hwndStatusBar, SB_SIMPLE, (WPARAM)TRUE, 0L);

            /* Set the text for the status bar. */
            SendMessage(hwndStatusBar, SB_SETTEXT, (WPARAM)255 | SBT_NOBORDERS,
               (LPARAM)szCommandString);
         }
         return(DefWindowProc(hwnd, uMsg, wParam, lParam));

      case WM_SHOW_MESSAGE:
         if(pWindowInfo->hwndMessageWindow == NULL)
         {
            pWindowInfo->pszCurrentMessage = (char *)lParam;
            pWindowInfo->nCurrentMessageFlags = (int)wParam;

            /* Create the message window. */
            DialogBoxParam(pWindowInfo->hInstance,
               MAKEINTRESOURCE(IDD_MESSAGE), hwnd, ODFrameMessageDlgProc,
               (LPARAM)pWindowInfo);
         }
         break;

      case WM_REMOVE_MESSAGE:
         if(pWindowInfo->hwndMessageWindow != NULL)
         {
            PostMessage(pWindowInfo->hwndMessageWindow, WM_COMMAND,
               MAKELONG(IDOK, 0), 0L);
            pWindowInfo->hwndMessageWindow = NULL;
         }
         break;

      default:
         /* Pass messages that we don't explicitly handle on to the */
         /* default window proc.                                    */
         return(DefWindowProc(hwnd, uMsg, wParam, lParam));
   }

   return(0);
}


/* ----------------------------------------------------------------------------
 * ODFrameUpdateCmdUI()
 *
 * Updates the enabled and checked state of OpenDoors commands that may change.
 *
 * Parameters: None.
 *
 *     Return: void.
 */
void ODFrameUpdateCmdUI(void)
{
   HWND hwndFrame = hwndCurrentFrame;
   HMENU hMenu = GetMenu(hwndFrame);
   HWND hwndToolbar = GetDlgItem(hwndFrame, ID_TOOLBAR);
   tODFrameWindowInfo *pWindowInfo;

   if(hwndFrame == NULL) return;

   /* Obtain window information structure. */
   pWindowInfo = (tODFrameWindowInfo *)GetWindowLong(hwndFrame, GWL_USERDATA);
   if(pWindowInfo == NULL) return;

   /* Check or uncheck the toolbar and status bar menu items. */
   CheckMenuItem(hMenu, ID_VIEW_TOOL_BAR, MF_BYCOMMAND |
      (pWindowInfo->bToolbarOn ? MF_CHECKED : MF_UNCHECKED));
   CheckMenuItem(hMenu, ID_VIEW_STAT_BAR, MF_BYCOMMAND |
      (pWindowInfo->bStatusBarOn ? MF_CHECKED : MF_UNCHECKED));

   /* Check or uncheck the inactivity timer menu item. */
   CheckMenuItem(hMenu, ID_USER_INACTIVITYTIMER, MF_BYCOMMAND |
      (od_control.od_disable_inactivity ? MF_UNCHECKED : MF_CHECKED));

   /* Check or uncheck the sysop next menu item and toolbar button. */
   CheckMenuItem(hMenu, ID_DOOR_SYSOPNEXT, MF_BYCOMMAND |
      (od_control.sysop_next ? MF_CHECKED : MF_UNCHECKED));
   SendMessage(hwndToolbar, TB_CHECKBUTTON,
      ID_DOOR_SYSOPNEXT, MAKELONG(od_control.sysop_next, 0));

   /* Check or uncheck the keyboard off menu item and toolbar button. */
   CheckMenuItem(hMenu, ID_DOOR_USERKEYBOARDOFF, MF_BYCOMMAND |
      (od_control.od_user_keyboard_on ? MF_UNCHECKED : MF_CHECKED));
   SendMessage(hwndToolbar, TB_CHECKBUTTON,
      ID_DOOR_USERKEYBOARDOFF,
      MAKELONG(!od_control.od_user_keyboard_on, 0));

   /* Update the chat mode menu item and toolbar button. */
   CheckMenuItem(hMenu, ID_DOOR_CHATMODE, MF_BYCOMMAND |
      (od_control.od_chat_active ? MF_CHECKED : MF_UNCHECKED));
   SendMessage(hwndToolbar, TB_CHECKBUTTON, ID_DOOR_CHATMODE,
      MAKELONG(od_control.od_chat_active, 0));
}


/* ----------------------------------------------------------------------------
 * ODFrameUpdateTimeDisplay()
 *
 * Updates the remaining time online that is displayed anywhere by the frame
 * window. Uses ODFrameUpdateTimeLeft().
 *
 * Parameters: None.
 *
 *     Return: void.
 */
void ODFrameUpdateTimeDisplay(void)
{
   tODFrameWindowInfo *pWindowInfo;

   /* If there is no current frame window, then return without doing */
   /* anything.                                                      */
   if(hwndCurrentFrame == NULL) return;

   pWindowInfo = (tODFrameWindowInfo *)GetWindowLong(hwndCurrentFrame,
      GWL_USERDATA);
   ASSERT(pWindowInfo != NULL);

   ODFrameUpdateTimeLeft(pWindowInfo);
}


/* ----------------------------------------------------------------------------
 * ODFrameUpdateWantChat()
 *
 * Updates the state of the flashing wants-chat indicator on the frame window.
 *
 * Parameters: None.
 *
 *     Return: void.
 */
void ODFrameUpdateWantChat(void)
{
   tODFrameWindowInfo *pWindowInfo;

   /* If there is no current frame window, then return without doing */
   /* anything.                                                      */
   if(hwndCurrentFrame == NULL) return;

   pWindowInfo = (tODFrameWindowInfo *)GetWindowLong(hwndCurrentFrame,
      GWL_USERDATA);
   ASSERT(pWindowInfo != NULL);

   /* If the status bar is on, then update the text displayed in the */
   /* status bar's main pane.                                        */
   if(pWindowInfo->bStatusBarOn)
   {
      ODFrameSetMainStatusText(pWindowInfo->hwndStatusBar);
   }

   /* Toggle the state of the wants-chat indicator, of needed. */
   if(pWindowInfo->bWantsChatIndicator && !od_control.user_wantchat)
   {
      /* Restore original window text. */
      SetWindowText(hwndCurrentFrame, od_control.od_prog_name);

      /* Restore the window flash to its original state. */
      FlashWindow(hwndCurrentFrame, FALSE);

      /* Destroy the Windows timer. */
      KillTimer(hwndCurrentFrame, 1);

      /* Record that wants chat indicator is now off. */
      pWindowInfo->bWantsChatIndicator = FALSE;
   }
   else if (!pWindowInfo->bWantsChatIndicator && od_control.user_wantchat)
   {
      /* Set window title to include the wants chat indicator. */
      char szNewWindowTitle[sizeof(od_control.od_prog_name) + 20];
      sprintf(szNewWindowTitle, "%s - User Wants Chat",
         od_control.od_prog_name);
      SetWindowText(hwndCurrentFrame, szNewWindowTitle);

      /* Start the flashing the window. */
      SetTimer(hwndCurrentFrame, 1,
         GetCaretBlinkTime(), NULL);

      /* Record that wants chat indicator is now on. */
      pWindowInfo->bWantsChatIndicator = TRUE;
   }
}


/* ----------------------------------------------------------------------------
 * ODFrameDestroyWindow()                              *** PRIVATE FUNCTION ***
 *
 * Destroys the OpenDoors frame window and its children.
 *
 * Parameters: hwndFrame   - Handle to the window previously created by
 *                           ODFrameCreateWindow().
 *
 *     Return: void.
 */
static void ODFrameDestroyWindow(HWND hwndFrame)
{
   tODFrameWindowInfo *pWindowInfo;

   ASSERT(hwndFrame != NULL);

   /* Obtain a pointer to the frame window information structure. */
   pWindowInfo = (tODFrameWindowInfo *)GetWindowLong(hwndFrame, GWL_USERDATA);

   /* At this point, deallocate the accelerator table. */
   if(pWindowInfo->hacclFrameCommands != NULL)
   {
      DestroyAcceleratorTable(pWindowInfo->hacclFrameCommands);
   }

   /* Destroying the main frame window will automatically cause its */
   /* children to be destroyed.                                     */
   DestroyWindow(hwndFrame);
}


/* ----------------------------------------------------------------------------
 * ODFrameToolbarProc()                                *** PRIVATE FUNCTION ***
 *
 * The toolbar window proceedure.
 *
 * Parameters: hwnd   - Handle to the toolbar window.
 *
 *             uMsg   - Specifies the message.
 *
 *             wParam - Specifies additional message information. The content
 *                      of this parameter depends on the value of the uMsg
 *                      parameter.
 *
 *             lParam - Specifies additional message information. The content
 *                      of this parameter depends on the value of the uMsg
 *                      parameter.
 *
 *     Return: The return value is the result of the message processing and
 *             depends on the message.
 */
LRESULT CALLBACK ODFrameToolbarProc(HWND hwnd, UINT uMsg, WPARAM wParam,
   LPARAM lParam)
{
   switch(uMsg)
   {
      /* Forward needed message to the main frame window proceedure. */
      case WM_VSCROLL:
      case WM_COMMAND:
         SendMessage(GetParent(hwnd), uMsg, wParam, lParam);
         break;
   }

   /* Pass all messages on to the default toolbar window proceedure. */
   return(CallWindowProc(pfnDefToolbarProc, hwnd, uMsg, wParam, lParam));
}


/* ----------------------------------------------------------------------------
 * ODFrameUpdateTimeLeft()                             *** PRIVATE FUNCTION ***
 *
 * Updates the displayed time remaining from od_control.user_timelimit.
 *
 * Parameters: pWindowInfo - Pointer to frame window information structure.
 *
 *     Return: void.
 */
static void ODFrameUpdateTimeLeft(tODFrameWindowInfo *pWindowInfo)
{
   char szTimeLeft[12];
   RECT rcWindow;

   if(pWindowInfo->hwndTimeEdit == NULL)
   {
      /* If the time limit edit control does not exist (i.e., if the       */
      /* toolbar is not currently on), then there is nothing for us to do. */
      return;
   }

   /* Generate the string to be displayed in the edit control. */
   sprintf(szTimeLeft, "%d min.", od_control.user_timelimit);

   /* Set the edit control's text to the new string. */
   SetWindowText(pWindowInfo->hwndTimeEdit, szTimeLeft);

   /* Force edit control to be redrawn. (Except for rightmost pixel */
   /* column.)                                                      */
   GetWindowRect(pWindowInfo->hwndTimeEdit, &rcWindow);
   rcWindow.right--;
   InvalidateRect(pWindowInfo->hwndTimeEdit, &rcWindow, TRUE);

   /* Set the position of the up-down control to match. */
   SendMessage(pWindowInfo->hwndTimeUpDown, UDM_SETPOS, 0,
      (LPARAM)MAKELONG(od_control.user_timelimit, 0));
}


/* ----------------------------------------------------------------------------
 * ODFrameTimeEditProc()                               *** PRIVATE FUNCTION ***
 *
 * The time edit window proceedure. Relays mouse messages from the edit box
 * to the tooltip control, and then passes all messages on to the standard
 * edit box window proceedure.
 *
 * Parameters: hwnd   - Handle to the time edit window.
 *
 *             uMsg   - Specifies the message.
 *
 *             wParam - Specifies additional message information. The content
 *                      of this parameter depends on the value of the uMsg
 *                      parameter.
 *
 *             lParam - Specifies additional message information. The content
 *                      of this parameter depends on the value of the uMsg
 *                      parameter.
 *
 *     Return: The return value is the result of the message processing and
 *             depends on the message.
 */
LRESULT CALLBACK ODFrameTimeEditProc(HWND hwnd, UINT uMsg, WPARAM wParam,
   LPARAM lParam)
{
   switch(uMsg)
   {
      case WM_MOUSEMOVE:
      case WM_LBUTTONDOWN:
      case WM_LBUTTONUP:
      {
         MSG msg;
         HWND hwndToolTip;

         /* Setup message structure. */
         msg.lParam = lParam;
         msg.wParam = wParam;
         msg.message = uMsg;
         msg.hwnd = hwnd;

         /* Obtain handle to the tooltip window. */
         hwndToolTip = (HWND)SendMessage(GetParent(hwnd), TB_GETTOOLTIPS,
            0, 0);

         /* Relay the message to the tooltip window. */
         SendMessage(hwndToolTip, TTM_RELAYEVENT, 0, (LPARAM)(LPMSG)&msg);

         break;
      }
   }

   /* Pass all messages on to the default edit box window proceedure. */
   return(CallWindowProc(pfnDefEditProc, hwnd, uMsg, wParam, lParam));
}


/* ----------------------------------------------------------------------------
 * ODFrameAboutDlgProc()
 *
 * DialogProc for the OpenDoors default Help About dialog box.
 *
 * Parameters: hwndDlg  - Window handle to the dialog box.
 *
 *             uMsg     - Message ID.
 *
 *             wParam   - First message parameter.
 *
 *             lParam   - Second message parameter.
 *
 *     Return: TRUE if message is processed, FALSE otherwise.
 */
BOOL CALLBACK ODFrameAboutDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,
   LPARAM lParam)
{
   switch(uMsg)
   {
      case WM_INITDIALOG:
         /* At dialog box creation time, update the text in the about      */
         /* box with any information provided by the OpenDoors programmer. */

         /* If a program name has been provided, then display it. */
         if(strcmp(od_control.od_prog_name, OD_VER_SHORTNAME) != 0)
         {
            SetWindowText(GetDlgItem(hwndDlg, IDC_DOORNAME),
               od_control.od_prog_name);
         }

         /* If copyright information has been provided, then display it. */
         if(strlen(od_control.od_prog_copyright) > 0)
         {
            SetWindowText(GetDlgItem(hwndDlg, IDC_COPYRIGHT),
               od_control.od_prog_copyright);
         }

         /* If program version information has been provided, then display */
         /* it.                                                            */
         if(strlen(od_control.od_prog_version) > 0)
         {
            SetWindowText(GetDlgItem(hwndDlg, IDC_VERSION),
               od_control.od_prog_version);
         }

         /* Center the about dialog box in the area occupied by the */
         /* main frame window.                                      */
         ODFrameCenterWindowInParent(hwndDlg);

         return(TRUE);

      case WM_COMMAND:
         /* If a command has been chosen. */
         switch(LOWORD(wParam))
         {
            case IDCANCEL:
            case IDOK:
               /* If the OK button has been pressed, then close the dialog. */
               EndDialog(hwndDlg, IDOK);
               break;
         }
         return(TRUE);

      default:
         /* Otherwise, indicate that this message has not been processed. */
         return(FALSE);
   }
}


/* ----------------------------------------------------------------------------
 * ODFrameCenterWindowInParent()                       *** PRIVATE FUNCTION ***
 *
 * Repositions the specified window so that it is centered in its parent.
 *
 * Parameters: hwndChild - The window to reposition.
 *
 *     Return: void.
 */
void ODFrameCenterWindowInParent(HWND hwndChild)
{
   HWND hwndParent;
   RECT rcParent;
   RECT rcChild;
   INT nChildWidth;
   INT nChildHeight;
   INT nParentWidth;
   INT nParentHeight;

   ASSERT(hwndChild != NULL);

   /* Obtain a handle to the parent window. */
   hwndParent = GetParent(hwndChild);
   ASSERT(hwndParent != NULL);

   /* Obtain the bounding boxes of both windows. */
   GetWindowRect(hwndChild, &rcChild);
   GetWindowRect(hwndParent, &rcParent);
   
   /* Determine the height and width of both windows. */
   nChildWidth = rcChild.right - rcChild.left;
   nChildHeight = rcChild.bottom - rcChild.top;
   nParentWidth = rcParent.right - rcParent.left;
   nParentHeight = rcParent.bottom - rcParent.top;

   /* Move the child to the center of the parent. */
   SetWindowPos(hwndChild, NULL,
      rcParent.left + (nParentWidth - nChildWidth) / 2,
      rcParent.top + (nParentHeight - nChildHeight) / 2,
      0, 0, SWP_NOSIZE | SWP_NOZORDER);
}


/* ----------------------------------------------------------------------------
 * ODFrameMessageLoop()                                *** PRIVATE FUNCTION ***
 *
 * Message loop for OpenDoors local UI thread (frame window handling).
 *
 * Parameters: hInstance   - Handle to current instance.
 *
 *             hwndFrame   - Handle to the frame window.
 *
 *     Return: void.
 */
static void ODFrameMessageLoop(HANDLE hInstance, HWND hwndFrame)
{
   MSG msg;

   ASSERT(hInstance != NULL);
   ASSERT(hwndFrame != NULL);

   /* Loop, fetching, translating and dispatching messages for any windows */
   /* created by this thread. (GetMessage() blocks when no messages are    */
   /* available.)                                                          */
   while(GetMessage(&msg, NULL, 0, 0))
   {
      if(!ODFrameTranslateAccelerator(hwndFrame, &msg))
      {
         TranslateMessage(&msg);
         DispatchMessage(&msg);
      }
   }
}


/* ----------------------------------------------------------------------------
 * ODFrameTranslateAccelerator()
 *
 * Translates WM_KEYDOWN or WM_SYSKEYDOWN messages to frame window commands,
 * if needed, based on the frame window's accelerator table.
 *
 * Parameters: hwndFrame  - Handle to the OpenDoors main frame window.
 *
 *             pMsg       - Pointer to the message that may require
 *                          translation.
 *
 *     Return: TRUE if message was translated, FALSE if not.
 */
BOOL ODFrameTranslateAccelerator(HWND hwndFrame, LPMSG pMsg)
{
   tODFrameWindowInfo *pWindowInfo;

   ASSERT(hwndFrame != NULL);
   ASSERT(pMsg != NULL);

   /* Obtain a pointer to the frame window information structure. */
   pWindowInfo = (tODFrameWindowInfo *)GetWindowLong(hwndFrame, GWL_USERDATA);
   ASSERT(pWindowInfo != NULL);

   /* Perform accelerator translation, based on the frame window's */
   /* accelerator table, sending any resulting WM_COMMAND messages */
   /* to the frame window.                                         */
   return(TranslateAccelerator(hwndFrame, pWindowInfo->hacclFrameCommands,
      pMsg) != 0);
}


/* ----------------------------------------------------------------------------
 * ODFrameThreadProc()                                 *** PRIVATE FUNCTION ***
 *
 * Function that execute the OpenDoors frame window thread.
 *
 * Parameters: pParam   - The thread parameter, which must be the handle to the
 *                        current application instance.
 *
 *     Return: TRUE on success, or FALSE on failure.
 */
DWORD OD_THREAD_FUNC ODFrameThreadProc(void *pParam)
{
   HWND hwndFrame;
   HANDLE hInstance = (HANDLE)pParam;

   /* Create the frame window. */
   hwndFrame = ODFrameCreateWindow(hInstance);

   if(hwndFrame == NULL)
   {
      return(FALSE);
   }

   /* Store a pointer to the frame window. */
   hwndCurrentFrame = hwndFrame;

   /* Loop, processing messages for the frame window. */
   ODFrameMessageLoop(hInstance, hwndFrame);

   /* Destroy the frame window. */
   ODFrameDestroyWindow(hwndFrame);

   return(TRUE);
}


/* ----------------------------------------------------------------------------
 * ODFrameStart()
 *
 * Function that starts up the frame window.
 *
 * Parameters: hInstance     - Handle to the current application instance.
 *
 *             phFrameThread - Pointer to the frame thread handle.
 *
 *     Return: kODRCSuccess on success, or an error code on failure.
 */
tODResult ODFrameStart(HANDLE hInstance, tODThreadHandle *phFrameThread)
{
   return(ODThreadCreate(phFrameThread, ODFrameThreadProc,
      (void *)hInstance));
}


/* ----------------------------------------------------------------------------
 * ODFrameMessageDlgProc()
 *
 * Dialog proceedure for the OpenDoors message window.
 *
 * Parameters: hwndDlg  - Window handle to the dialog box.
 *
 *             uMsg     - Message ID.
 *
 *             wParam   - First message parameter.
 *
 *             lParam   - Second message parameter.
 *
 *     Return: TRUE if message is processed, FALSE otherwise.
 */
BOOL CALLBACK ODFrameMessageDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,
   LPARAM lParam)
{
   switch(uMsg)
   {
      case WM_INITDIALOG:
      {
         tODFrameWindowInfo *pWindowInfo;

         pWindowInfo = (tODFrameWindowInfo *)lParam;

         ASSERT(pWindowInfo != NULL);

         pWindowInfo->hwndMessageWindow = hwndDlg;
         
         /* Set the message window title. */
         SetWindowText(hwndDlg, od_control.od_prog_name);

         /* Change the text displayed in the message window. */
         SetWindowText(GetDlgItem(hwndDlg, IDC_MESSAGE_TEXT1),
            (char *)pWindowInfo->pszCurrentMessage);

         /* Center window in parent window. */
         ODFrameCenterWindowInParent(hwndDlg);

         return(FALSE);
      }

      case WM_COMMAND:
         /* If a command has been chosen. */
         switch(LOWORD(wParam))
         {
            case IDOK:
               /* If the OK button has been pressed, then close the dialog. */
               EndDialog(hwndDlg, IDOK);
               break;
         }
         return(TRUE);

      default:
         /* Indicate that this message has not been processed. */
         return(FALSE);
   }

   return(TRUE);
}


#endif /* ODPLAT_WIN32 */