windows-server-2003/enduser/netmeeting/ui/msconfwb/mwnd.cpp

//
// MWND.CPP
// Main WB Window
//
// Copyright Microsoft 1998-
//

// PRECOMP
#include "precomp.h"
#include <dde.h>
#include "version.h"


static const TCHAR s_cszHtmlHelpFile[] = TEXT("nmwhiteb.chm");

// Class name
TCHAR szMainClassName[] = "Wb32MainWindowClass";


//
// Scroll accelerators
//
typedef struct tagSCROLL
{
    UINT uiMenuId;
    UINT uiMessage;
    UINT uiScrollCode;
}
SCROLL;

static const SCROLL s_MenuToScroll[] =
{
  { IDM_PAGEUP,        WM_VSCROLL, SB_PAGEUP },
  { IDM_PAGEDOWN,      WM_VSCROLL, SB_PAGEDOWN },
  { IDM_SHIFTPAGEUP,   WM_HSCROLL, SB_PAGEUP },
  { IDM_SHIFTPAGEDOWN, WM_HSCROLL, SB_PAGEDOWN },
  { IDM_HOME,          WM_HSCROLL, SB_TOP },
  { IDM_HOME,          WM_VSCROLL, SB_TOP },
  { IDM_END,           WM_HSCROLL, SB_BOTTOM },
  { IDM_END,           WM_VSCROLL, SB_BOTTOM },
  { IDM_LINEUP,        WM_VSCROLL, SB_LINEUP },
  { IDM_LINEDOWN,      WM_VSCROLL, SB_LINEDOWN },
  { IDM_SHIFTLINEUP,   WM_HSCROLL, SB_LINEUP },
  { IDM_SHIFTLINEDOWN, WM_HSCROLL, SB_LINEDOWN }
};


// tooltip data
// check codes
#define NA    0   // dont't check checked state
#define TB    1    // check toolbar for checked state
#define BT    2    // check tipped wnd (a button) for checked state

typedef struct
{
    UINT    nID;
    UINT    nCheck;
    UINT    nUpTipID;
    UINT    nDownTipID;
}
TIPIDS;

TIPIDS g_tipIDsArray[]    =
{
{IDM_SELECT,            TB, IDS_HINT_SELECT,        IDS_HINT_SELECT},
{IDM_ERASER,            TB, IDS_HINT_ERASER,        IDS_HINT_ERASER},
{IDM_TEXT,              TB, IDS_HINT_TEXT,          IDS_HINT_TEXT},
{IDM_HIGHLIGHT,         TB, IDS_HINT_HIGHLIGHT,     IDS_HINT_HIGHLIGHT},
{IDM_PEN,               TB, IDS_HINT_PEN,           IDS_HINT_PEN},
{IDM_LINE,              TB, IDS_HINT_LINE,          IDS_HINT_LINE},
{IDM_BOX,               TB, IDS_HINT_BOX,           IDS_HINT_BOX},
{IDM_FILLED_BOX,        TB, IDS_HINT_FBOX,          IDS_HINT_FBOX},
{IDM_ELLIPSE,           TB, IDS_HINT_ELLIPSE,       IDS_HINT_ELLIPSE},
{IDM_FILLED_ELLIPSE,    TB, IDS_HINT_FELLIPSE,      IDS_HINT_FELLIPSE},
{IDM_ZOOM,              TB, IDS_HINT_ZOOM_UP,       IDS_HINT_ZOOM_DOWN},
{IDM_REMOTE,            TB, IDS_HINT_REMOTE_UP,     IDS_HINT_REMOTE_DOWN},
{IDM_LOCK,              TB, IDS_HINT_LOCK_UP,       IDS_HINT_LOCK_DOWN},
{IDM_SYNC,              TB, IDS_HINT_SYNC_UP,       IDS_HINT_SYNC_DOWN},
{IDM_GRAB_AREA,         TB, IDS_HINT_GRAB_AREA,     IDS_HINT_GRAB_AREA},
{IDM_GRAB_WINDOW,       TB, IDS_HINT_GRAB_WINDOW,   IDS_HINT_GRAB_WINDOW},

{IDM_WIDTH_1,           NA, IDS_HINT_WIDTH_1,       IDS_HINT_WIDTH_1},
{IDM_WIDTH_2,           NA, IDS_HINT_WIDTH_2,       IDS_HINT_WIDTH_2},
{IDM_WIDTH_3,           NA, IDS_HINT_WIDTH_3,       IDS_HINT_WIDTH_3},
{IDM_WIDTH_4,           NA, IDS_HINT_WIDTH_4,       IDS_HINT_WIDTH_4},

{IDM_PAGE_FIRST,        BT, IDS_HINT_PAGE_FIRST,    IDS_HINT_PAGE_FIRST},
{IDM_PAGE_PREV,         BT, IDS_HINT_PAGE_PREVIOUS, IDS_HINT_PAGE_PREVIOUS},
{IDM_PAGE_ANY,          NA, IDS_HINT_PAGE_ANY,      IDS_HINT_PAGE_ANY},
{IDM_PAGE_NEXT,         BT, IDS_HINT_PAGE_NEXT,     IDS_HINT_PAGE_NEXT},
{IDM_PAGE_LAST,         BT, IDS_HINT_PAGE_LAST,     IDS_HINT_PAGE_LAST},
{IDM_PAGE_INSERT_AFTER, BT, IDS_HINT_PAGE_INSERT,   IDS_HINT_PAGE_INSERT}
    };
////////////






//
//
// Function:    WbMainWindow constructor
//
// Purpose:     Create the main Whiteboard window. An exception is thrown
//              if an error occurs during construction.
//
//
WbMainWindow::WbMainWindow(void)
{
    OSVERSIONINFO   OsData;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::WbMainWindow");

    //
    // Initialize member vars first!
    //
    m_hwnd = NULL;
    ZeroMemory(m_ToolArray, sizeof(m_ToolArray));

    m_hwndToolTip = NULL;
    ZeroMemory(&m_tiLastHit, sizeof(m_tiLastHit));
    m_nLastHit = -1;

    m_bInitOk = FALSE;
    m_bDisplayingError = FALSE;

    g_pwbCore = NULL;

    m_dwDomain = 0;
    m_bTimerActive = FALSE;
    m_bSyncUpdateNeeded = FALSE;

    m_hPageClip     = WB_PAGE_HANDLE_NULL;
    m_hGraphicClip  = NULL;
    m_pDelayedGraphicClip = NULL;
    m_pDelayedDataClip = NULL;

    m_bToolBarOn    = FALSE;

    // Load the main accelerator table
    m_hAccelTable =
        ::LoadAccelerators(g_hInstance, MAKEINTRESOURCE(MAINACCELTABLE));

    m_hwndPageSortDlg = NULL;
    m_hwndQuerySaveDlg = NULL;
    m_hwndWaitForEventDlg = NULL;
    m_hwndWaitForLockDlg = NULL;
    m_hwndInitDlg = NULL;

    m_hwndSB = NULL;
    m_bStatusBarOn = TRUE;

    m_pCurrentTool = NULL;
    m_uiSavedLockType = WB_LOCK_TYPE_NONE;
	ZeroMemory(m_strFileName, sizeof(m_strFileName));

    m_hCurrentPage = WB_PAGE_HANDLE_NULL;

    // Load the alternative accelerator table for the pages edit
    // field and text editor
    m_hAccelPagesGroup =
        ::LoadAccelerators(g_hInstance, MAKEINTRESOURCE(PAGESGROUPACCELTABLE));
    m_hAccelTextEdit   =
        ::LoadAccelerators(g_hInstance, MAKEINTRESOURCE(TEXTEDITACCELTABLE));

    m_pLocalUser = NULL;
    m_pLockOwner = NULL;

    // Show that we are not yet in a call
    m_uiState = STARTING;
    m_uiSubState = SUBSTATE_IDLE;

    // We are not currently displaying a menu
    m_hContextMenuBar = NULL;
    m_hContextMenu = NULL;
    m_hGrobjContextMenuBar = NULL;
    m_hGrobjContextMenu = NULL;

    m_bPromptingJoinCall = FALSE;
    m_bInSaveDialog = FALSE;
    m_bJoinCallPending = FALSE;
    m_dwPendingDomain = 0;
    m_bPendingCallKeepContents = FALSE;
    m_dwJoinDomain = 0;
    m_bCallActive = FALSE;

    m_hInitMenu = NULL;
    m_numRemoteUsers = 0;
    m_bSelectAllInProgress = FALSE;
    m_bUnlockStateSettled = TRUE;
    m_bQuerySysShutdown = FALSE;

    // figure out if we're on Win95
    m_bIsWin95 = FALSE;
    OsData.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    if( GetVersionEx( &OsData ) )
    {
        if( OsData.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
            m_bIsWin95 = TRUE;
    }

    m_cancelModeSent = FALSE;

    //
    // We only do this once for the lifetime of the DLL.  There is no
    // way really to clean up registered window messages, and each register
    // bumps up a ref count.  If we registered each time WB was started up
    // during one session of CONF, we'd overflow the refcount.
    //
    if (!g_uConfShutdown)
    {
        g_uConfShutdown = ::RegisterWindowMessage( NM_ENDSESSION_MSG_NAME );
    }
}


//
// Open()
// Do Main window initialization (stuff that can fail).  After this,
// the run code will try to join the current domain and do message loop
// stuff.
//
BOOL WbMainWindow::Open(int iCommand)
{
    WNDCLASSEX  wc;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::Open");

    //
    // CREATE OTHER GLOBALS
    //

    // Start the Whiteboard Core
    if (!CreateWBObject(WbMainWindowEventHandler, &g_pwbCore))
    {
        ERROR_OUT(("WBP_Start failed"));
        DefaultExceptionHandler(WBFE_RC_WB, UT_RC_NO_MEM);
        return FALSE;
    }

    if (!InitToolArray())
    {
        ERROR_OUT(("Can't create tools; failing to start up"));
        return(FALSE);
    }

    g_pUsers = new WbUserList;
    if (!g_pUsers)
    {
        ERROR_OUT(("Can't create g_pUsers"));
        return(FALSE);
    }

    g_pIcons = new DCWbColorToIconMap();
    if (!g_pIcons)
    {
        ERROR_OUT(("Can't create g_pIcons"));
        return(FALSE);
    }

    //
    // Init comon controls
    //
    InitCommonControls();

    //
    // CREATE THE MAIN FRAME WINDOW
    //
    ASSERT(!m_hwnd);

    // Get the class info for it, and change the name.
    ZeroMemory(&wc, sizeof(wc));
    wc.cbSize = sizeof(wc);
    wc.style            = CS_DBLCLKS; // CS_HREDRAW | CS_VREDRAW?
    wc.lpfnWndProc      = WbMainWindowProc;
    wc.hInstance        = g_hInstance;
    wc.hIcon            = ::LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_APP));
    wc.hCursor          = ::LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));
    wc.hbrBackground    = (HBRUSH)(COLOR_BTNFACE + 1);
    wc.lpszMenuName     = MAKEINTRESOURCE(MAINMENU);
    wc.lpszClassName    = szMainClassName;

    if (!::RegisterClassEx(&wc))
    {
        ERROR_OUT(("Can't register private frame window class"));
        return(FALSE);
    }

    // Create the main drawing window.
    if (!::CreateWindowEx(WS_EX_APPWINDOW | WS_EX_WINDOWEDGE, szMainClassName,
        NULL, WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
        CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, g_hInstance, this))
    {
        // Could not create the main window
        ERROR_OUT(("Failed to create main window"));
        return(FALSE);
    }

    ASSERT(m_hwnd);

    // Create the pop-up context menu
    if (!CreateContextMenus())
    {
        ERROR_OUT(("Failed to create context menus"));
        return(FALSE);
    }

    // Register the the main window for Drag/Drop messages.
    DragAcceptFiles(m_hwnd, TRUE);


    //
    // CREATE THE CHILD WINDOWS
    //

    // Create the drawing pane
    // (the Create call throws an exception on error)
    RECT    clientRect;
    RECT    drawingAreaRect;

    ::GetClientRect(m_hwnd, &clientRect);
    drawingAreaRect = clientRect;

    // Every control in the main window has a border on it, so increase the
    // client size by 1 to force these borders to be drawn under the inside
    // black line in the window frame.  This prevents a 2 pel wide border
    // being drawn
    ::InflateRect(&clientRect, 1, 1);

    SIZE sizeAG;
    m_AG.GetNaturalSize(&sizeAG);

    //
    // The drawing area is the top part of the client.  The attributes group
    // and status bar are below it.
    //
    drawingAreaRect.bottom -= (STATUSBAR_HEIGHT
                          + GetSystemMetrics(SM_CYBORDER)
                          + sizeAG.cy);
    if (!m_drawingArea.Create(m_hwnd, &drawingAreaRect))
    {
        ERROR_OUT(("Failed to create drawing area"));
        return(FALSE);
    }


    if (!m_TB.Create(m_hwnd))
    {
        ERROR_OUT(("Failed to create tool window"));
        return(FALSE);
    }


    // Lock the drawing area initially. This prevents the user attempting
    // to make changes before we are in a call.
    LockDrawingArea();

    // disable remote pointer while we are initing (bug 4767)
    m_TB.Disable(IDM_REMOTE);


    m_hwndSB = ::CreateWindowEx(0, STATUSCLASSNAME, NULL,
        WS_CHILD | WS_VISIBLE | CCS_NOPARENTALIGN | CCS_NOMOVEY |
        CCS_NORESIZE | SBARS_SIZEGRIP,
        clientRect.left, clientRect.bottom - STATUSBAR_HEIGHT,
        (clientRect.right - clientRect.left), STATUSBAR_HEIGHT,
        m_hwnd, 0, g_hInstance, NULL);
    if (!m_hwndSB)
    {
        ERROR_OUT(("Failed to create status bar window"));
        return(FALSE);
    }

    //
    // Create the attributes group
    // The attributes group is on the bottom, underneath the
    // drawing area, above the status bar.
    //
    RECT    rectAG;

    rectAG.left = clientRect.left;
    rectAG.right = clientRect.right;
    rectAG.top = drawingAreaRect.bottom;
    rectAG.bottom = rectAG.top + sizeAG.cy;

    if (!m_AG.Create(m_hwnd, &rectAG))
    {
        ERROR_OUT(("Failed to create attributes group window"));
        return(FALSE);
    }

    //
    // Create the widths group.
    // The widths group is on the left side, underneath the tools group
    //
    SIZE    sizeWG;
    RECT    rectWG;


    // The widths group is on the left side, underneath the toolbar
    m_WG.GetNaturalSize(&sizeWG);
    rectWG.left = 0;
    rectWG.right = rectWG.left + sizeWG.cx;
    rectWG.bottom = rectAG.top;
    rectWG.top  = rectWG.bottom - sizeWG.cy;

    if (!m_WG.Create(m_hwnd, &rectWG))
    {
        ERROR_OUT(("Failed to create widths group window"));
        return(FALSE);
    }

    // The main window is created with the status bar visible. So make sure
    // that the relevant menu item is checked. This is subject to change
    // depending on options in the Open member function.
    CheckMenuItem(IDM_STATUS_BAR_TOGGLE);

    // Initialize the color, width and tool menus
    InitializeMenus();

    m_currentMenuTool       = IDM_SELECT;
    m_pCurrentTool          = m_ToolArray[TOOL_INDEX(IDM_SELECT)];


    m_hwndToolTip = ::CreateWindowEx(NULL, TOOLTIPS_CLASS, NULL,
        WS_POPUP | TTS_ALWAYSTIP, CW_USEDEFAULT, CW_USEDEFAULT,
        CW_USEDEFAULT, CW_USEDEFAULT, m_hwnd, NULL, g_hInstance, NULL);
    if (!m_hwndToolTip)
    {
        ERROR_OUT(("Unable to create tooltip window"));
        return(FALSE);
    }

    // Add a dead-area tooltip
    TOOLINFO ti;

    ZeroMemory(&ti, sizeof(ti));
    ti.cbSize = sizeof(TOOLINFO);
    ti.uFlags = TTF_IDISHWND;
    ti.hwnd = m_hwnd;
    ti.uId = (UINT_PTR)m_hwnd;
    ::SendMessage(m_hwndToolTip, TTM_ADDTOOL, 0, (LPARAM)&ti);

    // Ensure the page buttons are disabled while starting
    UpdatePageButtons();

    // If this is the first time we have created a clipboard object,
    // register the private Whiteboard formats.
    if (g_ClipboardFormats[CLIPBOARD_PRIVATE_SINGLE_OBJ] == 0)
    {
        g_ClipboardFormats[CLIPBOARD_PRIVATE_SINGLE_OBJ] =
            (int) ::RegisterClipboardFormat("DCGWbClipFormat");
    }

    if (g_ClipboardFormats[CLIPBOARD_PRIVATE_MULTI_OBJ] == 0)
    {
        g_ClipboardFormats[CLIPBOARD_PRIVATE_MULTI_OBJ] =
            (int) ::RegisterClipboardFormat("DCGWbMultiObjClipFormat");
    }

    // There is no deleted graphic yet
    m_LastDeletedGraphic.BurnTrash();

    m_bInitOk = TRUE;

    BOOL bSuccess = TRUE;    // indicates whether window opened successfully

    // Get the position of the window from options
    RECT    rectWindow;
    RECT    rectDefault;

    ::SetRectEmpty(&rectDefault);

    OPT_GetWindowRectOption(OPT_MAIN_MAINWINDOWRECT, &rectWindow, &rectDefault);

    if (!::IsRectEmpty(&rectWindow))
    {
        ::MoveWindow(m_hwnd, rectWindow.left, rectWindow.top,
            rectWindow.right - rectWindow.left,
            rectWindow.bottom - rectWindow.top, FALSE );
    }


    // Check whether the help bar is to be visible
    if (!OPT_GetBooleanOption(OPT_MAIN_STATUSBARVISIBLE, DFLT_MAIN_STATUSBARVISIBLE))
    {
        // Update the window to turn the help bar off
        OnStatusBarToggle();
    }

    //
    // Position the toolbar
    //

    // Hide the tool bar before moving it (otherwise we get some
    // problems redrawing it).
    ::ShowWindow(m_TB.m_hwnd, SW_HIDE);

    // Resize the window panes to allow room for the tools
    if (m_bToolBarOn)
    {
        ResizePanes();
        ::ShowWindow(m_TB.m_hwnd, SW_SHOW);
    }

    // Move the focus back from the tool window to the main window
    ::SetFocus(m_hwnd);

    // Check whether the tool window is to be visible
    if (OPT_GetBooleanOption(OPT_MAIN_TOOLBARVISIBLE, DFLT_MAIN_TOOLBARVISIBLE))
    {
        // Display the tool window, and check the associated menu item
        OnToolBarToggle();
    }

    // Set up the variable saving the maximized/minimized state of
    // the window and the extra style necessary for displaying the
    // window correctly initially.
    if (OPT_GetBooleanOption(OPT_MAIN_MAXIMIZED, DFLT_MAIN_MAXIMIZED))
    {
        m_uiWindowSize = SIZEFULLSCREEN;
        iCommand = SW_SHOWMAXIMIZED;
    }
    else if (OPT_GetBooleanOption(OPT_MAIN_MINIMIZED, DFLT_MAIN_MINIMIZED))
    {
        m_uiWindowSize = SIZEICONIC;
        iCommand = SW_SHOWMINIMIZED;
    }
    else
    {
        // Default
        m_uiWindowSize = SIZENORMAL;
        iCommand = SW_SHOWNORMAL;
    }

    UpdateWindowTitle();
    ::ShowWindow(m_hwnd, iCommand);
    ::UpdateWindow(m_hwnd);

    // Update the tool window
    ::UpdateWindow(m_TB.m_hwnd);

    // Select the tool
    m_currentMenuTool           = IDM_SELECT;
    m_pCurrentTool              = m_ToolArray[TOOL_INDEX(IDM_SELECT)];
    ::PostMessage(m_hwnd, WM_COMMAND, m_currentMenuTool, 0L);

    // Return value indicating success or failure
    return(bSuccess);
}


//
//
// Function:    WbMainWindow destructor
//
// Purpose:     Tidy up main window on destruction.
//
//
WbMainWindow::~WbMainWindow()
{
    //
    // Destroy the tooltip window
    //
    if (m_hwndToolTip)
    {
        ::DestroyWindow(m_hwndToolTip);
        m_hwndToolTip = NULL;
    }

    // Make sure the clipboard discards its saved graphic
    // before the drawingArea gets deleted.
    CLP_FreeDelayedGraphic();

    if (m_hGrobjContextMenuBar != NULL)
    {
        ::DestroyMenu(m_hGrobjContextMenuBar);
        m_hGrobjContextMenuBar = NULL;
    }
    m_hGrobjContextMenu = NULL;

    if (m_hContextMenuBar != NULL)
    {
        ::DestroyMenu(m_hContextMenuBar);
        m_hContextMenuBar = NULL;
    }
    m_hContextMenu = NULL;

	POSITION position = m_pageToPosition.GetHeadPosition();

	PAGE_POSITION * pPoint;

	while (position)
	{
		pPoint = (PAGE_POSITION*)m_pageToPosition.GetNext(position);
		delete pPoint;
	}

	m_pageToPosition.EmptyList();

    if (g_pwbCore)
    {
        //
        //We must call an explicit stop function, rather than 'delete'
        // because we need to pass in the event proc
        //
        g_pwbCore->WBP_Stop(WbMainWindowEventHandler);
        g_pwbCore = NULL;
    }

    DestroyToolArray();

    // Destroy our window
    if (m_hwnd != NULL)
    {
        ::DestroyWindow(m_hwnd);
        m_hwnd = NULL;
    }

    // Deregister our class
    ::UnregisterClass(szMainClassName, g_hInstance);

    //
    // Free the palette
    //
    if (g_hRainbowPaletteDisplay)
    {
        DeletePalette(g_hRainbowPaletteDisplay);
        g_hRainbowPaletteDisplay = NULL;
    }

    g_bPalettesInitialized = FALSE;
    g_bUsePalettes = FALSE;


    if (g_pIcons)
    {
        delete g_pIcons;
        g_pIcons = NULL;
    }

    if (g_pUsers)
    {
        delete g_pUsers;
        g_pUsers = NULL;
    }
}



//
// JoinDomain()
// Attach to the empty domain or current call
//
BOOL WbMainWindow::JoinDomain(void)
{
    BOOL bSuccess;

    CM_STATUS cmStatus;

    // If there is a call available - join it.
    if (CMS_GetStatus(&cmStatus))
    {
        m_bCallActive = TRUE;

        // Get the domain ID of the call
        m_dwJoinDomain = (DWORD) cmStatus.callID;

        // Join the call
        bSuccess = JoinCall(FALSE);
    }
    else
    {
        // No call available so join the local domain

        // Set the domain ID to "no call"
        m_dwJoinDomain = (DWORD) OM_NO_CALL;

        // Join the call
        bSuccess = JoinCall(FALSE);
    }

    // Wait for the call to be joined, if not abandoned
    if (bSuccess)
    {
        bSuccess = WaitForJoinCallComplete();
    }

    // take down init dlg
    KillInitDlg();

    return(bSuccess);
}




//
// KillInitDlg()
// Take down the init dialog
//
void WbMainWindow::KillInitDlg(void)
{
    if (m_hwndInitDlg != NULL )
    {
        ::DestroyWindow(m_hwndInitDlg);
        m_hwndInitDlg = NULL;

        ::EnableWindow(m_hwnd, TRUE);
    }

}



//
// OnToolHitTest()
// This handles tooltips for child windows.
//
int WbMainWindow::OnToolHitTest(POINT pt, TOOLINFO* pTI) const
{
    HWND    hwnd;
    int     status;
    int     nHit = -1;

    ASSERT(!IsBadWritePtr(pTI, sizeof(TOOLINFO)));

    hwnd = ::ChildWindowFromPointEx(m_hwnd, pt, CWP_SKIPINVISIBLE);
    if (hwnd == m_AG.m_hwnd)
    {
        ::MapWindowPoints(m_hwnd, m_AG.m_hwnd, &pt, 1);
        hwnd = ::ChildWindowFromPointEx(m_AG.m_hwnd, pt, CWP_SKIPINVISIBLE);

        if (hwnd != NULL)
        {
            nHit = ::GetDlgCtrlID(hwnd);

            pTI->hwnd = m_hwnd;
            pTI->uId = (UINT_PTR)hwnd;
            pTI->uFlags |= TTF_IDISHWND;
            pTI->lpszText = LPSTR_TEXTCALLBACK;

            return(nHit);
        }
    }
    else if (hwnd == m_WG.m_hwnd)
    {
        int iItem;

        ::MapWindowPoints(m_hwnd, m_WG.m_hwnd, &pt, 1);

        iItem = m_WG.ItemFromPoint(pt.x, pt.y);

        pTI->hwnd = m_WG.m_hwnd;
        pTI->uId  = iItem;

        // Since the area isn't a window, we must fill in the rect ourself
        m_WG.GetItemRect(iItem, &pTI->rect);
        pTI->lpszText = LPSTR_TEXTCALLBACK;

        return(iItem);
    }
    else if (hwnd == m_TB.m_hwnd)
    {
        RECT        rect;
        TBBUTTON    button;
        int         i;

        for (i = 0; i < TOOLBAR_MAXBUTTON; i++)
        {
            if (::SendMessage(m_TB.m_hwnd, TB_GETITEMRECT, i, (LPARAM)&rect) &&
                ::PtInRect(&rect, pt) &&
                ::SendMessage(m_TB.m_hwnd, TB_GETBUTTON, i, (LPARAM)&button) &&
                !(button.fsStyle & TBSTYLE_SEP))
            {
                nHit = button.idCommand;

                pTI->hwnd = m_TB.m_hwnd;
                pTI->uId = nHit;
                pTI->rect = rect;
                pTI->lpszText = LPSTR_TEXTCALLBACK;

                // found matching rect, return the ID of the button
                return(nHit);
            }
        }
    }

    return(-1);
}


//
// WbMainWindowProc()
// Frame window message handler
//
LRESULT WbMainWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    LRESULT lResult = 0;
    WbMainWindow * pMain;

    pMain = (WbMainWindow *)::GetWindowLongPtr(hwnd, GWLP_USERDATA);

    switch (message)
    {
        case WM_NCCREATE:
            pMain = (WbMainWindow *)((LPCREATESTRUCT)lParam)->lpCreateParams;
            ASSERT(pMain);

            pMain->m_hwnd = hwnd;
            ::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pMain);
            goto DefWndProc;
            break;

        case WM_DESTROY:
            ShutDownHelp();
            break;

        case WM_NCDESTROY:
            pMain->m_hwnd = NULL;
            break;

        case WM_MOVE:
            pMain->OnMove();
            break;

        case WM_SIZE:
            pMain->OnSize((UINT)wParam, LOWORD(lParam), HIWORD(lParam));
            break;

        case WM_ACTIVATE:
            if (GET_WM_ACTIVATE_STATE(wParam, lParam) == WA_INACTIVE)
            {
                // Cancel the tooltip if it's around
                if (pMain->m_hwndToolTip)
                    ::SendMessage(pMain->m_hwndToolTip, TTM_ACTIVATE, FALSE, 0);
            }
            goto DefWndProc;
            break;

        case WM_SETFOCUS:
            pMain->OnSetFocus();
            break;

        case WM_CANCELMODE:
            pMain->OnCancelMode();
            break;

        case WM_TIMER:
            pMain->OnTimer(wParam);
            break;

        case WM_INITMENUPOPUP:
            pMain->OnInitMenuPopup((HMENU)wParam, LOWORD(lParam), HIWORD(lParam));
            break;

        case WM_MENUSELECT:
            pMain->OnMenuSelect(GET_WM_MENUSELECT_CMD(wParam, lParam),
                GET_WM_MENUSELECT_FLAGS(wParam, lParam),
                GET_WM_MENUSELECT_HMENU(wParam, lParam));
            break;

        case WM_MEASUREITEM:
            pMain->OnMeasureItem((int)wParam, (LPMEASUREITEMSTRUCT)lParam);
            break;

        case WM_DRAWITEM:
            pMain->OnDrawItem((int)wParam, (LPDRAWITEMSTRUCT)lParam);
            break;

        case WM_QUERYNEWPALETTE:
            lResult = pMain->OnQueryNewPalette();
            break;

        case WM_PALETTECHANGED:
            pMain->OnPaletteChanged((HWND)wParam);
            break;

        case WM_HELP:
            pMain->OnCommand(IDM_HELP, 0, NULL);
            break;

        case WM_CLOSE:
            pMain->OnClose();
            break;

        case WM_QUERYENDSESSION:
            lResult = pMain->OnQueryEndSession();
            break;

        case WM_ENDSESSION:
            pMain->OnEndSession((BOOL)wParam);
            break;

        case WM_SYSCOLORCHANGE:
            pMain->OnSysColorChange();
            break;

        case WM_USER_PRIVATE_PARENTNOTIFY:
            pMain->OnParentNotify(GET_WM_PARENTNOTIFY_MSG(wParam, lParam));
            break;

        case WM_GETMINMAXINFO:
            if (pMain)
                pMain->OnGetMinMaxInfo((LPMINMAXINFO)lParam);
            break;

        case WM_RENDERALLFORMATS:
            pMain->OnRenderAllFormats();
            break;

        case WM_RENDERFORMAT:
            pMain->CLP_RenderFormat((int)wParam);
            break;

        case WM_COMMAND:
            pMain->OnCommand(LOWORD(wParam), HIWORD(wParam), (HWND)lParam);
            break;

        case WM_NOTIFY:
            pMain->OnNotify((UINT)wParam, (NMHDR *)lParam);
            break;

        case WM_DROPFILES:
            pMain->OnDropFiles((HDROP)wParam);
            break;

        case WM_USER_GOTO_USER_POSITION:
            pMain->OnGotoUserPosition(lParam);
            break;

        case WM_USER_GOTO_USER_POINTER:
            pMain->OnGotoUserPointer(lParam);
            break;

        case WM_USER_JOIN_CALL:
            pMain->OnJoinCall((BOOL)wParam, lParam);
            break;

        case WM_USER_DISPLAY_ERROR:
            pMain->OnDisplayError(wParam, lParam);
            break;

        case WM_USER_UPDATE_ATTRIBUTES:
            pMain->m_AG.DisplayTool(pMain->m_pCurrentTool);
            break;

        case WM_USER_JOIN_PENDING_CALL:
            pMain->OnJoinPendingCall();
            break;

        default:
            if (message == g_uConfShutdown)
            {
                lResult = pMain->OnConfShutdown(wParam, lParam);
            }
            else
            {
DefWndProc:
                lResult = DefWindowProc(hwnd, message, wParam, lParam);
            }
            break;
    }

    return(lResult);
}


//
// OnCommand()
// Command dispatcher for the main window
//
void WbMainWindow::OnCommand(UINT cmd, UINT code, HWND hwndCtl)
{
    switch (cmd)
    {
        //
        // FILE MENU
        //
        case IDM_NEW:
            OnNew();
            break;

        case IDM_OPEN:
            OnOpen();
            break;

        case IDM_SAVE:
            OnSave(FALSE);
            break;

        case IDM_SAVE_AS:
            OnSave(TRUE);
            break;

        case IDM_PRINT:
            OnPrint();
            break;

        case IDM_EXIT:
            ::PostMessage(m_hwnd, WM_CLOSE, 0, 0);
            break;

        //
        // EDIT MENU
        //
        case IDM_DELETE:
            OnDelete();
            break;

        case IDM_UNDELETE:
            OnUndelete();
            break;

        case IDM_CUT:
            OnCut();
            break;

        case IDM_COPY:
            OnCopy();
            break;

        case IDM_PASTE:
            OnPaste();
            break;

        case IDM_SELECTALL:
            OnSelectAll();
            break;

        case IDM_BRING_TO_TOP:
            m_drawingArea.BringToTopSelection();
            break;

        case IDM_SEND_TO_BACK:
            m_drawingArea.SendToBackSelection();
            break;

        case IDM_CLEAR_PAGE:
            OnClearPage();
            break;

        case IDM_DELETE_PAGE:
            OnDeletePage();
            break;

        case IDM_PAGE_INSERT_BEFORE:
            OnInsertPageBefore();
            break;

        case IDM_PAGE_INSERT_AFTER:
            OnInsertPageAfter();
            break;

        case IDM_PAGE_SORTER:
            OnPageSorter();
            break;

        //
        // VIEW MENU
        //
        case IDM_TOOL_BAR_TOGGLE:
            OnToolBarToggle();
            break;

        case IDM_STATUS_BAR_TOGGLE:
            OnStatusBarToggle();
            break;

        case IDM_ZOOM:
            OnZoom();
            break;

        //
        // TOOLS MENU
        //
        case IDM_SELECT:
        case IDM_PEN:
        case IDM_HIGHLIGHT:
        case IDM_TEXT:
        case IDM_ERASER:
        case IDM_LINE:
        case IDM_BOX:
        case IDM_FILLED_BOX:
        case IDM_ELLIPSE:
        case IDM_FILLED_ELLIPSE:
            OnSelectTool(cmd);
            break;

        case IDM_REMOTE:
            OnRemotePointer();
            break;

        case IDM_GRAB_AREA:
            OnGrabArea();
            break;

        case IDM_GRAB_WINDOW:
            OnGrabWindow();
            break;

        case IDM_SYNC:
            OnSync();
            break;

        case IDM_LOCK:
            OnLock();
            break;

        //
        // OPTIONS MENU
        //
        case IDM_COLOR:
            OnSelectColor();
            break;

        case IDM_EDITCOLOR:
            m_AG.OnEditColors();
            break;

        case IDM_FONT:
            OnChooseFont();
            break;

        case IDM_WIDTH_1:
        case IDM_WIDTH_2:
        case IDM_WIDTH_3:
        case IDM_WIDTH_4:
            OnSelectWidth(cmd);
            break;

        //
        // HELP MENU
        //
        case IDM_ABOUT:
            OnAbout();
            break;

        case IDM_HELP:
            ShowHelp();
            break;

        //
        // PAGE BAR
        //
        case IDM_PAGE_FIRST:
            OnFirstPage();
            break;

        case IDM_PAGE_PREV:
            OnPrevPage();
            break;

        case IDM_PAGE_GOTO:
            OnGotoPage();
            break;

        case IDM_PAGE_NEXT:
            OnNextPage();
            break;

        case IDM_PAGE_LAST:
            OnLastPage();
            break;

        //
        // SCROLLING
        //
        case IDM_PAGEUP:
        case IDM_PAGEDOWN:
        case IDM_SHIFTPAGEUP:
        case IDM_SHIFTPAGEDOWN:
        case IDM_HOME:
        case IDM_END:
        case IDM_LINEUP:
        case IDM_LINEDOWN:
        case IDM_SHIFTLINEUP:
        case IDM_SHIFTLINEDOWN:
            OnScrollAccelerator(cmd);
            break;
    }
}


