// // MWND.HPP // Main WB Window // // Copyright Microsoft 1998- // #ifndef __MWND_HPP_ #define __MWND_HPP_ #define ARRAYSIZE(a) (sizeof(a) / sizeof(a[0])) // // The progress timer meter is kinda the heart beat of this thing // #define MAIN_PROGRESS_TIMER 1000 // Milliseconds #define MAIN_DIALOG_DELAY 1500 #define MAIN_REGISTRATION_TIMEOUT 300000 // These are long, for modems #define MAIN_LOCK_TIMEOUT 120000 // // Timer IDs // #define TIMERID_PROGRESS_METER 4 #define TIMERID_MAXDISPLAY 10 // // Timed dialog information // typedef struct tagTMDLG { BOOL bLockNotEvent; BOOL bVisible; UINT uiMaxDisplay; } TMDLG; // This constant must only be defined in FAR EAST sdk // since it is not in US version. In Sook Choi (Korea) says // it is 40h so thats what I will use. Bug 3258. #ifndef CLIP_DFA_OVERRIDE #define CLIP_DFA_OVERRIDE (0x40) #endif // Constants for width menu commands (bug 433) #define MENUPOS_OPTIONS 4 #define OPTIONSPOS_WIDTH 2 // // Main state // STARTING = Whiteboard just started, not ready for user input. // In this state until registration dialog is cleared. // IN_CALL = Whiteboard ready for input // ERROR_STATE = a serious error has occurred, Whiteboard must be closed // JOINING = joining a call (join call dialog is up) // JOINED = Received join call indication, waiting for 'join call' // dialog to be dismissed. // CLOSING = Whiteboard is shutting down. Ignore all messages. // // enum { STARTING = 0, IN_CALL, ERROR_STATE, JOINING, JOINED, CLOSING }; // // Substate - valid only when in call // IDLE = Normal state - user can do anything permitted by // current lock status. // LOADING = Currently loading a file // NEW_IN_PROGRESS = Currently deleting contents // // #define SUBSTATE_IDLE 0 #define SUBSTATE_LOADING 1 #define SUBSTATE_NEW_IN_PROGRESS 2 // // Capture options // #define CAPTURE_TO_SAME 0 #define CAPTURE_TO_NEW 1 // // Border to be left around the checkmark in the color and width menus and // width of items in these menus. // #define CHECKMARK_BORDER_X 3 #define CHECKMARK_BORDER_Y 5 #define COLOR_MENU_WIDTH 40 typedef struct tagWBFINDDIALOG { HWND hwndDialog; HWND hwndOwner; } WBFINDDIALOG; #define MAX_FONT_SIZE 20 #define STATUSBAR_HEIGHT (MAX_FONT_SIZE + 2*::GetSystemMetrics(SM_CYEDGE)) // // // Class: WbMainWindow // // Purpose: Main Whiteboard window // // class WbMainWindow { // // Event handler friend used for redirecting events to specific main // window objects. // friend BOOL CALLBACK WbMainWindowEventHandler(LPVOID utHandle, UINT event, UINT_PTR param1, UINT_PTR param2); friend LRESULT CALLBACK WbMainWindowProc(HWND, UINT, WPARAM, LPARAM); friend BOOL CALLBACK WbFindCurrentDialog(HWND hwnd, LPARAM); friend DCWbGraphicMarker; // needs to get at LastDeletedGraphic friend ObjectTrashCan; // needs to get at drawingArea public: // // Construction and destruction // WbMainWindow(void); ~WbMainWindow(void); // // Initialization - display the window and its children // BOOL Open(int iCommand); BOOL JoinDomain(void); // // Popup context menu for drawing area // void PopupContextMenu(int x, int y); // // Check whether the application is idle (not opening or doing a new) // BOOL IsIdle(void); // widthbar needs access to the current tool to get the current widths WbTool *GetCurrentTool( void ) {return( m_pCurrentTool );} BOOL IsToolBarOn( void ) {return( m_bToolBarOn );} WB_PAGE_HANDLE GetCurrentPage(void) {return(m_hCurrentPage);} BOOL UsersMightLoseData( BOOL *pbWasPosted, HWND hwnd ); BOOL HasGraphicChanged( PWB_GRAPHIC pOldHeaderCopy, const PWB_GRAPHIC pNewHeader ); void UpdateWindowTitle(void); // // Handles tool tips and accelerators // BOOL FilterMessage(MSG* pMsg); // // Global data // HWND m_hwnd; WbTool * m_ToolArray[TOOL_COUNT]; // Dropping files onto the window void OnDropFiles(HDROP hDropInfo); protected: // // Tooltips // HWND m_hwndToolTip; TOOLINFO m_tiLastHit; int m_nLastHit; int OnToolHitTest(POINT pt, TOOLINFO* pTI) const; // WindowProc handlers int OnCreate(LPCREATESTRUCT lpcs); void OnDestroy(); void OnClose(void); void OnSize(UINT, int, int); void OnMove(void); void OnSetFocus(void); void OnInitMenuPopup(HMENU hMenu, UINT uiIndex, BOOL bSystem); void OnMenuSelect(UINT uiItemID, UINT uiFlags, HMENU hSysMenu); void OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT measureStruct); void OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT drawStruct); void OnGetMinMaxInfo(MINMAXINFO FAR* lpmmi); void OnRenderAllFormats(void); void OnPaletteChanged(HWND hwndPalette); LRESULT OnQueryNewPalette(void); void OnTimer(UINT_PTR uiTimerId); LRESULT OnQueryEndSession(void); LRESULT OnConfShutdown( WPARAM, LPARAM ); void OnEndSession(BOOL bEnding); void OnParentNotify(UINT msg); LRESULT OnToolTipText(UINT, NMHDR*); // // HELP // void ShowHelp(void); // Command handlers void OnCommand(UINT id, UINT code, HWND hwndCtl); void OnAbout(void); void OnNew(void); void OnOpen(void); void OnClearPage(void); void OnDelete(void); void OnUndelete(void); void OnCut(void); void OnCopy(void); void OnPaste(void); void OnSelectAll( void ); void OnChooseFont(void); void OnToolBarToggle(void); void OnStatusBarToggle(void); void OnGrabWindow(void); void OnZoom(void); int OnSave(BOOL bPrompt); void OnPrint(void); void OnPageSorter(void); void OnInsertPageBefore(void); void OnInsertPageAfter(void); void OnDeletePage(void); void OnGrabArea(void); void OnLButtonDown(void); void OnLButtonUp(void); void OnMouseMove(void); void OnRemotePointer(void); void OnSync(void); void OnLock(void); void OnSelectTool(UINT id); // Select the current tool void OnSelectColor(void); // Color changed in palette void OnSelectWidth(UINT id); // Select pen width // Scrolling control (accessed via accelerators) void OnScrollAccelerator(UINT id); // Moving through the pages void OnFirstPage(void); void OnPrevPage(void); void OnNextPage(void); void OnLastPage(void); void OnGotoPage(void); void OnGotoUserPosition(LPARAM lParam); void OnGotoUserPointer(LPARAM lParam); void OnJoinCall(BOOL bKeepContents, LPARAM lParam); void OnDisplayError(WPARAM wParam, LPARAM lParam); void OnJoinPendingCall(void); void LoadCmdLine(LPCSTR szFileName); // CancelMode processing void OnCancelMode(); void OnNotify(UINT id, NMHDR* pNM); void OnSysColorChange( void ); BOOL m_bInitOk; // // Flag indicating that we are currently displaying a serious error // message. // BOOL m_bDisplayingError; // // Domain ID of the call we are currently in // DWORD m_dwDomain; // // Start registration with the necessary cores and join a call initially // BOOL JoinCall(BOOL bLocal); BOOL WaitForJoinCallComplete(void); // // Move to a given position in the page // void GotoPosition(int x, int y); // // Go to a specific page // void GotoPage(WB_PAGE_HANDLE hPage); void GotoPageNumber(UINT uiPageNumber); // // Go to a specified position // void GotoSyncPosition(void); // // Flag used to prevent processing of WM_TIMER messages. Even if the // timer is stopped there may be old messages in the queue. This flag // prevents these messages being processed. // BOOL m_bTimerActive; // // Flag indicating whether an update to the sync position is needed. The // update is performed from the OnTimer member when it is next entered. // BOOL m_bSyncUpdateNeeded; // // Event handler for DC-Groupware events // BOOL EventHandler(UINT Event, UINT_PTR param1, UINT_PTR param2); void ProcessEvents(UINT Event, UINT_PTR param1, UINT_PTR param2); // // Individual DC-Groupware event handlers // void OnCMSNewCall(BOOL fTopProvider, DWORD _dwDomain); void OnCMSEndCall(void); void OnALSLoadResult(UINT reason); void OnWBPJoinCallOK(void); void OnWBPJoinCallFailed(void); void OnWBPNetworkLost(void); void OnWBPError(void); void OnWBPPageClearInd(WB_PAGE_HANDLE hPage); void OnWBPPageOrderUpdated(void); void OnWBPPageDeleteInd(WB_PAGE_HANDLE hPage); void OnWBPContentsLocked(POM_OBJECT hUser); void OnWBPPageOrderLocked(POM_OBJECT hUser); void OnWBPUnlocked(POM_OBJECT hUser); void OnWBPLockFailed(void); void OnWBPGraphicAdded(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic); void OnWBPGraphicMoved(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic); void OnWBPGraphicUpdateInd(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic); void OnWBPGraphicReplaceInd(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic); void OnWBPGraphicDeleteInd(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic); void OnWBPUserJoined(POM_OBJECT hUser); void OnWBPUserLeftInd(POM_OBJECT hUser); void OnWBPUserUpdateInd(POM_OBJECT hUser, BOOL bReplace); void OnWBPSyncPositionUpdated(void); void OnWBPLoadComplete(void); void OnWBPLoadFailed(void); // // Clipboard access // BOOL DoCopy(BOOL bRenderNow); // Copy selection to the clipboard // Clipboard vars WB_PAGE_HANDLE m_hPageClip; WB_GRAPHIC_HANDLE m_hGraphicClip; DCWbGraphic * m_pDelayedGraphicClip; PWB_GRAPHIC m_pDelayedDataClip; // Clipboard routines WB_PAGE_HANDLE CLP_LastCopiedPage(void) const; WB_GRAPHIC_HANDLE CLP_LastCopiedGraphic(void) const; int CLP_AcceptableClipboardFormat(void); DCWbGraphic * CLP_Paste(void); BOOL CLP_Copy(DCWbGraphic * pGraphic, BOOL bRenderNow = FALSE); void CLP_SaveDelayedGraphic(void); void CLP_FreeDelayedGraphic(void); BOOL CLP_RenderFormat(int iFormat); BOOL CLP_RenderAllFormats(void); BOOL CLP_RenderAllFormats(DCWbGraphic * pGraphic); BOOL CLP_DelayAllFormats(DCWbGraphic * pGraphic); BOOL CLP_RenderPrivateFormat(DCWbGraphic* pGraphic); BOOL CLP_RenderPrivateSingleFormat(DCWbGraphic* pGraphic); BOOL CLP_RenderAsImage(DCWbGraphic* pGraphic); BOOL CLP_RenderAsText(DCWbGraphic* pGraphic); BOOL CLP_RenderAsBitmap(DCWbGraphic* pGraphic); #ifdef RENDER_AS_MF BOOL CLP_RenderMetafileFormat(DCWbGraphic* pGraphic); #endif // // Access functions for saved delayed graphic // PWB_GRAPHIC CLP_GetGraphicData(void); DCWbGraphic* CLP_GetGraphic(void); void CLP_ReleaseGraphicData(PWB_GRAPHIC pHeader); // // Tool bar window // WbToolBar m_TB; BOOL m_bToolBarOn; // // Make updates based on a new user joining the call // void UserJoined(WbUser* pUser); // // Insert a new page after the specified page // void InsertPageAfter(WB_PAGE_HANDLE hPageAfter); public: // // Drawing pane window // WbDrawingArea m_drawingArea; void RemoveGraphicPointer(DCWbGraphicPointer *p) { m_drawingArea.RemoveGraphicPointer(p); } UINT GetSubState( void ) {return(m_uiSubState );} // // Get a lock on the Whiteboard contents. The first parameter // determines the type of lock, the second whether a visible or // invisible dialog is to be used (use SW_SHOW or SW_HIDE). // BOOL GetLock(UINT uiLockType, UINT uiHide = SW_SHOW); void SetLockOwner( const WbUser *pLockOwner ) {m_pLockOwner = pLockOwner;} const WbUser * GetLockOwner( void ) {return(m_pLockOwner );} // // FRAME WINDOW VARS // HACCEL m_hAccelTable; // // Get the window title // TCHAR * GetWindowTitle(void); WbWidthsGroup m_WG; // Pen Widths void EnableToolbar( BOOL bEnable ); // // Page sorter dialog // HWND m_hwndPageSortDlg; // // Dialog that asks whether to save changes. // HWND m_hwndQuerySaveDlg; // // Timed dialogs that are running while the main window is waiting // for a specific event. // HWND m_hwndWaitForEventDlg; HWND m_hwndWaitForLockDlg; protected: HWND m_hwndInitDlg; void KillInitDlg(void); UINT GetTipId(HWND hTipWnd, UINT nID); // // Color palette, font, page controls // WbAttributesGroup m_AG; // // Status bar // HWND m_hwndSB; BOOL m_bStatusBarOn; void UpdateStatus(void); // // Initialize the menus (color and width menu items are all ownerdraw) // void InitializeMenus(void); // // Resize function for subpanes - called when the window is resized by // the user. // void ResizePanes(void); // // Current window size - normal, maximized or minimized // UINT m_uiWindowSize; // // Save the current window position to the options file // void SaveWindowPosition(void); // // Menu selection functions // UINT m_currentMenuTool; // Current tool menu Id UINT m_currentMenuWidth; // Current width menu Id // // Current drawing tool // WbTool* m_pCurrentTool; // // Menu update functions // void CheckMenuItem(UINT uiId); void UncheckMenuItem(UINT uiId); BOOL CheckMenuItemRecursive(HMENU hMenu, UINT uiId, BOOL bCheck); HMENU GetMenuWithItem(HMENU hMenu, UINT uiId); // // Select a window for grabbing // HWND SelectWindow(void); // // Add a captured bitmap to the contents // void AddCapturedImage(DCWbGraphicDIB& dib); // // Get confirmation for destructive functions (new, clear) // int QuerySaveRequired(BOOL bCancelBtn); // // Load a file // void LoadFile(LPCSTR strLoadFileName); // // Perform a save // // // Get a file name for saving // int GetFileName(); // // Members saving and restoring the lock state. These can be used to // save the lock state before obtaining a temporary lock (e.g. for // adding a new page). They cannot be nested. // void SaveLock(void); void RestoreLock(void); WB_LOCK_TYPE m_uiSavedLockType; // // Release page order lock - this should be called after an asynchronous // function which requires the page order lock until it has completed. // void ReleasePageOrderLock(void); // // Display a message box for an error // void DisplayError(UINT uiCaption, UINT uiMessage); // // Current file name for saving image // TCHAR m_strFileName[2*_MAX_PATH]; // // Grab an area of the screen into a bitmap // void GetGrabArea(LPRECT lprect); // // Hide/show the main window and its associated popups // void ShowAllWindows(int iShow); void ShowAllWindows(void) { ShowAllWindows(SW_RESTORE); } void HideAllWindows(void) { ShowAllWindows(SW_MINIMIZE); } // // Current page of graphics // WB_PAGE_HANDLE m_hCurrentPage; // // Handle of alternative accelerator table for page and text edit fields // HACCEL m_hAccelPagesGroup; HACCEL m_hAccelTextEdit; // // Local user // WbUser* m_pLocalUser; // current lock owner const WbUser* m_pLockOwner; // // Registration state variables // UINT m_uiState; UINT m_uiSubState; // // Pointer to last deleted graphic(s) // ObjectTrashCan m_LastDeletedGraphic; // // Context menu for drawing area // HMENU m_hContextMenuBar; HMENU m_hContextMenu; HMENU m_hGrobjContextMenuBar; HMENU m_hGrobjContextMenu; // // Member function to create pop-up context menu for the drawing area // BOOL CreateContextMenus(void); // // Flag to indicate that we are currently prompting the user to save // changes before joining a call // BOOL m_bPromptingJoinCall; // We remember if we're in a save dialog so we can canel it on certain events BOOL m_bInSaveDialog; void CancelSaveDialog(void); // // Recover the whiteboard into a good state // void Recover(void); // // Lock/unlock the drawing area // void LockDrawingArea(void); void UnlockDrawingArea(void); // // Update the page buttons disable/enable status // void UpdatePageButtons(void); // // Sync/unsync with other users. // void Sync(void); void Unsync(void); // // Cancel a load in progress // void CancelLoad(BOOL bReleaseLock = TRUE); // // Set the application substate // void SetSubstate(UINT newSubState); // // Ensure the attributes window is up to date // void OnUpdateAttributes(void) { m_AG.DisplayTool(m_pCurrentTool); } // // Map of page handles to positions // typedef struct PAGEPOSITION { WORD hPage; POINT position; } PAGE_POSITION; COBLIST m_pageToPosition; void PositionUpdated(void); // // Pending call status // BOOL m_bJoinCallPending; // Join-call pending? DWORD m_dwPendingDomain; // domain of pending join-call BOOL m_bPendingCallKeepContents; // keep contents on pending call UINT m_dwJoinDomain; // domain that is currently being // joined BOOL m_bCallActive; // Is there a call up ? // // Menu state. // - SetMenuStates grays items on the specified menu // - InvalidateActiveMenu calls SetMenuStates and forces a re-draw of // the currently active menu (if any) // - m_pInitMenu stores a pointer to the currently active menu. // public: void SetMenuStates(HMENU hInitMenu); protected: void InvalidateActiveMenu(); HMENU m_hInitMenu; // // Number of remote users // UINT m_numRemoteUsers; BOOL m_bSelectAllInProgress; BOOL GetDefaultPath( LPTSTR csDefaultPath, UINT size ); BOOL m_bUnlockStateSettled; BOOL m_bQuerySysShutdown; BOOL m_bIsWin95; // // Interface for determining if a WM_CANCELMODE message has been sent // protected: BOOL m_cancelModeSent; public: void ResetCancelMode() { m_cancelModeSent = FALSE; }; BOOL CancelModeSent() { return m_cancelModeSent; }; }; // // Timed dialog proc // INT_PTR CALLBACK TimedDlgProc(HWND, UINT, WPARAM, LPARAM); // // QuerySave dialog proc // INT_PTR CALLBACK QuerySaveDlgProc(HWND, UINT, WPARAM, LPARAM); // // WarnSelectWindow dialog proc // INT_PTR CALLBACK WarnSelectWindowDlgProc(HWND, UINT, WPARAM, LPARAM); // // WarnSelectArea dialog proc // INT_PTR CALLBACK WarnSelectAreaDlgProc(HWND, UINT, WPARAM, LPARAM); // // About Box dialog proc // INT_PTR CALLBACK AboutDlgProc(HWND, UINT, WPARAM, LPARAM); #endif // __MWND_HPP_