able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/netmeeting/ui/msconfwb/mwnd.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

9682 lines
250 KiB
C++
Raw Blame History

//
// 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;
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))
{
int 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);
// 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;
POSITION position = m_pageToPosition.GetHeadPosition();
BOOL bFound = FALSE;
while (position && !bFound)
{
mapob = (PAGE_POSITION *)m_pageToPosition.GetNext(position);
if ( 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
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;
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
GetWindowsDirectory( csDefaultPath, 2*_MAX_PATH );
lstrcpy(csDefaultPath,"\\Desktop");
}
if( hDefaultKey != NULL )
RegCloseKey( hDefaultKey );
return( TRUE );
}
else
{
return( FALSE );
}
}
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;
}
}
Reference in a new issue View git blame Copy permalink