//
// WinHelp() wrapper
//
void WbMainWindow::ShowHelp(void)
{
    HWND hwndCapture;

    // Get the main window out of any mode
    ::SendMessage(m_hwnd, WM_CANCELMODE, 0, 0);

    // Cancel any other tracking
    if (hwndCapture = ::GetCapture())
        ::SendMessage(hwndCapture, WM_CANCELMODE, 0, 0);

	// finally, run the Windows Help engine
    ShowNmHelp(s_cszHtmlHelpFile);
}

//
//
// Function:    OnJoinCall
//
// Purpose:     Join a call - displaying a dialog informing the user of
//              progress.
//
//
void WbMainWindow::OnJoinCall(BOOL bKeep, LPARAM lParam)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnJoinCall");

    // cancel the load if there's one in progress
    if (   (m_uiState == IN_CALL)
        && (m_uiSubState == SUBSTATE_LOADING))
    {
        CancelLoad();
    }

    // Get the parameters for JoinCall
    m_dwJoinDomain = (DWORD) lParam;

    // Start the process of joining the call
    BOOL bSuccess = JoinCall(bKeep);

    // Wait for the join call to complete, if not abandoned
    if (bSuccess)
    {
        bSuccess = WaitForJoinCallComplete();

        if (bSuccess)
        {
            TRACE_MSG(("Joined call OK"));
        }
        else
        {
            // WaitForJoinCallComplete displays appropriate error message
            TRACE_MSG(("Failed to join call"));

            // get into a good state
            Recover();
        }
    }

    // take down init dlg
    KillInitDlg();
}

//
//
// Function:    JoinCall
//
// Purpose:     Join a call - displaying a dialog informing the user of
//              progress.
//
//
BOOL WbMainWindow::JoinCall(BOOL bKeep)
{
    BOOL    bSuccess = TRUE;
    UINT    uiReturn;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::JoinCall");

    // We must not already be in a real call when we get here
    if ((m_uiState == IN_CALL) && (m_dwDomain != OM_NO_CALL))
    {
        ERROR_OUT(("In a call already"));
    }

    //
    // Prompt the user to save the current contents unless we are in
    // application start-up (when there can be no contents to save) or we
    // are keeping the contents (when there is no need to save).
    //
    if ((m_uiState != STARTING) && !bKeep)
    {
        //
        // Close the page sorter dialog if it's up.
        //
        if (m_hwndPageSortDlg != NULL)
        {
            ::SendMessage(m_hwndPageSortDlg, WM_COMMAND,
                MAKELONG(IDOK, BN_CLICKED), 0);
            ASSERT(m_hwndPageSortDlg == NULL);
        }

        TRACE_MSG(("Not in STARTING state - check whether save wanted"));

        if (m_hwndQuerySaveDlg != NULL)
        {
            ::SendMessage(m_hwndQuerySaveDlg, WM_COMMAND,
                MAKELONG(IDCANCEL, BN_CLICKED), 0);
            ASSERT(m_hwndQuerySaveDlg == NULL);
        }

        // flag that we are joining a call
        m_bPromptingJoinCall = TRUE;

        // ask the user whether to save changes (if required)
        int iDoNew = QuerySaveRequired(FALSE);

        // remove any save as dialog that is already up.
        if (m_bInSaveDialog)
        {
            m_bPromptingJoinCall = FALSE;
            CancelSaveDialog();
            m_bPromptingJoinCall = TRUE;
        }

        if (iDoNew == IDYES)
        {
            TRACE_MSG(("User has elected to save the changes"));

            // Save the changes
            iDoNew = OnSave(FALSE);
        }

        if (!m_bPromptingJoinCall)      // received end call notification
                                        // (during save-as or query-save)
        {
            TRACE_MSG(("Call ended - abandon JoinCall"));
            return(FALSE);
        }

        // flag we're no longer in a state where the join call can be
        // cancelled
        m_bPromptingJoinCall = FALSE;

        //
        // Reset the file name to Untitled, since we are receiving new
        // contents
        //
        ZeroMemory(m_strFileName, sizeof(m_strFileName));
		UpdateWindowTitle();
		
        // if we have the lock then release it
        if (WB_GotLock())
        {
             // Release the lock
             g_pwbCore->WBP_Unlock();

             // Set the locked check mark
             UncheckMenuItem(IDM_LOCK);

             // Pop up the lock button
             m_TB.PopUp(IDM_LOCK);
        }

        if(m_pLocalUser != NULL)
        {
            // if the remote pointer is active then turn it off
            DCWbGraphicPointer* pPointer = m_pLocalUser->GetPointer();
            if (pPointer->IsActive())
            {
                OnRemotePointer();
            }
        }

        // if sync is turned on then turn it off
        Unsync();

        // If we are not keeping the contents then the only valid current
        // page is the first page.
        g_pwbCore->WBP_PageHandle(WB_PAGE_HANDLE_NULL, PAGE_FIRST, &m_hCurrentPage);
    }

    //PUTBACK BY RAND - the progress timer meter is kinda the heart beat
    //                    of this thing which I ripped out when I removed the
    //                    progress meter. I put it back to fix 1476.
    if (m_bTimerActive)
    {
        ::KillTimer(m_hwnd, TIMERID_PROGRESS_METER);
        m_bTimerActive = FALSE;
    }

    //
    // lock the drawing area until the joining of the call has succeeded
    //
    TRACE_MSG(("Locking drawing area"));
    LockDrawingArea();

    //
    // Give the drawing area a null page during the joining process.  This
    // prevents the drawing area attempting to draw the objects in the page
    // during the process of joining the call.
    //
    TRACE_MSG(("Detaching drawing area"));
    m_drawingArea.Detach();

    // Show that we are no longer in a call, but joining a new one
    TRACE_MSG(("m_uiState %d", m_uiState));
    if (m_uiState != STARTING)
    {
        m_uiState = JOINING;
        UpdatePageButtons();
    }

    // put up init dlg
    if (m_bCallActive)
    {
        ::UpdateWindow(m_hwnd);

        //
        // Our init dialog doesn't have a proc, since it has no UI to
        // interact with.  We destroy it when we are done.  So, do the
        // init stuff here.
        //
        m_hwndInitDlg = ::CreateDialogParam(g_hInstance,
            MAKEINTRESOURCE(IM_INITIALIZING), m_hwnd, NULL, 0);

        if (!m_hwndInitDlg)
        {
            ERROR_OUT(("Couldn't create startup screen for WB"));
        }
        else
        {
            RECT    rcMovie;
            HWND    hwndMovieParent;
            HWND    hwndMovie;

            // Get the rectangle to create the animation control in
            hwndMovieParent = ::GetDlgItem(m_hwndInitDlg, IDC_INITIALIZING_ANIMATION);
            ::GetClientRect(hwndMovieParent, &rcMovie);

            hwndMovie = ::CreateWindowEx(0, ANIMATE_CLASS, NULL,
                WS_CHILD | WS_VISIBLE | ACS_TRANSPARENT | ACS_CENTER,
                rcMovie.left, rcMovie.top,
                rcMovie.right - rcMovie.left, rcMovie.bottom - rcMovie.top,
                hwndMovieParent, (HMENU)IDC_INITIALIZING_ANIMATION,
                g_hInstance, NULL);

            if (hwndMovie != NULL)
            {
                ::SendMessage(hwndMovie, ACM_OPEN, 0, (LPARAM)
                    MAKEINTRESOURCE(WBMOVIE));
            }

            // Disable the main window while the dialog is up.
            ::EnableWindow(m_hwnd, FALSE);

            ::ShowWindow(m_hwndInitDlg, SW_SHOW);
            ::UpdateWindow(m_hwndInitDlg);

            if (hwndMovie != NULL)
            {
                ::SendMessage(hwndMovie, ACM_PLAY, 0xFFFF,
                    MAKELPARAM(0, 0xFFFF));
            }
        }
    }

    //
    // Start joining the call.  Throws an exception on error.
    //
    ASSERT(g_pUsers);
    g_pUsers->Clear();

    uiReturn = g_pwbCore->WBP_JoinCall(bKeep, m_dwJoinDomain);
    if (uiReturn != 0)
    {
        bSuccess = FALSE;
    }

    return(bSuccess);
}




//
//
// Function:    WaitForJoinCallComplete
//
// Purpose:     Join a call - displaying a dialog informing the user of
//              progress.
//
//
BOOL WbMainWindow::WaitForJoinCallComplete(void)
{
    BOOL    bResult = FALSE;
    TMDLG   tmdlg;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::WaitForJoinCallComplete");

    //
    // Bring up a dialog to wait for call joining to complete.  This turns
    // the asynchronous registration process into a synchronous process as
    // far as this routine is concerned.
    //

    //
    // Set the window title to show we're no longer registering/joining a
    // call.
    //
	UpdateWindowTitle();

    ASSERT(m_hwndWaitForEventDlg == NULL);

    //
    // This is the data we use in the timed dialog
    //
    ZeroMemory(&tmdlg, sizeof(tmdlg));
    tmdlg.bVisible = FALSE;
    tmdlg.bLockNotEvent = FALSE;
    tmdlg.uiMaxDisplay = MAIN_REGISTRATION_TIMEOUT;

    ::DialogBoxParam(g_hInstance, MAKEINTRESOURCE(INVISIBLEDIALOG),
        m_hwnd, TimedDlgProc, (LPARAM)&tmdlg);

    ASSERT(m_hwndWaitForEventDlg == NULL);

    //
    // Set the window title to show we're no longer registering/joining a
    // call.
    //
	UpdateWindowTitle();
	
    if (m_uiState != IN_CALL)
    {
        //
        // We failed to join the call
        //
        WARNING_OUT(("User cancelled or joincall failed, m_uiState %d", m_uiState));

        //
        // We must display an error inline here because we will close
        // shortly
        //
        OnDisplayError(WBFE_RC_JOIN_CALL_FAILED, 0);
    }
    else
    {
        bResult = TRUE;
    }

    return(bResult);
}


//
// TimedDlgProc()
// This puts up a visible or invisible dialog which only goes away when
// an event occurs or a certain amount of time has passed.  We store the
// DialogBoxParam parameter, a TMDLG pointer, in our user data.  That is
// from the stack of the DialogBoxParam() caller, so it is valid until that
// function returns, which won't be until a bit after the dialog has been
// destroyed.
//
INT_PTR CALLBACK TimedDlgProc(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    BOOL        fHandled = FALSE;
    TMDLG *     ptm;

    switch (uMessage)
    {
        case WM_INITDIALOG:
            ptm = (TMDLG *)lParam;
            ASSERT(!IsBadWritePtr(ptm, sizeof(TMDLG)));
            ::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)ptm);

            //
            // Set the WbMainWindow hwnd
            //
            if (ptm->bLockNotEvent)
            {
                g_pMain->m_hwndWaitForLockDlg = hwnd;
            }
            else
            {
                g_pMain->m_hwndWaitForEventDlg = hwnd;
            }

            //
            // Set max timer
            //
            ::SetTimer(hwnd, TIMERID_MAXDISPLAY, ptm->uiMaxDisplay, NULL);

            //
            // Change the cursor if invisible
            //
            if (!ptm->bVisible)
                ::SetCursor(::LoadCursor(NULL, IDC_WAIT));

            fHandled = TRUE;
            break;

        case WM_TIMER:
            ASSERT(wParam == TIMERID_MAXDISPLAY);

            // End the dialog--since we timed out, it acts like cancel
            ::SendMessage(hwnd, WM_COMMAND, MAKELONG(IDCANCEL, BN_CLICKED), 0);

            fHandled = TRUE;
            break;

        case WM_COMMAND:
            switch (GET_WM_COMMAND_ID(wParam, lParam))
            {
                case IDOK:
                case IDCANCEL:
                    if (GET_WM_COMMAND_CMD(wParam, lParam) == BN_CLICKED)
                    {
                        ptm = (TMDLG *)::GetWindowLongPtr(hwnd, GWLP_USERDATA);
                        ASSERT(!IsBadWritePtr(ptm, sizeof(TMDLG)));

                        // Clear out the HWND variable
                        if (ptm->bLockNotEvent)
                        {
                            g_pMain->m_hwndWaitForLockDlg = NULL;
                        }
                        else
                        {
                            g_pMain->m_hwndWaitForEventDlg = NULL;
                        }

                        // Restore the cursor
                        if (!ptm->bVisible)
                            ::SetCursor(::LoadCursor(NULL, IDC_ARROW));

                        ::KillTimer(hwnd, TIMERID_MAXDISPLAY);

                        ::EndDialog(hwnd, GET_WM_COMMAND_ID(wParam, lParam));
                    }
                    break;
            }

            fHandled = TRUE;
            break;

        //
        // Don't let these dialogs be killed by any other means than our
        // getting an event or timing out.
        //
        case WM_CLOSE:
            fHandled = TRUE;
            break;
    }

    return(fHandled);
}

//
// FilterMessage()
//
// This does tooltip message filtering, then translates accelerators.
//
BOOL WbMainWindow::FilterMessage(MSG* pMsg)
{
    BOOL   bResult = FALSE;

   	if ((pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYLAST) ||
    	(pMsg->message == WM_LBUTTONDOWN || pMsg->message == WM_LBUTTONDBLCLK) ||
	    (pMsg->message == WM_RBUTTONDOWN || pMsg->message == WM_RBUTTONDBLCLK) ||
	    (pMsg->message == WM_MBUTTONDOWN || pMsg->message == WM_MBUTTONDBLCLK) ||
	    (pMsg->message == WM_NCLBUTTONDOWN || pMsg->message == WM_NCLBUTTONDBLCLK) ||
	    (pMsg->message == WM_NCRBUTTONDOWN || pMsg->message == WM_NCRBUTTONDBLCLK) ||
	    (pMsg->message == WM_NCMBUTTONDOWN || pMsg->message == WM_NCMBUTTONDBLCLK))
   	{
        // Cancel any tooltip up
        ::SendMessage(m_hwndToolTip, TTM_ACTIVATE, FALSE, 0);
   	}

	// handle tooltip messages (some messages cancel, some may cause it to popup)
	if ((pMsg->message == WM_MOUSEMOVE || pMsg->message == WM_NCMOUSEMOVE ||
		 pMsg->message == WM_LBUTTONUP || pMsg->message == WM_RBUTTONUP ||
		 pMsg->message == WM_MBUTTONUP) &&
		(GetKeyState(VK_LBUTTON) >= 0 && GetKeyState(VK_RBUTTON) >= 0 &&
		 GetKeyState(VK_MBUTTON) >= 0))
	{
#if 0
        //
        // If this mouse move isn't for a descendant of the main window, skip
        // it.  For example, when the tooltip is shown, it gets a mousemove
        // to itself, which if we didn't check for it, would cause us to
        // immediately dismiss this!
        //
        HWND    hwndTmp = pMsg->hwnd;

        while (hwndTmp && (::GetWindowLong(hwndTmp, GWL_STYLE) & WS_CHILD))
        {
            hwndTmp = ::GetParent(hwndTmp);
        }

        if (hwndTmp != m_hwnd)
        {
            // This is not for us, it's for another top level window in
            // our app.
            goto DoneToolTipFiltering;
        }
#endif

		// determine which tool was hit
        POINT   pt;

        pt = pMsg->pt;
		::ScreenToClient(m_hwnd, &pt);

		TOOLINFO tiHit;

        ZeroMemory(&tiHit, sizeof(tiHit));
		tiHit.cbSize = sizeof(TOOLINFO);

		int nHit = OnToolHitTest(pt, &tiHit);

		if (m_nLastHit != nHit)
		{
			if (nHit != -1)
			{
				// add new tool and activate the tip
                if (!::SendMessage(m_hwndToolTip, TTM_ADDTOOL, 0, (LPARAM)&tiHit))
                {
                    ERROR_OUT(("TTM_ADDTOOL failed"));
                }

				if (::GetActiveWindow() == m_hwnd)
				{
					// allow the tooltip to popup when it should
                    ::SendMessage(m_hwndToolTip, TTM_ACTIVATE, TRUE, 0);

					// bring the tooltip window above other popup windows
					::SetWindowPos(m_hwndToolTip, HWND_TOP, 0, 0, 0, 0,
						SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE);
				}
			}

			// relay mouse event before deleting old tool
            ::SendMessage(m_hwndToolTip, TTM_RELAYEVENT, 0, (LPARAM)pMsg);

			// now safe to delete the old tool
            if (m_tiLastHit.cbSize != 0)
                ::SendMessage(m_hwndToolTip, TTM_DELTOOL, 0, (LPARAM)&m_tiLastHit);

            m_nLastHit = nHit;
            m_tiLastHit = tiHit;
		}
		else
		{
			// relay mouse events through the tooltip
			if (nHit != -1)
                ::SendMessage(m_hwndToolTip, TTM_RELAYEVENT, 0, (LPARAM)pMsg);
		}
	}

#if 0
DoneToolTipFiltering:
#endif
    // Assume we will use the main accelerator table
    HACCEL hAccelTable = m_hAccelTable;

    // If this window has focus, just continue
    HWND hwndFocus = ::GetFocus();
    if (hwndFocus && (hwndFocus != m_hwnd))
    {
        // Check whether an edit field in the pages group has the focus
        if (m_AG.IsChildEditField(hwndFocus))
        {
            hAccelTable = m_hAccelPagesGroup;
        }
        // Check whether text editor has the focus and is active
        else if (   (hwndFocus == m_drawingArea.m_hwnd)
                 && (m_drawingArea.TextEditActive()))
        {
            // Let editbox do its own acceleration.
            hAccelTable = NULL;
        }
    }

    return (   (hAccelTable != NULL)
          && ::TranslateAccelerator(m_hwnd, hAccelTable, pMsg));
}




//
//
// Function:    OnDisplayError
//
// Purpose:     Display an error message
//
//
void WbMainWindow::OnDisplayError(WPARAM uiFEReturnCode, LPARAM uiDCGReturnCode)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnDisplayError");

    // Only continue if we are not currently displaying an error
    if (!m_bDisplayingError)
    {
        // Show that we are currently displaying an error message
        m_bDisplayingError = TRUE;

        // Display the error
        ::ErrorMessage((UINT)uiFEReturnCode, (UINT)uiDCGReturnCode);

        // Show that we are no longer displaying an error
        m_bDisplayingError = FALSE;
    }
}


//
//
// Function:    OnTimer
//
// Purpose:     Process a timer event. These are used to update the progress
//              meter and the sync position.
//
//
void WbMainWindow::OnTimer(UINT_PTR idTimer)
{
    TRACE_TIMER(("WbMainWindow::OnTimer"));

    //
    // Only do anything if the timer has not been switched off (this may be an
    // old timer message left in the queue when we stopped the timer).
    //
    if (m_bTimerActive)
    {
        //
        // Check for sync position update needed
        //

        // Check whether an update is flagged
        if (m_bSyncUpdateNeeded)
        {
            TRACE_TIMER(("Updating sync position"));

            // Check whether the local user is still synced
            if ((m_uiState == IN_CALL) &&
                (m_pLocalUser != NULL) &&
                (m_pLocalUser->IsSynced()) &&
                (!WB_ContentsLocked()))
            {
                RECT    rcVis;

                // Update the local user's position information
                m_drawingArea.GetVisibleRect(&rcVis);

                m_pLocalUser->SetVisibleRect(&rcVis);

                // Write the sync position from the local user's current position
                m_pLocalUser->PutSyncPosition();
            }

            // Show that the update has been done
            m_bSyncUpdateNeeded = FALSE;
        }
    }
}


//
//
// Function:    OnPaletteChanged
//
// Purpose:     The palette has changed.
//
//
void WbMainWindow::OnPaletteChanged(HWND hwndPalette)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnPaletteChanged");

    if ((hwndPalette != m_hwnd) &&
        (hwndPalette != m_drawingArea.m_hwnd))
    {
        // Tell the drawing area to realize its palette
        m_drawingArea.RealizePalette( TRUE );
    }
}



//
//
// Function:    OnQueryNewPalette
//
// Purpose:     We are getting focus and must realize our palette
//
//
LRESULT WbMainWindow::OnQueryNewPalette(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnQueryNewPalette");

    // Tell the drawing area to realize its palette
    m_drawingArea.RealizePalette( FALSE );

    return TRUE;
}



//
//
// Function:    WbMainWindowEventHandler
//
// Purpose:     Event handler for WbMainWindow objects. This is a class
//              wide function. The client data passed to it is a pointer
//              to the instance of WbMainWindow for which the event is
//              intended.
//
//
BOOL CALLBACK WbMainWindowEventHandler
(
    LPVOID  utHandle,
    UINT    event,
    UINT_PTR param1,
    UINT_PTR param2
)
{
    if (g_pMain->m_hwnd != NULL)
    {
        return(g_pMain->EventHandler(event, param1, param2));
    }
    else
    {
        return(FALSE);
    }
}


//
//
// Function:    EventHandler
//
// Purpose:     Handler for DC-Groupware events for this object
//
//
BOOL WbMainWindow::EventHandler(UINT Event, UINT_PTR param1, UINT_PTR param2)
{
    BOOL    processed;

    switch (Event)
    {
        case CMS_NEW_CALL:
        case CMS_END_CALL:

        case ALS_LOCAL_LOAD:
        case ALS_REMOTE_LOAD_RESULT:

        case WBP_EVENT_JOIN_CALL_OK:
        case WBP_EVENT_JOIN_CALL_FAILED:
        case WBP_EVENT_NETWORK_LOST:
        case WBP_EVENT_ERROR:
        case WBP_EVENT_PAGE_CLEAR_IND:
        case WBP_EVENT_PAGE_ORDER_UPDATED:
        case WBP_EVENT_PAGE_DELETE_IND:
        case WBP_EVENT_CONTENTS_LOCKED:
        case WBP_EVENT_PAGE_ORDER_LOCKED:
        case WBP_EVENT_UNLOCKED:
        case WBP_EVENT_LOCK_FAILED:
        case WBP_EVENT_GRAPHIC_ADDED:
        case WBP_EVENT_GRAPHIC_MOVED:
        case WBP_EVENT_GRAPHIC_UPDATE_IND:
        case WBP_EVENT_GRAPHIC_REPLACE_IND:
        case WBP_EVENT_GRAPHIC_DELETE_IND:
        case WBP_EVENT_PERSON_JOINED:
        case WBP_EVENT_PERSON_LEFT:
        case WBP_EVENT_PERSON_UPDATE:
        case WBP_EVENT_PERSON_REPLACE:
        case WBP_EVENT_SYNC_POSITION_UPDATED:
        case WBP_EVENT_LOAD_COMPLETE:
        case WBP_EVENT_LOAD_FAILED:
            // Process the Event
            ProcessEvents(Event, param1, param2);
            processed = TRUE;
            break;

        default:
            processed = FALSE;
            break;
    }

    return(processed);
}


//
//
// Function:    PopupContextMenu
//
// Purpose:     Popup the context menu for the drawing area. This is called
//              by the drawing area window on a right mouse click.
//
//
void WbMainWindow::PopupContextMenu(int x, int y)
{
    POINT   surfacePos;
    RECT    clientRect;
    DCWbGraphic * pGraphic;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::PopupContextMenu");

    surfacePos.x = x;
    surfacePos.y = y;

    // figure out which popup menu to use (bug 426)
    if (m_pCurrentTool->ToolType() == TOOLTYPE_SELECT)
    {
        m_drawingArea.ClientToSurface(&surfacePos);
        if( (pGraphic = m_drawingArea.GetHitObject( surfacePos )) != NULL )
        {
            // we clicked over an object, see if its already selected
            if( !m_drawingArea.IsSelected( pGraphic ) )
            {
                // object is not already selected, zap current selection and then select it
                m_drawingArea.ClearSelection();
                m_drawingArea.SelectGraphic( pGraphic );
            }
            else
            {
                // plug leak by deleteing pGraphic
                delete pGraphic;
            }
        }

        if( m_drawingArea.GraphicSelected() )
        {
            // selector tool is active, and one or more objects are selected
            m_hInitMenu = m_hGrobjContextMenu;
        }
        else
        {
            // no current selection, show drawing menu
            m_hInitMenu = m_hContextMenu;
        }
    }
    else
    {
        // no objects selected, use drawing menu
        m_hInitMenu = m_hContextMenu;
    }

    // set up current menu state
    SetMenuStates(m_hInitMenu);

    // pop it up
    ::GetClientRect(m_drawingArea.m_hwnd, &clientRect);
    ::MapWindowPoints(m_drawingArea.m_hwnd, NULL, (LPPOINT)&clientRect.left, 2);

    ::TrackPopupMenu(m_hInitMenu, TPM_RIGHTALIGN | TPM_RIGHTBUTTON,
                                 x + clientRect.left,
                                 y + clientRect.top,
                                 0,
                                 m_hwnd,
                                 NULL);

    // reset m_hInitMenu to indicate the popup menu isn't being shown anymore
    m_hInitMenu = NULL;
}




//
//
// Function: ProcessEvents
//
// Purpose: Process events that have been queued internally
//
//
void WbMainWindow::ProcessEvents(UINT Event, UINT_PTR param1, UINT_PTR param2)
{
    HWND hwndLastPopup;

    TRACE_EVENT(("WbMainWindow::ProcessEvents"));

    //
    // If we are closing, ignore it.
    //
    if (m_uiState == CLOSING)
    {
        TRACE_EVENT(("ProcessEvents: ignored because WB is closing"));
        return;
    }

    //
    // If we are busy drawing,  we postpone it until later when we can
    // handle it.
    //
    // If the page sorter dialog is up, it gets notified by the appropriate
    // event handler after the fact.
    //
    if (m_drawingArea.IsBusy())
    {
        TRACE_EVENT(("Reposting event %x, param1 %d param2 %d", Event, param1, param2));
        g_pwbCore->WBP_PostEvent(200, Event, param1, param2);
        return;
    }

    TRACE_EVENT(("Event %x, m_uiState %d", Event, m_uiState));

    //
    // Process according to the event type.
    //
    switch (Event)
    {
        case CMS_NEW_CALL:
            OnCMSNewCall((BOOL)param1, (DWORD)param2);
            break;

        case CMS_END_CALL:
            OnCMSEndCall();
            break;

        case ALS_LOCAL_LOAD:
            switch (m_uiState)
            {
                case IN_CALL:
                case ERROR_STATE:
                    // show the main window normal/minimized as necessary
                    hwndLastPopup = ::GetLastActivePopup(m_hwnd);

                    if (::IsIconic(m_hwnd))
                        ::ShowWindow(m_hwnd, SW_RESTORE);
                    else
                        ::ShowWindow(m_hwnd, SW_SHOW);

                    ::SetForegroundWindow(hwndLastPopup);

                    if (param2)
                    {
                        if (m_uiState == IN_CALL)
                            LoadCmdLine((LPCSTR)param2);
                        ::GlobalFree((HGLOBAL)param2);
                    }
                    break;

                default:
                    TRACE_MSG(("Joining a call so try load later",
                            (LPCTSTR)param2));
                    g_pwbCore->WBP_PostEvent(400, Event, param1, param2);
                    break;
            }
            break;

        case ALS_REMOTE_LOAD_RESULT:
            OnALSLoadResult((UINT)param1);
            break;

        case WBP_EVENT_JOIN_CALL_OK:
            OnWBPJoinCallOK();
            break;

        case WBP_EVENT_JOIN_CALL_FAILED:
            OnWBPJoinCallFailed();
            break;

        case WBP_EVENT_NETWORK_LOST:
            OnWBPNetworkLost();
            break;

        case WBP_EVENT_ERROR:
            OnWBPError();
            break;

        case WBP_EVENT_PAGE_CLEAR_IND:
            OnWBPPageClearInd((WB_PAGE_HANDLE) param1);
            break;

        case WBP_EVENT_PAGE_ORDER_UPDATED:
            OnWBPPageOrderUpdated();
            break;

        case WBP_EVENT_PAGE_DELETE_IND:
            OnWBPPageDeleteInd((WB_PAGE_HANDLE) param1);
            break;

        case WBP_EVENT_CONTENTS_LOCKED:
            OnWBPContentsLocked((POM_OBJECT) param2);
            break;

        case WBP_EVENT_PAGE_ORDER_LOCKED:
            OnWBPPageOrderLocked((POM_OBJECT) param2);
            break;

        case WBP_EVENT_UNLOCKED:
            OnWBPUnlocked((POM_OBJECT) param2);
            break;

        case WBP_EVENT_LOCK_FAILED:
            OnWBPLockFailed();
            break;

        case WBP_EVENT_GRAPHIC_ADDED:
            OnWBPGraphicAdded((WB_PAGE_HANDLE) param1, (WB_GRAPHIC_HANDLE) param2);
            break;

        case WBP_EVENT_GRAPHIC_MOVED:
            OnWBPGraphicMoved((WB_PAGE_HANDLE) param1, (WB_GRAPHIC_HANDLE) param2);
            break;

        case WBP_EVENT_GRAPHIC_UPDATE_IND:
            OnWBPGraphicUpdateInd((WB_PAGE_HANDLE) param1, (WB_GRAPHIC_HANDLE) param2);
            break;

        case WBP_EVENT_GRAPHIC_REPLACE_IND:
            OnWBPGraphicReplaceInd((WB_PAGE_HANDLE) param1, (WB_GRAPHIC_HANDLE) param2);
            break;

        case WBP_EVENT_GRAPHIC_DELETE_IND:
            OnWBPGraphicDeleteInd((WB_PAGE_HANDLE) param1, (WB_GRAPHIC_HANDLE) param2);
            break;

        case WBP_EVENT_PERSON_JOINED:
            OnWBPUserJoined((POM_OBJECT) param2);
            break;

        case WBP_EVENT_PERSON_LEFT:
            OnWBPUserLeftInd((POM_OBJECT) param2);
            break;

        case WBP_EVENT_PERSON_UPDATE:
            OnWBPUserUpdateInd((POM_OBJECT) param2, FALSE);
            break;

        case WBP_EVENT_PERSON_REPLACE:
            OnWBPUserUpdateInd((POM_OBJECT) param2, TRUE);
            break;

        case WBP_EVENT_SYNC_POSITION_UPDATED:
            OnWBPSyncPositionUpdated();
            break;

        case WBP_EVENT_LOAD_COMPLETE:
            OnWBPLoadComplete();
            break;

        case WBP_EVENT_LOAD_FAILED:
            OnWBPLoadFailed();
            break;

        default:
            WARNING_OUT(("Unrecognized event %x", Event));
            break;
    }
}


//
//
// Function:    OnCMSNewCall
//
// Purpose:     Handler for CMS_NEW_CALL
//
//
void WbMainWindow::OnCMSNewCall(BOOL fTopProvider, DWORD _m_dwDomain)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnCMSNewCall");

    //
    // If we created the call
    //
    if (fTopProvider)
    {
        // Join the call, keep existing contents
        if (m_uiState == IN_CALL)
        {
            //
            // Join the call but keep any existing messages.
            //
            ::PostMessage(m_hwnd, WM_USER_JOIN_CALL, 1, (LONG) _m_dwDomain);
        }
        else
        {
            m_bJoinCallPending = TRUE;
            m_dwPendingDomain = _m_dwDomain;
            m_bPendingCallKeepContents = TRUE;
        }
    }
    else
    {
        CM_STATUS status;

        CMS_GetStatus(&status);

        if (!(status.attendeePermissions & NM_PERMIT_USEOLDWBATALL))
        {
            WARNING_OUT(("OLD WB: not joining call, not permitted"));
            return;
        }

        if (m_uiState == IN_CALL)
        {
            //
            // Join the call, throwing away our current contents (after
            // prompting the user to save them first).
            //
            ::PostMessage(m_hwnd, WM_USER_JOIN_CALL, 0, (LONG) _m_dwDomain);
        }
        else
        {
            m_bJoinCallPending = TRUE;
            m_dwPendingDomain = _m_dwDomain;
            m_bPendingCallKeepContents = FALSE;
        }
    }

    //
    // Get the call status correct.
    //
    m_bCallActive = TRUE;
	UpdateWindowTitle();
}

//
//
// Function:    OnJoinPendingCall
//
// Purpose:     Handler for WM_USER_JOIN_PENDING_CALL
//
//
void WbMainWindow::OnJoinPendingCall(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnJoinPendingCall");

    //
    // If there's still a pending call (haven't received an end-call message
    // between posting the WM_USER_JOIN_PENDING_CALL and getting here).
    //
    if (m_bJoinCallPending)
    {
        //
        // Post a message to join the call
        //
        ::PostMessage(m_hwnd, WM_USER_JOIN_CALL,
                  m_bPendingCallKeepContents,
                  (LONG) m_dwPendingDomain);

        // cancel call-pending status
        m_bJoinCallPending = FALSE;
    }
}


