// XTPDockingPaneDefines.h : public defines, structures and enumerations. // // This file is a part of the XTREME DOCKINGPANE MFC class library. // (c)1998-2012 Codejock Software, All Rights Reserved. // // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN // CONSENT OF CODEJOCK SOFTWARE. // // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A // SINGLE COMPUTER. // // CONTACT INFORMATION: // support@codejock.com // http://www.codejock.com // ///////////////////////////////////////////////////////////////////////////// //{{AFX_CODEJOCK_PRIVATE #if !defined(__XTPDOCKINGPANEDEFINES_H__) #define __XTPDOCKINGPANEDEFINES_H__ //}}AFX_CODEJOCK_PRIVATE #if _MSC_VER >= 1000 #pragma once #endif // _MSC_VER >= 1000 class CXTPDockingPane; class CXTPDockingPaneBase; class CXTPDockingPaneBase; //----------------------------------------------------------------------- // Summary: // Docking direction enumeration // Example: // // CXTPDockingPane* pwndPane1 = GetDockingPaneManager()->CreatePane( // IDR_PANE1, CRect(0, 0, 200, 120), xtpPaneDockTop); // // See Also: // CXTPDockingPaneManager::CreatePane, CXTPDockingPaneManager // // //----------------------------------------------------------------------- enum XTPDockingPaneDirection { xtpPaneDockLeft, // To dock the pane to the left of the pane or frame. xtpPaneDockRight, // To dock the pane to the right of the pane or frame. xtpPaneDockTop, // To dock the pane to the top of the pane or frame. xtpPaneDockBottom // To dock the pane to the bottom of the pane or frame. }; //----------------------------------------------------------------------- // Summary: // Docking pane type // Example: // // if (pPane->GetType() == xtpPaneTypeDockingPane) // { // // This is CXTPDockingPane object // } // // See Also: CXTPDockingPaneBase::GetType, CXTPDockingPaneBase // // //----------------------------------------------------------------------- enum XTPDockingPaneType { xtpPaneTypeDockingPane, // Object is the docking pane. xtpPaneTypeTabbedContainer, // Object is the tabbed container. xtpPaneTypeSplitterContainer, // Object is the splitter container. xtpPaneTypeMiniWnd, // Object is the mini window container. xtpPaneTypeClient, // Object is the pane contained client area. xtpPaneTypeAutoHidePanel, // Object is the auto hide panel. xtpPaneTypeSidePanel // Object is the side panel. }; //----------------------------------------------------------------------- // Summary: // Visual theme enumeration // Example: // m_paneManager.SetTheme(xtpPaneThemeVisualStudio2005Beta1); // See Also: CXTPDockingPaneManager, CXTPDockingPaneManager::SetTheme // // //----------------------------------------------------------------------- enum XTPDockingPanePaintTheme { xtpPaneThemeDefault, // Default Style Theme xtpPaneThemeVisualStudio2003, // Visual Studio 2003 Style Theme xtpPaneThemeOffice2003, // Office 2003 Style Theme xtpPaneThemeWinNative, // Windows Native Style Theme xtpPaneThemeGrippered, // Gripper Style Theme xtpPaneThemeOffice2002Visio, // Office 2002 Visio Style Theme xtpPaneThemeVisualStudio2005Beta1, // Visual Studio 2005 Whidbey Beta 1 Style Theme xtpPaneThemeOffice2003Outlook, // Office 2003 Outlook Style Theme xtpPaneThemeWinExplorer, // Windows Explorer Style Theme xtpPaneThemeVisualStudio2005, // Visual Studio 2005 Style Theme xtpPaneThemeResource, // Office 2007/2010 Style Theme xtpPaneThemeOffice2007Word, // Office 2007 Word Style Theme xtpPaneThemeOffice2007Outlook, // Office 2007 Outlook Style Theme xtpPaneThemeVisualStudio6, // Visual Studio 6 Style Theme xtpPaneThemeVisualStudio2005Beta2, // Visual Studio 2005 Whidbey Beta 2 Style Theme xtpPaneThemeVisualStudio2008, // Visual Studio 2008 Style Theme xtpPaneThemeVisualStudio2010, // Visual Studio 2010 Beta 1 Style Theme xtpPaneThemeOffice2003Visio, // Office 2003 Visio Style Theme xtpPaneThemeOffice2007Visio, // Office 2007 Visio Style Theme xtpPaneThemeCustom, // Custom User Defined Theme. //{{AFX_CODEJOCK_PRIVATE // obsolete, for backward compatibility only. xtpPaneThemeOffice = xtpPaneThemeVisualStudio2003, xtpPaneThemeNativeWinXP = xtpPaneThemeWinNative, xtpPaneThemeExplorer = xtpPaneThemeWinExplorer, xtpPaneThemeVisio = xtpPaneThemeOffice2002Visio, xtpPaneThemeWhidbey = xtpPaneThemeVisualStudio2005Beta1, xtpPaneThemeShortcutBar2003 = xtpPaneThemeOffice2003Outlook, xtpPaneThemeWord2007 = xtpPaneThemeOffice2007Word, xtpPaneThemeOutlook2007 = xtpPaneThemeOffice2007Outlook, xtpPaneThemeOffice2007 = xtpPaneThemeResource, //}}AFX_CODEJOCK_PRIVATE }; //----------------------------------------------------------------------- // Summary: // Docking Panes sticker style enumeration // Example: // m_paneManager.SetStickerStyle(xtpPaneStickerStyleVisualStudio2005); // // //----------------------------------------------------------------------- enum XTPDockingContextStickerStyle { xtpPaneStickerStyleVisualStudio2005Beta, // Visual Studio 2005 Whidbey Beta stickers xtpPaneStickerStyleVisualStudio2005, // Visual Studio 2005 stickers xtpPaneStickerStyleVisualStudio2008, // Visual Studio 2008 stickers xtpPaneStickerStyleVisualStudio2010, // Visual Studio 2010 stickers //{{AFX_CODEJOCK_PRIVATE // obsolete, for backward compatibility only. xtpPaneStickerStyleWhidbey = xtpPaneStickerStyleVisualStudio2005Beta, //}}AFX_CODEJOCK_PRIVATE }; //----------------------------------------------------------------------- // Summary: // Docking Pane Options enumeration // Example: // // // Remove Hide button for all panes // m_paneManager.SetDefaultPaneOptions(xtpPaneNoHideable); // // Remove close button for pPane // pPane->SetOptions(xtpPaneNoCloseable); // // See Also: CXTPDockingPaneManager::SetDefaultPaneOptions, CXTPDockingPane::SetOptions // // //----------------------------------------------------------------------- enum XTPDockingPaneOptions { xtpPaneNoCloseable = 1, // Pane can't be closed. xtpPaneNoHideable = 2, // Pane can't be hidden. xtpPaneNoFloatable = 4, // Pane can't be floated. xtpPaneNoCaption = 8, // Pane has no caption. xtpPaneHasMenuButton = 16, // Pane has menu button. xtpPaneNoDockable = 32, // Pane can't be docked. xtpPaneNoFloatableByTabDoubleClick = 64, // Pane can't be floated by a double-click on the tab button. xtpPaneNoFloatableByCaptionDoubleClick = 128, // Pane can't be floated by a double-click on the pane caption. xtpPaneNoHoverShow = 1024 }; //----------------------------------------------------------------------- // Summary: // Docking Pane Caption direction enumeration // Example: // // m_paneManager.SetCaptionDirection(xtpPaneCaptionAutoBySize); // // See Also: CXTPDockingPaneManager::SetCaptionDirection // // //----------------------------------------------------------------------- enum XTPDockingPaneCaptionDirection { xtpPaneCaptionHorizontal, // Show caption on top xtpPaneCaptionVertical, // Show caption on left xtpPaneCaptionAutoByPosition, // Automatically xtpPaneCaptionAutoBySize // Automatically }; //----------------------------------------------------------------------- // Summary: // Actions a docking pane is currently performing. // Example: // // BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd) // ON_MESSAGE(XTPWM_DOCKINGPANE_NOTIFY, OnDockingPaneNotify) // END_MESSAGE_MAP() // // LRESULT CMainFrame::OnDockingPaneNotify(WPARAM wParam, LPARAM lParam) // { // if (wParam == XTP_DPN_ACTION) // { // XTP_DOCKINGPANE_ACTION* pAction = (XTP_DOCKINGPANE_ACTION*)lParam; // TRACE("Action %i\n", pAction->action); // return TRUE; // } // return FALSE; // } // // See Also: XTP_DOCKINGPANE_ACTION, XTP_DPN_ACTION // // //----------------------------------------------------------------------- enum XTPDockingPaneAction { xtpPaneActionFloating, // Docking pane is currently floating. This occurs when the user clicks on the title bar of a docking pane and drags the pane to another location. When this occurs, the pane is said to be "floating." xtpPaneActionFloated, // Docking pane has been docked, and is currently floating. xtpPaneActionClosing, // Docking pane is currently closing. This occurs when the close button of the pane is clicked. xtpPaneActionClosed, // Docking pane has been closed. This occurs when the docking pane has finished closing. xtpPaneActionDocking, // Docking pane is in the process of docking. xtpPaneActionDocked, // Docking pane has been docked. This occurs when the docking pane has finished docking. xtpPaneActionAttaching, // Docking pane is in the process of attaching to another pane. xtpPaneActionAttached, // Docking pane has been attached. This occurs when the docking pane has finished attaching to another pane. xtpPaneActionPinning, // Docking pane is currently pinning (hiding). This occurs when the "pin" button is clicked. xtpPaneActionPinned, // Docking pane has been pinned. This occurs when the docking pane has finished pinning. xtpPaneActionCollapsing, // Docking pane is currently collapsing (hiding). This occurs when a pane is going back to its AutoHide position. If a pane is hidden and the mouse is positioned over the tab to display the pane, the pane is expanding, when the mouse is moved off of the pane it begins to collapse. xtpPaneActionCollapsed, // Docking Pane has been collapsed. This occurs when the docking pane has finished collapsing. xtpPaneActionExpanding, // Docking pane is currently expanding. This occurs when a pane is being displayed from its AutoHide position. If a pane is hidden and the mouse is positioned over the tab to display the pane, the pane is then expanding, when the mouse is moved off of the pane it begins to collapse. xtpPaneActionExpanded, // Docking pane is expanded, this is when the pane is fully shown from the auto-hide position. xtpPaneActionActivated, // Docking pane become active xtpPaneActionDeactivated, // Docking pane deactivated xtpPaneActionDetaching, // Docking pane removing from tabbed container xtpPaneActionDragging, // Docking pane has been dragged xtpPaneActionUnpinning, // Docking pane is currently docked. This occurs when the "pin" button is clicked. xtpPaneActionUnpinned, // Docking pane has been unpinned. This occurs when the docking pane has finished pinning. xtpPaneActionSplitterResizing, // Docking pane splitter resizing xtpPaneActionSplitterResized // Docking pane splitter resized }; //------------------------------------------------------------------------- // Summary: // Enable options of the pane //------------------------------------------------------------------------- enum XTPDockingPaneEnableOptions { xtpPaneDisabled = 0, // Pane is disabled xtpPaneEnableClient = 1, // Client is enabled xtpPaneEnableActions = 2, // All actions are enabled xtpPaneEnabled = 3, // Pane is enabled xtpPaneEnabledAuto = 4 + 3 }; //----------------------------------------------------------------------- // Summary: // Keyboard options indicates which key can be used to navigate panes // Example: // // m_paneManager.EnableKeyboardNavigate(xtpPaneKeyboardUseAll); // // See Also: CXTPDockingPaneManager::EnableKeyboardNavigate //----------------------------------------------------------------------- enum XTPDockingPaneKeyboardNavigate { xtpPaneKeyboardUnused = 0, // Don't use keyboard xtpPaneKeyboardUseAltMinus = 1, // To use Alt+'-' to show context menu xtpPaneKeyboardUseAltF6 = 2, // To use Alt+F6 to select next pane xtpPaneKeyboardUseAltF7 = 4, // To use Alt+F7 to show window select dialog xtpPaneKeyboardUseCtrlTab = 8, // To use Ctrl+Tab to show window select dialog xtpPaneKeyboardUseAll = 15 // To use all keys }; //----------------------------------------------------------------------- // Summary: // XTP_DOCKINGPANE_CLICK structure contains information about pane // was used in XTP_DPN_PANEMENUCLICK message // See Also: // XTP_DPN_PANEMENUCLICK //----------------------------------------------------------------------- struct XTP_DOCKINGPANE_CLICK { CXTPDockingPane* pPane; // Docking Pane pointer CXTPDockingPaneBase* pContainer; // Docking Pane container CPoint pt; // Mouse pointer CRect rcExclude; // Exclude rectangle }; //----------------------------------------------------------------------- // Summary: // XTP_DOCKINGPANE_ACTION structure contains information about action // performed by user with docking panes. // Example: // // LRESULT CMainFrame::OnDockingPaneNotify(WPARAM wParam, LPARAM lParam) // { // if (wParam == XTP_DPN_ACTION) // { // XTP_DOCKINGPANE_ACTION* pAction = (XTP_DOCKINGPANE_ACTION*)lParam; // TRACE("Action %i\n", pAction->action); // return TRUE; // } // return FALSE; // } // // See Also: XTP_DPN_ACTION, XTPDockingPaneAction //----------------------------------------------------------------------- struct XTP_DOCKINGPANE_ACTION { //{{AFX_CODEJOCK_PRIVATE XTP_DOCKINGPANE_ACTION(XTPDockingPaneAction _action) { pPane = NULL; pDockContainer = NULL; action = _action; bCancel = FALSE; dockDirection = (XTPDockingPaneDirection)-1; } //}}AFX_CODEJOCK_PRIVATE XTPDockingPaneAction action; // Current action the pane is performing. BOOL bCancel; // If TRUE, the current action will be ignored/canceled CXTPDockingPane* pPane; // Pane performing the action. CXTPDockingPaneBase* pDockContainer; // Container of xtpPaneActionDocking action. XTPDockingPaneDirection dockDirection; // The direction that the pane is trying to dock, if any. }; //----------------------------------------------------------------------- // Summary: // Internal structure used by Layout manager // See Also: CXTPDockingPaneLayout //----------------------------------------------------------------------- struct XTP_DOCKINGPANE_INFO { //{{AFX_CODEJOCK_PRIVATE XTP_DOCKINGPANE_INFO(CXTPDockingPane* p = NULL) { pPane = p; pLastHolder = pDockingHolder = pFloatingHolder = 0; } operator CXTPDockingPane*() { return pPane;} CXTPDockingPane* operator->() { return pPane;} //}}AFX_CODEJOCK_PRIVATE CXTPDockingPane* pPane; // Docking Pane CXTPDockingPaneBase* pFloatingHolder; // Last floating holder of the pane CXTPDockingPaneBase* pDockingHolder; // Last docking holder of the pane CXTPDockingPaneBase* pLastHolder; // Last holder (must be pFloatingHolder or pDockingHolder) }; //----------------------------------------------------------------------- // Summary: // This list is used by the CXTPDockingPaneTabbedContainer class for // maintaining a CXTPDockingPane collection. // See Also: // CXTPDockingPaneTabbedContainer::GetPanes //----------------------------------------------------------------------- typedef CList CXTPDockingPaneList; //----------------------------------------------------------------------- // Summary: // This list is used for maintaining a CXTPDockingPaneBase collection. // See Also: // CXTPDockingPaneBase::FindPane, CXTPDockingPaneAutoHidePanel::GetPanes //----------------------------------------------------------------------- typedef CList CXTPDockingPaneBaseList; //----------------------------------------------------------------------- // Summary: // This list is used by the CXTPDockingPaneLayout class for // maintaining a XTP_DOCKINGPANE_INFO collection. // See Also: // CXTPDockingPaneLayout::GetPaneList, CXTPDockingPaneManager::GetPaneList //----------------------------------------------------------------------- typedef CList CXTPDockingPaneInfoList; //----------------------------------------------------------------------- // Summary: // This map is used for mapping CXTPDockingPaneBase objects. // Example: // // CXTPDockingPaneBase* CXTPDockingPaneBase::Clone( // CXTPDockingPaneLayout* pLayout, // CXTPPaneToPaneMap* pMap, // DWORD /*dwIgnoredOptions*/) // { // ASSERT(pMap); // CXTPDockingPaneBase* pClone = new CXTPDockingPaneBase(m_type, pLayout); // pMap->SetAt(this, pClone); // return pClone; // } // // See Also: // CXTPDockingPaneBase::Clone, CXTPDockingPane::Clone //----------------------------------------------------------------------- typedef CMap CXTPPaneToPaneMap; //----------------------------------------------------------------------- // Summary: // This map is used for mapping index to CXTPDockingPaneBase objects. //------------------------------------------------------------------------- typedef CMap CXTPPaneIndexToPaneMap; //=========================================================================== // Summary: // Base for all docking pane messages //=========================================================================== const UINT WM_XTP_DOCKINGPANE_BASE = (WM_USER + 9900); //=========================================================================== // Summary: // The XTPWM_DOCKINGPANE_NOTIFY message is sent to the Docking Pane Manager // owner window whenever an action occurs within the DockingPanes. // Remarks: // The XTPWM_DOCKINGPANE_NOTIFY notification message is sent to inform the // owner window that an action occurs within the DockingPanes. // The owner window of the color picker receives this notification // through the WM_COMMAND message. // // XTPWM_DOCKINGPANE_NOTIFY // CXTPDockingPane* pPane = (CXTPDockingPane*)lParam; // pointer to an CXTPDockingPane object // // // wParam can be one of the following: // * XTP_DPN_SHOWWINDOW // The docking pane is just a virtual container for a user window. The best // place to associate them is after the pane becomes visible because, initially, // it can be created, closed, hidden, or as a non-active tab. You can create your // user window in this handler. // Process this message to attach an existing window to the Docking Pane container using the // Attach member function. // * XTP_DPN_RCLICK // User presses the right mouse button on the docking pane container. // * XTP_DPN_CLOSEPANE // User close the Pane. You can return XTP_ACTION_NOCLOSE while processing the XTP_DPN_CLOSEPANE notification to disable closing docking pane windows. // * XTP_DPN_ACTION // Extended action occur (see XTPDockingPaneAction) // * XTP_DPN_CONTEXTMENU // User pressed menu button or right click to show context menu // // Parameters: // pPane - The value of lParam points to a CXTPDockingPane object that becomes visible.(for XTP_DPN_SHOWWINDOW) // This pointer should never be NULL. // // Example: // Here is an example of how an application would process the XTPWM_DOCKINGPANE_NOTIFY // message. // // BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd) // ON_MESSAGE(XTPWM_DOCKINGPANE_NOTIFY, OnDockingPaneNotify) // END_MESSAGE_MAP() // // LRESULT CMainFrame::OnDockingPaneNotify(WPARAM wParam, LPARAM lParam) // { // switch ((int)wParam) // { // case XTP_DPN_SHOWWINDOW: // { // CXTPDockingPane* pPane = (CXTPDockingPane*)lParam; // // // check if the Pane hasn't been attached yet. // if (!pPane->IsValid()) // { // // check if the user window hasn't been created. // if (!m_wndPane.m_hWnd) // { // // create it. // m_wndPane.CreateEx(WS_EX_STATICEDGE, _T("EDIT"), _T(""), // WS_CHILD | ES_AUTOVSCROLL | ES_MULTILINE, // CRect(0, 0, 200, 120), this, 0); // } // // attach it to the Pane. // pPane->Attach(&m_wndPane); // } // return TRUE; // } // case XTP_DPN_CLOSEPANE: // { // // Disable the user from closing docking panes. // return XTP_ACTION_NOCLOSE; // } // } // // return FALSE; // } // // Returns: // If the application is to process this message, the return value should be // TRUE, otherwise the return value is FALSE. // //=========================================================================== #define XTPWM_DOCKINGPANE_NOTIFY (WM_XTP_DOCKINGPANE_BASE + 1) const int XTP_DPN_SHOWWINDOW = 1; // const int XTP_DPN_RCLICK = 2; // const int XTP_DPN_CLOSEPANE = 3; // const int XTP_DPN_ACTION = 4; // const int XTP_DPN_CONTEXTMENU = 5; // const int XTP_ACTION_NOCLOSE = -1; // //{{AFX_CODEJOCK_PRIVATE // Obsolete #define XTP_DPN_PANEMENUCLICK XTP_DPN_CONTEXTMENU //}}AFX_CODEJOCK_PRIVATE #endif // #if !defined(__XTPDOCKINGPANEDEFINES_H__)