You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1325 lines
59 KiB
C++
1325 lines
59 KiB
C++
// XTPDockingPaneManager.h : interface for the CXTPDockingPaneManager class.
|
|
//
|
|
// 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(__XTPDOCKINGPANEMANAGER_H__)
|
|
#define __XTPDOCKINGPANEMANAGER_H__
|
|
//}}AFX_CODEJOCK_PRIVATE
|
|
|
|
#if _MSC_VER >= 1000
|
|
#pragma once
|
|
#endif // _MSC_VER >= 1000
|
|
|
|
class CXTPDockingPane;
|
|
class CXTPDockingPaneBase;
|
|
class CXTPDockingPaneBase;
|
|
class CXTPDockingPaneManager;
|
|
class CXTPDockingPaneSplitterContainer;
|
|
class CXTPDockingPaneTabbedContainer;
|
|
class CXTPDockingPaneMiniWnd;
|
|
class CXTPDockingPaneContext;
|
|
class CXTPDockingPaneLayout;
|
|
class CXTPDockingPanePaintManager;
|
|
class CXTPImageManagerIcon;
|
|
class CXTPImageManager;
|
|
class CXTPToolTipContext;
|
|
class CXTPDockingPaneSidePanel;
|
|
class CXTPImageManagerIconHandle;
|
|
class CXTPPropExchange;
|
|
|
|
//===========================================================================
|
|
// Summary:
|
|
// CXTPDockingPaneManager is a CWnd derived class. It is used to manipulate
|
|
// docking panes.
|
|
//===========================================================================
|
|
class _XTP_EXT_CLASS CXTPDockingPaneManager : public CWnd, public CXTPAccessible
|
|
{
|
|
public:
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Constructs a CXTPDockingPaneManager object
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPaneManager();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Destroys a CXTPDockingPaneManager object, handles cleanup and
|
|
// deallocation
|
|
//-----------------------------------------------------------------------
|
|
~CXTPDockingPaneManager();
|
|
|
|
public:
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member function to install docking panes.
|
|
// Parameters:
|
|
// pParent - Parent frame of the panes.
|
|
// bClipChildren - 'true' to add WS_CLIPCHILDREN and WS_CLIPSIBLING
|
|
// styles to frame windows so panes are displayed
|
|
// correctly displayed from a hidden state.
|
|
// Returns:
|
|
// 'true' if the Docking Pane manager was correctly initialized, otherwise
|
|
// returns 'false'.
|
|
// Remarks:
|
|
// You must call this member function first to initialize the Docking Pane
|
|
// manager. This must be called first before any other member functions
|
|
// are called.
|
|
//-----------------------------------------------------------------------
|
|
bool InstallDockingPanes(CWnd* pParent, bool bClipChildren=true);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member function to create a docking pane.
|
|
// Parameters:
|
|
// nID - Unique identifier of the pane.
|
|
// rc - Initial size of the pane.
|
|
// direction - Docking direction. Can be any of the values listed in the Remarks section.
|
|
// pNeighbour - Pane's Neighbor. It can be NULL to use the frame as a neighbor.
|
|
// Remarks:
|
|
// direction parameter can be one of the following:
|
|
// * <b>xtpPaneDockTop</b> Docks the pane to the top of the neighbor.
|
|
// * <b>xtpPaneDockLeft</b> Docks the pane to the left of the neighbor.
|
|
// * <b>xtpPaneDockRight</b> Docks the pane to the right of the neighbor.
|
|
// * <b>xtpPaneDockBottom</b> Docks the pane to the bottom of the neighbor.
|
|
// Returns:
|
|
// The pointer to the created pane.
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPane* CreatePane(UINT nID, CRect rc, XTPDockingPaneDirection direction, CXTPDockingPaneBase* pNeighbour = NULL);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to dock an existing pane.
|
|
// Parameters:
|
|
// pPane - Pane to be docked.
|
|
// direction - Docking direction. Can be any of the values listed in the Remarks section.
|
|
// pNeighbour - Pane's Neighbor.
|
|
// Remarks:
|
|
// direction parameter can be one of the following:
|
|
// * <b>xtpPaneDockTop</b> Docks the pane to the top of the neighbor.
|
|
// * <b>xtpPaneDockLeft</b> Docks the pane to the left of the neighbor.
|
|
// * <b>xtpPaneDockRight</b> Docks the pane to the right of the neighbor.
|
|
// * <b>xtpPaneDockBottom</b> Docks the pane to the bottom of the neighbor.
|
|
//-----------------------------------------------------------------------
|
|
void DockPane(CXTPDockingPaneBase* pPane, XTPDockingPaneDirection direction, CXTPDockingPaneBase* pNeighbour = NULL);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to dock an existing pane to a dock panel.
|
|
// Parameters:
|
|
// pPane - Pane to be docked.
|
|
// direction - Docking direction. Can be any of the values listed in the Remarks section.
|
|
// rc - Number of pixels to offset the pane from the inside top edge of the client area. This only has an effect when using the DockLeftOf and DockRightOf direction.
|
|
// Remarks:
|
|
// DockSidePane will dock a pane to the inside edge of the client using code.
|
|
// SideDocking must be enabled for DockSidePane to have any effect.
|
|
//
|
|
// SideDocking enables or disabled "Visio" style client edge docking.
|
|
// Side docking can only occur to the inside edges of the client area.
|
|
// When SideDocking is enabled any pane that is dragged to an inside edge
|
|
// of the client area will attempt to "snap" to that inside edge of the
|
|
// client. The pane will "snap" to the inside edge of the client and
|
|
// will leave a margin equal to that specified by SetSideDockingMargin.
|
|
//
|
|
// SideDocking does not effect normal docking of panes. You will need
|
|
// to drag the pane past the side docking margin for normal docking
|
|
// algorithms to be used.
|
|
// Returns:
|
|
// Reference to the side panel the pane is docked to.
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPaneSidePanel* DockSidePane(CXTPDockingPaneBase* pPane, XTPDockingPaneDirection direction, CRect rc);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to float an existing pane.
|
|
// Parameters:
|
|
// pPane - Pane to be floated.
|
|
// rc - Floating rectangle.
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPaneMiniWnd* FloatPane(CXTPDockingPaneBase* pPane, CRect rc);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to attach a pane to another one.
|
|
// Parameters:
|
|
// pPane - Pane to be attached.
|
|
// pNeighbour - Pane's Neighbor.
|
|
//-----------------------------------------------------------------------
|
|
void AttachPane(CXTPDockingPaneBase* pPane, CXTPDockingPaneBase* pNeighbour);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to switch the pane's position (docking/floating).
|
|
// Parameters:
|
|
// pPane - Docking Pane.
|
|
//-----------------------------------------------------------------------
|
|
void ToggleDocking(CXTPDockingPaneBase* pPane);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to switch the pane's Auto hide (docking/auto hide).
|
|
// Parameters:
|
|
// pPane - Docking Pane.
|
|
//-----------------------------------------------------------------------
|
|
void ToggleAutoHide(CXTPDockingPaneBase* pPane);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to show (activate) a pane
|
|
// Parameters:
|
|
// nID - Pane's identifier.
|
|
// pPane - Pane need to show
|
|
// bSetFocus - TRUE to set focus to selected pane
|
|
//-----------------------------------------------------------------------
|
|
void ShowPane(int nID, BOOL bSetFocus = TRUE);
|
|
void ShowPane(CXTPDockingPane* pPane, BOOL bSetFocus = TRUE); // <COMBINE CXTPDockingPaneManager::ShowPane@int@BOOL>
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to close a pane
|
|
// Parameters:
|
|
// nID - Pane's identifier.
|
|
// pPane - Pane need to close
|
|
//-----------------------------------------------------------------------
|
|
void ClosePane(int nID);
|
|
void ClosePane(CXTPDockingPane* pPane); // <COMBINE CXTPDockingPaneManager::ClosePane@int>
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to destroy a pane
|
|
// Parameters:
|
|
// nID - Pane's identifier.
|
|
// pPane - Pane need to destroy
|
|
// See Also: ClosePane
|
|
//-----------------------------------------------------------------------
|
|
void DestroyPane(int nID);
|
|
void DestroyPane(CXTPDockingPane* pPane); // <COMBINE CXTPDockingPaneManager::DestroyPane@int>
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to hide a pane.
|
|
// Parameters:
|
|
// nID - Pane's identifier.
|
|
// pPane - Pane need to hide
|
|
//-----------------------------------------------------------------------
|
|
void HidePane(int nID);
|
|
void HidePane(CXTPDockingPaneBase* pPane);// <COMBINE CXTPDockingPaneManager::HidePane@int>
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to find a pane by its identifier.
|
|
// Parameters:
|
|
// nID - Pane's identifier.
|
|
// Returns:
|
|
// A pointer to a CXTPDockingPane object.
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPane* FindPane(int nID) const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to check if the pane is closed.
|
|
// Parameters:
|
|
// nID - Pane's identifier.
|
|
// pPane - Pane need to close.
|
|
// Returns:
|
|
// TRUE if the pane is closed.
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsPaneClosed(int nID) const;
|
|
BOOL IsPaneClosed(CXTPDockingPane* pPane) const; // <COMBINE CXTPDockingPaneManager::IsPaneClosed@int@const>
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to check if the pane is hidden.
|
|
// Parameters:
|
|
// nID - Pane's identifier.
|
|
// pPane - Points to a CXTPDockingPane object.
|
|
// Returns:
|
|
// TRUE if the pane is hidden.
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsPaneHidden(int nID) const;
|
|
BOOL IsPaneHidden(CXTPDockingPane* pPane) const; // <COMBINE CXTPDockingPaneManager::IsPaneHidden@int@const>
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to check if the pane is selected.
|
|
// Parameters:
|
|
// nID - Pane's identifier.
|
|
// pPane - Points to a CXTPDockingPane object.
|
|
// Returns:
|
|
// TRUE if the pane is selected.
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsPaneSelected(int nID) const;
|
|
BOOL IsPaneSelected(CXTPDockingPane* pPane) const; // <COMBINE CXTPDockingPaneManager::IsPaneSelected@int@const>
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to set icons to panes.
|
|
// Parameters:
|
|
// nIDResource - Resource Identifier.
|
|
// nIDs - Pointer to an array of pane Ids.
|
|
// nCount - Number of elements in the array pointed to by nIDs.
|
|
// clrMask - RGB value of transparent color.
|
|
// Returns:
|
|
// TRUE if successful, otherwise returns FALSE.
|
|
//-----------------------------------------------------------------------
|
|
BOOL SetIcons(UINT nIDResource, const int* nIDs, int nCount, COLORREF clrMask = 0xC0C0C0);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to set an icon to the pane.
|
|
// Parameters:
|
|
// nID - Docking pane's identifier.
|
|
// hIcon - Icon handle.
|
|
//-----------------------------------------------------------------------
|
|
void SetIcon(UINT nID, const CXTPImageManagerIconHandle& hIcon);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to get an icon of the pane.
|
|
// Parameters:
|
|
// nID - Docking pane's identifier.
|
|
// nWidth - Width of icon to retrieve.
|
|
// Returns:
|
|
// The docking pane's icon.
|
|
//-----------------------------------------------------------------------
|
|
CXTPImageManagerIcon* GetIcon(UINT nID, int nWidth = 16) const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to remove all icons.
|
|
//-----------------------------------------------------------------------
|
|
void ClearIconMap();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to set the speed of animation.
|
|
// Parameters:
|
|
// dAnimationDelay - Must be -1 to use nAnimationDuration and nAnimationInterval.
|
|
// nAnimationDuration - Total time of animation, in milliseconds
|
|
// nAnimationInterval - Amount of time to rest, in milliseconds, between
|
|
// each step.
|
|
// Remarks:
|
|
// To disable animation set nAnimationDuration = 0.
|
|
// See Also: GetAnimationDelay
|
|
//-----------------------------------------------------------------------
|
|
void SetAnimationDelay(double dAnimationDelay = -1, int nAnimationDuration = 128, int nAnimationInterval = 16);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to get the animation speed.
|
|
// Parameters:
|
|
// pAnimationDuration - Pointer to receive total time of animation, in milliseconds.
|
|
// pAnimationInterval - Pointer to receive amount of time to rest, in milliseconds, between
|
|
// each step.
|
|
// Returns:
|
|
// Animation delay.
|
|
// See Also: SetAnimationDelay
|
|
//-----------------------------------------------------------------------
|
|
double GetAnimationDelay(int* pAnimationDuration = NULL, int* pAnimationInterval = NULL) const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to allow user switch and move panes using keyboard.
|
|
// Parameters:
|
|
// options - available keyboard keys that can be use to navigate items
|
|
// Remarks:
|
|
// options can be combination of the following:
|
|
// * <b>xtpPaneKeyboardUseAltMinus</b> To use Alt+'-' to show context menu
|
|
// * <b>xtpPaneKeyboardUseAltF6</b> To use Alt+F6 to select next pane
|
|
// * <b>xtpPaneKeyboardUseAltF7</b> To use Alt+F7 to show window select dialog
|
|
// * <b>xtpPaneKeyboardUseCtrlTab</b> To use Ctrl+Tab to show window select dialog
|
|
// * <b>xtpPaneKeyboardUseAll</b> To use all keys
|
|
//
|
|
// You can call SetKeyboardWindowSelectClass to set custom window for Ctrl-Tab and Alt_F7 operations
|
|
// See Also: XTPDockingPaneKeyboardNavigate
|
|
//-----------------------------------------------------------------------
|
|
void EnableKeyboardNavigate(DWORD options = xtpPaneKeyboardUseAll);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Determines if Keyboard Navigate options enabled.
|
|
// Returns:
|
|
// Returns combination of XTPDockingPaneKeyboardNavigate flags indicates which keys can be used
|
|
// to navigate panes
|
|
// See Also: EnableKeyboardNavigate, XTPDockingPaneKeyboardNavigate
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsKeyboardNavigateEnabled() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to set custom CXTPDockingPaneWindowSelect window, that will use to show active panes and files.
|
|
// Parameters:
|
|
// pWindowSelectClass - CRuntimeClass pointer of custom CXTPDockingPaneWindowSelect window.
|
|
// See Also: EnableKeyboardNavigate, XTPDockingPaneKeyboardNavigate
|
|
//-----------------------------------------------------------------------
|
|
void SetKeyboardWindowSelectClass(CRuntimeClass* pWindowSelectClass);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Determines Runtime class for CXTPDockingPaneWindowSelect window, that shows active panes and files.
|
|
// See Also: SetKeyboardWindowSelectClass, EnableKeyboardNavigate, XTPDockingPaneKeyboardNavigate
|
|
//-----------------------------------------------------------------------
|
|
CRuntimeClass* GetKeyboardWindowSelectClass() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to activate pane in cycle order
|
|
// Parameters:
|
|
// pPane - Pane to start; NULL to select first pane
|
|
// bForward - TRUE to select next pane; FALSE to select previous pane
|
|
//-----------------------------------------------------------------------
|
|
BOOL ActivateNextPane(CXTPDockingPane* pPane, BOOL bForward);
|
|
public:
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to get the list of the created panes.
|
|
// Returns:
|
|
// A list of created panes.
|
|
// See Also:
|
|
// GetPaneStack, CXTPDockingPaneInfoList
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPaneInfoList& GetPaneList() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to get the list of the created panes.including virtual containers
|
|
// Returns:
|
|
// A list of created panes with its containers.
|
|
// See Also: GetPaneList
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPaneBaseList& GetPaneStack() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to return the docking site of the manager.
|
|
// Returns:
|
|
// The docking site.
|
|
//-----------------------------------------------------------------------
|
|
CWnd* GetSite() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to switch the visual theme of the panes.
|
|
// Parameters:
|
|
// theme - New visual theme. Can be any of the values listed in the Remarks section.
|
|
// Remarks:
|
|
// theme can be one of the following:
|
|
// * <b>xtpPaneThemeDefault</b> Enables the default theme.
|
|
// * <b>xtpPaneThemeVisualStudio2003</b> Enables Visual Studio .NET style theme.
|
|
// * <b>xtpPaneThemeGrippered</b> Enables Visual Studio 6 style theme.
|
|
// * <b>xtpPaneThemeOffice2002Visio</b> Enables Visio style theme.
|
|
// * <b>xtpPaneThemeOffice2003</b> Enables Office 2003 style theme.
|
|
// * <b>xtpPaneThemeWinNative</b> Enables XP Theme.
|
|
// * <b>xtpPaneThemeVisualStudio2005Beta1</b> Enables Whidbey theme.
|
|
//-----------------------------------------------------------------------
|
|
void SetTheme(XTPDockingPanePaintTheme theme);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to set a custom theme. See the DockingPane sample
|
|
// as a sample of creating a new theme.
|
|
// Parameters:
|
|
// pTheme - New Theme.
|
|
//-----------------------------------------------------------------------
|
|
void SetCustomTheme(CXTPDockingPanePaintManager* pTheme);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to get the current visual theme.
|
|
// Returns:
|
|
// The current theme.
|
|
//-----------------------------------------------------------------------
|
|
XTPDockingPanePaintTheme GetCurrentTheme() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Retrieves paint manager of docking panes.
|
|
// Returns:
|
|
// Returns paint manager.
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPanePaintManager* GetPaintManager() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to create a new layout.
|
|
// Remarks:
|
|
// You must delete layout when it no longer used.
|
|
// Returns:
|
|
// A pointer to a CXTPDockingPaneLayout object.
|
|
//-----------------------------------------------------------------------
|
|
virtual CXTPDockingPaneLayout* CreateLayout();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to get the current layout.
|
|
// Parameters:
|
|
// pLayout - Pointer to the existing layout.
|
|
//-----------------------------------------------------------------------
|
|
void GetLayout(CXTPDockingPaneLayout* pLayout) const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to set the layout.
|
|
// Parameters:
|
|
// pLayout - Pointer to the existing layout.
|
|
//-----------------------------------------------------------------------
|
|
void SetLayout(const CXTPDockingPaneLayout* pLayout);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to redraw all panes.
|
|
//-----------------------------------------------------------------------
|
|
void RedrawPanes();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to retrieve client pane.
|
|
// Returns:
|
|
// A pointer to a CXTPDockingPaneBase object.
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPaneBase* GetClientPane() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to destroy all panes.
|
|
//-----------------------------------------------------------------------
|
|
void DestroyAll();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to close all panes.
|
|
//-----------------------------------------------------------------------
|
|
void CloseAll();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to retrieve Image Manager of Docking Panes.
|
|
// Returns:
|
|
// Image Manager of Docking Panes.
|
|
//-----------------------------------------------------------------------
|
|
CXTPImageManager* GetImageManager() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to set the specified image manager.
|
|
// Parameters:
|
|
// pImageManager - Points to a CXTPImageManager object.
|
|
//-----------------------------------------------------------------------
|
|
void SetImageManager(CXTPImageManager* pImageManager);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to hide client area.
|
|
// Parameters:
|
|
// bHide - TRUE to hide client.
|
|
//-----------------------------------------------------------------------
|
|
void HideClient(BOOL bHide);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Checks to see if the client is hidden.
|
|
// Returns:
|
|
// TRUE if the client is hidden, FALSE if otherwise
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsClientHidden() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to add margins around panes
|
|
// Parameters:
|
|
// nMargin - Width of margin for panes frame
|
|
//-----------------------------------------------------------------------
|
|
void SetClientMargin(int nMargin);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Retrieves width of margin around panes
|
|
//-----------------------------------------------------------------------
|
|
int GetClientMargin() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Sets the margin between the client area's edge and a docking pane
|
|
// docked to the edge of the client area when side docking is enabled.
|
|
// Parameters:
|
|
// rcMargin - Side docking margins (Margin between the right\top\lef\right
|
|
// edge of the client area and any docking panes that are docked
|
|
// to the left\top\right\bottom edge of the client area.)
|
|
// Remarks:
|
|
// SetSideDockingMargin sets the margins between the client ares's edge
|
|
// and a docking pane docked to the edge of the client area when side
|
|
// docking is enabled.
|
|
// See Also: SideDocking
|
|
//-----------------------------------------------------------------------
|
|
void SetSideDockingMargin(CRect rcMargin);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Gets the margin between the client area's edge and a docking pane
|
|
// docked to the edge of the client area when side docking is enabled.
|
|
// Remarks:
|
|
// SetSideDockingMargin sets the margins between the client ares's edge
|
|
// and a docking pane docked to the edge of the client area when side
|
|
// docking is enabled.
|
|
// Returns:
|
|
// Side docking margins (Margin between the right\top\lef\right
|
|
// edge of the client area and any docking panes that are docked
|
|
// to the left\top\right\bottom edge of the client area.)
|
|
// See Also: SideDocking, SetSideDockingMargin
|
|
//-----------------------------------------------------------------------
|
|
CRect GetSideDockingMargin() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to use trackers.
|
|
// Parameters:
|
|
// bSplitterTracker - TRUE to use trackers.
|
|
// Remarks:
|
|
// This member function will display the contents for child pane
|
|
// while the splitter is resized if bSplitterTracker is set to FALSE.
|
|
// See Also: IsSplitterTrackerUsed
|
|
//-----------------------------------------------------------------------
|
|
void UseSplitterTracker(BOOL bSplitterTracker);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to determine if the splitter tracker is used.
|
|
// Returns:
|
|
// TRUE if the splitter tracker is used; otherwise returns FALSE.
|
|
// See Also: UseSplitterTracker
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsSplitterTrackerUsed() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to set direction of captions
|
|
// Parameters:
|
|
// captionDirection - New direction to be set
|
|
// Remarks:
|
|
// captionDirection parameter can be one of the following:
|
|
// * <b>xtpPaneCaptionHorizontal</b>
|
|
// * <b>xtpPaneCaptionVertical</b>
|
|
// * <b>xtpPaneCaptionAutoByPosition</b>
|
|
// * <b>xtpPaneCaptionAutoBySize</b>
|
|
// Example:
|
|
// m_paneManager.GetPaintManager()->SetCaptionDirection(xtpPaneCaptionAutoSize);
|
|
//-----------------------------------------------------------------------
|
|
void SetCaptionDirection(XTPDockingPaneCaptionDirection captionDirection);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member determine the direction the tab buttons are displayed.
|
|
// Remarks:
|
|
// Can return one of the following direction:
|
|
// * <b>xtpPaneCaptionHorizontal</b>
|
|
// * <b>xtpPaneCaptionVertical</b>
|
|
// * <b>xtpPaneCaptionAutoByPosition</b>
|
|
// * <b>xtpPaneCaptionAutoBySize</b>
|
|
// Returns:
|
|
// A XTPDockingPaneCaptionDirection flag indicating which direction the
|
|
// pane caption is displayed.
|
|
// See Also: SetCaptionDirection
|
|
//-----------------------------------------------------------------------
|
|
XTPDockingPaneCaptionDirection GetCaptionDirection() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to lock splitters.
|
|
// Parameters:
|
|
// bLock - TRUE to forbid splitter window panes to
|
|
// be resized.
|
|
//-----------------------------------------------------------------------
|
|
void LockSplitters(BOOL bLock = TRUE);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to determine if the splitters are locked.
|
|
// Returns:
|
|
// TRUE if the splitters are locked; otherwise returns FALSE.
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsSplittersLocked() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to set common caption for floating frames.
|
|
// Parameters:
|
|
// lpszCaption - Caption to be set.
|
|
//-----------------------------------------------------------------------
|
|
void SetFloatingFrameCaption(LPCTSTR lpszCaption);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to use themes for floating frames.
|
|
// Parameters:
|
|
// bThemedFloatingFrames - TRUE to use themed floating panes, FALSE otherwise.
|
|
//-----------------------------------------------------------------------
|
|
void SetThemedFloatingFrames(BOOL bThemedFloatingFrames);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Determines if themes are used for the floating frames.
|
|
// Returns:
|
|
// TRUE if they are used; otherwise returns FALSE.
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsThemedFloatingFrames() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to enable sticky floating frames
|
|
// Parameters:
|
|
// bSticky - TRUE to use sticky floating frames, FALSE otherwise.
|
|
//-----------------------------------------------------------------------
|
|
void SetStickyFloatingFrames(BOOL bSticky);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Determines if sticky floating frames option enabled
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsStickyFloatingFrames() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to set opacity for inactive floating frames
|
|
// Parameters:
|
|
// nOpacity - Alpha value. When nOpacity is 0, the window is completely transparent. When nOpacity is 255, the window is opaque.
|
|
//-----------------------------------------------------------------------
|
|
void SetFloatingFramesOpacity(int nOpacity);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Determines opacity for inactive floating frames
|
|
//-----------------------------------------------------------------------
|
|
int GetFloatingFramesOpacity() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to keep the activation of floating frames windows in sync with the activation of the top level frame window.
|
|
// Parameters:
|
|
// bSyncActiveFloatingFrames - TRUE to synchronizes the activation of the mini-frame window
|
|
// to the activation of its parent window.
|
|
//-----------------------------------------------------------------------
|
|
void SyncActiveFloatingFrames(BOOL bSyncActiveFloatingFrames);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to determine if the current layout is Right-to-Left (RTL).
|
|
// Returns:
|
|
// TRUE if the current layout is Right-to-Left (RTL), FALSE if the
|
|
// layout is Left-to-Right.
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsLayoutRTL() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to return the Right-to-Left (RTL) docking direction
|
|
// equivalent to the direction passed in if IsLayoutRTL returns TRUE.
|
|
// Parameters:
|
|
// direction - Docking direction
|
|
// Returns:
|
|
// Returns the Righ-to-Left docking direction of the supplied direction
|
|
// if IsLayoutRTL returns TRUE. If IsLayoutRTL returns FALSE, then
|
|
// the direction passed in remains the same.
|
|
//-----------------------------------------------------------------------
|
|
XTPDockingPaneDirection GetRTLDirection(XTPDockingPaneDirection direction) const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to determine the XTPDockingPaneDirection of pPane.
|
|
// Parameters:
|
|
// pPane - Points to a CXTPDockingPaneBase object
|
|
// Returns:
|
|
// The current XTPDockingPaneDirection of pPane.
|
|
//-----------------------------------------------------------------------
|
|
XTPDockingPaneDirection GetPaneDirection(const CXTPDockingPaneBase* pPane) const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Retrieves top level virtual container for site window.
|
|
// Remarks:
|
|
// Top level container always splitter container (xtpPaneTypeSplitterContainer)
|
|
// Returns:
|
|
// Top level container.
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPaneBase* GetTopPane() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to use custom docking context.
|
|
// Parameters:
|
|
// pDockingContext - Points to a CXTPDockingPaneContext object
|
|
//-----------------------------------------------------------------------
|
|
void SetDockingContext(CXTPDockingPaneContext* pDockingContext);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Retrieves current docking context pointer.
|
|
// Returns:
|
|
// Pointer to current docking context.
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPaneContext* GetDockingContext() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to determine if Alpha Docking Context is used when
|
|
// panes are being dragged and dropped.
|
|
// Returns:
|
|
// TRUE if AlphaDockingContext is enabled, FALSE if it is disabled.
|
|
// Remarks:
|
|
// AlphaDockingContext must be TRUE if Docking Context Stickers will
|
|
// be used.
|
|
// See Also: SetAlphaDockingContext, IsShowDockingContextStickers, SetShowDockingContextStickers
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsAlphaDockingContext() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to specify whether an alpha docking context is
|
|
// used to indicate where a pane can be docked while dragging the pane.
|
|
// Parameters:
|
|
// bAlphaDockingContext - TRUE to enable Alpha colorization while docking.
|
|
// Remarks:
|
|
// Specifies whether the area that a docking pane can occupy is
|
|
// shaded in gray as the pane is dragged to its new location. The
|
|
// shaded area indicates the area on the application the docking
|
|
// pane will occupy if docked in that location.
|
|
// AlphaDockingContext must be TRUE if Docking Context Stickers will
|
|
// be used.
|
|
// See Also: IsAlphaDockingContext, IsShowDockingContextStickers, SetShowDockingContextStickers
|
|
//-----------------------------------------------------------------------
|
|
void SetAlphaDockingContext(BOOL bAlphaDockingContext);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to determine whether Docking Context Stickers are used.
|
|
// Returns:
|
|
// TRUE if Docking Context Stickers are used, FALSE if they are not used.
|
|
// See Also: SetAlphaDockingContext, IsAlphaDockingContext, SetShowDockingContextStickers
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsShowDockingContextStickers() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to specify whether Visual Studio 2005 style
|
|
// Docking Context Stickers are used while dragging a docking pane.
|
|
// Parameters:
|
|
// bShowDockingContextStickers - If TRUE, docking stickers are drawn
|
|
// on the screen indicating all the possible locations that the docking
|
|
// pane can be docked while the pane is dragged over the application.
|
|
// AlphaDockingContext must also be True to display the stickers.
|
|
// Remarks:
|
|
// AlphaDockingContext must be TRUE if Docking Context Stickers will
|
|
// be used.
|
|
// See Also: SetAlphaDockingContext, IsAlphaDockingContext, IsShowDockingContextStickers, SetDockingContextStickerStyle
|
|
//-----------------------------------------------------------------------
|
|
void SetShowDockingContextStickers(BOOL bShowDockingContextStickers);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to set Docking Context Stickers style.
|
|
// Parameters:
|
|
// style - Style of docking pane stickers.
|
|
// Remarks:
|
|
// Call SetShowDockingContextStickers to enable Stickers.
|
|
// Style parameter can be one of the following:
|
|
// * <b>xtpPaneStickerStyleVisualStudio2005Beta</b> Whidbey stickers.
|
|
// * <b>xtpPaneStickerStyleVisualStudio2005</b> Visual Studio 2005 stickers.
|
|
// See Also: SetShowDockingContextStickers, GetDockingContextStickerStyle
|
|
//-----------------------------------------------------------------------
|
|
void SetDockingContextStickerStyle(XTPDockingContextStickerStyle style);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to get Docking Context Stickers style.
|
|
// Returns:
|
|
// Style of docking pane stickers.
|
|
// Remarks:
|
|
// Call SetShowDockingContextStickers to enable Stickers.
|
|
// See Also: SetShowDockingContextStickers, SetDockingContextStickerStyle
|
|
//-----------------------------------------------------------------------
|
|
XTPDockingContextStickerStyle GetDockingContextStickerStyle() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member to set "Show window contents while dragging" option
|
|
// Parameters:
|
|
// bShow - TRUE to set show contents while dragging
|
|
//-----------------------------------------------------------------------
|
|
void SetShowContentsWhileDragging(BOOL bShow = TRUE);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Determines if "Show window contents while dragging" option is enabled
|
|
// Returns:
|
|
// TRUE if contents is visible while dragging.
|
|
//-----------------------------------------------------------------------
|
|
BOOL GetShowContentsWhileDragging() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to show Maximize/Restore buttons for docking panes
|
|
// Parameters:
|
|
// bShowMaximizeButton - TRUE to show maximize buttons for panes
|
|
// See Also: IsCaptionMaximizeButtonsVisible
|
|
//-----------------------------------------------------------------------
|
|
void ShowCaptionMaximizeButton(BOOL bShowMaximizeButton);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Determines if Maximize/Restore buttons for docking panes are visible
|
|
// See Also: ShowCaptionMaximizeButton
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsCaptionMaximizeButtonsVisible() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to save current splitter positions for all splitter containers
|
|
// See Also: CXTPDockingPaneSplitterContainer
|
|
//-----------------------------------------------------------------------
|
|
void NormalizeSplitters();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to recalculate layout for all parent frames of panes.
|
|
//-----------------------------------------------------------------------
|
|
void RecalcFramesLayout();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// This method updates XTP_DOCKINGPANE_INFO structure for each panes filling
|
|
// its members.
|
|
//-----------------------------------------------------------------------
|
|
void SyncPanesState();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to set default options for each pane
|
|
// Parameters:
|
|
// dwOptions - Option applied for each pane. Can be any of the values listed in the Remarks section.
|
|
// Remarks:
|
|
// dwOptions parameter can be one or more of the following:
|
|
// * <b>xtpPaneNoCloseable</b> Indicates the pane cannot be closed.
|
|
// * <b>xtpPaneNoHideable</b> Indicates the pane cannot be hidden.
|
|
// * <b>xtpPaneNoFloatable</b> Indicates the pane cannot be floated.
|
|
// * <b>xtpPaneNoCaption</b> Indicates the pane has no caption..
|
|
// See Also: GetDefaultPaneOptions, CXTPDockingPane::SetOptions, XTPDockingPaneOptions
|
|
//-----------------------------------------------------------------------
|
|
void SetDefaultPaneOptions(DWORD dwOptions);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Retrieves default panes options.
|
|
// Returns:
|
|
// Default options used for each pane.
|
|
// See Also: SetDefaultPaneOptions, XTPDockingPaneOptions
|
|
//-----------------------------------------------------------------------
|
|
DWORD GetDefaultPaneOptions() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member function to set the application's panes into and out of print-preview mode.
|
|
// Parameters:
|
|
// bPreview - Specifies whether or not to place the application in print-preview mode. Set to TRUE to place in print preview, FALSE to cancel preview mode.
|
|
//-----------------------------------------------------------------------
|
|
void OnSetPreviewMode (BOOL bPreview);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member function to get pane currently active (focused)
|
|
//-----------------------------------------------------------------------
|
|
CXTPDockingPane* GetActivePane() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to get tooltip context pointer.
|
|
//-----------------------------------------------------------------------
|
|
CXTPToolTipContext* GetToolTipContext() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this member function to save/restore the settings of the pane.
|
|
// Parameters:
|
|
// pPX - Points to a CXTPPropExchange object.
|
|
// Returns:
|
|
// TRUE if successful; otherwise returns FALSE.
|
|
//-----------------------------------------------------------------------
|
|
BOOL DoPropExchange(CXTPPropExchange* pPX);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// This method is called to recalculate layout of pane's site.
|
|
// Parameters:
|
|
// pPane - Pane which site need to recalculate
|
|
// bDelay - TRUE to recalculate after small delay
|
|
//-----------------------------------------------------------------------
|
|
void RecalcFrameLayout(CXTPDockingPaneBase* pPane, BOOL bDelay = FALSE);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// This method is called to update panes state
|
|
//-----------------------------------------------------------------------
|
|
virtual void UpdatePanes();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// This member is called to notify the parent window that an event
|
|
// has occurred in the docking pane.
|
|
// Parameters:
|
|
// nCode - Specifies which event has occurred.
|
|
// lParam - Additional message-specific information.
|
|
//-----------------------------------------------------------------------
|
|
virtual LRESULT NotifyOwner(UINT nCode, LPARAM lParam);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to show and activate pane
|
|
// Parameters:
|
|
// pPane - pane to show
|
|
// See Also: ShowPane
|
|
//-----------------------------------------------------------------------
|
|
void EnsureVisible(CXTPDockingPaneBase* pPane);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Enables or disables side docking.
|
|
// Parameters:
|
|
// bEnable - TRUE to enable side docking, FALSE to disable side docking.
|
|
// See Also: SideDocking, SetSideDockingMargin
|
|
//-----------------------------------------------------------------------
|
|
void EnableSideDocking(BOOL bEnable = TRUE);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Determines if side docking is enabled.
|
|
// Returns:
|
|
// TRUE if side docking is enabled, FALSE if side docking is disabled.
|
|
// See Also: SideDocking, SetSideDockingMargin, EnableSideDocking
|
|
//-----------------------------------------------------------------------
|
|
BOOL IsSideDockingEnabled() const;
|
|
|
|
public:
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// This method is called when a pane is created.
|
|
// Parameters:
|
|
// type - Type of pane that is created.
|
|
// pLayout - Points to a CXTPDockingPaneLayout object.
|
|
// Returns:
|
|
// Created pane.
|
|
//-----------------------------------------------------------------------
|
|
virtual CXTPDockingPaneBase* OnCreatePane(XTPDockingPaneType type, CXTPDockingPaneLayout* pLayout);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// This method is called when a pane activated/deactivated
|
|
// Parameters:
|
|
// bActive - TRUE if pane activated, FALSE otherwise;
|
|
// pPane - Pane was activated/deactivated.
|
|
//-----------------------------------------------------------------------
|
|
virtual void OnActivatePane(BOOL bActive, CXTPDockingPane* pPane);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// The framework calls this method when a docking pane is performing an action.
|
|
// Parameters:
|
|
// action - The action the docking pane is performing.
|
|
// pPane - The pane performing the action.
|
|
// pDockContainer - Object used to provide additional information about where a Pane will be\has been docked.
|
|
// dockDirection - Specifies the direction where a pane is docking.
|
|
// Returns:
|
|
// TRUE if the action was successful, FALSE if the action was cancelled or failed.
|
|
//-----------------------------------------------------------------------
|
|
BOOL NotifyAction(XTPDockingPaneAction action, CXTPDockingPane* pPane, CXTPDockingPaneBase* pDockContainer = NULL, XTPDockingPaneDirection dockDirection = xtpPaneDockLeft);
|
|
protected:
|
|
//{{AFX_CODEJOCK_PRIVATE
|
|
DECLARE_MESSAGE_MAP()
|
|
|
|
//{{AFX_MSG(CXTPDockingPaneManager)
|
|
afx_msg void OnSysColorChange();
|
|
afx_msg void OnSettingChange(UINT uFlags, LPCTSTR lpszSection);
|
|
afx_msg LRESULT OnSizeParent(WPARAM, LPARAM lParam);
|
|
afx_msg LRESULT OnIdleUpdateCmdUI(WPARAM wParam, LPARAM);
|
|
afx_msg void OnInitialUpdate();
|
|
afx_msg LRESULT OnGetObject(WPARAM wParam, LPARAM lParam);
|
|
BOOL OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult);
|
|
//}}AFX_MSG
|
|
//}}AFX_CODEJOCK_PRIVATE
|
|
|
|
protected:
|
|
//{{AFX_CODEJOCK_PRIVATE
|
|
// System accessibility support.
|
|
virtual HRESULT GetAccessibleParent(IDispatch** ppdispParent);
|
|
virtual HRESULT GetAccessibleChildCount(long* pcountChildren);
|
|
virtual HRESULT GetAccessibleChild(VARIANT varChild, IDispatch** ppdispChild);
|
|
virtual HRESULT GetAccessibleName(VARIANT varChild, BSTR* pszName);
|
|
virtual HRESULT GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole);
|
|
virtual HRESULT AccessibleLocation(long *pxLeft, long *pyTop, long *pcxWidth, long* pcyHeight, VARIANT varChild);
|
|
virtual HRESULT AccessibleHitTest(long xLeft, long yTop, VARIANT* pvarChild);
|
|
virtual HRESULT GetAccessibleState(VARIANT varChild, VARIANT* pvarState);
|
|
virtual CCmdTarget* GetAccessible();
|
|
|
|
DECLARE_INTERFACE_MAP()
|
|
//}}AFX_CODEJOCK_PRIVATE
|
|
|
|
|
|
private:
|
|
CXTPDockingPaneLayout* GetCurrentLayout() const;
|
|
|
|
CRect _CalculateResultDockingRect(CXTPDockingPaneBase* pPane, XTPDockingPaneDirection direction, CXTPDockingPaneBase* pNeighbour);
|
|
void _InsertPane(CXTPDockingPaneBase* pPane, XTPDockingPaneDirection direction, CXTPDockingPaneBase* pNeighbour);
|
|
void _RemovePane(CXTPDockingPaneBase* pPane);
|
|
void _AttachPane(CXTPDockingPaneBase* pPane, CXTPDockingPaneBase* pNeighbour);
|
|
CXTPDockingPaneBase* _GetHolder(CXTPDockingPaneBase* pPane, BOOL bFloating);
|
|
CXTPDockingPaneBase* _Clone(CXTPDockingPaneBase* pPane);
|
|
|
|
void _TrackPopupContextMenu(CXTPDockingPane* pPane);
|
|
void _Redraw();
|
|
void _DetachAll();
|
|
BOOL _ToggleDocking(CXTPDockingPane* pPane, CXTPDockingPaneBase* pHolder);
|
|
|
|
public:
|
|
int m_nSplitterGap; // Minimum available width of panes.
|
|
BOOL m_bCloseGroupOnButtonClick; // If TRUE, when the close button on a group of panes is clicked, then the entire group of panes is closed. If FALSE, the only the currently visible pane in the group will be closed.
|
|
BOOL m_bHideGroupOnButtonClick; // If TRUE, when the hide button on a group of panes is clicked, then the entire group of panes is hidden. If FALSE, the only the currently visible pane in the group will be hidden.
|
|
BOOL m_bShowSizeCursorWhileDragging; // TRUE to show size cursor while panes are dragged
|
|
CPoint m_ptMinClientSize; // Minimum client size
|
|
int m_nStickyGap; // Sticky gap
|
|
BOOL m_bShowPanelScrollButtons; // TRUE to show scroll buttons for AutoHide Panels.
|
|
BOOL m_bAutoInitialUpdate; // TRUE to send WM_INITIIALUPDATE to Pane Children
|
|
XTPTabNavigateButtonFlags m_bShowCloseTabButton; // Close Tab Button Flag
|
|
|
|
protected:
|
|
CWnd* m_pSite; // Parent window of docking manager.
|
|
CXTPDockingPaneLayout* m_pLayout; // Selected layout.
|
|
CXTPDockingPanePaintManager* m_pPaintManager; // Current paint manager.
|
|
CXTPDockingPane* m_pActivePane; // Current Active pane;
|
|
|
|
int m_nClientMargin; // Client margins
|
|
CRect m_rcSideDockingMargin; // Side docking margin, this is the margin between the client area's edge and a docking pane docked to the edge of the client area when side docking is enabled.
|
|
BOOL m_bStickyFloatingFrames; // TRUE to enable sticky option for floating panes
|
|
|
|
CXTPImageManager* m_pImageManager; // Image manager of docking panes.
|
|
|
|
BOOL m_bSideDocking; // TRUE if side docking is enabled, FALSE if disabled.
|
|
|
|
BOOL m_bHideClient; // If TRUE, the client area is hidden so that only the docking panes are visible and occupy the entire area.
|
|
BOOL m_bUseSplitterTracker; // If TRUE, splitter trackers are used. When resizing a docking pane, an outline of the pane is drawn as the splitter is dragged. If FALSE, the docking pane will be resized in "real-time."
|
|
BOOL m_bShowMaximizeButton; // Allow panes to be maximized.
|
|
|
|
BOOL m_bLockSplitters; // If TRUE, you can not resize the panes when they are docked. However, panes can be resized via code and when they are floated.
|
|
BOOL m_bAlphaDockingContext; // If TRUE, alpha docking context is used when dragging a pane, the shaded area indicates the panes new location of dropped.
|
|
BOOL m_bShowDockingContextStickers; // If TRUE, docking context stickers are drawn when the pane is being dragged and dropped. m_bAlphaDockingContext must be TRUE.
|
|
BOOL m_bShowContentsWhileDragging; // If TRUE, window contents is visible while dragging.
|
|
|
|
BOOL m_bThemedFloatingFrames; // If TRUE, floating docking panes will use the currently set theme.
|
|
BOOL m_bSyncActiveFloatingFrames; // Synchronizes the activation of the mini-frame window to the activation of its parent window.
|
|
BOOL m_nFloatingFramesOpacity; // Opacity of floating frames
|
|
DWORD m_bKeyboardEnabled; // XTPDockingPaneKeyboardNavigate options
|
|
|
|
DWORD m_dwDefaultPaneOptions; // Default Panes options.
|
|
XTPDockingPaneCaptionDirection m_captionDirection; // Caption Direction
|
|
|
|
CString m_strFloatingFrameCaption; // The caption that is displayed in the title bar of a floating frame that has panes docked. This is the floating frame that contains other docking panes.
|
|
|
|
XTPDockingContextStickerStyle m_nDockingContextStickerStyle; // Sticker style.
|
|
|
|
CXTPDockingPaneContext* m_pDockingContext; // Docking context helper.
|
|
CXTPDockingPaneLayout* m_pPreviewLayout; // Preview mode layout.
|
|
CXTPToolTipContext* m_pToolTipContext; // Tooltip Context.
|
|
|
|
typedef BOOL (WINAPI *PFNSETLAYEREDWINDOWATTRIBUTES) (HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags);
|
|
PFNSETLAYEREDWINDOWATTRIBUTES m_pfnSetLayeredWindowAttributes; // POinter to SetLayeredWindowAttributes API function
|
|
CRuntimeClass* m_pWindowSelectClass; // Runtime class of WindowSelect
|
|
|
|
private:
|
|
HWND m_hwndLastFocus;
|
|
BOOL m_bAttachingPane;
|
|
BOOL m_bLayoutCreated;
|
|
BOOL m_bInitialUpdateCalled;
|
|
CString m_strMove;
|
|
|
|
friend class CXTPDockingPaneBase;
|
|
friend class CXTPDockingPaneBaseContainer;
|
|
friend class CXTPDockingPaneSplitterContainer;
|
|
friend class CXTPDockingPaneTabbedContainer;
|
|
friend class CXTPDockingPaneMiniWnd;
|
|
friend class CXTPDockingPaneAutoHideWnd;
|
|
friend class CXTPDockingPaneContext;
|
|
friend class CXTPDockingPane;
|
|
friend class CXTPDockingPaneLayout;
|
|
friend class CXTPDockingPaneAutoHidePanel;
|
|
friend class CDockingPaneSite;
|
|
friend class CDockingPaneCtrl;
|
|
friend class CDockingPaneOptions;
|
|
|
|
};
|
|
|
|
AFX_INLINE CWnd* CXTPDockingPaneManager::GetSite() const {
|
|
return m_pSite;
|
|
}
|
|
AFX_INLINE CXTPDockingPaneLayout* CXTPDockingPaneManager::GetCurrentLayout() const {
|
|
return m_pLayout;
|
|
}
|
|
|
|
AFX_INLINE void CXTPDockingPaneManager::RedrawPanes() {
|
|
_Redraw();
|
|
}
|
|
AFX_INLINE CXTPDockingPanePaintManager* CXTPDockingPaneManager::GetPaintManager() const {
|
|
return m_pPaintManager;
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsClientHidden() const {
|
|
return m_bHideClient;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::UseSplitterTracker(BOOL bSplitterTracker) {
|
|
m_bUseSplitterTracker = bSplitterTracker;
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsSplitterTrackerUsed() const {
|
|
return m_bUseSplitterTracker;
|
|
}
|
|
AFX_INLINE CXTPImageManager* CXTPDockingPaneManager::GetImageManager() const {
|
|
return m_pImageManager;
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsSplittersLocked() const {
|
|
return m_bLockSplitters;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::SetFloatingFrameCaption(LPCTSTR lpszCaption) {
|
|
m_strFloatingFrameCaption = lpszCaption;
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsThemedFloatingFrames() const {
|
|
return m_bThemedFloatingFrames;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::SetStickyFloatingFrames(BOOL bSticky) {
|
|
m_bStickyFloatingFrames = bSticky;
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsStickyFloatingFrames() const {
|
|
return m_bStickyFloatingFrames;
|
|
}
|
|
AFX_INLINE CXTPDockingPaneContext* CXTPDockingPaneManager::GetDockingContext() const {
|
|
return m_pDockingContext;
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsAlphaDockingContext() const {
|
|
return m_bAlphaDockingContext;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::SetAlphaDockingContext(BOOL bAlphaDockingContext) {
|
|
m_bAlphaDockingContext = bAlphaDockingContext;
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsShowDockingContextStickers() const {
|
|
return m_bShowDockingContextStickers;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::SetShowDockingContextStickers(BOOL bShowDockingContextStickers) {
|
|
m_bShowDockingContextStickers = bShowDockingContextStickers;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::SetDefaultPaneOptions(DWORD dwOptions) {
|
|
m_dwDefaultPaneOptions = dwOptions;
|
|
}
|
|
AFX_INLINE DWORD CXTPDockingPaneManager::GetDefaultPaneOptions() const {
|
|
return m_dwDefaultPaneOptions;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::ClosePane(int nID) {
|
|
ClosePane(FindPane(nID));
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::ShowPane(int nID, BOOL bSetFocus) {
|
|
ShowPane(FindPane(nID), bSetFocus);
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::DestroyPane(int nID) {
|
|
DestroyPane(FindPane(nID));
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsPaneClosed(int nID) const {
|
|
return IsPaneClosed(FindPane(nID));
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsPaneHidden(int nID) const {
|
|
return IsPaneHidden(FindPane(nID));
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsPaneSelected(int nID) const {
|
|
return IsPaneSelected(FindPane(nID));
|
|
}
|
|
AFX_INLINE CXTPDockingPane* CXTPDockingPaneManager::GetActivePane() const {
|
|
return m_pActivePane;
|
|
}
|
|
AFX_INLINE CXTPToolTipContext* CXTPDockingPaneManager::GetToolTipContext() const {
|
|
return m_pToolTipContext;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::ShowCaptionMaximizeButton(BOOL bShowMaximizeButton) {
|
|
m_bShowMaximizeButton = bShowMaximizeButton;
|
|
RedrawPanes();
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsCaptionMaximizeButtonsVisible() const {
|
|
return m_bShowMaximizeButton;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::SetDockingContextStickerStyle(XTPDockingContextStickerStyle style) {
|
|
m_nDockingContextStickerStyle = style;
|
|
}
|
|
AFX_INLINE XTPDockingContextStickerStyle CXTPDockingPaneManager::GetDockingContextStickerStyle() const {
|
|
return m_nDockingContextStickerStyle;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::SetCaptionDirection(XTPDockingPaneCaptionDirection captionDirection) {
|
|
m_captionDirection = captionDirection;
|
|
RedrawPanes();
|
|
}
|
|
AFX_INLINE XTPDockingPaneCaptionDirection CXTPDockingPaneManager::GetCaptionDirection() const {
|
|
return m_captionDirection;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::SetShowContentsWhileDragging(BOOL bShow) {
|
|
m_bShowContentsWhileDragging = bShow;
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::GetShowContentsWhileDragging() const {
|
|
return m_bShowContentsWhileDragging;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::SetClientMargin(int nMargin) {
|
|
if (m_nClientMargin != nMargin) {
|
|
m_nClientMargin = nMargin;
|
|
RecalcFrameLayout(NULL, TRUE);
|
|
}
|
|
}
|
|
AFX_INLINE int CXTPDockingPaneManager::GetClientMargin() const {
|
|
return m_nClientMargin;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::SetSideDockingMargin(CRect rcMargin) {
|
|
if (m_rcSideDockingMargin != rcMargin) {
|
|
m_rcSideDockingMargin = rcMargin;
|
|
RecalcFrameLayout(NULL, TRUE);
|
|
}
|
|
}
|
|
AFX_INLINE CRect CXTPDockingPaneManager::GetSideDockingMargin() const {
|
|
return m_rcSideDockingMargin;
|
|
}
|
|
AFX_INLINE int CXTPDockingPaneManager::GetFloatingFramesOpacity() const {
|
|
return m_nFloatingFramesOpacity;
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsKeyboardNavigateEnabled() const {
|
|
return m_bKeyboardEnabled;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::SetKeyboardWindowSelectClass(CRuntimeClass* pWindowSelectClass) {
|
|
m_pWindowSelectClass = pWindowSelectClass;
|
|
}
|
|
AFX_INLINE CRuntimeClass* CXTPDockingPaneManager::GetKeyboardWindowSelectClass() const {
|
|
return m_pWindowSelectClass;
|
|
}
|
|
AFX_INLINE void CXTPDockingPaneManager::EnableSideDocking(BOOL bEnable) {
|
|
m_bSideDocking = bEnable;
|
|
}
|
|
AFX_INLINE BOOL CXTPDockingPaneManager::IsSideDockingEnabled() const {
|
|
return m_bSideDocking;
|
|
}
|
|
|
|
|
|
#endif //#if !defined(__XTPDOCKINGPANEMANAGER_H__)
|