//
//
// Function:    OnCMSEndCall
//
// Purpose:     Handler for CMS_END_CALL
//
//
void WbMainWindow::OnCMSEndCall(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnCMSEndCall");

    //
    // Flag to cancel any current join-call processing, and destroy any
    // associated dialogs.
    //
    if (m_bPromptingJoinCall)
    {
        m_bPromptingJoinCall = FALSE;
        if (m_hwndQuerySaveDlg != NULL)
        {
            ::SendMessage(m_hwndQuerySaveDlg, WM_COMMAND,
                MAKELONG(IDCANCEL, BN_CLICKED), 0);
            ASSERT(m_hwndQuerySaveDlg == NULL);
        }
    }

    //
    // Show that we are no longer in a call
    //
    m_dwDomain = OM_NO_CALL;

    //
    // If currently in the process of joining a call, then set the domain
    // we're joining to NO_CALL and join the local (singleton) domain.
    // Get the call status correct.
    //
    m_bCallActive = FALSE;
    TRACE_MSG(("m_uiState %d", m_uiState));
    m_dwDomain = OM_NO_CALL;

    //
    // Show there is no call pending
    //
    m_bJoinCallPending = FALSE;

    //
    // Update the window title with "not in call"
    //
	UpdateWindowTitle();
}

//
//
// Function:    OnWBPJoinCallOK
//
// Purpose:     Handler for WBP_EVENT_JOIN_CALL_OK
//
//
void WbMainWindow::OnWBPJoinCallOK(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPJoinCallOK");

    //
    // Record that we have joined the call, but the drawing area is not yet
    // ready for input (because we have not yet attached to a page).
    //
    m_uiState = JOINED;

    //
    // Get the local user
    //
    m_pLocalUser = WB_LocalUser();
    if (!m_pLocalUser)
    {
        ERROR_OUT(("Can't join call; can't create local user object, m_pLocalUser!"));
        m_uiState = ERROR_STATE;
    }
    else
    {
        //
        // Get the first user in the call
        //
        WbUser* pUser = WB_GetFirstUser();

        //
        // Loop through all available users
        //
        while (pUser != NULL)
        {
            //
            // Make updates necessary for a user joining
            //
            UserJoined(pUser);

            //
            // Get the next user
            //
            pUser = WB_GetNextUser(pUser);
        }

        //
        // If the registration dialog is up - cancel it
        //
        m_uiState = IN_CALL; // have to set m_uiState before zapping
                                      // m_hwndWaitForEventDlg or it will
                                      // think the call failed now (the
                                      // delay has been removed from
                                      // EndDialogDelayed() (bug 3881)
    }

    if (m_hwndWaitForEventDlg != NULL)
    {
        TRACE_MSG(("Joined call OK - end dialog"));
        ::SendMessage(m_hwndWaitForEventDlg, WM_COMMAND, MAKELONG(IDOK, BN_CLICKED), 0);
        ASSERT(m_hwndWaitForEventDlg == NULL);
    }

    if (!m_pLocalUser)
    {
        //
        // BAIL out, we can't join the call
        return;
    }

    //
    // Now complete the join call processing
    //
    TRACE_MSG(("Successfully joined the call"));
    m_dwDomain = m_dwJoinDomain;

    //
    // If we have never attached to a page before (ie at start up), attach
    // to the first available page in the drawing area.  If we are joining
    // a call then we reattach to the current page
    //
    if (m_hCurrentPage == WB_PAGE_HANDLE_NULL)
    {
        TRACE_MSG(("Attach to first page"));
        g_pwbCore->WBP_PageHandle(WB_PAGE_HANDLE_NULL, PAGE_FIRST, &m_hCurrentPage);
    }
    else
    {
        TRACE_DEBUG(("Just joined new call, reattach to the current page."));
    }
    m_drawingArea.Attach(m_hCurrentPage);

    // Display the initial status
    UpdateStatus();


    ::SetTimer(m_hwnd, TIMERID_PROGRESS_METER, MAIN_PROGRESS_TIMER, NULL);
    m_bTimerActive = TRUE;

    //
    // Unlock the drawing area, allowing user updates (unless its already
    // locked by someone else)
    //
    if (!WB_ContentsLocked())
    {
        UnlockDrawingArea();
    }

    // Set the substate (also updates page buttons)
    SetSubstate(SUBSTATE_IDLE);

    //
    // If we aren't synced, then sync now.
    // Set the window title to show we're no longer registering/joining a
    // call
    //
    Sync();
	UpdateWindowTitle();

    //
    // If we were joining the local domain, and a join call message arrived
    // in the meantime, then join that call now.
    //
    if ((m_bJoinCallPending) && (m_dwJoinDomain == OM_NO_CALL))
    {
        ::PostMessage(m_hwnd, WM_USER_JOIN_PENDING_CALL, 0, 0L);
    }
}


//
//
// Function:    OnWBPJoinCallFailed
//
// Purpose:     Handler for WBP_EVENT_JOIN_CALL_FAILED
//
//
void WbMainWindow::OnWBPJoinCallFailed(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPJoinCallFailed");

    //
    // If we have just failed to join a new call (not a single domain) it
    // may be because the call ended before we had time to join it
    // completely - try joining the single domain.
    //
    if ((m_uiState == STARTING) && (m_dwJoinDomain != OM_NO_CALL))
    {
        WARNING_OUT(("Failed to join call on startup, try local domain"));
        m_dwJoinDomain = OM_NO_CALL;
        m_bCallActive  = FALSE;
        JoinCall(FALSE);
    }
    else
    {
        //
        // Tell the registration dialog to finish
        //
        if (m_hwndWaitForEventDlg != NULL)
        {
            WARNING_OUT(("Failed to join call - end dialog"));
            ::SendMessage(m_hwndWaitForEventDlg, WM_COMMAND, MAKELONG(IDOK, BN_CLICKED), 0);
            ASSERT(m_hwndWaitForEventDlg == NULL);
        }

        m_uiState = ERROR_STATE;
    }
}


//
//
// Function:    OnWBPNetworkLost
//
// Purpose:     Handler for WBP_EVENT_NETWORK_LOST
//
//
void WbMainWindow::OnWBPNetworkLost(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPNetworkLost");

    //
    // We have lost contact with the other people in the call.
    // Treat as if we got an end call (we should get an end call too, but
    // other intervening events might occur (such as trying to join a
    // call).
    //
    OnCMSEndCall();
}

//
//
// Function:    OnWBPError
//
// Purpose:     Handler for WBP_EVENT_ERROR
//
//
void WbMainWindow::OnWBPError(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPError");

    // Inform the user of the error.
    ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, 0);
}

//
//
// Function:    OnWBPPageClearInd
//
// Purpose:     Handler for WBP_EVENT_PAGE_CLEAR_IND
//
//
void WbMainWindow::OnWBPPageClearInd(WB_PAGE_HANDLE hPage)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPPageClearInd");

    // Confirm the clearing of the page. This is OK even if the page being
    // cleared is the current page because we already know that the drawing
    // area is not busy (otherwise we would not be here).

    // If there's an object on the page which has been copied to the
    // clipboard with delayed rendering, then save it
    if (CLP_LastCopiedPage() == hPage)
    {
        CLP_SaveDelayedGraphic();
    }

    // If it is the current page being cleared
    if (m_hCurrentPage == hPage)
        {
        m_drawingArea.PageCleared();
        }

    // If there is a last deleted graphic
    // and it belongs to the page being cleared.
    if ((m_LastDeletedGraphic.GotTrash()) &&
        (m_LastDeletedGraphic.Page() == hPage))
    {
        // Free the last deleted graphic
        m_LastDeletedGraphic.BurnTrash();
    }

    g_pwbCore->WBP_PageClearConfirm(hPage);

    //
    // Notify the page sorter AFTER the page has been cleared
    //
    if (m_hwndPageSortDlg != NULL)
    {
        ::SendMessage(m_hwndPageSortDlg, WM_PS_PAGECLEARIND, (WPARAM)hPage, 0);
    }
}


//
//
// Function:    OnWBPPageOrderUpdated
//
// Purpose:     Handler for WBP_EVENT_PAGE_ORDER_UPDATED
//
//
void WbMainWindow::OnWBPPageOrderUpdated(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPPageOrderUpdated");

    m_drawingArea.CancelDrawingMode();

    // The page order has changed, we just need to update the number of the
    // current page in the pages group.
    UpdateStatus();

    //
    // Notify the page sorter AFTER the page order has been updated
    //
    if (m_hwndPageSortDlg != NULL)
    {
        ::SendMessage(m_hwndPageSortDlg, WM_PS_PAGEORDERUPD, 0, 0);
    }
}

//
//
// Function:    OnWBPPageDeleteInd
//
// Purpose:     Handler for WBP_EVENT_PAGE_DELETE_IND
//
//
void WbMainWindow::OnWBPPageDeleteInd(WB_PAGE_HANDLE hPage)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPPageDeleteInd");

    //
    // Notify the page sorter BEFORE the page is deleted
    //
    if (m_hwndPageSortDlg != NULL)
    {
        ::SendMessage(m_hwndPageSortDlg, WM_PS_PAGEDELIND, (WPARAM)hPage, 0);
    }

    m_drawingArea.CancelDrawingMode();

    // Remove it from the page-position map
    PAGE_POSITION *mapob;
    POSITION savedPos;
	POSITION position = m_pageToPosition.GetHeadPosition();
	BOOL bFound = FALSE;
	while (position && !bFound)
	{
		savedPos = position;
		mapob = (PAGE_POSITION *)m_pageToPosition.GetNext(position);
		if ( mapob->hPage == hPage)
		{
			bFound = TRUE;
		}
	}

	if(bFound)
	{
        m_pageToPosition.RemoveAt(savedPos);
        delete mapob;
    }

    // A page has been deleted.  If it is the current page we must attach
    // a different page to the drawing area. In any case we should confirm
    // the delete.

    // If there's an object on the page which has been copied to the
    // clipboard with delayed rendering, then save it
    if (CLP_LastCopiedPage() == hPage)
    {
        CLP_SaveDelayedGraphic();
    }

    if (hPage == m_hCurrentPage)
    {
        // Check whether we are deleting the last page
        WB_PAGE_HANDLE hNewPage;

        g_pwbCore->WBP_PageHandle(WB_PAGE_HANDLE_NULL, PAGE_LAST, &hNewPage);
        if (hNewPage == hPage)
        {
            // We are deleting the last page, so go back one
            hNewPage = PG_GetPreviousPage(hPage);
        }
        else
        {
            // We are not deleting the last page, so go forward one
            hNewPage = PG_GetNextPage(hPage);
        }

        // Check that we got a different page to the one being deleted
        ASSERT(hNewPage != hPage);

        // Lock the drawing area - this ensures we are no longer editing
        // any text etc.
        LockDrawingArea();

        // Move to the new page
        GotoPage(hNewPage);

        // Unlock the drawing area (unless we're doing a new, in which case we
        // leave it locked - it will become unlocked when the new completes)
        if (   (!WB_ContentsLocked())
            && (m_uiState == IN_CALL)
            && (m_uiSubState != SUBSTATE_NEW_IN_PROGRESS))
        {
            UnlockDrawingArea();
        }
    }

    // If there is a last deleted graphic
    if ((m_LastDeletedGraphic.GotTrash()) &&
        (m_LastDeletedGraphic.Page() == hPage))
    {
        // Free the last deleted graphic
        m_LastDeletedGraphic.BurnTrash();
    }

    // if the remote pointer is on the deleted page then turn it off
    ASSERT(m_pLocalUser);
    DCWbGraphicPointer* pPointer = m_pLocalUser->GetPointer();
    if (   (pPointer->IsActive())
        && (pPointer->Page() == hPage))
        {
        OnRemotePointer();
        }

    // Let the core delete the page
    g_pwbCore->WBP_PageDeleteConfirm(hPage);

    // if this is last page to be deleted, then the file/new is complete
    if ((m_uiSubState == SUBSTATE_NEW_IN_PROGRESS)
        && (g_pwbCore->WBP_ContentsCountPages() == 1))
        {
        SetSubstate(SUBSTATE_IDLE);

        ReleasePageOrderLock();

        if (!WB_ContentsLocked())
            {
            UnlockDrawingArea();
            }
        }

    // Update the status (there is a new number of pages)
    UpdateStatus();
}

//
//
// Function:    OnWBPContentsLocked
//
// Purpose:     Handler for WBP_EVENT_CONTENTS_LOCKED
//
//
void WbMainWindow::OnWBPContentsLocked(POM_OBJECT hUser)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPContentsLocked");

    //
    // Notify page sorter dialog that the lock status has changed
    //
    if (m_hwndPageSortDlg != NULL)
    {
        ::SendMessage(m_hwndPageSortDlg, WM_PS_LOCKCHANGE, 0, 0);
    }

    if (m_uiState != IN_CALL)
    {
        TRACE_MSG(("Lock indication received out of call - ignored"));
    }
    else
    {
        ASSERT(m_pLocalUser);

        if (m_pLocalUser->Handle() == hUser)
        {
            // We have acquired the lock

            // Set the locked check mark
            CheckMenuItem(IDM_LOCK);

            // Tell the tool bar of the new selection
            m_TB.PushDown(IDM_LOCK);
        }
        else
        {
            //
            // A remote user has acquired the lock:
            // If we're not synced, then sync now.
            //
            Sync();

            // Tell the drawing area it is now locked
            LockDrawingArea();

            // ensure the page button enable/disable state is correct
            UpdatePageButtons();
        }
    }

    //
    // If the lock dialog is up - cancel it.
    //
    if (m_hwndWaitForLockDlg != NULL)
    {
        ::SendMessage(m_hwndWaitForLockDlg, WM_COMMAND, MAKELONG(IDOK, BN_CLICKED), 0);
        ASSERT(m_hwndWaitForLockDlg == NULL);
    }
}

//
//
// Function:    OnWBPPageOrderLocked
//
// Purpose:     Handler for WBP_EVENT_PAGE_ORDER_LOCKED
//
//
void WbMainWindow::OnWBPPageOrderLocked(POM_OBJECT)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPPageOrderLocked");

    // If the lock dialog is up - cancel it
    if (m_hwndWaitForLockDlg != NULL)
    {
        ::SendMessage(m_hwndWaitForLockDlg, WM_COMMAND, MAKELONG(IDOK, BN_CLICKED), 0);
        ASSERT(m_hwndWaitForLockDlg == NULL);
    }

    // Update the page sorter
    if (m_hwndPageSortDlg != NULL)
    {
        ::SendMessage(m_hwndPageSortDlg, WM_PS_LOCKCHANGE, 0, 0);
    }

    if (!WB_GotLock())
    {
        EnableToolbar( FALSE );
        UpdatePageButtons();
    }
}

//
//
// Function:    OnWBPUnlocked
//
// Purpose:     Handler for WBP_EVENT_UNLOCKED
//
//
void WbMainWindow::OnWBPUnlocked(POM_OBJECT hUser)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPUnlocked");

    // Update the page sorter if it's around
    if (m_hwndPageSortDlg != NULL)
    {
        ::SendMessage(m_hwndPageSortDlg, WM_PS_LOCKCHANGE, 0, 0);
    }

    // Uncheck the lock menu item
    UncheckMenuItem(IDM_LOCK);

    // Tell the tool bar of the change
    m_TB.PopUp(IDM_LOCK);

    // If a remote user is releasing the lock, and we're in a state where
    // it's safe to unlock the drawing area...
    if ((m_pLocalUser != NULL) &&
        (m_pLocalUser->Handle() != hUser) &&
        (m_uiState == IN_CALL))
    {
        // Tell the drawing area it is no longer locked
        UnlockDrawingArea();
    }

    // ensure the page button enable/disable state is correct
    UpdatePageButtons();
    m_bUnlockStateSettled = TRUE; //Allow page operations now
}

//
//
// Function:    OnWBPLockFailed
//
// Purpose:     Handler for WBP_EVENT_LOCK_FAILED
//
//
void WbMainWindow::OnWBPLockFailed(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPLockFailed");

    // If the lock dialog is up - kill it
    if (m_hwndWaitForLockDlg != NULL)
    {
        ::SendMessage(m_hwndWaitForLockDlg, WM_COMMAND, MAKELONG(IDOK, BN_CLICKED), 0);
        ASSERT(m_hwndWaitForLockDlg == NULL);
    }
}

//
//
// Function:    OnWBPGraphicAdded
//
// Purpose:     Handler for WBP_EVENT_GRAPHIC_ADDED
//
//
void WbMainWindow::OnWBPGraphicAdded
(
    WB_PAGE_HANDLE      hPage,
    WB_GRAPHIC_HANDLE   hGraphic
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPGraphicAdded");

    // We only need to take action if the page to which the graphic has
    // been added is the current page.
    if (hPage == m_hCurrentPage && (!(hGraphic->flags & DELETED)))
    {
        // Retrieve the graphic that has been added
        DCWbGraphic* pGraphic = DCWbGraphic::ConstructGraphic(hPage, hGraphic);

        // Tell the drawing area of the new graphic
        m_drawingArea.GraphicAdded(pGraphic);

        // Free the graphic
        delete pGraphic;
    }
}

//
//
// Function:    OnWBPGraphicMoved
//
// Purpose:     Handler for WBP_EVENT_GRAPHIC_MOVED
//
//
void WbMainWindow::OnWBPGraphicMoved
(
    WB_PAGE_HANDLE      hPage,
    WB_GRAPHIC_HANDLE   hGraphic
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPGraphicMoved");

    // We only need to take action if the graphic belongs to the current page
    if (hPage == m_hCurrentPage  && (!(hGraphic->flags & DELETED)))
    {
        // Retrieve the graphic that has been moved
        DCWbGraphic* pGraphic = DCWbGraphic::ConstructGraphic(hPage, hGraphic);

        if( NULL != pGraphic )
        {
            // Tell the drawing area of the new graphic
            m_drawingArea.GraphicUpdated(pGraphic, TRUE, FALSE);

            // set paint to draw only objects above this object inclusive
            if (pGraphic->IsGraphicTool() == enumGraphicText)
            {
                m_drawingArea.SetStartPaintGraphic( NULL );
                    // this optimization screws up text
                    // so short it out if this is text
                    // (text draws transparently and background
                    //  isn't repainted properly if this is active)
            }
            else
            {
                m_drawingArea.SetStartPaintGraphic( hGraphic );
                // not text so optimize by drawing only this
                // object and everthing above it
            }

            // Free the graphic
            delete pGraphic;
        }
    }
}

//
//
// Function:    OnWBPGraphicUpdateInd
//
// Purpose:     Handler for WBP_EVENT_GRAPHIC_UPDATE_IND
//
//
void WbMainWindow::OnWBPGraphicUpdateInd
(
    WB_PAGE_HANDLE      hPage,
    WB_GRAPHIC_HANDLE   hGraphic
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPGraphicUpdateInd");

	if(hGraphic->flags & DELETED)
	{
		return;
	}

    PWB_GRAPHIC  pOldHeader;
    PWB_GRAPHIC  pOldHeaderCopy;
    DCWbGraphic* pOldGraphic;

    PWB_GRAPHIC  pNewHeader;
    DCWbGraphic* pNewGraphic;

    if (hPage != m_hCurrentPage)
    {
        // nothing visual has changed, confirm and we're done
        g_pwbCore->WBP_GraphicUpdateConfirm(hPage, hGraphic);
        return;
    }


    // Retrieve the original graphic and make a copy
    // Get the page of the update
    pOldHeader = PG_GetData(hPage, hGraphic);
    pOldHeaderCopy = (PWB_GRAPHIC) new BYTE[ pOldHeader->length ];

    if( pOldHeaderCopy == NULL )
    {
        ERROR_OUT( ("Can't copy pOldHeader, can't update drawing") );

        g_pwbCore->WBP_GraphicRelease(hPage, hGraphic, pOldHeader );
        g_pwbCore->WBP_GraphicUpdateConfirm(hPage, hGraphic);
        return;
    }

    CopyMemory( (PVOID)pOldHeaderCopy, (CONST VOID *)pOldHeader, pOldHeader->length );

    // confirm and get the new one
    g_pwbCore->WBP_GraphicRelease(hPage, hGraphic, pOldHeader );
    g_pwbCore->WBP_GraphicUpdateConfirm(hPage, hGraphic);

    pNewHeader = PG_GetData(hPage, hGraphic);

    // This update might affect painting. See if old and new are visually different
    if( HasGraphicChanged( pOldHeaderCopy, (const PWB_GRAPHIC)pNewHeader ) )
    {
        // they're different, invalidate/erase old graphic's bounding rect
        pOldGraphic = DCWbGraphic::ConstructGraphic(hPage, hGraphic, pOldHeaderCopy );
        m_drawingArea.GraphicUpdated( pOldGraphic, FALSE, TRUE );

        // draw new graphic (don't need to erase)
        pNewGraphic = DCWbGraphic::ConstructGraphic(hPage, hGraphic, pNewHeader );
        g_pwbCore->WBP_GraphicRelease(hPage, hGraphic, pNewHeader );
        m_drawingArea.GraphicUpdated( pNewGraphic, TRUE, FALSE );

        // If the graphic is selected, ensure the attributes bar is up to date
        if (m_drawingArea.GraphicSelected())
            {
            DCWbGraphic* pSelectedGraphic = m_drawingArea.GetSelection();
            if ((pSelectedGraphic != NULL) &&
                (pSelectedGraphic->Handle() == hGraphic))
                {
                m_pCurrentTool->SelectGraphic(pNewGraphic);
                OnUpdateAttributes();
                }
            }

        delete pOldGraphic;
        delete pNewGraphic;
    }
    else
    {
        g_pwbCore->WBP_GraphicRelease(hPage, hGraphic, pNewHeader);
    }

    delete [] pOldHeaderCopy;
}



//
//
// Function:    OnWBPGraphicReplaceInd
//
// Purpose:     Handler for WBP_EVENT_GRAPHIC_REPLACE_IND
//
//
void WbMainWindow::OnWBPGraphicReplaceInd
(
    WB_PAGE_HANDLE      hPage,
    WB_GRAPHIC_HANDLE   hGraphic
)
{

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPGraphicReplaceInd");

	if(hGraphic->flags & DELETED)
	{
		return;
	}

    // Retrieve the graphic that has been replaced
    DCWbGraphic* pGraphic = DCWbGraphic::ConstructGraphic(hPage, hGraphic);

    if (pGraphic->IsGraphicTool() == enumGraphicFreeHand)
    {
        // Confirm the replace - the graphic reads its new details
        pGraphic->ReplaceConfirm();

        // Only redraw the graphic if it is on the current page
        if (hPage == m_hCurrentPage)
        {
            // Redraw the graphic
            m_drawingArea.GraphicFreehandUpdated(pGraphic);
        }
    }
    else
    {
        // We make two updates to the drawing area - one with the graphic in its
        // current state and one after the update is confirmed. The first one
        // invalidates the rectangle that the graphic now occupies. The second one
        // invalidates the new rectangle. This ensures that the graphic is
        // correctly redrawn.

        // If the graphic is on the current page...
        if (hPage == m_hCurrentPage)
        {
            // Update the drawing area for the old version of the graphic
            m_drawingArea.GraphicUpdated(pGraphic, FALSE);
        }

        // Confirm the replace - the graphic reads its new details
        pGraphic->ReplaceConfirm();

        // If the graphic is on the current page...
        if (hPage == m_hCurrentPage)
        {
            // Update the drawing area for the new version of the graphic
            m_drawingArea.GraphicUpdated(pGraphic, TRUE);
        }
    }

    // If the graphic is selected, ensure the attributes bar is up to date
    if (m_drawingArea.GraphicSelected())
    {
        DCWbGraphic* pSelectedGraphic = m_drawingArea.GetSelection();
        if ((pSelectedGraphic != NULL) &&
            (pSelectedGraphic->Handle() == hGraphic))
        {
            m_pCurrentTool->SelectGraphic(pGraphic);
            OnUpdateAttributes();
        }
    }

    // Free the graphic
    delete pGraphic;
}

//
//
// Function:    OnWBPGraphicDeleteInd
//
// Purpose:     Handler for WBP_EVENT_GRAPHIC_DELETE_IND
//
//
void WbMainWindow::OnWBPGraphicDeleteInd
(
    WB_PAGE_HANDLE      hPage,
    WB_GRAPHIC_HANDLE   hGraphic
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPGraphicDeleteInd");

    // if the graphic was copied into the clipboard and was delayed,
    // then save it in case we are asked to render it later
    if (   (CLP_LastCopiedPage() == hPage)
        && (CLP_LastCopiedGraphic() == hGraphic))
    {
        CLP_SaveDelayedGraphic();
    }

    // Retrieve the graphic that is to be deleted
    DCWbGraphic* pGraphic = DCWbGraphic::ConstructGraphic(hPage, hGraphic);

    // If the graphic is on the current page...
    if (hPage == m_hCurrentPage)
    {
        // Update the drawing area
        m_drawingArea.GraphicDeleted(pGraphic);
    }

    // Confirm the delete
    g_pwbCore->WBP_GraphicDeleteConfirm(hPage, hGraphic);

    // Free the graphic
    delete pGraphic;
}

//
//
// Function:    UserJoined
//
// Purpose:     Make updates necessary for a new user joining the call
//
//
void WbMainWindow::UserJoined(WbUser* pUser)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::UserJoined");

    // Get the user's remote pointer
    ASSERT(pUser);
    DCWbGraphicPointer* pPointer = pUser->GetPointer();

    // If the pointer is active and on the current page...
    ASSERT(pPointer);

    if (   (pPointer->IsActive())
        && (pPointer->Page() == m_hCurrentPage))
    {
        // Update the drawing area
        m_drawingArea.PointerUpdated(pPointer);
    }
}

//
//
// Function:  OnWBPUserJoined
//
// Purpose:   Handler for WBP_EVENT_PERSON_JOINED
//
//
void WbMainWindow::OnWBPUserJoined(POM_OBJECT hUser)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPUserJoined");

    // Create a user object from the handle
    WbUser* pUser = WB_GetUser(hUser);
    if (!pUser)
    {
        WARNING_OUT(("Can't handle OnWBPUserJoined; can't create user object for 0x%08x", hUser));
    }
    else
    {
        // Make the necessary updates
        UserJoined(pUser);
    }

    // Update the title bar to reflect the number of users.  Do this here,
    // rather than in UserJoined because we go through this function for
    // remote users only, but through UserJoined for the local user too.

	UpdateWindowTitle();
}

//
//
// Function:    OnWBPUserLeftInd
//
// Purpose:     Handler for WBP_EVENT_PERSON_LEFT
//
//
void WbMainWindow::OnWBPUserLeftInd(POM_OBJECT hUser)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPUserLeft");

    // Create a user object from the handle
    WbUser* pUser = WB_GetUser(hUser);

    if (!pUser)
    {
        WARNING_OUT(("Can't handle OnWBPUserLeftInd; can't get user object for 0x%08x", hUser));
    }
    else
    {
        // Get the user's remote pointer
        DCWbGraphicPointer* pPointer = pUser->GetPointer();
        ASSERT(pPointer);

        // If the pointer is on the current page...
        if (pPointer->Page() == m_hCurrentPage)
        {
            // Update the drawing area
            m_drawingArea.PointerRemoved(pPointer);
        }
    }

    // Confirm the update.
    g_pwbCore->WBP_PersonLeftConfirm(hUser);

    //
    // Get this dude out of our list
    //
    if (pUser != NULL)
    {
        ASSERT(g_pUsers);

        POSITION position = g_pUsers->GetHeadPosition();

        WbUser * pRemovedUser;

        while (position)
        {
            POSITION savedPosition = position;
            pRemovedUser = (WbUser*)g_pUsers->GetNext(position);
            if (pRemovedUser == pUser)
            {
                g_pUsers->RemoveAt(savedPosition);
                position = NULL;
            }
        }

        delete pUser;
    }

    // Update the title bar to reflect the number of users
	UpdateWindowTitle();
}

//
//
// Function:    OnWBPUserUpdateInd
//
// Purpose:     Handler for WBP_EVENT_PERSON_UPDATE
//
//
void WbMainWindow::OnWBPUserUpdateInd(POM_OBJECT hUser, BOOL bReplace)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPUserUpdateInd");
    BOOL     bActiveOld, bActiveNew;
    WB_PAGE_HANDLE  hPointerPageOld, hPointerPageNew;
    POINT    pointOld, pointNew;
    WB_PAGE_HANDLE  hUserPageOld, hUserPageNew;
    BOOL     syncOld, syncNew;
    DCWbGraphicPointer * pPointer = NULL;

    // Get the user object associated with the handle, and the remote pointer
    WbUser* pUser = WB_GetUser(hUser);

    if (!pUser)
    {
        WARNING_OUT(("Can't handle OnWBPUserUpdatedInd; can't get user object for 0x%08x", hUser));
    }
    else
    {
        pPointer = pUser->GetPointer();
        ASSERT(pPointer);

        //
        // Save the interesting bits of the user's state before the change.
        //
        bActiveOld     = pPointer->IsActive();
        hPointerPageOld = pPointer->Page();
        pPointer->GetPosition(&pointOld);
        hUserPageOld    = pUser->Page();
        syncOld        = pUser->IsSynced();
    }

    //
    // Confirm the change
    //
    if (bReplace)
    {
        g_pwbCore->WBP_PersonReplaceConfirm(hUser);
    }
    else
    {
        g_pwbCore->WBP_PersonUpdateConfirm(hUser);
    }

    if (pUser != NULL)
    {
        pUser->Refresh();

        //
        // We do nothing for the local user; since we made the updates locally,
        // we should have already accounted for them.
        //
        if (pUser == m_pLocalUser)
        {
            return;
        }

        //
        // Get the state after the change.
        //
        pPointer       = pUser->GetPointer();
        ASSERT(pPointer);

        bActiveNew     = pPointer->IsActive();
        hPointerPageNew = pPointer->Page();
        pPointer->GetPosition(&pointNew);
        hUserPageNew    = pUser->Page();
        syncNew        = pUser->IsSynced();


        // Check whether anything in the pointer has changed
        if (   (bActiveNew != bActiveOld)
            || (hPointerPageNew    != hPointerPageOld)
            || (!EqualPoint(pointNew, pointOld)))
        {
            // Check that at least one of the pages is the current page
            if (   (hPointerPageNew == m_hCurrentPage)
                || (hPointerPageOld == m_hCurrentPage))
            {
                m_drawingArea.PointerUpdated(pPointer);
            }
        }

        if (syncOld != syncNew)
        {
            // ensure the page button enable/disable state is correct
            UpdatePageButtons();
        }
    }
}

//
//
// Function:    OnWBPSyncPositionUpdated
//
// Purpose:     Handler for WBP_EVENT_SYNC_POSITION_UPDATED
//
//
void WbMainWindow::OnWBPSyncPositionUpdated(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPSyncPositionUpdated");

  //
  // Dont do anythig if we don't have a local user.
  //
  if (m_pLocalUser == NULL)
  {
      ERROR_OUT(("Got a WBP_EVENT_SYNC_POSITION_UPDATED event and pLocaUser is NULL "));
      return;
  }

    // If the local user is synced, change the current page/position
    if (m_pLocalUser->IsSynced())
    {
        GotoSyncPosition();
    }
}

//
//
// Function:    OnSize
//
// Purpose:     The window has been resized.
//
//
void WbMainWindow::OnSize(UINT nType, int cx, int cy )
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnSize");


    // Only process this message if the window is not minimized
    if (nType != SIZE_MINIMIZED)
    {
        // Hide the statusbar to avoid drawing problems
	if (m_bStatusBarOn)
	{
            ::ShowWindow(m_hwndSB, SW_HIDE);
        }
	
        // Resize the subpanes of the window
        ResizePanes();

        // Show it again
        if (m_bStatusBarOn)
        {
            ::ShowWindow(m_hwndSB, SW_SHOW);
        }
    }

    // The user's view has changed
    PositionUpdated();

    // If the status has changed, set the option
    if (m_uiWindowSize != nType)
    {
        m_uiWindowSize = nType;

        // Write the new option values to file
        OPT_SetBooleanOption(OPT_MAIN_MAXIMIZED,
                             (m_uiWindowSize == SIZE_MAXIMIZED));
        OPT_SetBooleanOption(OPT_MAIN_MINIMIZED,
                             (m_uiWindowSize == SIZE_MINIMIZED));
    }

    // If this is setting the window to a new normal size,
    // save the new position.
    if (nType == SIZE_RESTORED)
    {
        SaveWindowPosition();
    }
}

//
//
// Function:    SaveWindowPosition
//
// Purpose:     Save the current window position to the options file.
//
//
void WbMainWindow::SaveWindowPosition(void)
{
    RECT    rectWindow;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::SaveWindowPosition");

    // Get the new window rectangle
    ::GetWindowRect(m_hwnd, &rectWindow);

    // Write the new option values to file
    OPT_SetWindowRectOption(OPT_MAIN_MAINWINDOWRECT, &rectWindow);
}

//
//
// Function:    OnMove
//
// Purpose:     The window has been moved.
//
//
void WbMainWindow::OnMove(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnMove");

    // If we are not maximized
    if (!::IsZoomed(m_hwnd) && !::IsIconic(m_hwnd))
    {
        // Save the new position of the window
        SaveWindowPosition();
    }
}

//
//
// Function:    ResizePanes
//
// Purpose:     Resize the subpanes of the main window.
//
//
void WbMainWindow::ResizePanes(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::ResizePanes");

    //
    //
    // The client area is organized as follows:
    //
    //  -------------------------------------
    //  |   |                               |
    //  | T |                               |
    //  | o |   Drawing Area                |
    //  | o |                               |
    //  | l |                               |
    //  | s |                               |
    //  |---|                               |
    //  | W |                               |
    //  | i |                               |
    //  | d |                               |
    //  | t |                               |
    //  | h |                               |
    //  | s |                               |
    //  |-----------------------------------|
    //  | Attributes (colors)   | Pages     |
    //  |-----------------------------------|
    //  |       Status                      |
    //  -------------------------------------
    //
    //

    RECT clientRect;
    RECT rectStatusBar;
    RECT rectToolBar;
    RECT rectWG;
    RECT rectAG;
    RECT rectDraw;
    SIZE size;
    SIZE sizeAG;

    // Get the client rectangle
    ::GetClientRect(m_hwnd, &clientRect);
    rectStatusBar = clientRect;

    // Resize the help bar and progress meter
    if (m_bStatusBarOn)
    {
        rectStatusBar.top = rectStatusBar.bottom - STATUSBAR_HEIGHT;

        ::MoveWindow(m_hwndSB, rectStatusBar.left, rectStatusBar.top,
            rectStatusBar.right - rectStatusBar.left,
            rectStatusBar.bottom - rectStatusBar.top, TRUE);
    }
    else
    {
        // Status bar is off - set it's height to zero
        rectStatusBar.top = rectStatusBar.bottom;
    }

    // Resize the tool and width windows
    m_TB.GetNaturalSize(&size);
    rectToolBar.left  = 0;
    rectToolBar.right = rectToolBar.left + size.cx;
    rectToolBar.top =  0;
    rectToolBar.bottom = rectToolBar.top + size.cy;

    m_WG.GetNaturalSize(&size);
    rectWG.left = rectToolBar.left;
    rectWG.top = rectToolBar.bottom;
    rectWG.bottom = rectWG.top + size.cy;

    if (!m_bToolBarOn)
    {
        // Toolbar is either off or floating - set its width to zero
        rectToolBar.right = rectToolBar.left;
    }
    rectWG.right = rectToolBar.right;

    // Position attribute group
    m_AG.GetNaturalSize(&sizeAG);

    ::MoveWindow(m_AG.m_hwnd, rectToolBar.left, rectStatusBar.top - sizeAG.cy,
        clientRect.right - rectToolBar.left, sizeAG.cy, TRUE);

    // finish fiddling with tools and widths bars
    if (m_bToolBarOn)
    {
        //
        // We make the toolbar, which includes the width bar, extend all
        // down the left side.
        //
        rectToolBar.bottom = rectStatusBar.top - sizeAG.cy;
        rectWG.left += TOOLBAR_MARGINX;
        rectWG.right -= 2*TOOLBAR_MARGINX;

        ::MoveWindow(m_TB.m_hwnd, rectToolBar.left,
            rectToolBar.top, rectToolBar.right - rectToolBar.left,
            rectToolBar.bottom - rectToolBar.top, TRUE);

        ::MoveWindow(m_WG.m_hwnd, rectWG.left, rectWG.top,
            rectWG.right - rectWG.left, rectWG.bottom - rectWG.top, TRUE);

        ::BringWindowToTop(m_WG.m_hwnd);
    }

    // Resize the drawing pane
    rectDraw = clientRect;
    rectDraw.bottom = rectStatusBar.top - sizeAG.cy;
    rectDraw.left   = rectToolBar.right;
    ::MoveWindow(m_drawingArea.m_hwnd, rectDraw.left, rectDraw.top,
        rectDraw.right - rectDraw.left, rectDraw.bottom - rectDraw.top, TRUE);

    // Check to see if Width group is overlapping Attributes group. This can happen if
    // the menu bar has wrapped because the window isn't wide enough (bug 424)
    RECT crWidthWnd;
    RECT crAttrWnd;

    ::GetWindowRect(m_WG.m_hwnd, &crWidthWnd);
    ::GetWindowRect(m_AG.m_hwnd, &crAttrWnd);

    if (crAttrWnd.top < crWidthWnd.bottom)
    {
        // the menu bar has wrapped and our height placements are wrong. Adjust window
        // by difference and try again
        RECT crMainWnd;

        ::GetWindowRect(m_hwnd, &crMainWnd);
        crMainWnd.bottom += (crWidthWnd.bottom - crAttrWnd.top + ::GetSystemMetrics(SM_CYFIXEDFRAME));

        ::MoveWindow(m_hwnd, crMainWnd.left, crMainWnd.top,
            crMainWnd.right - crMainWnd.left, crMainWnd.bottom - crMainWnd.top,
            FALSE);

        // this is going to recurse but the adjustment will happen only once.....
    }
}


//
//
// Function:    WbMainWindow::OnGetMinMaxInfo
//
// Purpose:     Set the minimum and maximum tracking sizes of the window
//
//
void WbMainWindow::OnGetMinMaxInfo(LPMINMAXINFO lpmmi)
{
    if (m_TB.m_hwnd == NULL)
        return; // not ready to do this yet

    SIZE    csFrame;
    SIZE    csSeparator;
    SIZE    csAG;
    SIZE    csToolBar;
    SIZE    csWidthBar;
    SIZE    csStatusBar;
    RECT    rectStatusBar;
    SIZE    csMaxSize;
    SIZE    csScrollBars;

    csFrame.cx = ::GetSystemMetrics(SM_CXSIZEFRAME);
    csFrame.cy = ::GetSystemMetrics(SM_CYSIZEFRAME);

    csSeparator.cx = ::GetSystemMetrics(SM_CXEDGE);
    csSeparator.cy = ::GetSystemMetrics(SM_CYEDGE);

    csScrollBars.cx = ::GetSystemMetrics(SM_CXVSCROLL);
    csScrollBars.cy = ::GetSystemMetrics(SM_CYHSCROLL);

    m_AG.GetNaturalSize(&csAG);

    m_TB.GetNaturalSize(&csToolBar);
    m_WG.GetNaturalSize(&csWidthBar);

    csStatusBar.cx = 0;
    if (m_bStatusBarOn)
    {
        csStatusBar.cy = STATUSBAR_HEIGHT;
    }
    else
    {
        csStatusBar.cy = 0;
    }

    // Set the minimum width and height of the window
    lpmmi->ptMinTrackSize.x =
      csFrame.cx + csAG.cx + csFrame.cx;

    lpmmi->ptMinTrackSize.y =
      csFrame.cy +
      GetSystemMetrics( SM_CYCAPTION ) +
      GetSystemMetrics( SM_CYMENU ) +
      csToolBar.cy +
      csWidthBar.cy +
      csSeparator.cy +
      csAG.cy +
      csSeparator.cy +
      csStatusBar.cy +
      csFrame.cy ;

    //
    // Retrieves the size of the work area on the primary display monitor. The work
    // area is the portion of the screen not obscured by the system taskbar or by
    // application desktop toolbars
    //
    RECT rcWorkArea;
    ::SystemParametersInfo( SPI_GETWORKAREA, 0, (&rcWorkArea), NULL );
    csMaxSize.cx = rcWorkArea.right - rcWorkArea.left;
    csMaxSize.cy = rcWorkArea.bottom - rcWorkArea.top;

    lpmmi->ptMaxPosition.x  = 0;
    lpmmi->ptMaxPosition.y  = 0;
    lpmmi->ptMaxSize.x      = csMaxSize.cx;
    lpmmi->ptMaxSize.y      = csMaxSize.cy;
    lpmmi->ptMaxTrackSize.x = csMaxSize.cx;
    lpmmi->ptMaxTrackSize.y = csMaxSize.cy;
}


//
//
// Function:    WbMainWindow::CreateContextMenus
//
// Purpose:     Create the pop-up context menus: used within the application
//              drawing area.
//
//
BOOL WbMainWindow::CreateContextMenus(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CreateContextMenus");

    m_hContextMenuBar = ::LoadMenu(g_hInstance, MAKEINTRESOURCE(CONTEXTMENU));
    if (!m_hContextMenuBar)
    {
        ERROR_OUT(("Failed to create context menu"));
        DefaultExceptionHandler(WBFE_RC_WINDOWS, 0);
        return FALSE;
    }
    m_hContextMenu = ::GetSubMenu(m_hContextMenuBar, 0);

    m_hGrobjContextMenuBar = ::LoadMenu(g_hInstance, MAKEINTRESOURCE(GROBJMENU));
    if (!m_hGrobjContextMenuBar)
    {
        ERROR_OUT(("Failed to create grobj context menu"));
        DefaultExceptionHandler(WBFE_RC_WINDOWS, 0);
        return FALSE;
    }
    m_hGrobjContextMenu = ::GetSubMenu(m_hGrobjContextMenuBar, 0);

    // make parts of m_hGrobjContextMenu be owner draw
    ::ModifyMenu(m_hGrobjContextMenu, IDM_WIDTH_1, MF_ENABLED | MF_OWNERDRAW,
                                 IDM_WIDTH_1, NULL);
    ::ModifyMenu(m_hGrobjContextMenu, IDM_WIDTH_2, MF_ENABLED | MF_OWNERDRAW,
                                 IDM_WIDTH_2, NULL);
    ::ModifyMenu(m_hGrobjContextMenu, IDM_WIDTH_3, MF_ENABLED | MF_OWNERDRAW,
                                 IDM_WIDTH_3, NULL);
    ::ModifyMenu(m_hGrobjContextMenu, IDM_WIDTH_4, MF_ENABLED | MF_OWNERDRAW,
                                 IDM_WIDTH_4, NULL);

    return TRUE;
}




//
//
// Function:    WbMainWindow::InitializeMenus
//
// Purpose:     Initialise the menus: set up owner-drawn menu items and
//              those read from options file.
//
//
void WbMainWindow::InitializeMenus(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::InitializeMenus");

    // Make the width menu ownerdraw
    HMENU hMenu = GetMenuWithItem(::GetMenu(m_hwnd), IDM_WIDTH_1);
    if (hMenu != NULL)
    {
        // Change each entry to be ownerdraw (loop until failure)
        int iIndex;
        UINT uiId;
        int iCount = ::GetMenuItemCount(hMenu);

        for (iIndex = 0; iIndex < iCount; iIndex++)
        {
            uiId = ::GetMenuItemID(hMenu, iIndex);
            ::ModifyMenu(hMenu, iIndex,
                        MF_BYPOSITION
                      | MF_ENABLED
                      | MF_OWNERDRAW,
                      uiId,
                      NULL);
        }
    }
}




//
//
// Function:    WbMainWindow::OnMeasureItem
//
// Purpose:     Return the size of an item in the widths menu
//
//
void WbMainWindow::OnMeasureItem
(
    int                 nIDCtl,
    LPMEASUREITEMSTRUCT measureStruct
)
{
    // Check that this is for a color menu item
    if (    (measureStruct->itemID >= IDM_WIDTHS_START)
         && (measureStruct->itemID < IDM_WIDTHS_END))
    {
        measureStruct->itemWidth  = ::GetSystemMetrics(SM_CXMENUCHECK) +
            (2 * CHECKMARK_BORDER_X) + COLOR_MENU_WIDTH;
        measureStruct->itemHeight = ::GetSystemMetrics(SM_CYMENUCHECK) +
            (2 * CHECKMARK_BORDER_Y);
    }
}

//
//
// Function:    WbMainWindow::OnDrawItem
//
// Purpose:     Draw an item in the color menu
//
//
void WbMainWindow::OnDrawItem
(
    int     nIDCtl,
    LPDRAWITEMSTRUCT drawStruct
)
{
    COLORREF crMenuBackground;
    COLORREF crMenuText;
    HPEN     hOldPen;
    HBRUSH      hOldBrush;
    COLORREF crOldBkgnd;
    COLORREF crOldText;
    int         nOldBkMode;
    HBITMAP hbmp = NULL;
    BITMAP  bitmap;
    UINT    uiCheckWidth;
    UINT    uiCheckHeight;
    RECT    rect;
    RECT    rectCheck;
    RECT    rectLine;
    HDC     hMemDC;
    UINT    uiWidthIndex;
    UINT    uiWidth;
    HPEN    hPenMenu;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnDrawItem");

    // Check that this is a width menu item
    if( (drawStruct->itemID < IDM_WIDTHS_START) ||
        (drawStruct->itemID >= IDM_WIDTHS_END) )
    {
        return;
    }

    // get menu item colors
    if( (drawStruct->itemState & ODS_SELECTED) ||
        ((drawStruct->itemState & (ODS_SELECTED |ODS_CHECKED)) ==
            (ODS_SELECTED |ODS_CHECKED))
        )
    {
        crMenuBackground = COLOR_HIGHLIGHT;
        crMenuText = COLOR_HIGHLIGHTTEXT;
    }
    else if( drawStruct->itemState & ODS_GRAYED)
    {
        crMenuBackground = COLOR_MENU;
        crMenuText = COLOR_GRAYTEXT;
    }
    else
    {
        crMenuBackground = COLOR_MENU;
        crMenuText = COLOR_MENUTEXT;
    }

    hPenMenu = ::CreatePen(PS_SOLID, 0, ::GetSysColor(crMenuBackground));
    if (!hPenMenu)
    {
        TRACE_MSG(("Failed to create penMenu"));
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
        goto bail_out;
    }

    rect = drawStruct->rcItem;

    // Fill the whole box with current menu background color
    hOldPen     = SelectPen(drawStruct->hDC, hPenMenu);
    hOldBrush   = SelectBrush(drawStruct->hDC, GetSysColorBrush(crMenuBackground));

    ::Rectangle(drawStruct->hDC, rect.left, rect.top, rect.right, rect.bottom);

    SelectBrush(drawStruct->hDC, hOldBrush);
    SelectPen(drawStruct->hDC, hOldPen);

    if( (hbmp = (HBITMAP)LoadImage( NULL, MAKEINTRESOURCE( OBM_CHECK ), IMAGE_BITMAP,
                0,0, 0 ))
        == NULL )
    {
        TRACE_MSG(("Failed to create check image"));
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
        goto bail_out;
    }

    // Get the width and height of the bitmap (allowing some border)
    ::GetObject(hbmp, sizeof(BITMAP), &bitmap);
    uiCheckWidth  = bitmap.bmWidth  + (2 * CHECKMARK_BORDER_X);
    uiCheckHeight = bitmap.bmHeight;

    // Draw in a checkmark (if needed)
    if (drawStruct->itemState & ODS_CHECKED)
    {
        hMemDC = ::CreateCompatibleDC(drawStruct->hDC);
        if (!hMemDC)
        {
            ERROR_OUT(("Failed to create memDC"));
            ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
            goto bail_out;
        }

        crOldBkgnd = ::SetBkColor(drawStruct->hDC, GetSysColor( crMenuBackground ) );
        crOldText = ::SetTextColor(drawStruct->hDC, GetSysColor( crMenuText ) );
        nOldBkMode = ::SetBkMode(drawStruct->hDC, OPAQUE );

        HBITMAP hOld = SelectBitmap(hMemDC, hbmp);

        if (hOld != NULL)
        {
            rectCheck = rect;
            rectCheck.top += ((rectCheck.bottom - rectCheck.top)/2 - uiCheckHeight/2);
            rectCheck.right  = rectCheck.left + uiCheckWidth;
            rectCheck.bottom = rectCheck.top + uiCheckHeight;

            ::BitBlt(drawStruct->hDC, rectCheck.left,
                        rectCheck.top,
                        rectCheck.right - rectCheck.left,
                        rectCheck.bottom - rectCheck.top,
                        hMemDC,
                        0,
                        0,
                        SRCCOPY);

            SelectBitmap(hMemDC, hOld);
        }

        ::SetBkMode(drawStruct->hDC, nOldBkMode);
        ::SetTextColor(drawStruct->hDC, crOldText);
        ::SetBkColor(drawStruct->hDC, crOldBkgnd);

        ::DeleteDC(hMemDC);
    }

    DeleteBitmap(hbmp);

    // Allow room for the checkmark to the left of the color
    rect.left += uiCheckWidth;

    uiWidthIndex = drawStruct->itemID - IDM_WIDTHS_START;
    uiWidth = g_PenWidths[uiWidthIndex];

    // If pens are very wide they can be larger than the allowed rectangle.
    // So we reduce the clipping rectangle here. We save the DC so that we
    // can restore it - getting the clip region back.
    if (::SaveDC(drawStruct->hDC) == 0)
    {
        ERROR_OUT(("Failed to save DC"));
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
        goto bail_out;
    }

    if (::IntersectClipRect(drawStruct->hDC, rect.left, rect.top,
        rect.right, rect.bottom) == ERROR)
    {
        ERROR_OUT(("Failed to set clip rect"));

        ::RestoreDC(drawStruct->hDC, -1);
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
        goto bail_out;
    }

    hOldPen   = SelectPen(drawStruct->hDC, hPenMenu);
    hOldBrush = SelectBrush(drawStruct->hDC, GetSysColorBrush(crMenuText));

    rectLine.left = rect.left;
    rectLine.top    = rect.top + ((rect.bottom - rect.top) / 2) - uiWidth/2;
    rectLine.right= rect.right - ((rect.right - rect.left) / 6);
    rectLine.bottom = rectLine.top + uiWidth + 2;

    ::Rectangle(drawStruct->hDC, rectLine.left, rectLine.top,
        rectLine.right, rectLine.bottom);

    SelectBrush(drawStruct->hDC, hOldBrush);
    SelectPen(drawStruct->hDC, hOldPen);

    ::RestoreDC(drawStruct->hDC, -1);

bail_out:
    if (hPenMenu != NULL)
    {
        ::DeletePen(hPenMenu);
    }
}



//
//
// Function:    OnSetFocus
//
// Purpose:     The window is getting the focus
//
//
void WbMainWindow::OnSetFocus(void)
{
    // We pass the focus on to the main drawing area
    ::SetFocus(m_drawingArea.m_hwnd);
}


//
//
// Function:    UpdateStatus
//
// Purpose:     Set the text in the status bar
//
//
void WbMainWindow::UpdateStatus()
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::UpdateStatus");

    //
    // Update the current and last page numbers
    //
    m_AG.SetCurrentPageNumber(g_pwbCore->WBP_PageNumberFromHandle(m_hCurrentPage));
    m_AG.SetLastPageNumber(g_pwbCore->WBP_ContentsCountPages());

    //
    // Update the user information with the page.
    //
    if (m_pLocalUser != NULL)
    {
        m_pLocalUser->SetPage(m_hCurrentPage);
    }
}



//
//
// Function:    SetMenuState
//
// Purpose:     Sets menu contents to their correct enabled/disabled state
//
//
void WbMainWindow::SetMenuStates(HMENU hInitMenu)
{
    BOOL  bLocked;
    BOOL  bPageOrderLocked;
    BOOL  bPresentationMode;
    UINT  uiEnable;
    UINT  uiCountPages;
    BOOL  bIdle;
    BOOL  bSelected;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::SetMenuStates");

    //
    // Check menu exists
    //
    if (hInitMenu == NULL)
    {
        WARNING_OUT(("Menu doesn't exist"));
        return;
    }

    HMENU hMainMenu = ::GetMenu(m_hwnd);

    // Get the window's main menu and check that the menu
    // now being popped up is one on the top-level. (We do not
    // seem to be able to associate the index number passed with
    // sub-menus easily.)
    if ((hInitMenu != m_hContextMenu) && (hInitMenu != m_hGrobjContextMenu))
    {
        BOOL bTopLevel = FALSE;

        int nCount = ::GetMenuItemCount(hMainMenu);

        for (int nNext = 0; nNext < nCount; nNext++)
        {
            HMENU hNextMenu = ::GetSubMenu(hMainMenu, nNext);
            if (hNextMenu != NULL)
            {
                if (hNextMenu == hInitMenu)
                {
                    bTopLevel = TRUE;
                    break;
                }
            }
        }

        // not a top level, so leave the function now
        if (!bTopLevel)
        {
            TRACE_DEBUG(("Not top-level menu"));
            return;
        }
    }

    // Get the lock and selection states:
    // If we are joining a call, we cannot assume that the contents
    // and user/client details have been created yet, so just set the
    // locked state to true.
    bIdle     = IsIdle();
    bSelected = m_drawingArea.GraphicSelected();
    TRACE_DEBUG(("m_uiState %d", m_uiState));
    if ((m_uiState == STARTING) || (m_uiState == JOINING))
    {
        TRACE_DEBUG(("Not initilalised yet"));
        bLocked           = TRUE;
        bPageOrderLocked  = TRUE;
        bPresentationMode = TRUE;
        uiCountPages      = 1;
    }
    else
    {
        //
        // Note that bLocked and bPageOrderLocked are always true when
        // we're not in idle state.
        //
        uiCountPages      = g_pwbCore->WBP_ContentsCountPages();
        bLocked           = (WB_Locked() || !bIdle);
        bPageOrderLocked  = (WB_Locked() || !bIdle);
        bPresentationMode = (((m_uiState == IN_CALL) &&
                              (WB_PresentationMode()))
                            || (!bIdle));
    }

    //
    // Functions which are disabled when contents is locked
    //
    uiEnable = MF_BYCOMMAND | (bLocked ? MF_GRAYED : MF_ENABLED);

    ::EnableMenuItem(hInitMenu, IDM_OPEN,    uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_SAVE,    uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_SAVE_AS, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_PRINT,   uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_GRAB_AREA, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_GRAB_WINDOW, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_SELECTALL, uiEnable);

    ::EnableMenuItem(hInitMenu, IDM_SELECT,    uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_PEN, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_HIGHLIGHT, uiEnable);

    // Don't allow editing in zoom mode
    if( m_drawingArea.Zoomed() )
        ::EnableMenuItem(hInitMenu, IDM_TEXT, MF_GRAYED);
    else
        ::EnableMenuItem(hInitMenu, IDM_TEXT, uiEnable);

    ::EnableMenuItem(hInitMenu, IDM_CLEAR_PAGE, uiEnable);

    ::EnableMenuItem(hInitMenu, IDM_ERASER, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_LINE, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_BOX, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_FILLED_BOX, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_ELLIPSE, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_FILLED_ELLIPSE, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_ZOOM, uiEnable);


    // So toolbar will follow menu (MFC-auto-update is broken for this)
    EnableToolbar( !bLocked );


    //
    // File/New is disabled if page order is locked, or not in a call,
    // or a new is already in progress.
    //
    ::EnableMenuItem(hInitMenu, IDM_NEW, MF_BYCOMMAND |
      (bPageOrderLocked ? MF_GRAYED : MF_ENABLED));

    //
    // Paste enabled only if not locked, and there's something in the
    // clipboard
    //
    uiEnable = MF_BYCOMMAND | MF_ENABLED;
    if (   (CLP_AcceptableClipboardFormat() == NULL)
        || (bLocked))
    {
        // No acceptable format available, or the contents
        // are locked by another user - gray the Paste command.
        uiEnable = MF_BYCOMMAND | MF_GRAYED;
    }
    ::EnableMenuItem(hInitMenu, IDM_PASTE, uiEnable);

    //
    // Functions which require a graphic to be selected
    //
    uiEnable = MF_BYCOMMAND | MF_ENABLED;
    if( !m_drawingArea.TextEditActive() )
    {
        if (!bSelected || bLocked)
        {
            // No acceptable format available - gray the menu item
            uiEnable = MF_BYCOMMAND | MF_GRAYED;
        }
    }

    ::EnableMenuItem(hInitMenu, IDM_CUT, uiEnable);

    // don't do textedit delete for now
    if( m_drawingArea.TextEditActive() )
        ::EnableMenuItem(hInitMenu, IDM_DELETE, MF_BYCOMMAND | MF_GRAYED);
    else
        ::EnableMenuItem(hInitMenu, IDM_DELETE, uiEnable);

    ::EnableMenuItem(hInitMenu, IDM_BRING_TO_TOP, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_SEND_TO_BACK, uiEnable);

    //
    // Can copy even if contents are locked
    //
    //COMMENT BY RAND - To fix 556 I changed !bIdle to bIdle like the current
    //                    16bit code does.
    ::EnableMenuItem(hInitMenu, IDM_COPY, MF_BYCOMMAND |
      (m_drawingArea.TextEditActive()||(bSelected && bIdle)
        ? MF_ENABLED : MF_GRAYED));    //CHANGED BY RAND for 556

    //
    // Object to undelete?
    //
    ::EnableMenuItem(hInitMenu, IDM_UNDELETE, MF_BYCOMMAND |
      ((m_LastDeletedGraphic.GotTrash() &&
        (m_LastDeletedGraphic.Page() == m_hCurrentPage) &&
        (!bLocked)) ? MF_ENABLED : MF_GRAYED));

    //
    // Page functions depend on number of pages
    //
    ::EnableMenuItem(hInitMenu, IDM_DELETE_PAGE, MF_BYCOMMAND |
      ((bPageOrderLocked ||
       (uiCountPages == 1)||
       (!m_bUnlockStateSettled))
        ? MF_GRAYED : MF_ENABLED));

    uiEnable = MF_BYCOMMAND | MF_ENABLED;
    if ((bPageOrderLocked) ||
       (uiCountPages == WB_MAX_PAGES)||
       (!m_bUnlockStateSettled))
    {
        uiEnable = MF_BYCOMMAND | MF_GRAYED;
    }
    ::EnableMenuItem(hInitMenu, IDM_PAGE_INSERT_BEFORE, uiEnable);
    ::EnableMenuItem(hInitMenu, IDM_PAGE_INSERT_AFTER, uiEnable);

    //
    // Can't bring up page sorter if locked
    //
    ::EnableMenuItem(hInitMenu, IDM_PAGE_SORTER, MF_BYCOMMAND |
      (bPresentationMode ? MF_GRAYED : MF_ENABLED));

    // Enable page controls
    m_AG.EnablePageCtrls(!bPresentationMode);

    //
    // Lock enabled only if not already locked
    //
    ::EnableMenuItem(hInitMenu, IDM_LOCK, MF_BYCOMMAND |
      (bPageOrderLocked ? MF_GRAYED : MF_ENABLED));

    //
    // Enable sync if not in "presentation" mode
    //
    ::EnableMenuItem(hInitMenu, IDM_SYNC, MF_BYCOMMAND |
      (((!bPresentationMode) && bIdle) ? MF_ENABLED : MF_GRAYED));

    //
    // Gray font/color/widths if inappropriate for current tool.
    //
    ::EnableMenuItem(hInitMenu, IDM_FONT, MF_BYCOMMAND |
        (!bLocked && m_pCurrentTool->HasFont() ? MF_ENABLED : MF_GRAYED));

    ::EnableMenuItem(hInitMenu, IDM_EDITCOLOR, MF_BYCOMMAND |
        (!bLocked && m_pCurrentTool->HasColor() ? MF_ENABLED : MF_GRAYED));


    // enable width menu (bug 433)
    HMENU hOptionsMenu = ::GetSubMenu(hMainMenu, MENUPOS_OPTIONS);
    uiEnable = (!bLocked && m_pCurrentTool->HasWidth())?MF_ENABLED:MF_GRAYED;

    if (hOptionsMenu == hInitMenu )
        ::EnableMenuItem(hOptionsMenu, OPTIONSPOS_WIDTH, MF_BYPOSITION | uiEnable );

    UINT i;
    UINT uIdmCurWidth = 0;
    if( uiEnable == MF_ENABLED )
        uIdmCurWidth = m_pCurrentTool->GetWidthIndex() + IDM_WIDTH_1;

    // set width state(bug 426)
    for( i=IDM_WIDTH_1; i<=IDM_WIDTH_4; i++ )
    {
        ::EnableMenuItem(hInitMenu,  i, uiEnable );

        if( uiEnable == MF_ENABLED )
        {
            if( uIdmCurWidth == i )
                ::CheckMenuItem(hInitMenu, i, MF_CHECKED );
            else
                ::CheckMenuItem(hInitMenu, i, MF_UNCHECKED );
        }
    }
}


//
//
// Function:    OnInitMenuPopup
//
// Purpose:     Process a WM_INITMENUPOPUP event
//
//
void WbMainWindow::OnInitMenuPopup
(
    HMENU   hMenu,
    UINT    uiIndex,
    BOOL    bSystemMenu
)
{

    // 1/2 of fix for strange MFC4.2 build bug that clogs up DCL's message pipe.
    // The other 1/2 and a better comment are in LoadFile().
    if( m_bIsWin95 )
    {
        if( GetSubState() == SUBSTATE_LOADING )
        {
            ::SetFocus(m_drawingArea.m_hwnd);
            return;
        }
   }


    // Ignore the event if it relates to the system menu
    if (!bSystemMenu)
    {
        if (hMenu)
        {
            SetMenuStates(hMenu);
            m_hInitMenu = hMenu;
        }
        else
        {
            m_hInitMenu = NULL;
        }

        // Save the last menu we handled, so that we can alter its state
        // if necessary whilst it is still visible
    }
}


//
//
// Function : OnMenuSelect
//
// Purpose  : Update the text in the help bar
//
//
void WbMainWindow::OnMenuSelect(UINT uiItemID, UINT uiFlags, HMENU hSysMenu)
{
    UINT   firstMenuId;
    UINT   statusId;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnMenuSelect");

    //
    // Work out the help ID for the menu item.  We have to store this now
    // because when the user presses F1 from a menu item, we can't tell
    // which item it was.
    //
    if (uiFlags == (UINT)-1)
    {
        //
        // The menu has been dismissed
        //
        m_hInitMenu = NULL;
        statusId   = IDS_DEFAULT;

        if( hSysMenu == 0 )
            {
            // Menu was dismissed, check cursor loc.
            DCWbGraphic *pGraphic;

            POINT surfacePos;
            ::GetCursorPos( &surfacePos );
            ::ScreenToClient(m_drawingArea.m_hwnd, &surfacePos);
            m_drawingArea.ClientToSurface(&surfacePos );

            if( (pGraphic = m_drawingArea.GetHitObject( surfacePos )) == NULL )
                {
                // we clicked dead air, don't lose current selection (bug 426)
                m_drawingArea.SetLClickIgnore( TRUE );
                }
            else
                delete pGraphic; // plug leak
            }
    }
    else if ((uiFlags & MF_POPUP) && (uiFlags & MF_SYSMENU))
    {
        //
        // System menu selected
        //
        statusId   = IDS_MENU_SYSTEM;
    }
    else if (uiFlags & MF_POPUP)
    {
        // get popup menu handle and first item (bug NM4db:463)
        HMENU hPopup = ::GetSubMenu( hSysMenu, uiItemID );
        firstMenuId = ::GetMenuItemID( hPopup, 0 );

        // figure out which popup it is so we can display the right help text
        switch (firstMenuId)
        {
            case IDM_NEW:
                statusId   = IDS_MENU_FILE;
                break;

            case IDM_DELETE:
                statusId   = IDS_MENU_EDIT;
                break;

            case IDM_TOOL_BAR_TOGGLE:
                statusId   = IDS_MENU_VIEW;
                break;

            case IDM_EDITCOLOR:
                // The first item in the options menu is the color popup
                // menu - popup menus have Id -1
                statusId   = IDS_MENU_OPTIONS;
                break;

            case IDM_TOOLS_START:
                statusId   = IDS_MENU_TOOLS;
                break;

            case IDM_HELP:
                statusId = IDS_MENU_HELP;
                break;

            case IDM_WIDTH_1: // (added for bug NM4db:463)
                statusId   = IDS_MENU_WIDTH;
                break;

            default:
                statusId   = IDS_DEFAULT;
                break;
        }
    }
    else
    {
        //
        // A normal menu item has been selected
        //
        statusId   = uiItemID;
    }

    // Set the new help text
    TCHAR   szStatus[256];

    if (::LoadString(g_hInstance, statusId, szStatus, 256))
    {
        ::SetWindowText(m_hwndSB, szStatus);
    }
}


//
//
// Function:    OnParentNotfiy
//
// Purpose:     Process a message coming from a child window
//
//
void WbMainWindow::OnParentNotify(UINT uiMessage)
{
    switch (uiMessage)
    {
        // Scroll message from the drawing area. These are sent when the user
        // scrolls the area using the scroll bars. We queue an update of the
        // current sync position.
        case WM_HSCROLL:
        case WM_VSCROLL:
            // The user's view has changed
            PositionUpdated();
            break;
    }
}


//
//
// Function:    QuerySaveRequired
//
// Purpose:     Check whether the drawing pane contents are to be saved
//              before a destructive function is performed.
//
//
int WbMainWindow::QuerySaveRequired(BOOL bCancelBtn)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::QuerySaveRequired");

    // Default the response to "no save required"
    int  iResult = IDNO;

    //
    // If we are already displaying a "Save As" dialog, dismiss it.
    //
    if (m_hwndQuerySaveDlg != NULL)
    {
        ::SendMessage(m_hwndQuerySaveDlg, WM_COMMAND,
            MAKELONG(IDCANCEL, BN_CLICKED), 0);
        ASSERT(m_hwndQuerySaveDlg == NULL);
    }

    // If any of the pages has changed - ask the user if they want to
    // save the contents of the Whiteboard.
    if (g_pwbCore->WBP_ContentsChanged())
    {
        ::SetForegroundWindow(m_hwnd); //bring us to the top first

        // SetForegroundWindow() does not work properly in Memphis when its called during a
        // SendMessage handler, specifically, when conf calls me to shutdown. The window activation
        // state is messed up or something and my window does not pop to the top. So I have to
        // force my window to the top using SetWindowPos. But even after that the titlebar is not
        // highlighted properly. I tried combinations of SetActiveWindow, SetFocus, etc but to no
        // avail. But, at least the dialog is visible so you can clear it thus fixing the
        // bug (NM4db:2103). SetForegroundWindow() works ok for Win95 and NT here without
        // having to use SetWindowPos (it doesn't hurt anyting to do it anyway so I didn't
        // do a platform check).
        ::SetWindowPos(m_hwnd, HWND_TOPMOST, 0,0, 0,0, SWP_NOMOVE | SWP_NOSIZE );       // force to top
        ::SetWindowPos(m_hwnd, HWND_NOTOPMOST, 0,0, 0,0, SWP_NOMOVE | SWP_NOSIZE );  // let go of topmost

        //
        // Display a dialog box with the relevant question
        //      LOWORD of user data is "cancel command is allowed"
        //      HIWORD of user data is "disable cancel button"
        //
        iResult = (int)DialogBoxParam(g_hInstance,
            bCancelBtn ? MAKEINTRESOURCE(QUERYSAVEDIALOGCANCEL)
                       : MAKEINTRESOURCE(QUERYSAVEDIALOG),
            m_hwnd,
            QuerySaveDlgProc,
            MAKELONG(bCancelBtn, FALSE));
    }

    return iResult;
}



//
// QuerySaveDlgProc()
// Handler for query save dialogs.  We save some flags in GWL_USER
//
INT_PTR CALLBACK QuerySaveDlgProc(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    BOOL    fHandled = FALSE;

    switch (uMessage)
    {
        case WM_INITDIALOG:
            //
            // Save away our HWND so this dialog can be cancelled if necessary
            //
            g_pMain->m_hwndQuerySaveDlg = hwnd;

            // Remember the flags we passed
            ::SetWindowLongPtr(hwnd, GWLP_USERDATA, lParam);

            // Should the cancel button be disabled?
            if (HIWORD(lParam))
                ::EnableWindow(::GetDlgItem(hwnd, IDCANCEL), FALSE);

            // Bring us to the front
            ::SetForegroundWindow(hwnd);

            fHandled = TRUE;
            break;

        case WM_CLOSE:
            // Even if the cancel button is disabled, kill the dialog
            ::PostMessage(hwnd, WM_COMMAND, IDCANCEL, 0);
            fHandled = TRUE;
            break;

        case WM_COMMAND:
            switch (GET_WM_COMMAND_ID(wParam, lParam))
            {
                case IDCANCEL:
                    //
                    // If a dialog doesn't have a cancel button or it's
                    // disabled and the user pressed the close btn, we can
                    // get here.
                    //
                    if (!LOWORD(::GetWindowLongPtr(hwnd, GWLP_USERDATA)))
                        wParam = MAKELONG(IDNO, HIWORD(wParam));
                    // FALL THRU

                case IDYES:
                case IDNO:
                    if (GET_WM_COMMAND_CMD(wParam, lParam) == BN_CLICKED)
                    {
                        g_pMain->m_hwndQuerySaveDlg = NULL;

                        ::EndDialog(hwnd, GET_WM_COMMAND_ID(wParam, lParam));
                        break;
                    }
                    break;
            }
            fHandled = TRUE;
            break;
    }

    return(fHandled);
}


//
//
// Function:    OnNew
//
// Purpose:     Clear the workspace and associated filenames
//
//
void WbMainWindow::OnNew(void)
{
    int iDoNew;

    if( UsersMightLoseData( NULL, NULL ) ) // bug NM4db:418
        return;


    // check state before proceeding - if we're already doing a new, then abort
    if (   (m_uiState != IN_CALL)
        || (m_uiSubState == SUBSTATE_NEW_IN_PROGRESS))
    {
        // post an error message indicating the whiteboard is busy
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, WB_RC_BUSY);
        goto OnNewCleanup;
    }
    // if we're currently loading, then cancel the load and proceed (don't
    // prompt to save).
    else if (m_uiSubState == SUBSTATE_LOADING)
    {
        // cancel load, not releasing the page order lock, because
        // we need it immediately afterwards
        CancelLoad(FALSE);
        iDoNew = IDNO;
    }
    // otherwise prompt to save if necessary
    else
    {
        // Get confirmation for the new
        iDoNew = QuerySaveRequired(TRUE);
    }

    if (iDoNew == IDYES)
    {
        // Save the changes
        iDoNew = OnSave(FALSE);
    }

  // If the user did not cancel the operation, clear the drawing area
  if (iDoNew != IDCANCEL)
  {
      // Go to the first page, as this won't be deleted - stops flashing
      // with locking contents for each page delete
      OnFirstPage();
      GotoPosition(0, 0);

      // lock the drawing area
      LockDrawingArea();

      // Save the current lock status
      SaveLock();

      // Get the Page Order Lock (with an invisible dialog)
      BOOL bGotLock = GetLock(WB_LOCK_TYPE_PAGE_ORDER, SW_HIDE);
      if (!bGotLock)
      {
        RestoreLock();
      }
      else
      {
            UINT    uiReturn;

            // Remove all the pages
            uiReturn = g_pwbCore->WBP_ContentsDelete();
            if (uiReturn != 0)
            {
                DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
                return;
            }

        // if there is only one page, the new is implemented just as a page-
        // clear, so we don't need to go into NEW_IN_PROGRESS substate.
        if (g_pwbCore->WBP_ContentsCountPages() > 1)
        {
          // set substate to show we're doing a new
          SetSubstate(SUBSTATE_NEW_IN_PROGRESS);
        }
        else
        {
          // Restore the lock status
          RestoreLock();
        }

        // Clear the associated file name
        ZeroMemory(m_strFileName, sizeof(m_strFileName));

        // Update the window title with no file name
		UpdateWindowTitle();
      }
  }

OnNewCleanup:

  // unlock the drawing area if the new is not asynchronous
  if (   (m_uiSubState != SUBSTATE_NEW_IN_PROGRESS)
      && (!WB_ContentsLocked()))
  {
    UnlockDrawingArea();
  }

  return;
}

//
//
// Function:    OnNextPage
//
// Purpose:     Move to the next worksheet in the pages list
//
//
void WbMainWindow::OnNextPage(void)
{
    // ignore this command if in presentation mode
    if (   (m_uiState == IN_CALL)
        && (!WB_PresentationMode()))
    {
        // Go to the next page
        GotoPage(PG_GetNextPage(m_hCurrentPage));
    }
}

//
//
// Function:    OnPrevPage
//
// Purpose:     Move to the previous worksheet in the pages list
//
//
void WbMainWindow::OnPrevPage(void)
{
    // ignore this command if in presentation mode
    if (   (m_uiState == IN_CALL)
        && (!WB_PresentationMode()))
    {
        // Go to the previous page
        GotoPage(PG_GetPreviousPage(m_hCurrentPage));
    }
}

//
//
// Function:    OnFirstPage
//
// Purpose:     Move to the first worksheet in the pages list
//
//
void WbMainWindow::OnFirstPage(void)
{
    // ignore this command if in presentation mode
    if (   (m_uiState == IN_CALL)
        && (!WB_PresentationMode()))
    {
        // Go to the first page
        WB_PAGE_HANDLE   hPage;

        g_pwbCore->WBP_PageHandle(WB_PAGE_HANDLE_NULL, PAGE_FIRST, &hPage);
        GotoPage(hPage);
    }
}

//
//
// Function:    OnLastPage
//
// Purpose:     Move to the last worksheet in the pages list
//
//
void WbMainWindow::OnLastPage(void)
{
    // ignore this command if in presentation mode
    if (   (m_uiState == IN_CALL)
        && (!WB_PresentationMode()))
    {
        // Go to the last page
        WB_PAGE_HANDLE hPage;

        g_pwbCore->WBP_PageHandle(WB_PAGE_HANDLE_NULL, PAGE_LAST, &hPage);
        GotoPage(hPage);
    }
}

//
//
// Function:    OnGotoPage
//
// Purpose:     Move to the specified page (if it exists)
//
//
void WbMainWindow::OnGotoPage(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnGotoPage");

    // ignore this command if in presentation mode
    if (   (m_uiState == IN_CALL)
        && (!WB_PresentationMode()))
    {
        // Get the requested page number from the pages group
        UINT uiPageNumber = m_AG.GetCurrentPageNumber();

        // Goto the page
        GotoPageNumber(uiPageNumber);
    }
}

//
//
// Function:    GotoPage
//
// Purpose:     Move to the specified page
//
//
void WbMainWindow::GotoPage(WB_PAGE_HANDLE hPageNew)
{
    BOOL inEditField;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::GotoPage");

    inEditField = m_AG.IsChildEditField(::GetFocus());

    // If we are changing page
    if (hPageNew != m_hCurrentPage)
    {
        m_drawingArea.CancelDrawingMode();

        // Attach the new page to the drawing area
        m_hCurrentPage = hPageNew;
        m_drawingArea.Attach(m_hCurrentPage);

        // Update the local user information with the new page
        if (m_pLocalUser != NULL)
            m_pLocalUser->SetPage(m_hCurrentPage);

        // Show that we need to update the sync position
        m_bSyncUpdateNeeded = TRUE;

	    PAGE_POSITION *mapob = NULL;
		POSITION position = m_pageToPosition.GetHeadPosition();
		BOOL bFound = FALSE;
		while (position && !bFound)
		{
			mapob = (PAGE_POSITION *)m_pageToPosition.GetNext(position);
			if ( mapob && mapob->hPage == hPageNew)
			{
				bFound = TRUE;
			}
		}

        if (!bFound)
        {
            // page not in map, so go to the top-left
            //CHANGED BY RAND - to fix memory leak
            GotoPosition( 0, 0);
        }
        else
      	{
      		if(mapob)
		{
			GotoPosition(mapob->position.x, mapob->position.y);
		}
      	}
    }

    // Update the status display
    UpdateStatus();

    // set the focus back to the drawing area
    if (!inEditField)
    {
        ::SetFocus(m_drawingArea.m_hwnd);
    }
}

//
//
// Function:    GotoPageNumber
//
// Purpose:     Move to the specified page
//
//
void WbMainWindow::GotoPageNumber(UINT uiPageNumber)
{
    GotoPage(PG_GetPageNumber(uiPageNumber));
}


//
//
// Function:    GotoPosition
//
// Purpose:     Move to the specified position within the page
//
//
void WbMainWindow::GotoPosition(int x, int y)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::GotoPosition");

    // Move the drawing area to the new position
    m_drawingArea.GotoPosition(x, y);

    // The user's view has changed
    PositionUpdated();
}

//
//
// Function:    GotoSyncPosition
//
// Purpose:     Move to the the current sync position
//
//
void WbMainWindow::GotoSyncPosition(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::GotoSyncPosition");

    //
    // Get the local user to determine the new position.
    //
    if (!m_pLocalUser)
    {
        ERROR_OUT(("Skipping GotoSyncPosition; no local user object"));
        return;
    }

    m_pLocalUser->GetSyncPosition();

    //
    // If the page is different to where we are currently, get the number
    // of the page and select the current page
    //
    if (m_pLocalUser->Page() != m_hCurrentPage)
    {
        GotoPageNumber(g_pwbCore->WBP_PageNumberFromHandle(m_pLocalUser->Page()));
    }

    // Get the requested position from the user
    RECT rectVisibleUser;
    m_pLocalUser->GetVisibleRect(&rectVisibleUser);

    // Scroll to the required position
    GotoPosition(rectVisibleUser.left, rectVisibleUser.top);

    // Make sure we are zoomed / not zoomed as appropriate
    if ((m_pLocalUser->GetZoom()) != m_drawingArea.Zoomed())
    {
        OnZoom();
    }

    //
    // Reset the sync position update flag that will have been turned on by
    // the calls above.  We do not want to change the current sync position
    // when we are merely changing our position to match that set by
    // another user in the call.
    //
    m_bSyncUpdateNeeded = FALSE;

    // Inform the other users that we have changed position
    m_pLocalUser->Update();
}

//
//
// Function:    OnGotoUserPosition
//
// Purpose:     Move to the the current position of the specified user
//
//
void WbMainWindow::OnGotoUserPosition(LPARAM lParam)
{
    UINT            uiPageNumber = 1;
    WB_PAGE_HANDLE  hPage;
    WbUser  *     pUser;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnGotoUserPosition");

    //
    // If the drawing area is busy, ignore this command.  This is unlikely
    // since this command is generated by selecting a menu entry on a user
    // icon.  The user should not therefore be drawing on the page by the
    // time we get the message.
    //
    if (m_drawingArea.IsBusy())
    {
        TRACE_DEBUG(("drawing area is busy just now.."));
        return;
    }

    //
    // Get a user object (throws an exception if the handle specified is no
    // longer valid).
    //
    pUser = WB_GetUser((POM_OBJECT) lParam);
    if (!pUser)
    {
        WARNING_OUT(("Can't handle OnGotoUserPosition; can't get user object for 0x%08x", lParam));
        return;
    }

    //
    // Get the requested page from the user.
    //
    hPage = pUser->Page();

    //
    // Quit if the requested page is not valid locally.
    //
    if (hPage == WB_PAGE_HANDLE_NULL)
    {
        TRACE_DEBUG(("Page is not valid locally"));
        return;
    }

    //
    // Don't go to user's position if it's on another page and we're in
    // presentation mode (this shouldn't normally happen, since we should
    // all be on the same page, but there is a window at the start-up of
    // presentation mode.
    //
    if ( (hPage == m_hCurrentPage) ||
         (!WB_PresentationMode()) )
    {
        //
        // If the page is different to where we are currently, get the
        // number of the page and select the current page.
        //
        if (hPage != m_hCurrentPage)
        {
            uiPageNumber = g_pwbCore->WBP_PageNumberFromHandle(hPage);
            GotoPageNumber(uiPageNumber);
        }

        //
        // Get the requested position from the user and scroll to it.
        //
        RECT rectVisibleUser;
        pUser->GetVisibleRect(&rectVisibleUser);
        GotoPosition(rectVisibleUser.left, rectVisibleUser.top);

        //
        // Zoom/unzoom if the sync zoom state is different to our current
        // zoom state.
        //
        if ( (m_pLocalUser->GetZoom()) != (m_drawingArea.Zoomed()) )
        {
            TRACE_DEBUG(("Change zoom state"));
            OnZoom();
        }
    }
}

//
//
// Function:    OnGotoUserPointer
//
// Purpose:     Move to the pointer position of the specified user
//
//
void WbMainWindow::OnGotoUserPointer(LPARAM lParam)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnGotoUserPointer");

    // If the drawing area is busy, ignore this command.
    // This is unlikely since this command is generated by selecting
    // a menu entry on a user icon. The user should not therefore be
    // drawing on the page by the time we get the message.
    if (!m_drawingArea.IsBusy())
    {
        // Get a user object (throws an exception if the
        // handle specified is no longer valid).
        WbUser* pUser = WB_GetUser((POM_OBJECT) lParam);

        if (!pUser)
        {
            WARNING_OUT(("Can't handle OnGotoUserPointer; can't get user object for 0x%08x", lParam));
            return;
        }

        DCWbGraphicPointer* pPointer = pUser->GetPointer();
        ASSERT(pPointer != NULL);

        // Continue only if the user is using the pointer
        if (pPointer->IsActive())
        {
            // Get the requested page from the user
            WB_PAGE_HANDLE hPage = pPointer->Page();

            // Check that the requested page is valid locally
            if (hPage != WB_PAGE_HANDLE_NULL)
            {
                // If the pointer is on a different page, change to the
                // correct page.
                if (hPage != m_hCurrentPage)
                {
                    GotoPageNumber(g_pwbCore->WBP_PageNumberFromHandle(hPage));
                }

                // Move within the page if the pointer is not wholly visible
                // in the drawing area window.
                RECT rectPointer;
                RECT rcVis;
                RECT rcT;

                pPointer->GetBoundsRect(&rectPointer);
                m_drawingArea.GetVisibleRect(&rcVis);

                ::IntersectRect(&rcT, &rcVis, &rectPointer);
                if (!::EqualRect(&rcT, &rectPointer))
                {
                    // Adjust the position so that the pointer is shown
                    // in the centre of the window.
                    POINT   position;
                    SIZE    size;

                    position.x = rectPointer.left;
                    position.y = rectPointer.top;

                    size.cx = (rcVis.right - rcVis.left) - (rectPointer.right - rectPointer.left);
                    size.cy = (rcVis.bottom - rcVis.top) - (rectPointer.bottom - rectPointer.top);

                    position.x += -size.cx / 2;
                    position.y += -size.cy / 2;

                    // Scroll to the required position
                    GotoPosition(position.x, position.y);
                }
            }
        }
    }
}


//
//
// Function:    LoadFile
//
// Purpose:     Load a metafile into the application. Errors are reported
//              to the caller by the return code.
//
//
void WbMainWindow::LoadFile
(
    LPCSTR szLoadFileName
)
{
    UINT    uRes;

    // Check we're in idle state
    if (!IsIdle())
    {
        // post an error message indicating the whiteboard is busy
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, WB_RC_BUSY);
        goto UserPointerCleanup;
    }

    if (*szLoadFileName)
    {
        // Change the cursor to "wait"
        ::SetCursor(::LoadCursor(NULL, IDC_WAIT));

       // Save the current lock
       SaveLock();

       // Get the Page Order Lock (with an invisible dialog)
       BOOL bGotLock = GetLock(WB_LOCK_TYPE_PAGE_ORDER, SW_HIDE);

       if (!bGotLock)
       {
           RestoreLock();
           goto UserPointerCleanup;
       }

       // Load the file
       uRes = g_pwbCore->WBP_ContentsLoad(szLoadFileName);
       if (uRes != 0)
       {
           DefaultExceptionHandler(WBFE_RC_WB, uRes);
           return;
       }

        // Set the window title to the new file name
        lstrcpy(m_strFileName, szLoadFileName);

        // Update the window title with the new file name
		UpdateWindowTitle();

        // Set the state to say that we are loading a file
        SetSubstate(SUBSTATE_LOADING);
    }

UserPointerCleanup:

    // Restore the cursor
    ::SetCursor(::LoadCursor(NULL, IDC_ARROW));
}




//
//
// Function:    OnDropFiles
//
// Purpose:     Files have been dropped onto the Whiteboard window
//
//
void WbMainWindow::OnDropFiles(HDROP hDropInfo)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnDropFiles");

    UINT  uiFilesDropped = 0;
    UINT  eachfile;

    // Get the total number of files dropped
    uiFilesDropped = ::DragQueryFile(hDropInfo, (UINT) -1, NULL, (UINT) 0);

    // release mouse capture in case we report any errors (message boxes
    // won't repsond to mouse clicks if we don't)
    ReleaseCapture();

    if( UsersMightLoseData( NULL, NULL ) ) // bug NM4db:418
        goto bail_out;

    // Don't prompt to save file if we're already loading
    int iOnSave;
    if( m_uiSubState != SUBSTATE_LOADING )
        {
        // Check whether there are changes to be saved
        iOnSave = QuerySaveRequired(TRUE);
        }
    else
        {
        goto bail_out;
        }

    if( iOnSave == IDYES )
        {
        // User wants to save the drawing area contents
        int iResult = OnSave(TRUE);

        if( iResult == IDOK )
            {
            // Update the window title with the new file name
			UpdateWindowTitle();
            }
        else
            {
            // cancelled out of save, so cancel the open operation
            goto bail_out;
            }
        }

    // see if user canceled the whole drop
    if( iOnSave == IDCANCEL )
        goto bail_out;

    for (eachfile = 0; eachfile < uiFilesDropped; eachfile++)
    {
        // Retrieve each file name
        char  szDropFileName[256];

        ::DragQueryFile(hDropInfo, eachfile,
            szDropFileName, 256);

        TRACE_MSG(("Loading file: %s", szDropFileName));

        // Load the file
        // If this is a valid whiteboard file, the action is simply to load it
        if (g_pwbCore->WBP_ValidateFile(szDropFileName, NULL) == 0)
        {
            LoadFile(szDropFileName);
        }
        else
        {
            ::Message(NULL, IDS_MSG_CAPTION,IDS_MSG_BAD_FILE_FORMAT);
        }
    }

bail_out:
    ::DragFinish(hDropInfo);
}



//
//
// Function:    OnOpen
//
// Purpose:     Load a metafile into the application.
//
//
void WbMainWindow::OnOpen(void)
{
    int iOnSave;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnOpen");

    if( UsersMightLoseData( NULL, NULL ) ) // bug NM4db:418
        return;

    // Check we're in idle state
    if ( (m_uiState != IN_CALL) || (m_uiSubState == SUBSTATE_NEW_IN_PROGRESS))
    {
        // post an error message indicating the whiteboard is busy
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, WB_RC_BUSY);
        return;
      }

    // Don't prompt to save file if we're already loading
    if (m_uiSubState != SUBSTATE_LOADING)
    {
        // Check whether there are changes to be saved
        iOnSave = QuerySaveRequired(TRUE);
    }
    else
    {
        iOnSave = IDNO;
    }

    if (iOnSave == IDYES)
    {
        // User wants to save the drawing area contents
        int iResult = OnSave(TRUE);

        if (iResult == IDOK)
        {
		    UpdateWindowTitle();
        }
        else
        {
            // cancelled out of Save As, so cancel the open operation
            iOnSave = IDCANCEL;
        }
    }

    // Only continue if the user has not cancelled the operation
    if (iOnSave != IDCANCEL)
    {
        OPENFILENAME    ofn;
        TCHAR           szFileName[_MAX_PATH];
        TCHAR           szFileTitle[64];
        TCHAR           strLoadFilter[2*_MAX_PATH];
        TCHAR           strDefaultExt[_MAX_PATH];
        TCHAR           strDefaultPath[2*_MAX_PATH];
        TCHAR *         pStr;
  	    UINT            strSize = 0;
      	UINT            totalSize;

        // Build the filter for loadable files
        pStr = strLoadFilter;
        totalSize = 2*_MAX_PATH;

        // These must be NULL separated, with a double NULL at the end
        strSize = ::LoadString(g_hInstance, IDS_FILTER_WHT, pStr, totalSize) + 1;
        pStr += strSize;
        ASSERT(totalSize > strSize);
        totalSize -= strSize;

        strSize = ::LoadString(g_hInstance, IDS_FILTER_WHT_SPEC, pStr, totalSize) + 1;
        pStr += strSize;
        ASSERT(totalSize > strSize);
        totalSize -= strSize;

        strSize = ::LoadString(g_hInstance, IDS_FILTER_ALL, pStr, totalSize) + 1;
        pStr += strSize;
        ASSERT(totalSize > strSize);
        totalSize -= strSize;

        strSize = ::LoadString(g_hInstance, IDS_FILTER_ALL_SPEC, pStr, totalSize) + 1;
        pStr += strSize;
        ASSERT(totalSize > strSize);
        totalSize -= strSize;

        *pStr = 0;

        //
        // Setup the OPENFILENAME struct
        //
        ZeroMemory(&ofn, sizeof(ofn));
        ofn.lStructSize = sizeof(ofn);
        ofn.hwndOwner = m_hwnd;

        // No file name supplied to begin with
        szFileName[0] = 0;
        ofn.lpstrFile = szFileName;
        ofn.nMaxFile = _MAX_PATH;

        // Default Extension:  .WHT
        ::LoadString(g_hInstance, IDS_EXT_WHT, strDefaultExt, sizeof(strDefaultExt));
        ofn.lpstrDefExt = strDefaultExt;

        // Default file title is empty
        szFileTitle[0] = 0;
        ofn.lpstrFileTitle = szFileTitle;
        ofn.nMaxFileTitle = 64;

        // Open flags
        ofn.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_EXPLORER;
        ofn.hInstance = g_hInstance;

        // Filter
        ofn.lpstrFilter = strLoadFilter;

        // Default path
        if (GetDefaultPath(strDefaultPath, sizeof(strDefaultPath)))
            ofn.lpstrInitialDir = strDefaultPath;

        // Get user input, continue only if the user selects the OK button
        if (::GetOpenFileName(&ofn))
        {
            // Change the cursor to "wait"
            ::SetCursor(::LoadCursor(NULL, IDC_WAIT));

            // if we're currently loading a file, cancel it, not releasing
            // the page order lock, because we need it immediately afterwards
            if (m_uiSubState == SUBSTATE_LOADING)
            {
                CancelLoad(FALSE);
            }

            // Load the file
            LoadFile(ofn.lpstrFile);
        }
    }
}




//
//
// Function:    GetFileName
//
// Purpose:     Get a file name for saving the contents
//
//
int WbMainWindow::GetFileName(void)
{
    OPENFILENAME    ofn;
    int             iResult;
    TCHAR           szFileTitle[64];
    TCHAR           strSaveFilter[2*_MAX_PATH];
    TCHAR           strDefaultExt[_MAX_PATH];
    TCHAR           strDefaultPath[2 * _MAX_PATH];
    TCHAR           szFileName[2*_MAX_PATH];
    TCHAR *         pStr;
    UINT            strSize = 0;
    UINT            totalSize;

    //
    // If we are already displaying a "Save As" dialog, dismiss it and create
    // a new one.  This can happen if Win95 shuts down whilst WB is
    // displaying the "Save As" dialog and the use selects "Yes" when asked
    // whether they want to save the contents - a second "Save As dialog
    // appears on top of the first.
    //
    if (m_bInSaveDialog)
    {
        CancelSaveDialog();
    }

    // Build the filter for save files
    pStr = strSaveFilter;
    totalSize = 2*_MAX_PATH;

    // These must be NULL separated, with a double NULL at the end
    strSize = ::LoadString(g_hInstance, IDS_FILTER_WHT, pStr, totalSize) + 1;
    pStr += strSize;
    ASSERT(totalSize > strSize);
    totalSize -= strSize;

    strSize = ::LoadString(g_hInstance, IDS_FILTER_WHT_SPEC, pStr, totalSize) + 1;
    pStr += strSize;
    ASSERT(totalSize > strSize);
    totalSize -= strSize;

    strSize = ::LoadString(g_hInstance, IDS_FILTER_ALL, pStr, totalSize) + 1;
    pStr += strSize;
    ASSERT(totalSize > strSize);
    totalSize -= strSize;

    strSize = ::LoadString(g_hInstance, IDS_FILTER_ALL_SPEC, pStr, totalSize) + 1;
    pStr += strSize;
    ASSERT(totalSize > strSize);
    totalSize -= strSize;

    *pStr = 0;

    //
    // Setup the OPENFILENAME struct
    //
    ZeroMemory(&ofn, sizeof(ofn));
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = m_hwnd;

    lstrcpy(szFileName, m_strFileName);
    ofn.lpstrFile = szFileName;
    ofn.nMaxFile = _MAX_PATH;

    // Build the default extension string
    ::LoadString(g_hInstance, IDS_EXT_WHT, strDefaultExt, sizeof(strDefaultExt));
    ofn.lpstrDefExt = strDefaultExt;

    szFileTitle[0] = 0;
    ofn.lpstrFileTitle = szFileTitle;
    ofn.nMaxFileTitle = 64;

    // Save flags
    ofn.Flags = OFN_HIDEREADONLY | OFN_NOREADONLYRETURN |
        OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST;
    ofn.hInstance = g_hInstance;

    // Filter
    ofn.lpstrFilter = strSaveFilter;

    // Default path
    if (GetDefaultPath(strDefaultPath, sizeof(strDefaultPath)))
        ofn.lpstrInitialDir = strDefaultPath;

    m_bInSaveDialog = TRUE;

    if (::GetSaveFileName(&ofn))
    {
        // The user selected OK
        iResult = IDOK;
        lstrcpy(m_strFileName, szFileName);
    }
    else
    {
        iResult = IDCANCEL;
    }

    m_bInSaveDialog = FALSE;

    return iResult;
}

//
//
// Function:    OnSave
//
// Purpose:     Save the contents of the Whiteboard using the current file
//              name (or prompting for a new name if there is no current).
//
//
int WbMainWindow::OnSave(BOOL bPrompt)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnSave");

    int iResult = IDOK;

    // save the old file name in case there's an error
    TCHAR *strOldName;
    UINT fileNameSize = lstrlen(m_strFileName);
    strOldName = new TCHAR[fileNameSize+1];

    if (!strOldName)
    {
        ERROR_OUT(("OnSave: failed to allocate strOldName TCHAR array, fail"));
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, WB_RC_BUSY);
        return(iResult);
    }
    else
    {
        lstrcpy(strOldName, m_strFileName);
    }

    BOOL bNewName = FALSE;

    if (!IsIdle())
    {
        // post an error message indicating the whiteboard is busy
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, WB_RC_BUSY);
        return(iResult);
    }

    // Check whether there is a filename available for use
    if (!fileNameSize || bPrompt)
    {
        // Get user input, continue only if the user selects the OK button
        iResult = GetFileName();

        if (iResult == IDOK)
        {
            // entering a blank file name is treated as cancelling the save
            if (!lstrlen(m_strFileName))
            {
                lstrcpy(m_strFileName, strOldName);
                iResult = IDCANCEL;
            }
            else
            {
                // flag that we've changed the contents file name
                bNewName = TRUE;
            }
        }
    }

    // Now save the file
    if ((iResult == IDOK) && lstrlen(m_strFileName))
    {
        WIN32_FIND_DATA findFileData;
        HANDLE          hFind;

        // Get attributes
        hFind = ::FindFirstFile(m_strFileName, &findFileData);
        if (hFind != INVALID_HANDLE_VALUE)
        {
            ::FindClose(hFind);

            // This is a read-only file; we can't change its contents
            if (findFileData.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
            {
                WARNING_OUT(("Dest file %s is read only", m_strFileName));
                ::Message(NULL, IDS_SAVE, IDS_SAVE_READ_ONLY);

                // If the file name was changed for this save then undo
                // the change
                if (bNewName)
                {
                    lstrcpy(m_strFileName, strOldName);
                    bNewName = FALSE;
                }

                // Change the return code to indicate no save was made
                iResult = IDCANCEL;
                return(iResult);
            }
        }

        // Change the cursor to "wait"
        ::SetCursor(::LoadCursor(NULL,IDC_WAIT));

        // Write the file
        if (g_pwbCore->WBP_ContentsSave(m_strFileName) != 0)
        {
            // Show that an error occurred saving the file.
            WARNING_OUT(("Error saving file"));
            ::Message(NULL, IDS_SAVE, IDS_SAVE_ERROR);

            // If the file name was changed for this save then undo
            // the change
            if (bNewName)
            {
                lstrcpy(m_strFileName, strOldName);
                bNewName = FALSE;
            }

            // Change the return code to indicate no save was made
            iResult = IDCANCEL;
        }

        // Restore the cursor
        ::SetCursor(::LoadCursor(NULL,IDC_ARROW));
    }

    // if the contents file name has changed as a result of the save then
    // update the window title
    if (bNewName)
    {
		UpdateWindowTitle();
    }

	delete [] strOldName;
    return(iResult);
}



//
// CancelSaveDialog()
// This cancels the save as dialog if up and we need to kill it to continue.
// We walk back up the owner chain in case the save dialog puts up help or
// other owned windows.
//
void WbMainWindow::CancelSaveDialog(void)
{
    WBFINDDIALOG        wbf;

    ASSERT(m_bInSaveDialog);

    wbf.hwndOwner = m_hwnd;
    wbf.hwndDialog = NULL;
    EnumThreadWindows(::GetCurrentThreadId(), WbFindCurrentDialog, (LPARAM)&wbf);

    if (wbf.hwndDialog)
    {
        // Found it!
        ::SendMessage(wbf.hwndDialog, WM_COMMAND, IDCANCEL, 0);
    }

    m_bInSaveDialog = FALSE;
}



BOOL CALLBACK WbFindCurrentDialog(HWND hwndNext, LPARAM lParam)
{
    WBFINDDIALOG * pwbf = (WBFINDDIALOG *)lParam;

    // Is this a dialog, owned by the main window?
    if ((::GetClassLong(hwndNext, GCW_ATOM) == 0x8002) &&
        (::GetWindow(hwndNext, GW_OWNER) == pwbf->hwndOwner))
    {
        pwbf->hwndDialog = hwndNext;
        return(FALSE);
    }

    return(TRUE);
}



//
//
// Function:    OnClose
//
// Purpose:     Close the Whiteboard
//
//
void WbMainWindow::OnClose()
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnClose");

    int iOnSave = IDOK;

    KillInitDlg();

    m_drawingArea.CancelDrawingMode();
    m_drawingArea.RemoveMarker(NULL);
    m_drawingArea.GetMarker()->DeleteAllMarkers( NULL );

    m_AG.SaveSettings();

    // If we got here, by way of OnDestroy from the DCL cores or
    // by system shutdown, then assume that user responded already to the
    // save-changes dialog that would have poped up during conf's global shutdown
    // message. We don't need to ask 'em again. What tangled webs......
    if ((!m_bQuerySysShutdown) && (IsIdle()))
    {
        // Check whether there are changes to be saved
        iOnSave = QuerySaveRequired(TRUE);
        if (iOnSave == IDYES)
        {
            // User wants to save the drawing area contents
            iOnSave = OnSave(TRUE);
        }
    }

    // If the exit was not cancelled, close the application
    if (iOnSave != IDCANCEL)
    {
        // Mark state as closing - stops any queued events being processed
        m_uiState = CLOSING;

        //PUTBACK BY RAND - the progress timer meter is kinda the heart beat
        //                    of this thing which I ripped out when I removed the
        //                    progress meter. I put it back to fix 1476.
        if (m_bTimerActive)
        {
            ::KillTimer(m_hwnd, TIMERID_PROGRESS_METER);
            m_bTimerActive = FALSE;
        }

        m_drawingArea.ShutDownDC();

        // Close the application
        ::PostQuitMessage(0);
    }

}


//
//
// Function:    OnClearPage
//
// Purpose:     Clear the Whiteboard drawing area. The user is prompted to
//              choose clearing of foreground, background or both.
//
//
void WbMainWindow::OnClearPage(void)
{
    int iResult;
    BOOL bWasPosted;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnClearPage");

    if( UsersMightLoseData( &bWasPosted, NULL ) ) // bug NM4db:418
        return;

    if( bWasPosted )
        iResult = IDYES;
    else
        iResult = ::Message(NULL, IDS_CLEAR_CAPTION, IDS_CLEAR_MESSAGE, MB_YESNO | MB_ICONQUESTION);


    if (iResult == IDYES)
    {
        TRACE_MSG(("User requested clear of page"));

        // lock the drawing area
        LockDrawingArea();

        // Save the current lock status
        SaveLock();

        // Get the Page Order Lock (with an invisible dialog)
        BOOL bGotLock = GetLock(WB_LOCK_TYPE_PAGE_ORDER, SW_HIDE);

        if( bGotLock  )
        {
            // clear only if we got the page lock (NM4db:470)
            m_drawingArea.Clear();
            GotoPosition(0, 0);
        }

        RestoreLock();
        UnlockDrawingArea();
    }
}




//
//
// Function:    OnDelete
//
// Purpose:     Delete the current selection
//
//
void WbMainWindow::OnDelete()
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnDelete");

    DCWbGraphic* pGraphicCopy = NULL;

    // cleanup select logic in case object context menu called us (bug 426)
    m_drawingArea.SetLClickIgnore( FALSE );

    // If the user currently has a graphic selected
    if (m_drawingArea.GraphicSelected())
    {
      m_LastDeletedGraphic.BurnTrash();

      // Delete the currently selected graphic and add to m_LastDeletedGraphic
      m_drawingArea.DeleteSelection();
    }
}

//
//
// Function:    OnUndelete
//
// Purpose:     Undo the last delete operation
//
//
void WbMainWindow::OnUndelete()
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnUndelete");

    // If there is a deleted graphic to restore
    if ( m_LastDeletedGraphic.GotTrash() )
    {
        // If the deleted graphic belongs to the current page
        if (m_LastDeletedGraphic.Page() == m_hCurrentPage)
        {
            // Add the graphic back into the current page
            m_LastDeletedGraphic.AddToPageLast(m_hCurrentPage);

            // if the current tool is a select tool then select the new
            // graphic, otherwise forget it.
            if (m_pCurrentTool->ToolType() == TOOLTYPE_SELECT)
            {
                m_LastDeletedGraphic.SelectTrash();
                m_LastDeletedGraphic.EmptyTrash();
            }
            else
            {
                // Free the local copy
                m_LastDeletedGraphic.BurnTrash();
            }
        }
    }
}



void WbMainWindow::OnSelectAll( void )
{
    // turn off any selections
    // cleanup select logic in case object context menu called us (bug 426)
    m_drawingArea.SetLClickIgnore( FALSE );

    // inhibit normal select-tool action
    m_bSelectAllInProgress = TRUE;

    //put us in select-tool mode first
    OnSelectTool(IDM_SELECT);

    // back to normal
    m_bSelectAllInProgress = FALSE;

    // now, select everything
    m_drawingArea.SelectMarkerFromRect( NULL );
}



//
//
// Function:    DoCopy
//
// Purpose:     Copy the current selection to the clipboard
//
//
BOOL WbMainWindow::DoCopy(BOOL bRenderNow)
{
    BOOL bResult = FALSE;
    DCWbGraphicMarker *pMarker;

    DCWbGraphic* pGraphic = m_drawingArea.GetSelection();
    if (pGraphic != NULL)
        {
        pMarker = m_drawingArea.GetMarker();
        if( pMarker->GetNumMarkers() > 1 )
            {
            // more objs than just pGraphic, do a multi-object-to-clipboard
            // operation.
            pGraphic = pMarker;
            }
        //else if == 1 then pMarker contains just pGraphic already
        //    so we do a single-object-to-clipboard operation.

        // Copy the graphic (or multiple marker objects) to the clipboard
        bResult = CLP_Copy(pGraphic, bRenderNow);

        // If an error occurred during the copy, report it now
        if (!bResult)
            {
            ::Message(NULL, IDS_COPY, IDS_COPY_ERROR);
            }
        }

    return bResult;
    }

//
//
// Function:    OnCut
//
// Purpose:     Cut the current selection
//
//
void WbMainWindow::OnCut()
{
    // cleanup select logic in case object context menu called us (bug 426)
    m_drawingArea.SetLClickIgnore( FALSE );

    if (m_drawingArea.TextEditActive())
    {
        m_drawingArea.TextEditCut();
        return;
    }

    if (DoCopy(TRUE))
    {
        // Graphic copied to the clipboard OK - delete it
        m_drawingArea.DeleteSelection();
    }
}


//
// OnCopy()
// Purpose:     Copy the current selection to the clipboard
//
//
void WbMainWindow::OnCopy(void)
{
    // cleanup select logic in case object context menu called us (bug 426)
    m_drawingArea.SetLClickIgnore( FALSE );

    if( m_drawingArea.TextEditActive() )
    {
        m_drawingArea.TextEditCopy();
        return;
    }

    DoCopy(TRUE);
}


//
//
// Function:    OnPaste
//
// Purpose:     Paste the contents of the clipboard into the drawing pane
//
//
void WbMainWindow::OnPaste()
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnPaste");

    // cleanup select logic in case object context menu called us (bug 426)
    m_drawingArea.SetLClickIgnore( FALSE );

    if (m_drawingArea.TextEditActive())
    {
        m_drawingArea.TextEditPaste();
        return;
    }

    // Get the data from the clipboard
    DCWbGraphic* pGraphic = CLP_Paste();
    if (pGraphic != NULL)
            {
            TRACE_MSG(("Got graphic object from clipboard OK"));

            //CHANGED BY RAND - have to handle marker sperately,
            //                    marker objects are already added to
            //                    m_hCurrentPage and positioned
            if( pGraphic->IsGraphicTool() == enumGraphicMarker)
            {
                ((DCWbGraphicMarker *)pGraphic)->Update();
                if( m_pCurrentTool->ToolType() == TOOLTYPE_SELECT )
                    {
                    // marker is already setup, just draw it
                    m_drawingArea.PutMarker(NULL);
                    }
                else
                    {
                    // don't select anything, dump marker
                    m_drawingArea.RemoveMarker(NULL);
                    }
                }
            else // not a marker, deal with single object
                {
                    RECT    rcVis;

                    // Position the graphic at the top left of the visible area of the
                    // drawing area
                    m_drawingArea.GetVisibleRect(&rcVis);
                pGraphic->MoveTo(rcVis.left, rcVis.top);

                // Add the graphic to the page
                pGraphic->AddToPageLast(m_hCurrentPage);

                // if the current tool is a select tool then select the new
                // object, otherwise forget it.
                if( m_pCurrentTool->ToolType() == TOOLTYPE_SELECT )
                    m_drawingArea.SelectGraphic(pGraphic);
                else
                    {
                    // Free the graphic
                    delete pGraphic;
                    }
                }
            }
        else
            {
            TRACE_MSG(("Could not get graphic from clipboard"));
            // display error message instead of throwing exception
            ::Message(NULL, IDS_PASTE, IDS_PASTE_ERROR);
            }

    }


//
//
// Function:    OnRenderAllFormats
//
// Purpose:     Render all formats of the graphic last copied to the
//              CLP_
//
//
void WbMainWindow::OnRenderAllFormats(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnRenderAllFormats");
  //
  // only render something if we have not done it already
  //
    if (CLP_LastCopiedPage() != WB_PAGE_HANDLE_NULL)
    {
        if (!CLP_RenderAllFormats())
        {
            // An error occurred rendering the formats
            ERROR_OUT(("Error rendering all formats"));
        }
    }
}

//
//
// Function:    CheckMenuItem
//
// Purpose:     Check an item on the application menus (main and context
//              menu.)
//
//
void WbMainWindow::CheckMenuItem(UINT uiId)
{
    CheckMenuItemRecursive(::GetMenu(m_hwnd), uiId, MF_BYCOMMAND | MF_CHECKED);
    CheckMenuItemRecursive(m_hContextMenu, uiId, MF_BYCOMMAND | MF_CHECKED);
    CheckMenuItemRecursive(m_hGrobjContextMenu, uiId, MF_BYCOMMAND | MF_CHECKED); // bug 426
}

//
//
// Function:    UncheckMenuItem
//
// Purpose:     Uncheck an item on the application menus (main and context
//              menus.)
//
//
void WbMainWindow::UncheckMenuItem(UINT uiId)
{
    CheckMenuItemRecursive(::GetMenu(m_hwnd), uiId, MF_BYCOMMAND | MF_UNCHECKED);
    CheckMenuItemRecursive(m_hContextMenu, uiId, MF_BYCOMMAND | MF_UNCHECKED);
    CheckMenuItemRecursive(m_hGrobjContextMenu, uiId, MF_BYCOMMAND | MF_UNCHECKED); // bug 426
}

//
//
// Function:    CheckMenuItemRecursive
//
// Purpose:     Check or uncheck an item on the any of the Whiteboard menus.
//              This function recursively searches through the menus until
//              it finds the specified item. The menu item Ids must be
//              unique for this function to work.
//
//
BOOL WbMainWindow::CheckMenuItemRecursive(HMENU hMenu,
                                            UINT uiId,
                                            BOOL bCheck)
{
    UINT uiNumItems = ::GetMenuItemCount(hMenu);

    // Attempt to check the menu item
    UINT uiCheck = MF_BYCOMMAND | (bCheck ? MF_CHECKED : MF_UNCHECKED);

    // A return code of -1 from CheckMenuItem implies that
    // the menu item was not found
    BOOL bChecked = ((::CheckMenuItem(hMenu, uiId, uiCheck) == -1) ? FALSE : TRUE);
    if (bChecked)
    {
        //
        // If this item is on the active menu, ensure it's redrawn now
        //
        if (hMenu == m_hInitMenu)
        {
            InvalidateActiveMenu();
        }
    }
    else
    {
        UINT   uiPos;
        HMENU hSubMenu;

        // Recurse through the submenus of the specified menu
        for (uiPos = 0; uiPos < uiNumItems; uiPos++)
        {
            // Assume that the next item is a submenu
            // and try to get a pointer to it
            hSubMenu = ::GetSubMenu(hMenu, (int)uiPos);

            // NULL return implies the item is a not submenu
            if (hSubMenu != NULL)
            {
                // Item is a submenu, make recursive call to search it
                bChecked = CheckMenuItemRecursive(hSubMenu, uiId, bCheck);
                if (bChecked)
                {
                    // We have found the item
                    break;
                }
            }
        }
    }

    return bChecked;
}

//
//
// Function:    GetMenuWithItem
//
// Purpose:     Return the menu which contains the specified item.
//
//
HMENU WbMainWindow::GetMenuWithItem(HMENU hMenu, UINT uiID)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::GetMenuWithItem");

    ASSERT(hMenu != NULL);

    HMENU hMenuResult = NULL;

    // Get the number ofitems in the menu
    UINT uiNumItems = ::GetMenuItemCount(hMenu);
    UINT   uiPos;
    UINT   uiNextID;

    // Look for the item through the menu
    for (uiPos = 0; uiPos < uiNumItems; uiPos++)
    {
        // Get the ID of the item at this position
        uiNextID = ::GetMenuItemID(hMenu, uiPos);

        if (uiNextID == uiID)
        {
            // We have found the item
            hMenuResult = hMenu;
            break;
        }
    }

    // If we have not yet found the item
    if (hMenuResult == NULL)
    {
        // Look through each of the submenus of the current menu
        HMENU hSubMenu;

        for (uiPos = 0; uiPos < uiNumItems; uiPos++)
        {
            // Get the ID of the item at this position
            uiNextID = ::GetMenuItemID(hMenu, uiPos);

            // If the item is a submenu
            if (uiNextID == -1)
            {
                // Get the submenu
                hSubMenu = ::GetSubMenu(hMenu, (int) uiPos);

                // Search the submenu
                hMenuResult = GetMenuWithItem(hSubMenu, uiID);
                if (hMenuResult != NULL)
                {
                    // We have found the menu with the requested item
                    break;
                }
            }
        }
    }

    return hMenuResult;
}

//
//
// Function:    OnScrollAccelerator
//
// Purpose:     Called when a scroll accelerator is used
//
//
void WbMainWindow::OnScrollAccelerator(UINT uiMenuId)
{
    int     iScroll;

    // Locate the scroll messages to be sent in the conversion table
    for (iScroll = 0; iScroll < ARRAYSIZE(s_MenuToScroll); iScroll++)
    {
        if (s_MenuToScroll[iScroll].uiMenuId == uiMenuId)
        {
            // Found it;
            break;
        }
    }

    // Send the messages
    if (iScroll < ARRAYSIZE(s_MenuToScroll))
    {
        while ((s_MenuToScroll[iScroll].uiMenuId == uiMenuId) && (iScroll < ARRAYSIZE(s_MenuToScroll)))
        {
            // Tell the drawing pane to scroll
            ::PostMessage(m_drawingArea.m_hwnd, s_MenuToScroll[iScroll].uiMessage,
                s_MenuToScroll[iScroll].uiScrollCode, 0);

            iScroll++;
        }

        // Indicate that scrolling has completed (in both directions)
        ::PostMessage(m_drawingArea.m_hwnd, WM_HSCROLL, SB_ENDSCROLL, 0L);
        ::PostMessage(m_drawingArea.m_hwnd, WM_VSCROLL, SB_ENDSCROLL, 0L);
    }
}



//
//
// Function:    OnZoom
//
// Purpose:     Zoom or unzoom the drawing area
//
//
void WbMainWindow::OnZoom()
{
    // If the drawing area is currently zoomed
    if (m_drawingArea.Zoomed())
    {
        // Remove the zoomed check mark
        UncheckMenuItem(IDM_ZOOM);

        // Tell the tool bar of the new selection
        m_TB.PopUp(IDM_ZOOM);

        // Inform the local user of the zoom state
        if (m_pLocalUser != NULL)
            m_pLocalUser->Unzoom();
    }
    else
    {
        // Set the zoomed check mark
        CheckMenuItem(IDM_ZOOM);

        // Tell the tool bar of the new selection
        m_TB.PushDown(IDM_ZOOM);

        // Inform the local user of the zoom state
        if (m_pLocalUser != NULL)
            m_pLocalUser->Zoom();
    }

    // Zoom/unzoom the drawing area
    m_drawingArea.Zoom();

    // Restore the focus to the drawing area
    ::SetFocus(m_drawingArea.m_hwnd);
}

//
//
// Function:    OnSelectTool
//
// Purpose:     Select the current tool
//
//
void WbMainWindow::OnSelectTool(UINT uiMenuId)
{
    UINT uiIndex;

    UncheckMenuItem(m_currentMenuTool);
    CheckMenuItem( uiMenuId);

    // Save the new menu Id
    m_currentMenuTool = uiMenuId;

    // Tell the tool bar of the new selection
    m_TB.PushDown(m_currentMenuTool);

    // Get the new tool
    m_pCurrentTool = m_ToolArray[TOOL_INDEX(m_currentMenuTool)];

    // Set the current attributes
    if( !m_bSelectAllInProgress )
    {
        m_AG.SetChoiceColor(m_pCurrentTool->GetColor() );

        ::SendMessage(m_hwnd, WM_COMMAND, IDM_COLOR, 0L);
        ::SendMessage(m_hwnd, WM_COMMAND, IDM_WIDTHS_START + m_pCurrentTool->GetWidthIndex(), 0L);//CHANGED BY RAND
    }

    // Report the change of tool to the attributes group
    m_AG.DisplayTool(m_pCurrentTool);

    // Select the new tool into the drawing area
    m_drawingArea.SelectTool(m_pCurrentTool);

    // Restore the focus to the drawing area
    ::SetFocus(m_drawingArea.m_hwnd);
}

//
//
// Function:    OnSelectColor
//
// Purpose:     Set the current color
//
//
void WbMainWindow::OnSelectColor(void)
{
    // Tell the attributes group of the new selection and get the
    // new color value selected ino the current tool.
    m_AG.SelectColor(m_pCurrentTool);

    // Select the changed tool into the drawing area
    m_drawingArea.SelectTool(m_pCurrentTool);

    // If we are using a select tool, change the color of the selected object
    if (m_pCurrentTool->ToolType() == TOOLTYPE_SELECT)
    {
        // If there is an object marked for changing
        if (m_drawingArea.GraphicSelected())
        {
            // Update the object
            m_drawingArea.SetSelectionColor(m_pCurrentTool->GetColor());
        }
    }

    // if currently editing a text object then change its color
    if (   (m_pCurrentTool->ToolType() == TOOLTYPE_TEXT)
        && (m_drawingArea.TextEditActive()))
    {
        m_drawingArea.SetSelectionColor(m_pCurrentTool->GetColor());
    }

    // Restore the focus to the drawing area
    ::SetFocus(m_drawingArea.m_hwnd);
}

//
//
// Function:    OnSelectWidth
//
// Purpose:     Set the current nib width
//
//
void WbMainWindow::OnSelectWidth(UINT uiMenuId)
{
    // cleanup select logic in case object context menu called us (bug 426)
    m_drawingArea.SetLClickIgnore( FALSE );

    // Move the check mark on the menu
    UncheckMenuItem(m_currentMenuWidth);
    CheckMenuItem(uiMenuId);

    // Save the new pen width
    m_currentMenuWidth = uiMenuId;

    // Tell the attributes display of the new selection
    m_WG.PushDown(uiMenuId - IDM_WIDTHS_START);

    if (m_pCurrentTool != NULL)
    {
        m_pCurrentTool->SetWidthIndex(uiMenuId - IDM_WIDTHS_START);
    }

    // Tell the drawing pane of the new selection
    m_drawingArea.SelectTool(m_pCurrentTool);

    // If we are using a select tool, change the color of the selected object
    if (m_pCurrentTool->ToolType() == TOOLTYPE_SELECT)
    {
        // If there is an object marked for changing
        if (m_drawingArea.GraphicSelected())
        {
            // Update the object
            m_drawingArea.SetSelectionWidth(m_pCurrentTool->GetWidth());
        }
    }

    // Restore the focus to the drawing area
    ::SetFocus(m_drawingArea.m_hwnd);
}


//
//
// Function:    OnChooseFont
//
// Purpose:     Let the user select a font
//
//
void WbMainWindow::OnChooseFont(void)
{
    HDC hdc;
    LOGFONT lfont;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnChooseFont");

    // cleanup select logic in case object context menu called us (bug 426)
    m_drawingArea.SetLClickIgnore( FALSE );

    // It is only really sensible to be here when a text tool is selected.
    // This is achieved by graying the Font selection menu entry when
    // anything other than a text tool is in use.

    // Get the font details from the current tool
    ::GetObject(m_pCurrentTool->GetFont(), sizeof(LOGFONT), &lfont);
    lfont.lfClipPrecision |= CLIP_DFA_OVERRIDE;

    //
    // The Font dialog is passed a LOGFONT structure which it uses to
    // initialize all of its fields (face name, weight etc).
    //
    // The face name passed in the LOGFONT structure is checked by the dialog
    // against the facenames of all available fonts.  If the name does not
    // match one of the available fonts, no name is displayed.
    //
    // WB stores the LOGFONT structure specifying the font used for a text
    // object in the object.  This LOGFONT is selected into a DC where the
    // GDIs font mapper decides which physical font most closely matches the
    // required logical font.  On boxes where the original font is not
    // supported the font is substituted for the closest matching font
    // available.
    //
    // So, if we pass the LOGFONT structure for a font which is not supported
    // into the Font dialog, no facename is displayed.  To bypass this we
    //
    // - select the logical font into a DC
    //
    // - determine the textmetrics and get the face name of the physical font
    //   chosen by the Font Mapper
    //
    // - use these textmetrics to create a LOGFONT structure which matches
    //   the substituted font!
    //
    // The resulting LOGFONT will have the correct weight, dimensions and
    // facename for the substituted font.
    //
    hdc = ::CreateCompatibleDC(NULL);
    if (hdc != NULL)
    {
        TEXTMETRIC  tm;
        HFONT       hFont;
        HFONT       hOldFont;

        hFont = ::CreateFontIndirect(&lfont);

        //
        // Get the face name and text metrics of the selected font.
        //
        hOldFont = SelectFont(hdc, hFont);
        if (hOldFont == NULL)
        {
            WARNING_OUT(("Failed to select font into DC"));
        }
        else
        {
            ::GetTextMetrics(hdc, &tm);
            ::GetTextFace(hdc, LF_FACESIZE, lfont.lfFaceName);

            //
            // Restore the old font back into the DC.
            //
            SelectFont(hdc, hOldFont);

            //
            // Create a LOGFONT structure which matches the Text metrics
            // of the font used by the DC so that the font dialog manages
            // to initialise all of its fields properly, even for
            // substituted fonts...
            //
            lfont.lfHeight    =  tm.tmHeight;
            lfont.lfWidth     =  tm.tmAveCharWidth;
            lfont.lfWeight    =  tm.tmWeight;
            lfont.lfItalic    =  tm.tmItalic;
            lfont.lfUnderline =  tm.tmUnderlined;
            lfont.lfStrikeOut =  tm.tmStruckOut;
            lfont.lfCharSet   =  tm.tmCharSet;

            //ADDED BY RAND - to make lfHeight be a char height. This makes
            //                the font dlg show the same pt size that is
            //                displayed in the sample font toolbar
            if( lfont.lfHeight > 0 )
            {
                lfont.lfHeight = -(lfont.lfHeight - tm.tmInternalLeading);
            }
        }

        ::DeleteDC(hdc);

        if (hFont != NULL)
        {
            ::DeleteFont(hFont);
        }
    }
    else
    {
        WARNING_OUT(("Failed to get DC to select font into"));
    }

    CHOOSEFONT  cf;
    TCHAR       szStyleName[64];

    ZeroMemory(&cf, sizeof(cf));
    ZeroMemory(szStyleName, sizeof(szStyleName));

    cf.lStructSize = sizeof(cf);
    cf.lpszStyle = szStyleName;
    cf.rgbColors = m_pCurrentTool->GetColor() & 0x00ffffff; // blow off palette bits (NM4db:2304)
    cf.Flags = CF_EFFECTS | CF_INITTOLOGFONTSTRUCT | CF_SCREENFONTS |
        CF_NOVERTFONTS;
    cf.lpLogFont = &lfont;
    cf.hwndOwner = m_hwnd;

    // Call up the ChooseFont dialog from COM DLG
    if (::ChooseFont(&cf))
    {
        lfont.lfClipPrecision |= CLIP_DFA_OVERRIDE;

        //ADDED BY RAND - set color selected in dialog.
        m_pCurrentTool->SetColor(cf.rgbColors);
        m_AG.DisplayTool( m_pCurrentTool );

        ::SendMessage(m_hwnd, WM_COMMAND,
                (WPARAM)MAKELONG( IDM_COLOR, BN_CLICKED ),
                (LPARAM)0 );

        // Inform the drawing pane of the new selection
        HFONT   hNewFont;

        hNewFont = ::CreateFontIndirect(&lfont);
        if (!hNewFont)
        {
            ERROR_OUT(("Failed to create font"));
            DefaultExceptionHandler(WBFE_RC_WINDOWS, 0);
            return;
        }

        //
        // We need to set the text editor font after inserting it in the DC
        // and querying the metrics, otherwise we may get a font with different
        // metrics in zoomed mode
        //
        HFONT   hNewFont2;
        HDC hDC = m_drawingArea.GetCachedDC();
        TEXTMETRIC textMetrics;

        m_drawingArea.PrimeFont(hDC, hNewFont, &textMetrics);
        lfont.lfHeight            = textMetrics.tmHeight;
        lfont.lfWidth             = textMetrics.tmAveCharWidth;
        lfont.lfPitchAndFamily    = textMetrics.tmPitchAndFamily;
        ::GetTextFace(hDC, sizeof(lfont.lfFaceName),
                     lfont.lfFaceName);
        TRACE_MSG(("Font face name %s", lfont.lfFaceName));

        // Inform the drawing pane of the new selection
        hNewFont2 = ::CreateFontIndirect(&lfont);
        if (!hNewFont2)
        {
            ERROR_OUT(("Failed to create font"));
            DefaultExceptionHandler(WBFE_RC_WINDOWS, 0);
            return;
        }


		m_drawingArea.SetSelectionColor(cf.rgbColors);
		
        m_drawingArea.SetSelectionFont(hNewFont2);

        if (m_pCurrentTool != NULL)
        {
            m_pCurrentTool->SetFont(hNewFont2);
        }
        m_drawingArea.SelectTool(m_pCurrentTool);

        //
        // discard the new font
        //
        m_drawingArea.UnPrimeFont( hDC );

        // Delete the fonts we created--everybody above makes copies
        ::DeleteFont(hNewFont2);
        ::DeleteFont(hNewFont);
    }

    // Restore the focus to the drawing area
    ::SetFocus(m_drawingArea.m_hwnd);
}


//
//
// Function:    OnToolBarToggle
//
// Purpose:     Let the user toggle the tool bar on/off
//
//
void WbMainWindow::OnToolBarToggle(void)
{
    RECT rectWnd;

    // Toggle the flag
    m_bToolBarOn = !m_bToolBarOn;

    // Make the necessary updates
    if (m_bToolBarOn)
    {
        // The tool bar was hidden, so show it
        ::ShowWindow(m_TB.m_hwnd, SW_SHOW);

        // The tool window is fixed so we must resize the other panes in
        // the window to make room for it
        ResizePanes();

        // Check the associated menu item
        CheckMenuItem(IDM_TOOL_BAR_TOGGLE);
    }
    else
    {
        // The tool bar was visible, so hide it
        ::ShowWindow(m_TB.m_hwnd, SW_HIDE);

        // Uncheck the associated menu item
        UncheckMenuItem(IDM_TOOL_BAR_TOGGLE);

        ResizePanes();
    }

    // Make sure things reflect current tool
    m_AG.DisplayTool(m_pCurrentTool);

    // Write the new option value to the options file
    OPT_SetBooleanOption(OPT_MAIN_TOOLBARVISIBLE,
                           m_bToolBarOn);

    ::GetWindowRect(m_hwnd, &rectWnd);
    ::MoveWindow(m_hwnd, rectWnd.left, rectWnd.top,
        rectWnd.right - rectWnd.left, rectWnd.bottom - rectWnd.top, TRUE);
}

//
//
// Function:    OnStatusBarToggle
//
// Purpose:     Let the user toggle the help bar on/off
//
//
void WbMainWindow::OnStatusBarToggle(void)
{
    RECT rectWnd;

    // Toggle the flag
    m_bStatusBarOn = !m_bStatusBarOn;

    // Make the necessary updates
    if (m_bStatusBarOn)
    {
        // Resize the panes to give room for the help bar
        ResizePanes();

        // The help bar was hidden, so show it
        ::ShowWindow(m_hwndSB, SW_SHOW);

        // Check the associated menu item
        CheckMenuItem(IDM_STATUS_BAR_TOGGLE);
    }
    else
    {
        // The help bar was visible, so hide it
        ::ShowWindow(m_hwndSB, SW_HIDE);

        // Uncheck the associated menu item
        UncheckMenuItem(IDM_STATUS_BAR_TOGGLE);

        // Resize the panes to take up the help bar space
        ResizePanes();
    }

    // Write the new option value to the options file
    OPT_SetBooleanOption(OPT_MAIN_STATUSBARVISIBLE, m_bStatusBarOn);

    ::GetWindowRect(m_hwnd, &rectWnd);
    ::MoveWindow(m_hwnd, rectWnd.left, rectWnd.top,
        rectWnd.right - rectWnd.left, rectWnd.bottom - rectWnd.top, TRUE);
}



//
//
// Function:    OnAbout
//
// Purpose:     Show the about box for the Whiteboard application. This
//              method is called whenever a WM_COMMAND with IDM_ABOUT
//              is issued by Windows.
//
//
void WbMainWindow::OnAbout()
{
    ::DialogBoxParam(g_hInstance, MAKEINTRESOURCE(ABOUTBOX), m_hwnd,
        AboutDlgProc, 0);
}


INT_PTR AboutDlgProc(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    BOOL    fHandled = FALSE;

    switch (uMessage)
    {
        case WM_INITDIALOG:
        {
            TCHAR   szFormat[256];
            TCHAR   szVersion[512];

            ::GetDlgItemText(hwnd, IDC_ABOUTVERSION, szFormat, 256);
            wsprintf(szVersion, szFormat, VER_PRODUCTRELEASE_STR,
                VER_PRODUCTVERSION_STR);
            ::SetDlgItemText(hwnd, IDC_ABOUTVERSION, szVersion);

            fHandled = TRUE;
            break;
        }

        case WM_COMMAND:
            switch (GET_WM_COMMAND_ID(wParam, lParam))
            {
                case IDOK:
                case IDCANCEL:
                    switch (GET_WM_COMMAND_CMD(wParam, lParam))
                    {
                        case BN_CLICKED:
                            ::EndDialog(hwnd, IDCANCEL);
                            break;
                    }
                    break;
            }

            fHandled = TRUE;
            break;
    }

    return(fHandled);
}





//
//
// Function:    SelectWindow
//
// Purpose:     Let the user select a window for grabbing
//
//
HWND WbMainWindow::SelectWindow(void)
{
    POINT   mousePos;            // Mouse position
    HWND    hwndSelected = NULL; // Window clicked on
    MSG     msg;                 // Current message

    // Load the grabbing cursors
    HCURSOR hGrabCursor = ::LoadCursor(g_hInstance, MAKEINTRESOURCE( GRABCURSOR ) );

    // Capture the mouse
    UT_CaptureMouse(m_hwnd);

    // Ensure we receive all keyboard messages.
    ::SetFocus(m_hwnd);

    // Reset the CancelMode state
    ResetCancelMode();

    // Change to the grab cursor
    HCURSOR hOldCursor = ::SetCursor(hGrabCursor);

    // Trap all mouse messages until a WM_LBUTTONUP is received
    for ( ; ; )
    {
        // Wait for the next message
        ::WaitMessage();


        // Cancel if we have been sent a WM_CANCELMODE message
        if (CancelModeSent())
        {
            break;
        }

        // If it is a mouse message, process it
        if (::PeekMessage(&msg, NULL, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE))
        {
            if (msg.message == WM_LBUTTONUP)
            {
                // Get mouse position
                mousePos.x = (short)LOWORD(msg.lParam);
                mousePos.y = (short)HIWORD(msg.lParam);

                // Convert to screen coordinates
                ::ClientToScreen(m_hwnd, &mousePos);

                // Get the window under the mouse
                hwndSelected = ::WindowFromPoint(mousePos);

                // Leave the loop
                break;
            }
        }

        // Cancel if ESCAPE is pressed.
        // or if another window receives the focus
        else if (::PeekMessage(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
        {
            if (msg.wParam == VK_ESCAPE)
            {
                break;
            }
        }
    }

    // Release the mouse
    UT_ReleaseMouse(m_hwnd);

    // Restore the cursor
    ::SetCursor(hOldCursor);

    return(hwndSelected);
}

//
//
// Function:    OnGrabWindow
//
// Purpose:     Allows the user to grab a bitmap of a window
//
//
void WbMainWindow::OnGrabWindow(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnGrabWindow");

    if (::DialogBoxParam(g_hInstance, MAKEINTRESOURCE(WARNSELECTWINDOW),
        m_hwnd, WarnSelectWindowDlgProc, 0) != IDOK)
    {
        // User cancelled; bail out
        return;
    }

    // Hide the application windows
    ::ShowWindow(m_hwnd, SW_HIDE);

    // Get window selection from the user
    HWND hwndSelected = SelectWindow();

    if (hwndSelected != NULL)
    {
        // Walk back to the find the 'real' window ancestor
        HWND    hwndParent;

        // The following piece of code attempts to find the frame window
        // enclosing the selected window. This allows us to bring the
        // enclosing window to the top, bringing the child window with it.
        DWORD dwStyle;

        while ((hwndParent = ::GetParent(hwndSelected)) != NULL)
        {
            // If we have reached a stand-alone window, stop the search
            dwStyle = ::GetWindowLong(hwndSelected, GWL_STYLE);

            if (   ((dwStyle & WS_POPUP) == WS_POPUP)
                || ((dwStyle & WS_THICKFRAME) == WS_THICKFRAME)
                || ((dwStyle & WS_DLGFRAME) == WS_DLGFRAME))
            {
                break;
            }

            // Move up to the parent window
            hwndSelected = hwndParent;
        }

        // Bring the selected window to the top
        ::BringWindowToTop(hwndSelected);
        ::UpdateWindow(hwndSelected);

        // Get an image copy of the window
        RECT areaRect;

        ::GetWindowRect(hwndSelected, &areaRect);

        DCWbGraphicDIB dib;
        dib.FromScreenArea(&areaRect);

        // Add the new grabbed bitmap
        AddCapturedImage(dib);

        // Force the selection tool to be selected
        ::PostMessage(m_hwnd, WM_COMMAND, IDM_TOOLS_START, 0L);
    }

    // Show the windows again
    ::ShowWindow(m_hwnd, SW_SHOW);

    // Restore the focus to the drawing area
    ::SetFocus(m_drawingArea.m_hwnd);
}


//
// WarnSelectWindowDlgProc()
// This puts up the warning/explanation dialog.  We use the default settings
// or whatever the user chose last time this dialog was up.
//
INT_PTR CALLBACK WarnSelectWindowDlgProc(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    BOOL    fHandled = FALSE;

    switch (uMessage)
    {
        case WM_INITDIALOG:
        {
            if (OPT_GetBooleanOption( OPT_MAIN_SELECTWINDOW_NOTAGAIN,
                            DFLT_MAIN_SELECTWINDOW_NOTAGAIN))
            {
                // End this right away, the user doesn't want a warning
                ::EndDialog(hwnd, IDOK);
            }

            fHandled = TRUE;
            break;
        }

        case WM_COMMAND:
            switch (GET_WM_COMMAND_ID(wParam, lParam))
            {
                case IDOK:
                    switch (GET_WM_COMMAND_CMD(wParam, lParam))
                    {
                        case BN_CLICKED:
                            //
                            // Update settings -- note that we don't have to write out
                            // FALSE--we wouldn't be in the dialog in the first place
                            // if the current setting weren't already FALSE.
                            //
                            if (::IsDlgButtonChecked(hwnd, IDC_SWWARN_NOTAGAIN))
                            {
                                OPT_SetBooleanOption(OPT_MAIN_SELECTWINDOW_NOTAGAIN, TRUE);
                            }

                            ::EndDialog(hwnd, IDOK);
                            break;
                    }
                    break;

                case IDCANCEL:
                    switch (GET_WM_COMMAND_CMD(wParam, lParam))
                    {
                        case BN_CLICKED:
                            ::EndDialog(hwnd, IDCANCEL);
                            break;
                    }
                    break;
            }

            fHandled = TRUE;
            break;
    }

    return(fHandled);
}



//
//
// Function:    ShowAllWindows
//
// Purpose:     Show or hide the main window and associated windows
//
//
void WbMainWindow::ShowAllWindows(int iShow)
{
    // Show/hide the main window
    ::ShowWindow(m_hwnd, iShow);

    // Show/hide the tool window
    if (m_bToolBarOn)
    {
        ::ShowWindow(m_TB.m_hwnd, iShow);
    }
}

//
//
// Function:    OnGrabArea
//
// Purpose:     Allows the user to grab a bitmap of an area of the screen
//
//
void WbMainWindow::OnGrabArea(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnGrabArea");

    if (::DialogBoxParam(g_hInstance, MAKEINTRESOURCE(WARNSELECTAREA),
        m_hwnd, WarnSelectAreaDlgProc, 0) != IDOK)
    {
        // User cancelled, so bail out
        return;
    }

    // Hide the application windows
    ::ShowWindow(m_hwnd, SW_HIDE);

    // Load the grabbing cursors
    HCURSOR hGrabCursor = ::LoadCursor(g_hInstance, MAKEINTRESOURCE( PENCURSOR ) );

    // Capture the mouse
    UT_CaptureMouse(m_hwnd);

    // Ensure we receive all keyboard messages.
    ::SetFocus(m_hwnd);

    // Reset the CancelMode status
    ResetCancelMode();

    // Change to the grab cursor
    HCURSOR hOldCursor = ::SetCursor(hGrabCursor);

    // Let the user select the area to be grabbed
    RECT rect;
    int  tmp;

    GetGrabArea(&rect);

    // Normalize coords
    if (rect.right < rect.left)
    {
        tmp = rect.left;
        rect.left = rect.right;
        rect.right = tmp;
    }

    if (rect.bottom < rect.top)
    {
        tmp = rect.top;
        rect.top = rect.bottom;
        rect.bottom = tmp;
    }

    DCWbGraphicDIB dib;
    if (!::IsRectEmpty(&rect))
    {
        // Get a bitmap copy of the screen area
        dib.FromScreenArea(&rect);
    }

    // Show the windows again now - if we do it later we get the bitmap to
    // be added re-drawn twice (once on the window show and once when the
    // graphic added indication arrives).
    ::ShowWindow(m_hwnd, SW_SHOW);
    ::UpdateWindow(m_hwnd);

    if (!::IsRectEmpty(&rect))
    {
        // Add the bitmap
        AddCapturedImage(dib);

        // Force the selection tool to be selected
        ::PostMessage(m_hwnd, WM_COMMAND, IDM_TOOLS_START, 0L);
    }

    // Release the mouse
    UT_ReleaseMouse(m_hwnd);

    // Restore the cursor
    ::SetCursor(hOldCursor);

    // Restore the focus to the drawing area
    ::SetFocus(m_drawingArea.m_hwnd);
}



//
// WarnSelectArea dialog handler
//
INT_PTR CALLBACK WarnSelectAreaDlgProc(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    BOOL    fHandled = FALSE;

    switch (uMessage)
    {
        case WM_INITDIALOG:
            if (OPT_GetBooleanOption(OPT_MAIN_SELECTAREA_NOTAGAIN,
                    DFLT_MAIN_SELECTAREA_NOTAGAIN))
            {
                // End this right away, the user doesn't want a warning
                ::EndDialog(hwnd, IDOK);
            }

            fHandled = TRUE;
            break;

        case WM_COMMAND:
            switch (GET_WM_COMMAND_ID(wParam, lParam))
            {
                case IDOK:
                    switch (GET_WM_COMMAND_CMD(wParam, lParam))
                    {
                        case BN_CLICKED:
                            //
                            // Update settings -- note that we don't have to write out
                            // FALSE--we wouldn't be in the dialog in the first place
                            // if the current setting weren't already FALSE.
                            //
                            if (::IsDlgButtonChecked(hwnd, IDC_SAWARN_NOTAGAIN))
                            {
                                OPT_SetBooleanOption(OPT_MAIN_SELECTAREA_NOTAGAIN, TRUE);
                            }

                            ::EndDialog(hwnd, IDOK);
                            break;
                    }
                    break;

                case IDCANCEL:
                    switch (GET_WM_COMMAND_CMD(wParam, lParam))
                    {
                        case BN_CLICKED:
                            ::EndDialog(hwnd, IDCANCEL);
                            break;
                    }
            }

            fHandled = TRUE;
            break;
    }

    return(fHandled);
}



//
//
// Function:    GetGrabArea
//
// Purpose:     Allows the user to grab a bitmap of an area of the screen
//
//
void WbMainWindow::GetGrabArea(LPRECT lprect)
{
    POINT  mousePos;            // Mouse position
    MSG    msg;                 // Current message
    BOOL   tracking = FALSE;    // Flag indicating mouse button is down
    HDC    hDC = NULL;
    POINT  grabStartPoint;      // Start point (when mouse button is pressed)
    POINT  grabEndPoint;        // End point (when mouse button is released)
    POINT  grabCurrPoint;       // Current mouse position

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::GetGrabArea");

    // Set the result to an empty rectangle
    ::SetRectEmpty(lprect);

    // Create the rectangle to be used for tracking
    DCWbGraphicTrackingRectangle rectangle;
    rectangle.SetColor(RGB(0, 0, 0));
    rectangle.SetPenWidth(1);
    rectangle.SetPenStyle(PS_DOT);

    // Get the DC for tracking
    HWND hDesktopWnd = ::GetDesktopWindow();
    hDC = ::GetWindowDC(hDesktopWnd);
    if (hDC == NULL)
    {
        WARNING_OUT(("NULL desktop DC"));
        goto GrabAreaCleanup;
    }

    // Trap all mouse messages until a WM_LBUTTONUP is received
    for ( ; ; )
    {
        // Wait for the next message
        ::WaitMessage();

        // Cancel if we have been sent a WM_CANCELMODE message
        if (CancelModeSent())
        {
            TRACE_MSG(("canceling grab"));

            // Erase the last tracking rectangle
            if (!EqualPoint(grabStartPoint, grabEndPoint))
            {
                rectangle.SetRectPts(grabStartPoint, grabEndPoint);
                rectangle.Draw(hDC);
            }

            break;
        }

        // If it is a mouse message, process it
        if (::PeekMessage(&msg, NULL, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE))
        {
            // Get mouse position
            TRACE_MSG( ("msg = %x, lParam = %0x", msg.message, msg.lParam) );
            mousePos.x = (short)LOWORD(msg.lParam);
            mousePos.y = (short)HIWORD(msg.lParam);

            TRACE_MSG( ("mousePos = %d,%d", mousePos.x, mousePos.y) );

            // Convert to screen coordinates
            ::ClientToScreen(m_hwnd, &mousePos);
            grabCurrPoint = mousePos;

            switch (msg.message)
            {
                // Starting the grab
                case  WM_LBUTTONDOWN:
                    // Save the starting position
                    TRACE_MSG(("grabbing start position"));
                    grabStartPoint = mousePos;
                    grabEndPoint   = mousePos;
                    tracking       = TRUE;
                    break;

                // Completing the rectangle
                case WM_LBUTTONUP:
                {
                    tracking       = FALSE;
                    // Check that there is an area to capture
                    TRACE_MSG(("grabbing end position"));
                    if (EqualPoint(grabStartPoint, grabCurrPoint))
                    {
                        TRACE_MSG(("start == end, skipping grab"));
                        goto GrabAreaCleanup;
                    }

                    // Erase the last tracking rectangle
                    if (!EqualPoint(grabStartPoint, grabEndPoint))
                    {
                        rectangle.SetRectPts(grabStartPoint, grabEndPoint);
                        rectangle.Draw(hDC);
                    }

                    // Update the rectangle object
                    rectangle.SetRectPts(grabStartPoint, grabCurrPoint);
                    *lprect = *rectangle.GetRect();

                    // We are done
                    goto GrabAreaCleanup;
                }
                break;

                // Continuing the rectangle
                case WM_MOUSEMOVE:
                    if (tracking)
                    {
                        TRACE_MSG(("tracking grab"));

                        // Erase the last tracking rectangle
                        if (!EqualPoint(grabStartPoint, grabEndPoint))
                        {
                            rectangle.SetRectPts(grabStartPoint, grabEndPoint);
                            rectangle.Draw(hDC);
                        }

                        // Draw the new rectangle
                        if (!EqualPoint(grabStartPoint, grabCurrPoint))
                        {
                            // Save the new box end point
                            grabEndPoint = grabCurrPoint;

                            // Draw the rectangle
                            TRACE_MSG( ("grabStartPoint = %d,%d",
                                grabStartPoint.x, grabStartPoint.y) );
                            TRACE_MSG( ("grabEndPoint = %d,%d",
                                grabEndPoint.x, grabEndPoint.y) );

                            rectangle.SetRectPts(grabStartPoint, grabEndPoint);
                            rectangle.Draw(hDC);
                        }
                    }
                    break;
            }
        }
        // Cancel if ESCAPE is pressed.
        else if (::PeekMessage(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
        {
            if( ((msg.message == WM_KEYUP)||(msg.message == WM_SYSKEYUP))&&
                (msg.wParam == VK_ESCAPE) )
            {
                TRACE_MSG(("grab cancelled by ESC"));

                // Erase the last tracking rectangle
                if (!EqualPoint(grabStartPoint, grabEndPoint))
                {
                    rectangle.SetRectPts(grabStartPoint, grabEndPoint);
                    rectangle.Draw(hDC);
                }
                break;
            }
        }
    }

GrabAreaCleanup:

    // Release the device context (if we have it)
    if (hDC != NULL)
    {
        ::ReleaseDC(hDesktopWnd, hDC);
    }
}



//
//
// Function:    AddCapturedImage
//
// Purpose:     Add a bitmap to the contents (adding a new page for it
//              if necessary).
//
//
void WbMainWindow::AddCapturedImage(DCWbGraphicDIB& dib)
{
    // Position the grabbed object at the top left of the currently visible
    // area.
    RECT    rcVis;
    m_drawingArea.GetVisibleRect(&rcVis);
    dib.MoveTo(rcVis.left, rcVis.top);

    // Add the new grabbed bitmap
    dib.AddToPageLast(m_hCurrentPage);
}

//
//
// Function:    OnPrint
//
// Purpose:     Print the contents of the drawing pane
//
//
void WbMainWindow::OnPrint()
{
    BOOL        bPrintError = FALSE;
    PRINTDLG    pd;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnPrint");

    if (!IsIdle())
    {
        // post an error message indicating the whiteboard is busy
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, WB_RC_BUSY);
        return;
    }

    //
    // Initialize the PRINTDLG structure
    //
    ZeroMemory(&pd, sizeof(pd));
    pd.lStructSize      = sizeof(pd);
    pd.hInstance        = g_hInstance;
    pd.hwndOwner        = m_hwnd;
    pd.Flags            = PD_ALLPAGES | PD_RETURNDC | PD_PAGENUMS |
        PD_HIDEPRINTTOFILE | PD_NOSELECTION;

    pd.nMinPage         = 1;
    pd.nMaxPage         = (WORD)g_pwbCore->WBP_ContentsCountPages();
    pd.nFromPage        = pd.nMinPage;
    pd.nToPage          = pd.nMaxPage;

    // Put up the COMMDLG print dialog
    if (::PrintDlg(&pd))
    {
        int nStartPage, nEndPage;

        // Get the start and end page numbers to be printed
        if (pd.Flags & PD_PAGENUMS)
        {
            nStartPage  = pd.nFromPage;
            nEndPage    = pd.nToPage;
        }
        else
        {
            nStartPage  = pd.nMinPage;
            nEndPage    = pd.nMaxPage;
        }

        // Check whether any pages are to be printed
        if (nStartPage <= pd.nMaxPage)
        {
            // Ensure that the start and end pages lie within range.
            nStartPage = max(nStartPage, pd.nMinPage);
            nEndPage = min(nEndPage, pd.nMaxPage);

            // Get the printer and output port names.
            // These are written to the dialog for the user to see
            // in the OnInitDialog member.
            TCHAR szDeviceName[2*_MAX_PATH];
            LPDEVNAMES lpDev;

            // Device name
            if (pd.hDevNames == NULL)
            {
                szDeviceName[0] = 0;
            }
            else
            {
                lpDev = (LPDEVNAMES)::GlobalLock(pd.hDevNames);

                wsprintf(szDeviceName, "%s %s",
                    (LPCTSTR)lpDev + lpDev->wDeviceOffset,
                    (LPCTSTR)lpDev + lpDev->wOutputOffset);

                ::GlobalUnlock(pd.hDevNames);
            }

            //
            // Tell the printer we are starting the print.
            // Note that the printer object handles the cancellation dialog.
            WbPrinter printer(szDeviceName);

            TCHAR szJobName[_MAX_PATH];
            ::LoadString(g_hInstance, IDS_PRINT_NAME, szJobName, _MAX_PATH);

            int nPrintResult = printer.StartDoc(pd.hDC, szJobName, nStartPage);
            if (nPrintResult < 0)
            {
                WARNING_OUT(("Print result %d", nPrintResult));
                bPrintError = TRUE;
            }
            else
            {
                // Find out how many copies to print
                int copyNum;

                copyNum = 0;
                while ((copyNum < pd.nCopies) && !bPrintError)
                {
                    // Loop through all pages
                    int nPrintPage;
                    WB_PAGE_HANDLE hPage;

                    for (nPrintPage = nStartPage; nPrintPage <= nEndPage; nPrintPage++)
                    {
                        // Get the first page
                        hPage = PG_GetPageNumber((WORD) nPrintPage);

                        // Only print the page if there are some objects on it
                        if (g_pwbCore->WBP_PageCountGraphics(hPage) > 0)
                        {
                            // Tell the printer we are starting a new page
                            printer.StartPage(pd.hDC, nPrintPage);
                            if (!printer.Error())
                            {
                                RECT    rectArea;

                                rectArea.left = 0;
                                rectArea.top = 0;
                                rectArea.right = DRAW_WIDTH;
                                rectArea.bottom = DRAW_HEIGHT;

                                // Print the page
                                PG_Print(hPage, pd.hDC, &rectArea);

                                // Inform the printer that the page is complete
                                printer.EndPage(pd.hDC);
                            }
                            else
                            {
                                bPrintError = TRUE;
                                break;
                            }
                        }
                    }

                    copyNum++;
                }

                // The print has completed
                nPrintResult = printer.EndDoc(pd.hDC);
                if (nPrintResult < 0)
                {
                    WARNING_OUT(("Print result %d", nPrintResult));
                    bPrintError = TRUE;
                }

                // reset the error if the user cancelled the print
                if (printer.Aborted())
                {
                    WARNING_OUT(("User cancelled print"));
                    bPrintError = FALSE;
                }
            }
        }
    }

    // Inform the user if an error occurred
    if (bPrintError)
    {
        // display a message informing the user the job terminated
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_PRINTER, 0);
    }

    //
    // Cleanup the hDevMode, hDevNames, and hdc blocks if allocated
    //
    if (pd.hDevMode != NULL)
    {
        ::GlobalFree(pd.hDevMode);
        pd.hDevMode = NULL;
    }

    if (pd.hDevNames != NULL)
    {
        ::GlobalFree(pd.hDevNames);
        pd.hDevNames = NULL;
    }

    if (pd.hDC != NULL)
    {
        ::DeleteDC(pd.hDC);
        pd.hDC = NULL;
    }

}


//
//
// Function:    OnPageSorter
//
// Purpose:     Re-order the pages
//
//
void WbMainWindow::OnPageSorter()
{
    // don't call up page sorter if another user is presenting (has the contents
    // locked and sync on)
    if (   (m_uiState == IN_CALL)
        && (!WB_PresentationMode()))
    {
        PAGESORT    ps;

        m_drawingArea.CancelDrawingMode();

        // Save the lock state (in case the Page Sorter gets it)
        SaveLock();

        //
        // Fill in the initial values
        //
        ZeroMemory(&ps, sizeof(ps));
        ps.hCurPage = m_hCurrentPage;
        ps.fPageOpsAllowed = (m_uiSubState == SUBSTATE_IDLE);

        //
        // Put up the dialog
        //
        ASSERT(m_hwndPageSortDlg == NULL);

        ::DialogBoxParam(g_hInstance, MAKEINTRESOURCE(PAGESORTERDIALOG),
            m_hwnd, PageSortDlgProc, (LPARAM)&ps);

        ASSERT(m_hwndPageSortDlg == NULL);

        // Restore the lock state
        RestoreLock();

        // Set up the new current page pointer
        if ((ps.hCurPage != m_hCurrentPage) || ps.fChanged)
        {
            GotoPage((WB_PAGE_HANDLE)ps.hCurPage);
        }

        // Update the page number display,
        // the number of the current page may have changed.
        UpdateStatus();
    }
}

//
//
// Function:    OnInsertPageBefore
//
// Purpose:     Insert a new page before the current page
//
//
void WbMainWindow::OnInsertPageBefore()
{
    if (!m_bUnlockStateSettled)
    {
        // Disable insert button code so crazed users can't insert again before
        // the conference wide page-lock status has settled. If we ask for the
        // page-lock again before the last unlock has finished then something
        // happens to the lock-event from the cores and we hang waiting for it
        // (until our wait-timeout runs out). This arguably could be called a
        // DCL core bug but I couldn't generate any convincing proof of that
        // so I just fixed it on Whiteboard's end by preventing asking for the
        // lock too soon.
        //
        // RestoreLock() will eventually set m_bUnlockStateSettled to TRUE (in
        // OnWBPUnlocked() by way of the WBP_EVENT_UNLOCKED event)
        MessageBeep( 0xffffffff );
        return;
    }

    // check state before allowing action
    if (!IsIdle())
    {
        // post an error message indicating the whiteboard is busy
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, WB_RC_BUSY);
        return;
    }

    // Save the current lock status
    SaveLock();

    // Catch exceptions so that we can restore the lock state
        // Get the Page Order Lock (with an invisible dialog)
        BOOL bGotLock = GetLock(WB_LOCK_TYPE_PAGE_ORDER, SW_HIDE);
        if (bGotLock)
        {
            UINT uiRet;
        WB_PAGE_HANDLE hPage;

        // Set flag to prevent any more inserts until
        // we have completely released the page-lock
        m_bUnlockStateSettled = FALSE;

        // Add the new page to the list (throws an exception on failure)
        uiRet = g_pwbCore->WBP_PageAddBefore(m_hCurrentPage, &hPage);
        if (uiRet != 0)
        {
            DefaultExceptionHandler(WBFE_RC_WB, uiRet);
            return;
        }

        // Go to the inserted page
        GotoPage(hPage);
    }

  //CHANGED BY RAND
  // Restore the lock status. This will eventually set m_bUnlockStateSettled
  // to TRUE (in OnWBPUnlocked() by way of the WBP_EVENT_UNLOCKED event)
  // and enable this function after the conference wide lock-status
  // has settled.
  RestoreLock();

}

//
//
// Function:    InsertPageAfter
//
// Purpose:     Insert a new page after the specified page.
//
//
void WbMainWindow::InsertPageAfter(WB_PAGE_HANDLE hPageAfter)
{
    if (!m_bUnlockStateSettled)
    {
        // Disable insert button code so crazed users can't insert again before
        // the conference wide page-lock status has settled. If we ask for the
        // page-lock again before the last unlock has finished then something
        // happens to the lock-event from the cores and we hang waiting for it
        // (until our wait-timeout runs out). This arguably could be called a
        // DCL core bug but I couldn't generate any convincing proof of that
        // so I just fixed it on Whiteboard's end by preventing asking for the
        // lock too soon.
        //
        // RestoreLock() will eventually set m_bUnlockStateSettled to TRUE (in
        // OnWBPUnlocked() by way of the WBP_EVENT_UNLOCKED event)
        MessageBeep( 0xffffffff );
        return;
    }


    // check state before allowing action
    if (!IsIdle())
    {
        // post an error message indicating the whiteboard is busy
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, WB_RC_BUSY);
        return;
    }

    // Save the current lock status
    SaveLock();

  // Catch exceptions so that we can restore the lock state
    BOOL bGotLock = GetLock(WB_LOCK_TYPE_PAGE_ORDER, SW_HIDE);
    if (bGotLock)
    {
        UINT    uiRet;
        WB_PAGE_HANDLE  hPage;

        // Set flag to prevent any more inserts until
        // we have completely released the page-lock
        m_bUnlockStateSettled = FALSE;

        uiRet = g_pwbCore->WBP_PageAddAfter(hPageAfter, &hPage);
        if (uiRet != 0)
        {
            DefaultExceptionHandler(WBFE_RC_WB, uiRet);
            return;
        }

        // Move to the added page
        GotoPage(hPage);

    }

  //CHANGED BY RAND
  // Restore the lock status. This will eventually set m_bUnlockStateSettled
  // to TRUE (in OnWBPUnlocked() by way of the WBP_EVENT_UNLOCKED event)
  // and enable this function after the conference wide lock-status
  // has settled.
  RestoreLock();

}

//
//
// Function:    OnInsertPageAfter
//
// Purpose:     Insert a new page after the current page
//
//
void WbMainWindow::OnInsertPageAfter()
{
    // Insert the new page
    InsertPageAfter(m_hCurrentPage);
}

//
//
// Function:    OnDeletePage
//
// Purpose:     Delete the current page
//
//
void WbMainWindow::OnDeletePage()
{
    int iResult;
    BOOL bWasPosted;

    if (!m_bUnlockStateSettled)
    {
        // Disable delete button code so crazed users can't delete again before
        // the conference wide page-lock status has settled. If we ask for the
        // page-lock again before the last unlock has finished then something
        // happens to the lock-event from the cores and we hang waiting for it
        // (until our wait-timeout runs out). This arguably could be called a
        // DCL core bug but I couldn't generate any convincing proof of that
        // so I just fixed it on Whiteboard's end by preventing asking for the
        // lock too soon.
        //
        // RestoreLock() will eventually set m_bUnlockStateSettled to TRUE (in
        // OnWBPUnlocked() by way of the WBP_EVENT_UNLOCKED event)
        MessageBeep( 0xffffffff );
        return;
    }

    // check state
    if (!IsIdle())
    {
        // post an error message indicating the whiteboard is busy
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, WB_RC_BUSY);
        return;
    }

    // Display a message box with the relevant question
    if( UsersMightLoseData( &bWasPosted, NULL ) ) // bug NM4db:418
        return;

    if( bWasPosted )
        iResult = IDYES;
    else
        iResult = ::Message(NULL, IDS_DELETE_PAGE, IDS_DELETE_PAGE_MESSAGE, MB_YESNO | MB_ICONQUESTION);


    // If the user wants to continue with the delete
    if (iResult == IDYES)
        {
        // If this is the only page
        if (g_pwbCore->WBP_ContentsCountPages() == 1)
            {
            // Just clear it. The core does handle this
            // case but it is better not to get the lock unnecessarily, the
            // lock is required to call the core delete page function.
            m_drawingArea.Clear();
            }
        else
            {
            // Lock the drawing area - this ensures we cannot draw to a bad page
            // It will normally be unlocked when we get the corresponding page
            // delete indication
            // - moved until after we have got the page order lock
            //LockDrawingArea();

            // Save the current lock status
            SaveLock();

            // Catch exceptions so that we can restore the lock state
                // Get the Page Order Lock (with an invisible dialog)
                BOOL bGotLock = GetLock(WB_LOCK_TYPE_PAGE_ORDER, SW_HIDE);
                if (bGotLock)
                {
                    UINT    uiRet;

                    // Set flag to prevent any more inserts until
                    // we have completely released the page-lock
                    m_bUnlockStateSettled = FALSE;

                    // Lock the drawing area - this ensures we cannot draw to a bad page
                    // It will normally be unlocked when we get the corresponding page
                    // delete indication
                    LockDrawingArea();

                    // Delete the page. The page is not deleted immediately but a
                    // WBP_EVENT_PAGE_DELETED event is generated.
                    uiRet = g_pwbCore->WBP_PageDelete(m_hCurrentPage);
                    if (uiRet != 0)
                    {
                        DefaultExceptionHandler(WBFE_RC_WB, uiRet);
                        return;
                    }
                    }

            //CHANGED BY RAND
            // Restore the lock status. This will eventually set m_bUnlockStateSettled
            // to TRUE (in OnWBPUnlocked() by way of the WBP_EVENT_UNLOCKED event)
            // and enable this function after the conference wide lock-status
            // has settled.
            RestoreLock();
            }
        }

    }

//
//
// Function:    OnRemotePointer
//
// Purpose:     Create a remote pointer
//
//
void WbMainWindow::OnRemotePointer(void)
{
    if (!m_pLocalUser)
        return;

    DCWbGraphicPointer* pPointer = m_pLocalUser->GetPointer();

    // This function toggles the presence of the user's remote pointer
    ASSERT(pPointer != NULL);
    if (pPointer->IsActive())
    {
        // Turn off the pointer in the user information
        pPointer->SetInactive();

        // Tell the drawing area of the change
        m_drawingArea.PointerUpdated(pPointer);

        // Set the check mark on the menu item
        UncheckMenuItem(IDM_REMOTE);

        // Pop up the sync button
        m_TB.PopUp(IDM_REMOTE);
    }
    else
    {
        // Calculate a position at which to drop the pointer. The centre of the
        // remote pointer is placed in the centre of the currently visible
        // area of the surface (the centre of the drawing area window).
        RECT rectVisible;
        RECT rectPointer;
        POINT ptCenter;

        m_drawingArea.GetVisibleRect(&rectVisible);
        pPointer->GetBoundsRect(&rectPointer);

        ptCenter.x = (rectVisible.left + rectVisible.right)  / 2;
        ptCenter.x -= ((rectPointer.right - rectPointer.left) / 2);
        ptCenter.y = (rectVisible.top  + rectVisible.bottom) / 2;
        ptCenter.y -= ((rectPointer.bottom - rectPointer.top) / 2);

        // Turn on the pointer in the user information
        pPointer->SetActive(m_hCurrentPage, ptCenter);

        // Tell the drawing area of the change
        m_drawingArea.PointerUpdated(pPointer);

        // Set the synced check mark
        CheckMenuItem(IDM_REMOTE);

        // Pop up the sync button
        m_TB.PushDown(IDM_REMOTE);

        // Force the selection tool to be selected
        ::PostMessage(m_hwnd, WM_COMMAND, IDM_TOOLS_START, 0L);
    }

    // Restore the focus to the drawing area
    ::SetFocus(m_drawingArea.m_hwnd);
}

//
//
// Function:    OnSync
//
// Purpose:     Sync or unsync the Whiteboard with other users
//
//
void WbMainWindow::OnSync(void)
{
    // disabled if in presentation mode (another user has lock & sync on)
    if (!WB_PresentationMode())
    {
        if (m_pLocalUser != NULL)
        {
            // Determine whether we are currently synced
            if (m_pLocalUser->IsSynced())
            {
                // currently synced, so unsync
                Unsync();
            }
            else
            {
                // currently unsynced, so sync
                Sync();
            }
        }
    }

    // Restore the focus to the drawing area
    ::SetFocus(m_drawingArea.m_hwnd);
}

//
//
// Function:    Sync
//
// Purpose:     Sync the Whiteboard with other users
//
//
void WbMainWindow::Sync(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::Sync");

    //
    // Dont do anything if the local user is already synced.
    //
    if (!m_pLocalUser || m_pLocalUser->IsSynced())
    {
        TRACE_DEBUG(("User already synced"));
        return;
    }

    //
    // Update the local user's position information, to make sure it's up
    // to date.
    //
    RECT rcVisDraw;
    RECT rcVisUser;

    m_drawingArea.GetVisibleRect(&rcVisDraw);

    m_pLocalUser->SetVisibleRect(&rcVisDraw);

    //
    // We are not currently synced - sync now (if we have the contents
    // lock, or are the first to sync, it will put our sync position).
    //
    m_pLocalUser->Sync();

    //
    // Set the synced check mark and pop up the sync button.
    //
    CheckMenuItem(IDM_SYNC);
    m_TB.PushDown(IDM_SYNC);

    //
    // If the sync position (or zoom state) chosen was not where we are
    // now, move to the current sync position (we are joining a set of
    // synced users).
    //
    m_drawingArea.GetVisibleRect(&rcVisDraw);

    m_pLocalUser->GetVisibleRect(&rcVisUser);

    if ( (m_pLocalUser->Page()        != m_hCurrentPage)               ||
         (!::EqualRect(&rcVisUser, &rcVisDraw)) ||
         (m_pLocalUser->GetZoom()     != m_drawingArea.Zoomed())  )    //CHANGED BY RAND
    {
        TRACE_DEBUG(("Move to new sync pos/state"));
        ::PostMessage(m_hwnd, WM_USER_GOTO_USER_POSITION, 0, (LPARAM)m_pLocalUser->Handle());
    }
} // Sync



//
//
// Function:    Unsync
//
// Purpose:     Unsync the Whiteboard with other users
//
//
void WbMainWindow::Unsync(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::Unsync");

    //
    // Dont do anythig if we are already unsynced.
    //
    if (!m_pLocalUser || !m_pLocalUser->IsSynced())
    {
        TRACE_DEBUG(("Already unsynced"));
        return;
    }

    //
    // Unsync.
    // Set the synced check mark and pop up the sync button.
    //
    m_pLocalUser->Unsync();
    UncheckMenuItem(IDM_SYNC);
    m_TB.PopUp(IDM_SYNC);

}  // Unsync

//
//
// Function:    SaveLock
//
// Purpose:     Save the current lock type
//
//
void WbMainWindow::SaveLock(void)
{
  MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::SaveLock");

  m_uiSavedLockType = WB_LOCK_TYPE_NONE;

  // If we have the contents lock
  if (WB_GotContentsLock())
  {
    TRACE_MSG(("Saved contents lock"));
    m_uiSavedLockType = WB_LOCK_TYPE_CONTENTS;
  }
  else
  {
    // If we have the page order lock
    if (WB_GotLock())
    {
      TRACE_MSG(("Saved page order lock"));
      m_uiSavedLockType = WB_LOCK_TYPE_PAGE_ORDER;
    }
  }
}

//
//
// Function:    RestoreLock
//
// Purpose:     Restore the current lock type (SaveLock must have been
//              called previously.
//
//
void WbMainWindow::RestoreLock(void)
{
  MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::RestoreLock");

  switch(m_uiSavedLockType)
  {
    case WB_LOCK_TYPE_CONTENTS:

      // If we do not have the contents lock
      if (!WB_GotContentsLock())
      {
        // Get the contents lock (with invisible dialog)
        TRACE_MSG(("Restoring contents lock"));
        GetLock(WB_LOCK_TYPE_CONTENTS, SW_HIDE);

      }

      // we really own the lock, clear settled flag so page buttons don't hang
      m_bUnlockStateSettled = TRUE;

    break;


    case WB_LOCK_TYPE_PAGE_ORDER:

      if (!WB_GotLock() || WB_GotContentsLock())
      {
        // Get the page order lock (with invisible dialog)
        TRACE_MSG(("Restoring page order lock"));
        GetLock(WB_LOCK_TYPE_PAGE_ORDER, SW_HIDE);

      }

      //ADDED BY RAND- we really own the lock, clear settled flag
      //                 so page buttons don't hang
      m_bUnlockStateSettled = TRUE;

    break;


    case WB_LOCK_TYPE_NONE:

      // If we have the lock
      if (WB_GotLock())
      {
        // Release the lock
        TRACE_MSG(("Restoring no lock"));

        // Let WBP_EVENT_LOCKED handle m_bUnlockStateSettled flag
        g_pwbCore->WBP_Unlock();
      }

    break;

    default:
      // We have saved an invalid lock type
      ERROR_OUT(("Bad saved lock type"));

      //ADDED BY RAND- somethings broken, clear settled flag
      //                 so page buttons don't hang
      m_bUnlockStateSettled = TRUE;
    break;
  }
}

//
//
// Function:    GetLock
//
// Purpose:     Get the Page Order Lock (synchronously)
//
//
BOOL WbMainWindow::GetLock(UINT uiLockType, UINT uiHide)
{
    BOOL    bGotRequiredLock = FALSE;
    BOOL    bCancelled       = FALSE;
    UINT  uiDialogReturn   = 0;
    UINT  lDialogDelay     = 1;
    UINT  lTimeout         = 0;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::GetLock");

    switch(uiLockType)
    {
        case WB_LOCK_TYPE_PAGE_ORDER:

            TRACE_DEBUG(("WB_LOCK_TYPE_PAGE_ORDER"));
            if (WB_GotLock())
            {
                TRACE_DEBUG(("Already got it"));
                bGotRequiredLock = TRUE;
                goto RestoreLockCleanup;
            }
            break;

        case WB_LOCK_TYPE_CONTENTS:

            TRACE_DEBUG(("WB_LOCK_TYPE_CONTENTS"));
            if (WB_GotContentsLock())
            {
                TRACE_DEBUG(("Already got it"));
                bGotRequiredLock = TRUE;
                goto RestoreLockCleanup;
            }
            break;

        default:
            ERROR_OUT(("Invalid lock type requested"));
            break;
    }

    if (WB_Locked())
    {
        TRACE_DEBUG(("Contents already locked"));
        goto RestoreLockCleanup;
    }


    // check for any object locks
    BOOL bAnObjectIsLocked;
    WB_PAGE_HANDLE hPage;
    DCWbGraphic* pGraphic;

    bAnObjectIsLocked = FALSE;
    hPage = m_drawingArea.Page();
    if (hPage != WB_PAGE_HANDLE_NULL)
    {
        WB_GRAPHIC_HANDLE hStart;

        pGraphic = PG_First(hPage, &hStart);
        while (pGraphic != NULL)
        {
            // get object lock
            bAnObjectIsLocked = pGraphic->Locked();

            // Release the current graphic
            delete pGraphic;

            // check object lock
            if( bAnObjectIsLocked )
                break;

            // Get the next one
            pGraphic = PG_Next(hPage, &hStart, NULL);
        }
    }

    if( bAnObjectIsLocked )
    {
        Message(NULL, IDS_LOCK, IDS_OBJECTSARELOCKED);
        return( FALSE );
    }

    //
    // If we get this far then we need to get the lock.
    //
    if (uiLockType == WB_LOCK_TYPE_PAGE_ORDER)
    {
        g_pwbCore->WBP_PageOrderLock();
    }
    else
    {
        g_pwbCore->WBP_ContentsLock();
    }

    //
    // Bring up a dialog to wait for the response.  This dialog is
    // cancelled by the event handler code when the lock response event is
    // received.
    //
    ASSERT(m_hwndWaitForLockDlg == NULL);

    TMDLG   tmdlg;

    ZeroMemory(&tmdlg, sizeof(tmdlg));
    tmdlg.bLockNotEvent = TRUE;
    tmdlg.uiMaxDisplay = MAIN_LOCK_TIMEOUT;

    if (uiHide == SW_SHOW)
    {
        tmdlg.bVisible = TRUE;

        uiDialogReturn = (UINT)::DialogBoxParam(g_hInstance, MAKEINTRESOURCE(LOCKDIALOG),
            m_hwnd, TimedDlgProc, (LPARAM)&tmdlg);
    }
    else
    {
        tmdlg.bVisible = FALSE;

        uiDialogReturn = (UINT)::DialogBoxParam(g_hInstance, MAKEINTRESOURCE(INVISIBLEDIALOG),
            m_hwnd, TimedDlgProc, (LPARAM)&tmdlg);
    }

    ASSERT(m_hwndWaitForLockDlg == NULL);

    if (uiDialogReturn == IDCANCEL)
    {
        // The user cancelled the lock request or it timed out
        TRACE_MSG(("User cancelled lock request"));
        bCancelled = TRUE;
        //
        // If we havent already got the lock then unlock here.
        //
        if (!WB_GotLock())
        {
            TRACE_DEBUG(("Havent got lock confirmation yet - cancel it"));
            g_pwbCore->WBP_Unlock();
        }

        goto RestoreLockCleanup;
    }

    switch(uiLockType)
    {
        case WB_LOCK_TYPE_PAGE_ORDER:

            if (WB_GotLock())
            {
                bGotRequiredLock = TRUE;
            }
            break;

        case WB_LOCK_TYPE_CONTENTS:

            if (WB_GotContentsLock())
            {
                bGotRequiredLock = TRUE;
            }
            break;

        default:
            // can't get here - trapped at top.
            ERROR_OUT(("Invalid lock type - internal error"));
        break;
    }

RestoreLockCleanup:

    if (!bGotRequiredLock)
    {
        if( !bCancelled )
        {
            // post error only if user didn't cancel (bug NM4db:429)
            TRACE_MSG(("Failed to get the lock"));
            // post an error message indicating the failure to get the lock
            ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, WB_RC_LOCKED);
        }
    }

    return(bGotRequiredLock);
}

//
//
// Function:    OnLock
//
// Purpose:     Lock or unlock the Whiteboard
//
//
void WbMainWindow::OnLock(void)
{
    // If we have the lock, this is an unlock request
    if (WB_GotContentsLock())
    {
        // if currently loading or doing a new, then restore page order lock
        if (!IsIdle())
        {
            GetLock(WB_LOCK_TYPE_PAGE_ORDER, SW_HIDE);
        }
        else
        {
            // Release the lock
            g_pwbCore->WBP_Unlock();
        }

        // Set the locked check mark
        UncheckMenuItem(IDM_LOCK);

        // Pop up the lock button
        m_TB.PopUp(IDM_LOCK);
    }
    else
    {
        // If another user has the lock.
        // We should not usually get here if another user has the lock because
        // the Lock menu entry (and button) will be grayed.
        if (WB_ContentsLocked())
        {
            // Display a message
            Message(NULL, IDS_LOCK, IDS_LOCK_ERROR);
        }
        else
        {
            // Save the current lock state (in case the user cancels the request)
            SaveLock();

            // Catch exceptions raised during the lock request
        // Request the lock
        BOOL bGotLock = GetLock(WB_LOCK_TYPE_CONTENTS, SW_SHOW);
        if (!bGotLock)
        {
          RestoreLock();
        }
        else
        {
          // Turn sync on and write our sync position
          Sync();
          m_pLocalUser->PutSyncPosition();
        }
      }
    }

    // Restore the focus to the drawing area
    ::SetFocus(m_drawingArea.m_hwnd);
}

//
//
// Function : OnWBPLoadComplete
//
// Purpose  : Finished loading a file
//
//
void WbMainWindow::OnWBPLoadComplete(void)
{
  MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPLoadComplete");
  if (m_uiSubState == SUBSTATE_LOADING)
  {
    TRACE_MSG(("Load has completed OK"));
    SetSubstate(SUBSTATE_IDLE);
    if (WB_GotLock())
    {
    }
    ReleasePageOrderLock();
  }
  else
  {
    TRACE_MSG(("Unexpected WBP_EVENT_LOAD_COMPLETE event ignored"));
  }
}

//
//
// Function : OnWBPLoadFailed
//
// Purpose  : Finished loading a file
//
//
void WbMainWindow::OnWBPLoadFailed(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnWBPLoadFailed");

    if (m_uiSubState == SUBSTATE_LOADING)
    {
        ::PostMessage(m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WB, WB_RC_BAD_FILE_FORMAT);

        TRACE_MSG(("Load has failed - tell the user about it..."));
        SetSubstate(SUBSTATE_IDLE);
        ReleasePageOrderLock();
    }
    else
    {
        TRACE_MSG(("Unexpected WBP_EVENT_LOAD_FAILED event ignored"));
    }
}

//
//
// Function:    GetWindowTitle
//
// Purpose:     Return a string for the window title
//
//
TCHAR * WbMainWindow::GetWindowTitle()
{

	// Calculate the size we will need
	int strSize=0;
    if( m_pLockOwner != NULL )
    {
        strSize = lstrlen(m_pLockOwner->Name());
    }

	// This is the worst scenario, the total size would be less than 2*_MAX_FNAME
	// but we give a lot of space for localization.
	int totalSize = 2*(_MAX_FNAME)
					+ strSize + 1
					+3*(_MAX_FNAME);	// account for the following strings, the total is probably < 200
										// IDS_UNTITLED
										// IDS_TITLE_SEPARATOR
										// IDS_DEFAULT
										// IDS_IN_CALL
										// IDS_IN_CALL_OTHERS
										// IDS_JOINING
										// IDS_INITIALIZING
										// IDS_NOT_IN_CALL
										// IDS_LOCKEDTITLE


	TCHAR *pTitle = new TCHAR[totalSize];
    if (!pTitle)
    {
        ERROR_OUT(("GetWindowTitle: failed to allocate TCHAR array"));
        return(NULL);
    }
	TCHAR inUseBy[_MAX_PATH];

    TCHAR *pStartTitle = pTitle;

    // Set title to either the "Untitled" string, or the loaded file name
    if( (!lstrlen(m_strFileName))||
        (GetFileTitle( m_strFileName, pTitle, 2*_MAX_FNAME ) != 0) )
    {
        strSize = ::LoadString(g_hInstance, IDS_UNTITLED, pTitle, totalSize );
		pTitle+=strSize;
		ASSERT(totalSize>strSize);
		totalSize -=strSize;
    }
    else
    {
		strSize = lstrlen(pTitle);
	    pTitle +=strSize;;
		ASSERT(totalSize>strSize);
	    totalSize -=strSize;
    }

    // Get the separator from resources
    strSize = ::LoadString(g_hInstance, IDS_TITLE_SEPARATOR, pTitle, totalSize);
    pTitle+=strSize;;
	ASSERT(totalSize>strSize);
    totalSize -=strSize;

    // Get the application title from options
    strSize = ::LoadString(g_hInstance, IDS_DEFAULT, pTitle, totalSize );
    pTitle+=strSize;
	ASSERT(totalSize>strSize);
    totalSize -=strSize;

    // Add either "In Call" or "Not in Call", or "Initialising" or
    // "Joining a call"
    strSize = ::LoadString(g_hInstance, IDS_TITLE_SEPARATOR, pTitle, totalSize);
    pTitle+=strSize;
	ASSERT(totalSize>strSize);
    totalSize -=strSize;

    if ((m_uiState == IN_CALL) && m_bCallActive)
    {
        UINT        count;

        count = g_pwbCore->WBP_PersonCountInCall();

		strSize = ::LoadString(g_hInstance, IDS_IN_CALL, inUseBy, totalSize);

		strSize=wsprintf(pTitle, inUseBy, (count-1));
		pTitle+=strSize;
		ASSERT(totalSize>strSize);
		totalSize -=strSize;

    }
    else  if ((m_uiState == JOINING) ||
        ((m_uiState == JOINED) && !m_bCallActive) ||
        ((m_uiState == IN_CALL) && (m_dwDomain != OM_NO_CALL) && !m_bCallActive))
    {
		strSize = ::LoadString(g_hInstance, IDS_JOINING, pTitle, totalSize );
		pTitle+=strSize;
		ASSERT(totalSize>strSize);
		totalSize -=strSize;
    }
    else if (m_uiState == STARTING)
    {
        strSize = ::LoadString(g_hInstance, IDS_INITIALIZING, pTitle, totalSize);
    	pTitle+=strSize;
		ASSERT(totalSize>strSize);
    	totalSize -=strSize;
    }
    else
    {
		strSize = ::LoadString(g_hInstance, IDS_NOT_IN_CALL, pTitle, totalSize);
		pTitle+=strSize;
		ASSERT(totalSize>strSize);
    	totalSize -=strSize;
    }
	

    // add lock info
    if( m_pLockOwner != NULL )
    {
	    strSize = ::LoadString(g_hInstance, IDS_LOCKEDTITLE, pTitle, totalSize);
        ASSERT(totalSize>strSize);
		pTitle+=strSize;
        lstrcpy(pTitle, m_pLockOwner->Name());
    }

    // Return the complete title string
    return pStartTitle;
}





LRESULT WbMainWindow::OnConfShutdown( WPARAM, LPARAM )
{
    if (OnQueryEndSession())
    {
        ::SendMessage(m_hwnd, WM_CLOSE, 0, 0); // do close immediately
        //    :
        // DON'T DO ANYTHING else at this point except for exit.
        return( 0 );// tell conf ok to shutdown
    }
    else
        return( (LRESULT)g_cuEndSessionAbort ); // don't shutdown
}


//
//
// Function:    OnQueryEndSession
//
// Purpose:     Ensure user is prompted to save changes when windows is
//              ended.
//
//
LRESULT WbMainWindow::OnQueryEndSession(void)
{
    HWND hwndPopup;

    if ((hwndPopup = ::GetLastActivePopup(m_hwnd)) != m_hwnd)
    {
        Message(NULL,  IDS_DEFAULT, IDS_CANTCLOSE );
        ::BringWindowToTop(hwndPopup);
        return( FALSE );
    }

    // If changes are required then prompt the user to save
    int iDoNew = IDOK;

    if (IsIdle())
    {
        iDoNew = QuerySaveRequired(TRUE);
        if (iDoNew == IDYES)
        {
            // Save the changes
            iDoNew = OnSave(FALSE);
        }
    }

    // remember what we did so OnClose can act appropriately
    m_bQuerySysShutdown = (iDoNew != IDCANCEL);

    // If the user did not cancel, let windows exit
    return( m_bQuerySysShutdown );
}


//
//
// Function:    Recover
//
// Purpose:     Ensure the whiteboard is not left partly registered.
//
//
//
void WbMainWindow::Recover()
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::Recover");

    // If the error occurred during start-up, then quit immediately
    if (m_uiState == STARTING)
    {
        TRACE_MSG(("error during startup - exiting"));
        ::PostMessage(m_hwnd, WM_CLOSE, FALSE, 0L);
    }
    else
    {
        // ensure the drawing area is locked while we are in a bad state
        LockDrawingArea();

        // disable remote pointer while we are handling this join failure (bug 4767)
        m_TB.Disable(IDM_REMOTE);

        // set state to starting - ensures we don't get in an infinite loop,
        // because if an error occurs then we will quit if we try to recover
        m_uiState = STARTING;
        TRACE_MSG(("Attempting to recover after join call failure - state set to STARTING"));

        // state changed: update page buttons
        UpdatePageButtons();

        // see if there is a call active
        CM_STATUS cmStatus;

        // if there's a call available, try to join it
        if (!CMS_GetStatus(&cmStatus))
            cmStatus.callID = OM_NO_CALL;

        ::PostMessage(m_hwnd, WM_USER_JOIN_CALL, FALSE, (LONG)cmStatus.callID);
    }
}

//
//
// Function:    UnlockDrawingArea
//
// Purpose:     Unlock the drawing area and enable the appropriate buttons
//
//
//
void WbMainWindow::UnlockDrawingArea()
{
    m_drawingArea.Unlock();

    // Enable tool-bar buttons that can now be used
    if (WB_Locked() || !IsIdle())
    {
        EnableToolbar( FALSE );
    }
    else
    {
        EnableToolbar( TRUE );
    }

    //
    // Show the tool attributes group.
    //
    m_AG.DisplayTool(m_pCurrentTool);
}



//
//
// Function:    LockDrawingArea
//
// Purpose:     Lock the drawing area and enable the appropriate buttons
//
//
//
void WbMainWindow::LockDrawingArea()
{
    m_drawingArea.Lock();

    // Disable tool-bar buttons that cannot be used while locked
    if (WB_Locked() || !IsIdle())
    {
        EnableToolbar( FALSE );
    }
    else
    {
        EnableToolbar( TRUE );
    }

    //
    // Hide the tool attributes
    //
    if (m_WG.m_hwnd != NULL)
    {
        ::ShowWindow(m_WG.m_hwnd, SW_HIDE);
    }
    m_AG.Hide();
}


void WbMainWindow::EnableToolbar( BOOL bEnable )
{
    if (bEnable)
    {
        m_TB.Enable(IDM_SELECT);

        // don't allow text editing in zoom mode
        if( m_drawingArea.Zoomed() )
            m_TB.Disable(IDM_TEXT);
        else
            m_TB.Enable(IDM_TEXT);

        m_TB.Enable(IDM_PEN);
        m_TB.Enable(IDM_HIGHLIGHT);

        m_TB.Enable(IDM_LINE);
        m_TB.Enable(IDM_ZOOM);
        m_TB.Enable(IDM_BOX);
        m_TB.Enable(IDM_FILLED_BOX);
        m_TB.Enable(IDM_ELLIPSE);
        m_TB.Enable(IDM_FILLED_ELLIPSE);
        m_TB.Enable(IDM_ERASER);

        m_TB.Enable(IDM_GRAB_AREA);
        m_TB.Enable(IDM_GRAB_WINDOW);
        m_TB.Enable(IDM_LOCK);
        m_TB.Enable(IDM_SYNC);

        // enable remote pointer incase it was disabled handling
        // join failures (bug 4767)
        m_TB.Enable(IDM_REMOTE);
    }
    else
    {
        m_TB.Disable(IDM_SELECT);
        m_TB.Disable(IDM_PEN);
        m_TB.Disable(IDM_HIGHLIGHT);
        m_TB.Disable(IDM_TEXT);
        m_TB.Disable(IDM_LINE);
        m_TB.Disable(IDM_ZOOM);
        m_TB.Disable(IDM_BOX);
        m_TB.Disable(IDM_FILLED_BOX);
        m_TB.Disable(IDM_ELLIPSE);
        m_TB.Disable(IDM_FILLED_ELLIPSE);
        m_TB.Disable(IDM_ERASER);

        m_TB.Disable(IDM_GRAB_AREA);
        m_TB.Disable(IDM_GRAB_WINDOW);
        m_TB.Disable(IDM_LOCK);
        m_TB.Disable(IDM_SYNC);
    }
}




//
//
// Function:    UpdatePageButtons
//
// Purpose:     Enable or disable the page buttons, according to the current
//              state.
//
//
//
void WbMainWindow::UpdatePageButtons()
{
    // Disable page buttons if not in a call, or doing a new, or another user
    // has the lock and is synced.
    if ( (m_uiState != IN_CALL) ||
       (m_uiSubState == SUBSTATE_NEW_IN_PROGRESS) ||
       (WB_PresentationMode()))
    {
        m_AG.EnablePageCtrls(FALSE);

        // when the page buttons are disabled, we do not allow the page sorter
        // dialog to be displayed
        if (m_hwndPageSortDlg != NULL)
        {
            ::SendMessage(m_hwndPageSortDlg, WM_COMMAND, MAKELONG(IDOK, BN_CLICKED),
                0);
            ASSERT(m_hwndPageSortDlg == NULL);
        }
    }
    else
    {
        m_AG.EnablePageCtrls(TRUE);
    }

    if (WB_Locked() || !IsIdle() )
    {
        EnableToolbar( FALSE );
    }
    else
    {
        EnableToolbar( TRUE );
    }


    //
    // If the page sorter is up, inform it of the state change
    //
    if (m_hwndPageSortDlg != NULL)
    {
        ::SendMessage(m_hwndPageSortDlg, WM_PS_ENABLEPAGEOPS,
            (m_uiSubState == SUBSTATE_IDLE), 0);
    }

    //
    // Enable the insert-page button if the page order's not locked
    //
    m_AG.EnableInsert( ((m_uiState == IN_CALL) &&
      (m_uiSubState == SUBSTATE_IDLE) &&
      (g_pwbCore->WBP_ContentsCountPages() < WB_MAX_PAGES) &&
      (!WB_Locked())));

    //
    // Ensure the currently active menu (if any) is correctly enabled
    //
    InvalidateActiveMenu();
}

//
//
//  Function:  InvalidateActiveMenu
//
//  Purpose:   If a menu is currently active, gray items according to
//             the current state, and force it to redraw.
//
//
void WbMainWindow::InvalidateActiveMenu()
{
  if (m_hInitMenu != NULL)
  {
      // A menu is displayed, so set the state appropriately and force a
      // repaint to show the new state
      SetMenuStates(m_hInitMenu);

      ::RedrawWindow(::GetTopWindow(::GetDesktopWindow()),
                     NULL, NULL,
                     RDW_FRAME | RDW_INVALIDATE | RDW_ERASE |
                                   RDW_ERASENOW | RDW_ALLCHILDREN);
  }
}

//
//
// Function:    CancelLoad
//
// Purpose:     Cancel any load in progress
//
//
void WbMainWindow::CancelLoad(BOOL bReleaseLock)
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CancelLoad");

    // Cancel the load
    g_pwbCore->WBP_CancelLoad();

    // reset file name to untitled
    ZeroMemory(m_strFileName, sizeof(m_strFileName));

	UpdateWindowTitle();

    // reset the whiteboard substate
    SetSubstate(SUBSTATE_IDLE);

    if (bReleaseLock)
    {
        ReleasePageOrderLock();
    }
}

//
//
// Function:    ReleasePageOrderLock
//
// Purpose:     Releases the page order lock, unless the user has got the
//              contents locked, in which case it has no effect. Called
//              after asynchronous functions requiring the page order lock
//              (file/new, file/open) have completed.
//
//
void WbMainWindow::ReleasePageOrderLock()
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::ReleasePageOrderLock");

    //
    // Only release the page order lock if:
    //     - the contents are not also locked (if they are then releasing
    //       the page order lock has no effect).
    //     - we actually have the page order locked in the first place.
    //
    if ( (!WB_GotContentsLock()) &&
         (WB_GotLock())   )
    {
        g_pwbCore->WBP_Unlock();
    }
}

//
//
// Function:    IsIdle
//
// Purpose:     Returns true if the main window is idle (in a call and not
//              loading a file/performing a new)
//
//
BOOL WbMainWindow::IsIdle()
{

    return((m_uiState == IN_CALL) && (m_uiSubState == SUBSTATE_IDLE));
}

//
//
// Function:    SetSubstate
//
// Purpose:     Sets the substate, informing the page sorter dialog of the
//              change, if necessary.
//
//
void WbMainWindow::SetSubstate(UINT newSubState)
{
  MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::SetSubstate");

  // substate only valid if in a call
  if (   (m_uiState != IN_CALL)
      || (newSubState != m_uiSubState))
  {
    m_uiSubState = newSubState;

    // Trace the substate change
    switch (m_uiSubState)
    {
      case SUBSTATE_IDLE:
        TRACE_DEBUG(("set substate to IDLE"));
        break;

      case SUBSTATE_LOADING:
        TRACE_DEBUG(("set substate to LOADING"));
        break;

      case SUBSTATE_NEW_IN_PROGRESS:
        TRACE_DEBUG(("set substate to NEW_IN_PROGRESS"));
        break;

      default:
        ERROR_OUT(("Unknown substate %hd",m_uiSubState));
        break;
    }

    // update the page buttons (may have become enabled/disabled)
    UpdatePageButtons();
  }

}

//
//
// Function:    PositionUpdated
//
// Purpose:     Called when the drawing area position has changed.
//              change, if necessary.
//
//
void WbMainWindow::PositionUpdated()
{
    RECT rectDraw;

    m_drawingArea.GetVisibleRect(&rectDraw);

    if (m_pLocalUser != NULL)
    {
        // Set the new position from the drawing area
        m_pLocalUser->SetVisibleRect(&rectDraw);

        // Show that an update of the sync position is pending
        m_bSyncUpdateNeeded = TRUE;
    }

    // If the current page is a valid one then store the user's position on
    // that page.
    if (m_hCurrentPage != WB_PAGE_HANDLE_NULL)
    {
        // Store position of this page
        WORD   pageIndex = (WORD)m_hCurrentPage;


	    PAGE_POSITION *mapob;
	    POSITION position = m_pageToPosition.GetHeadPosition();
		BOOL bFound = FALSE;
		while (position && !bFound)
		{
			mapob = (PAGE_POSITION *)m_pageToPosition.GetNext(position);
			if ( mapob->hPage == pageIndex)
			{
				bFound = TRUE;
			}
		}

        // If we're replacing an existing entry, then free the old entry.
        if (bFound)
        {
			mapob->position.x = rectDraw.left;
			mapob->position.y = rectDraw.top;
        }
        else
        {
			mapob = new PAGE_POSITION;

            if (!mapob)
            {
                ERROR_OUT(("PositionUpdated failing; couldn't allocate PAGE_POSITION object"));
            }
            else
            {
    			mapob->hPage = pageIndex;
	    		mapob->position.x = rectDraw.left;
		    	mapob->position.y = rectDraw.top;
			    m_pageToPosition.AddTail(mapob);
            }
        }
    }
}

//
//
// Function : OnALSLoadResult
//
// Purpose  : Deal with an ALS_LOAD_RESULT event
//
//
void WbMainWindow::OnALSLoadResult(UINT reason)
{

    int             errorMsg = 0;

    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnALSLoadResult");

    switch (reason)
    {
        case AL_LOAD_FAIL_NO_FP:
            WARNING_OUT(("Remote WB load failed - no FP"));
            errorMsg = IDS_MSG_LOAD_FAIL_NO_FP;
            break;

        case AL_LOAD_FAIL_NO_EXE:
            WARNING_OUT(("Remote WB load failed - no exe"));
            errorMsg = IDS_MSG_LOAD_FAIL_NO_EXE;
            break;

        case AL_LOAD_FAIL_BAD_EXE:
            WARNING_OUT(("Remote WB load failed - bad exe"));
            errorMsg = IDS_MSG_LOAD_FAIL_BAD_EXE;
            break;

        case AL_LOAD_FAIL_LOW_MEM:
            WARNING_OUT(("Remote WB load failed - low mem"));
            errorMsg = IDS_MSG_LOAD_FAIL_LOW_MEM;
            break;

        default:
            WARNING_OUT(("Bad ALSLoadResult reason %d", reason));
            break;
    }


    if (errorMsg)
    {
        //
        // Put up an error message
        //
        Message(NULL, IDS_MSG_CAPTION, errorMsg);
    }
}

//
//
// Function : OnEndSession
//
// Purpose  : Called when Windows is exiting
//
//
void WbMainWindow::OnEndSession(BOOL bEnding)
{
    if (bEnding)
    {
        ::PostQuitMessage(0);
    }
    else
    {
        m_bQuerySysShutdown = FALSE; // never mind, cancel OnClose special handling
    }
}


//
// Function: OnCancelMode()
//
// Purpose:  Called whenever a WM_CANCELMODE message is sent to the frame
//           window.
//           WM_CANCELMODE is sent when another app or dialog receives the
//           input focus.  The frame simply records that a WM_CANCELMODE
//           message has been sent.  This fact is used by the SelectWindow
//           code to determine if it should cancel the selecting of a
//           window
//
//
void WbMainWindow::OnCancelMode()
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::OnCancelMode");

    m_cancelModeSent = TRUE;

    //
    // Note: Not passed to the default handler as the default action on
    //       WM_CANCELMODE is to release mouse capture - we shall do this
    //       explicitly.
    //


    // blow off any dragging that might be in progress (bug 573)
    POINT   pt;
    ::GetCursorPos( &pt );
    ::ScreenToClient(m_drawingArea.m_hwnd, &pt);
    ::SendMessage(m_drawingArea.m_hwnd, WM_LBUTTONUP, 0, MAKELONG( pt.x, pt.y ) );

}



void WbMainWindow::LoadCmdLine(LPCSTR szFilename)
{
    int iOnSave;

    if (szFilename && *szFilename)
    {
        if( UsersMightLoseData( NULL, NULL ) ) // bug NM4db:418
            return;

        // Don't prompt to save file if we're already loading
        if (m_uiSubState != SUBSTATE_LOADING )
        {
            // Check whether there are changes to be saved
            iOnSave = QuerySaveRequired(TRUE);
        }
        else
        {
            return;
        }

        if (iOnSave == IDYES)
        {
            // User wants to save the drawing area contents
            int iResult = OnSave(TRUE);

            if( iResult == IDOK )
            {
				UpdateWindowTitle();
            }
            else
            {
                // cancelled out of save, so cancel the open operation
                return;
            }
        }

        // load filename
        if( iOnSave != IDCANCEL )
            LoadFile(szFilename);
    }
}



//
// OnNotify()
// Handles TTN_NEEDTEXTA and TTN_NEEDTEXTW
//
void WbMainWindow::OnNotify(UINT id, NMHDR * pNM)
{
    UINT    nID;
    HWND    hwnd = NULL;
    POINT ptCurPos;
    UINT  nTipStringID;

    if (!pNM)
        return;

    if (pNM->code == TTN_NEEDTEXTA)
    {
        TOOLTIPTEXTA *pTA = (TOOLTIPTEXTA *)pNM;

        // get id and hwnd
        if( pTA->uFlags & TTF_IDISHWND )
        {
            // idFrom is actually the HWND of the tool
            hwnd = (HWND)pNM->idFrom;
            nID = ::GetDlgCtrlID(hwnd);
        }
        else
        {
            nID = (UINT)pNM->idFrom;
        }

        // get tip string id
        nTipStringID = GetTipId(hwnd, nID);
        if (nTipStringID == 0)
            return;

        // give it to em
        pTA->lpszText = MAKEINTRESOURCE( nTipStringID );
        pTA->hinst = g_hInstance;
    }
    else if (pNM->code == TTN_NEEDTEXTW)
    {
        TOOLTIPTEXTW *pTW = (TOOLTIPTEXTW *)pNM;

        // get id and hwnd
        if( pTW->uFlags & TTF_IDISHWND )
        {
            // idFrom is actually the HWND of the tool
            hwnd = (HWND)pNM->idFrom;
            nID = ::GetDlgCtrlID(hwnd);
        }
        else
        {
            nID = (UINT)pNM->idFrom;
        }

        // get tip string id
        nTipStringID = GetTipId(hwnd, nID );
        if (nTipStringID == 0)
            return;

        // give it to em
        pTW->lpszText = (LPWSTR) MAKEINTRESOURCE( nTipStringID );
        pTW->hinst = g_hInstance;
    }
}




//
// GetTipId()
// Finds the tooltip for a control in Whiteboard
//
UINT WbMainWindow::GetTipId(HWND hwndTip, UINT nID)
{
    WbTool *  pTool;
    BOOL      bCheckedState;
    int       nTipID;
    int       nTipStringID;
    int       i;

    // find tip stuff relevant for nID
    nTipID = -1;
    for( i=0; i<((sizeof g_tipIDsArray)/(sizeof (TIPIDS) )); i++ )
    {
        if( g_tipIDsArray[i].nID == nID )
        {
            nTipID = i;
            break;
        }
    }

    // valid?
    if( nTipID < 0 )
        return( 0 );

    // get checked state
    switch( g_tipIDsArray[ nTipID ].nCheck )
    {
        case TB:
            bCheckedState =
                (::SendMessage(m_TB.m_hwnd, TB_ISBUTTONCHECKED, nID, 0) != 0);
            break;

        case BT:
            if (hwndTip != NULL)
            {
                bCheckedState =
                    (::SendMessage(hwndTip, BM_GETSTATE, 0, 0) & 0x0003) == 1;
            }
            else
                bCheckedState = FALSE;

            break;

        case NA:
        default:
            bCheckedState = FALSE;
            break;
    }

    // get tip string id
    if( bCheckedState )
        nTipStringID = g_tipIDsArray[ nTipID ].nDownTipID;
    else
        nTipStringID = g_tipIDsArray[ nTipID ].nUpTipID;

    // done
    return( nTipStringID );
}



// gets default path if no saves or opens have been done yet
// Returns FALSE if last default should be reused
BOOL WbMainWindow::GetDefaultPath(LPTSTR csDefaultPath , UINT size)
{
	DWORD dwType;
	DWORD dwBufLen = size;
	HKEY  hDefaultKey = NULL;
	BOOL bRet =FALSE;

	if( !lstrlen(m_strFileName) )
	{
		// a name has not been picked yet in this session, use path
		// to "My Documents"
		if( (RegOpenKeyEx( HKEY_CURRENT_USER,
			"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders",
			0,
			KEY_READ,
			&hDefaultKey )
			!= ERROR_SUCCESS) ||
			(RegQueryValueEx( hDefaultKey,
			"Personal",
			NULL,
			&dwType,
			(BYTE *)csDefaultPath,
			&dwBufLen )
			!= ERROR_SUCCESS))
		{
			// reg failed, use desktop
			LPITEMIDLIST pidl;
			if(SUCCEEDED (SHGetSpecialFolderLocation(GetDesktopWindow(),CSIDL_DESKTOPDIRECTORY,&pidl)))
				
			{
				bRet= SHGetPathFromIDList(pidl,csDefaultPath);
			}

			if( hDefaultKey != NULL )
				RegCloseKey( hDefaultKey );
		}
		else
		{
			bRet = TRUE;
		}
	}
	return bRet;
}





void WbMainWindow::OnSysColorChange( void )
{
    if (m_drawingArea.Page() != WB_PAGE_HANDLE_NULL)
    {
        PG_ReinitPalettes();

        ::InvalidateRect(m_hwnd, NULL, TRUE );
        ::UpdateWindow(m_hwnd);
    }

    m_TB.RecolorButtonImages();
    m_AG.RecolorButtonImages();
}



//
// posts a do-you-wana-do-that message if other users are in the conference
//
BOOL WbMainWindow::UsersMightLoseData( BOOL *pbWasPosted, HWND hwnd )
{
    if ( (m_uiState == IN_CALL) && m_bCallActive )
    {
        UINT    count;

        count = g_pwbCore->WBP_PersonCountInCall();

        if (count > 1)
        {
            if( pbWasPosted != NULL )
                *pbWasPosted = TRUE;

            return( ::Message(hwnd,  IDS_DEFAULT, IDS_MSG_USERSMIGHTLOSE, MB_YESNO | MB_ICONEXCLAMATION ) != IDYES );
        }
    }

    if( pbWasPosted != NULL )
        *pbWasPosted = FALSE;

    return( FALSE );
}



BOOL WbMainWindow::HasGraphicChanged( PWB_GRAPHIC pOldHeaderCopy, const PWB_GRAPHIC pNewHeader )
{
    MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::HasGraphicChanged");


    // If nothing is different but the lock state and some misc in a WBP_EVENT_GRAPHIC_UPDATE_IND then
    // the graphics are visually the same.
    //
    // NOTE: This does not check ZORDER. ZORDER changes are handled by WBP_EVENT_GRAPHIC_MOVED

    // if objects aren't the same length, they are different
    if( pOldHeaderCopy->length != pNewHeader->length )
        return( TRUE );

    // temporarialy set pOldHeaderCopy's locked state + misc to same as pNewHeader so we can do an
    // object compare.
    UINT uOldLocked = pOldHeaderCopy->locked;
    pOldHeaderCopy->locked = pNewHeader->locked;

    OM_OBJECT_ID oldlockPersonID = pOldHeaderCopy->lockPersonID;
    pOldHeaderCopy->lockPersonID = pNewHeader->lockPersonID;

    UINT  oldloadedFromFile = pOldHeaderCopy->loadedFromFile;
    pOldHeaderCopy->loadedFromFile = pNewHeader->loadedFromFile;

    NET_UID   oldloadingClientID = pOldHeaderCopy->loadingClientID;
    pOldHeaderCopy->loadingClientID = pNewHeader->loadingClientID;

    // compare objects
    BOOL bChanged = FALSE;
    if( memcmp( pOldHeaderCopy, pNewHeader, pOldHeaderCopy->length ) != 0 )
        bChanged = TRUE;


    // restore lock state + misc
    pOldHeaderCopy->locked = (TSHR_UINT8)uOldLocked;
    pOldHeaderCopy->lockPersonID = oldlockPersonID;
    pOldHeaderCopy->loadedFromFile = (TSHR_UINT16)oldloadedFromFile;
    pOldHeaderCopy->loadingClientID = oldloadingClientID;

    return( bChanged );
}



void WbMainWindow::UpdateWindowTitle(void)
{
    TCHAR *pTitle = GetWindowTitle();
    if (pTitle != NULL)
    {
        ::SetWindowText(m_hwnd, pTitle);
        delete pTitle;
    }
}