/**
 * @file XTPDockingPaneManager.h
 *
 * @copyright
 * (c) 1998-2025 Codejock Software, All Rights Reserved.
 *
 * This source file is the property of Codejock Software and must not be
 * redistributed by any means without the explicit written permission of
 * Codejock Software.
 *
 * The use of this source code is governed by the terms and conditions specified
 * in the Toolkit Pro license agreement. Codejock Software grants you, as a
 * single software developer, the limited right to use this software on one
 * computer only.
 *
 * Contact Information:
 * support@codejock.com
 * http://www.codejock.com
 *
 */

/** @cond */
#if !defined(__XTPDOCKINGPANEMANAGER_H__)
#	define __XTPDOCKINGPANEMANAGER_H__
/** @endcond */

#	if _MSC_VER >= 1000
#		pragma once
#	endif // _MSC_VER >= 1000

#	include "Common/Base/Diagnostic/XTPDisableNoisyWarnings.h"

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;

/**
 * @brief
 * CXTPDockingPaneManager is a CWnd derived class. It is used to manipulate
 * docking panes.
 */
class _XTP_EXT_CLASS CXTPDockingPaneManager
	: public CWnd
	, public CXTPAccessible
{
public:
	/**
	 * @brief
	 * Constructs a CXTPDockingPaneManager object.
	 */
	CXTPDockingPaneManager();

	/**
	 * @brief
	 * Destroys a CXTPDockingPaneManager object, handles cleanup and
	 * deallocation.
	 */
	~CXTPDockingPaneManager();

public:
	/**
	 * @brief
	 * Call this member function to install docking panes.
	 * @param pParent       Parent frame of the panes.
	 * @param bClipChildren 'true' to add WS_CLIPCHILDREN and WS_CLIPSIBLING
	 * styles to frame windows so panes are displayed
	 * correctly from a hidden state.
	 * @return
	 * 'true' if the Docking Pane manager was correctly initialized,
	 * otherwise 'false'.
	 * @details
	 * 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.
	 */
	virtual bool InstallDockingPanes(CWnd* pParent, bool bClipChildren = true);

	/**
	 * @brief
	 * Call this member function to create a docking pane.
	 * @param nID        Unique identifier of the pane.
	 * @param rc         Initial size of the pane.
	 * @param direction  Docking direction. Can be any of the values listed in the
	 * Remarks section.
	 * @param pNeighbour Pane's Neighbor. It can be NULL to use the frame as a neighbor.
	 * @details
	 * 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.
	 * @return
	 * The pointer to the created pane.
	 */
	virtual CXTPDockingPane* CreatePane(UINT nID, CRect rc, XTPDockingPaneDirection direction,
										CXTPDockingPaneBase* pNeighbour = NULL);

	/**
	 * @brief
	 * Call this member to dock an existing pane.
	 * @param pPane      Pane to be docked.
	 * @param direction  Docking direction. Can be any of the values listed in the
	 * Remarks section.
	 * @param pNeighbour Pane's Neighbor.
	 * @details
	 * 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.
	 */
	virtual void DockPane(CXTPDockingPaneBase* pPane, XTPDockingPaneDirection direction,
						  CXTPDockingPaneBase* pNeighbour = NULL);

	/**
	 * @brief
	 * Call this member to dock an existing pane to a dock panel.
	 * @param pPane      Pane to be docked.
	 * @param direction  Docking direction. Can be any of the values listed in the
	 * Remarks section.
	 * @param 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.
	 * @details
	 * 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 disables "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 affect normal docking of panes. You will need
	 * to drag the pane past the side docking margin for normal docking
	 * algorithms to be used.
	 * @return
	 * Reference to the side panel that the pane is docked to.
	 */
	virtual CXTPDockingPaneSidePanel* DockSidePane(CXTPDockingPaneBase* pPane,
												   XTPDockingPaneDirection direction, CRect rc);

	/**
	 * @brief
	 * Call this member to float an existing pane.
	 * @param pPane Pane to be floated.
	 * @param rc    Floating rectangle.
	 * @return A floating pane window object or NULL.
	 */
	virtual CXTPDockingPaneMiniWnd* FloatPane(CXTPDockingPaneBase* pPane, CRect rc);

	/**
	 * @brief
	 * Call this member to attach a pane to another one.
	 * @param pPane      Pane to be attached.
	 * @param pNeighbour Pane's Neighbor.
	 */
	virtual void AttachPane(CXTPDockingPaneBase* pPane, CXTPDockingPaneBase* pNeighbour);

	/**
	 * @brief
	 * Call this member to switch the pane's position (docking/floating).
	 * @param pPane Docking Pane.
	 */
	virtual void ToggleDocking(CXTPDockingPaneBase* pPane);

	/**
	 * @brief
	 * Call this member to switch the pane's auto-hide (docking/auto-hide).
	 * @param pPane Docking Pane.
	 */
	virtual void ToggleAutoHide(CXTPDockingPaneBase* pPane);

	/**
	 * @brief
	 * Call this member to show (activate) a pane.
	 * @param nID       Pane's identifier.
	 * @param bSetFocus TRUE to set focus to the selected pane.
	 */
	virtual void ShowPane(int nID, BOOL bSetFocus = TRUE);

	/**
	 * @brief
	 * Call this member to show (activate) a pane.
	 * @param pPane     Pane to show.
	 * @param bSetFocus TRUE to set focus to the selected pane.
	 */
	virtual void ShowPane(CXTPDockingPane* pPane, BOOL bSetFocus = TRUE);

	/**
	 * @brief
	 * Call this member to close a pane.
	 * @param nID   Pane's identifier.
	 */
	virtual void ClosePane(int nID);

	/**
	 * @brief
	 * Call this member to close a pane.
	 * @param pPane Pane to close.
	 */
	virtual void ClosePane(CXTPDockingPane* pPane);

	/**
	 * @brief
	 * Call this member to destroy a pane.
	 * @param nID   Pane's identifier.
	 * @see
	 * ClosePane
	 */
	virtual void DestroyPane(int nID);

	/**
	 * @brief
	 * Call this member to destroy a pane.
	 * @param pPane Pane to destroy.
	 * @see
	 * ClosePane
	 */
	virtual void DestroyPane(CXTPDockingPane* pPane);

	/**
	 * @brief
	 * Call this member to hide a pane.
	 * @param nID   Pane's identifier.
	 */
	virtual void HidePane(int nID);

	/**
	 * @brief
	 * Call this member to hide a pane.
	 * @param pPane Pane to hide.
	 */
	virtual void HidePane(CXTPDockingPaneBase* pPane);

	/**
	 * @brief
	 * Call this member to find a pane by its identifier.
	 * @param nID Pane's identifier.
	 * @return
	 * A pointer to a CXTPDockingPane object.
	 */
	CXTPDockingPane* FindPane(int nID) const;

	/**
	 * @brief
	 * Call this member to check if a pane is closed.
	 * @param nID   Pane's identifier.
	 * @return
	 * TRUE if the pane is closed.
	 */
	BOOL IsPaneClosed(int nID) const;

	/**
	 * @brief
	 * Call this member to check if a pane is closed.
	 * @param pPane Pointer to a CXTPDockingPane object.
	 * @return
	 * TRUE if the pane is closed.
	 */
	BOOL IsPaneClosed(CXTPDockingPane* pPane) const;

	/**
	 * @brief
	 * Call this member to check if a pane is hidden.
	 * @param nID   Pane's identifier.
	 * @return
	 * TRUE if the pane is hidden.
	 */
	BOOL IsPaneHidden(int nID) const;

	/**
	 * @brief
	 * Call this member to check if a pane is hidden.
	 * @param pPane Pointer to a CXTPDockingPane object.
	 * @return
	 * TRUE if the pane is hidden.
	 */
	BOOL IsPaneHidden(CXTPDockingPane* pPane) const;

	/**
	 * @brief
	 * Call this member to check if a pane is selected.
	 * @param nID   Pane's identifier.
	 * @return
	 * TRUE if the pane is selected.
	 */
	BOOL IsPaneSelected(int nID) const;

	/**
	 * @brief
	 * Call this member to check if a pane is selected.
	 * @param pPane Pointer to a CXTPDockingPane object.
	 * @return
	 * TRUE if the pane is selected.
	 */
	BOOL IsPaneSelected(CXTPDockingPane* pPane) const;

	/**
	 * @brief
	 * Call this member to set icons to panes.
	 * @param nIDResource Resource identifier.
	 * @param nIDs        Pointer to an array of pane IDs.
	 * @param nCount      Number of elements in the array pointed to by nIDs.
	 * @param clrMask     An RGB value of a transparent color.
	 * @return
	 * TRUE if successful, otherwise FALSE.
	 */
	BOOL SetIcons(UINT nIDResource, const int* nIDs, int nCount, COLORREF clrMask = 0xC0C0C0);

	/**
	 * @brief
	 * Call this member to set an icon to the pane.
	 * @param nID   Docking pane's identifier.
	 * @param hIcon Icon handle.
	 */
	void SetIcon(UINT nID, const CXTPImageManagerIconHandle& hIcon);

	/**
	 * @brief
	 * Call this member to get an icon of the pane.
	 * @param nID Docking pane's identifier.
	 * @param nWidth Width of the icon to retrieve.
	 * @return
	 * The docking pane's icon.
	 */
	CXTPImageManagerIcon* GetIcon(UINT nID, int nWidth = 16) const;

	/**
	 * @brief
	 * Call this member to remove all icons.
	 */
	void ClearIconMap();

	/**
	 * @brief
	 * Call this member to set the animation speed.
	 * @param dAnimationDelay    Must be -1 to use nAnimationDuration and nAnimationInterval.
	 * @param nAnimationDuration Total time of the animation, in milliseconds.
	 * @param nAnimationInterval Amount of time to rest, in milliseconds, between
	 * each animation step.
	 * @details
	 * To disable the animation, set nAnimationDuration = 0.
	 * @see
	 * GetAnimationDelay
	 */
	void SetAnimationDelay(double dAnimationDelay = -1, int nAnimationDuration = 128,
						   int nAnimationInterval = 16);

	/**
	 * @brief
	 * Call this member to get the animation speed.
	 * @param pAnimationDuration Pointer to an int that will receive the total time of
	 * the animation, in milliseconds.
	 * @param pAnimationInterval Pointer to an int that will receive the amount of time
	 * to rest, in milliseconds, between each animation step.
	 * @return
	 * The animation delay.
	 * @see
	 * SetAnimationDelay
	 */
	double GetAnimationDelay(int* pAnimationDuration = NULL, int* pAnimationInterval = NULL) const;

	/**
	 * @brief
	 * Call this member to allow the user to switch and move panes using
	 * the keyboard.
	 * @param options Available keyboard keys that can be used to navigate
	 * items.
	 * @details
	 * options can be combination of the following:
	 * <b>xtpPaneKeyboardUseAltMinus</b>: To use Alt+'-' to show the
	 * context menu.
	 * <b>xtpPaneKeyboardUseAltF6</b>: To use Alt+F6 to select the
	 * next pane.
	 * <b>xtpPaneKeyboardUseAltF7</b>: To use Alt+F7 to show the window
	 * select dialog.
	 * <b>xtpPaneKeyboardUseCtrlTab</b>: To use Ctrl+Tab to show the
	 * window select dialog.
	 * <b>xtpPaneKeyboardUseAll</b>: To use all keys.
	 *
	 * You can call SetKeyboardWindowSelectClass to set a custom window
	 * for Ctrl-Tab and Alt_F7 operations.
	 * @see
	 * XTPDockingPaneKeyboardNavigate
	 */
	void EnableKeyboardNavigate(DWORD options = xtpPaneKeyboardUseAll);

	/**
	 * @brief
	 * Determines if keyboard navigate options are enabled.
	 * @return
	 * A combination of XTPDockingPaneKeyboardNavigate flags indicating
	 * which keys can be used to navigate panes.
	 * @see
	 * EnableKeyboardNavigate, XTPDockingPaneKeyboardNavigate
	 */
	BOOL IsKeyboardNavigateEnabled() const;

	/**
	 * @brief
	 * Call this method to set a custom CXTPDockingPaneWindowSelect window
	 * that will be used to show active panes and files.
	 * @param pWindowSelectClass A CRuntimeClass pointer to a custom
	 * CXTPDockingPaneWindowSelect window.
	 * @see
	 * EnableKeyboardNavigate, XTPDockingPaneKeyboardNavigate
	 */
	void SetKeyboardWindowSelectClass(CRuntimeClass* pWindowSelectClass);

	/**
	 * @brief
	 * Determines the runtime class for a CXTPDockingPaneWindowSelect window
	 * that shows active panes and files.
	 * @return
	 * A CRuntimeClass pointer to a CXTPDockingPaneWindowSelect window.
	 * @see
	 * SetKeyboardWindowSelectClass, EnableKeyboardNavigate,
	 * XTPDockingPaneKeyboardNavigate
	 */
	CRuntimeClass* GetKeyboardWindowSelectClass() const;

	/**
	 * @brief
	 * Call this method to activate a pane in cycle order.
	 * @param pPane Pane to start. NULL to select the first pane.
	 * @param bForward TRUE to select the next pane, FALSE to select the previous pane.
	 * @return
	 * TRUE if the pane was successfully activated.
	 */
	BOOL ActivateNextPane(CXTPDockingPane* pPane, BOOL bForward);

public:
	/**
	 * @brief
	 * Call this member to get the list of created panes.
	 * @return
	 * The list of created panes.
	 * @see
	 * GetPaneStack, CXTPDockingPaneInfoList
	 */
	CXTPDockingPaneInfoList& GetPaneList() const;

	/**
	 * @brief
	 * Call this member to get the list of created panes, including
	 * its virtual containers.
	 * @return
	 * The list of created panes, including its virtual containers.
	 * @see
	 * GetPaneList
	 */
	CXTPDockingPaneBaseList& GetPaneStack() const;

	/**
	 * @brief
	 * Call this member to retrieve the docking site of the manager.
	 * @return
	 * The docking site.
	 */
	CWnd* GetSite() const;

	/**
	 * @brief
	 * Call this member to switch the visual theme of the panes.
	 * @param theme New visual theme. Can be any of the values listed in the
	 * Remarks section.
	 * @details
	 * 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 Visual Studio 2005 Beta 1 theme.
	 */
	void SetTheme(XTPDockingPanePaintTheme theme);

	/**
	 * @brief
	 * Call this member to set a custom theme. See the DockingPane sample
	 * as a sample of creating a new theme.
	 * @param pTheme New Theme.
	 */
	void SetCustomTheme(CXTPDockingPanePaintManager* pTheme);

	/**
	 * @brief
	 * Call this member to get the current visual theme.
	 * @return
	 * The current theme.
	 */
	XTPDockingPanePaintTheme GetCurrentTheme() const;

	/**
	 * @brief
	 * Retrieves the paint manager of docking panes.
	 * @return
	 * The paint manager of docking panes.
	 */
	CXTPDockingPanePaintManager* GetPaintManager() const;

	/**
	 * @brief
	 * Call this member to create a new layout.
	 * @details
	 * You must delete a layout when it no longer used.
	 * @return
	 * A pointer to a CXTPDockingPaneLayout object.
	 */
	virtual CXTPDockingPaneLayout* CreateLayout();

	/**
	 * @brief
	 * Call this member to get the current layout.
	 * @param pLayout Pointer to a CXTPDockingPaneLayout object to receive
	 * the current layout.
	 */
	void GetLayout(CXTPDockingPaneLayout* pLayout) const;

	/**
	 * @brief
	 * Call this member to set the current layout.
	 * @param pLayout Pointer to a CXTPDockingPaneLayout object.
	 */
	void SetLayout(const CXTPDockingPaneLayout* pLayout);

	/**
	 * @brief
	 * Call this member to redraw all panes.
	 */
	void RedrawPanes();

	/**
	 * @brief
	 * Call this member to retrieve the client pane.
	 * @return
	 * A pointer to a CXTPDockingPaneBase object.
	 */
	CXTPDockingPaneBase* GetClientPane() const;

	/**
	 * @brief
	 * Call this member to destroy all panes.
	 */
	void DestroyAll();

	/**
	 * @brief
	 * Call this member to close all panes.
	 */
	void CloseAll();

	/**
	 * @brief
	 * Call this member to retrieve the image manager of docking panes.
	 * @return
	 * The image manager of docking panes.
	 */
	CXTPImageManager* GetImageManager() const;

	/**
	 * @brief
	 * Call this member to set the image manager for docking panes.
	 * @param pImageManager Pointer to a CXTPImageManager object.
	 */
	void SetImageManager(CXTPImageManager* pImageManager);

	/**
	 * @brief
	 * Call this member to hide the client area.
	 * @param bHide TRUE to hide the client area.
	 */
	void HideClient(BOOL bHide);

	/**
	 * @brief
	 * Checks if the client area is hidden.
	 * @return
	 * TRUE if the client area is hidden, otherwise FALSE.
	 */
	BOOL IsClientHidden() const;

	/**
	 * @brief
	 * Sets the width for the client margin.
	 * @param nMargin Width, in pixels, for the client margin.
	 */
	void SetClientMargin(int nMargin);

	/**
	 * @brief
	 * Retrieves the width of the client margin.
	 * @return
	 * The width, in pixels, of the client margin.
	 */
	int GetClientMargin() const;

	/**
	 * @brief
	 * Sets the width for each side of the client margin (left, top, right,
	 * and bottom) individually using a CRect object.
	 * @param rcClientMargins A CRect object representing the width, in pixels,
	 * for each side of the client margin. Use the
	 * left, top, right, and bottom members to specify
	 * the width for each side of the client margin.
	 */
	void SetClientMargins(CRect rcClientMargins);

	/**
	 * @brief
	 * Retrieves the width for each side of the client margin (left, top,
	 * right, and bottom).
	 * @return
	 * A CRect object representing the width, in pixels, for each side of
	 * the client margin. The left, top, right, and bottom members specify
	 * the width for each side of the client margin.
	 */
	CRect GetClientMargins() const;

	/**
	 * @brief
	 * 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.
	 * @param rcMargin Side docking margins (margin between the right/top/left/bottom
	 * edge of the client area and any docking panes that are docked
	 * to the left/top/right/bottom edge of the client area.)
	 * @details
	 * SetSideDockingMargin sets the margins between the client areas's edge
	 * and a docking pane docked to the edge of the client area when side
	 * docking is enabled.
	 * @see
	 * SideDocking
	 */
	void SetSideDockingMargin(CRect rcMargin);

	/**
	 * @brief
	 * 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.
	 * @details
	 * SetSideDockingMargin sets the margins between the client areas's edge
	 * and a docking pane docked to the edge of the client area when side
	 * docking is enabled.
	 * @return
	 * Side docking margins (margin between the right/top/left/bottom
	 * edge of the client area and any docking panes that are docked
	 * to the left/top/right/bottom edge of the client area.)
	 * @see
	 * SideDocking, SetSideDockingMargin
	 */
	CRect GetSideDockingMargin() const;

	/**
	 * @brief
	 * Call this member to use the splitter tracker.
	 * @param bSplitterTracker TRUE to use the splitter tracker.
	 * @details
	 * If bSplitterTracker is set to FALSE, then this member function will
	 * display the contents of a child pane while the splitter is resized.
	 * @see
	 * IsSplitterTrackerUsed
	 */
	void UseSplitterTracker(BOOL bSplitterTracker);

	/**
	 * @brief
	 * Call this member to determine if the splitter tracker is used.
	 * @return
	 * TRUE if the splitter tracker is used, otherwise FALSE.
	 * @see
	 * UseSplitterTracker
	 */
	BOOL IsSplitterTrackerUsed() const;

	/**
	 * @brief
	 * Call this member to set the direction of captions.
	 * @param captionDirection An XTPDockingPaneCaptionDirection flag indicating
	 * which direction the pane captions are to be displayed.
	 *
	 * @details
	 * captionDirection parameter can be one of the following:
	 * <b>xtpPaneCaptionHorizontal</b>
	 * <b>xtpPaneCaptionVertical</b>
	 * <b>xtpPaneCaptionAutoByPosition</b>
	 * <b>xtpPaneCaptionAutoBySize</b>
	 *
	 * <b>Example:</b>
	 * m_paneManager.GetPaintManager()->SetCaptionDirection(xtpPaneCaptionAutoSize);
	 */
	void SetCaptionDirection(XTPDockingPaneCaptionDirection captionDirection);

	/**
	 * @brief
	 * Call this member to get the direction of captions.
	 * @details
	 * Can return one of the following direction:
	 * <b>xtpPaneCaptionHorizontal</b>
	 * <b>xtpPaneCaptionVertical</b>
	 * <b>xtpPaneCaptionAutoByPosition</b>
	 * <b>xtpPaneCaptionAutoBySize</b>
	 * @return
	 * An XTPDockingPaneCaptionDirection flag indicating which direction
	 * the pane captions are displayed.
	 * @see
	 * SetCaptionDirection
	 */
	XTPDockingPaneCaptionDirection GetCaptionDirection() const;

	/**
	 * @brief
	 * Call this method to lock the splitters.
	 * @param bLock TRUE to prevent splitter window panes from being resized.
	 */
	void LockSplitters(BOOL bLock = TRUE);

	/**
	 * @brief
	 * Call this member to determine if the splitters are locked.
	 * @return
	 * TRUE if the splitters are locked, otherwise FALSE.
	 */
	BOOL IsSplittersLocked() const;

	/**
	 * @brief
	 * Call this method to set the common caption for floating frames.
	 * @param lpszCaption Caption to be set.
	 */
	void SetFloatingFrameCaption(LPCTSTR lpszCaption);

	/**
	 * @brief
	 * Call this method to use themes for floating frames.
	 * @param bThemedFloatingFrames TRUE to use themes for floating panes,
	 * FALSE otherwise.
	 */
	void EnableFloatingFrameTheme(BOOL bThemedFloatingFrames);

	/**
	 * @brief
	 * Determines if themes are used for floating frames.
	 * @return
	 * TRUE if themes are used for floating frames, otherwise FALSE.
	 */
	BOOL IsFloatingFrameThemeEnabled() const;

	/** @cond */
	_XTP_DEPRECATED_IN_FAVOR(EnableFloatingFrameTheme)
	void SetThemedFloatingFrames(BOOL bThemedFloatingFrames)
	{
		EnableFloatingFrameTheme(bThemedFloatingFrames);
	}

	_XTP_DEPRECATED_IN_FAVOR(IsFloatingFrameThemeEnabled)
	BOOL IsThemedFloatingFrames() const
	{
		return IsFloatingFrameThemeEnabled();
	}
	/** @endcond */

	/**
	 * @brief
	 * Call this method to enable sticky floating frames.
	 * @param bSticky TRUE to enable sticky floating frames, FALSE otherwise.
	 */
	void SetStickyFloatingFrames(BOOL bSticky);

	/**
	 * @brief
	 * Determines if sticky floating frames are enabled.
	 * @return
	 * TRUE if sticky floating frames are enabled, otherwise FALSE.
	 */
	BOOL IsStickyFloatingFrames() const;

	/**
	 * @brief
	 * Call this method to set the opacity for inactive floating frames.
	 * @param nOpacity Alpha value. When nOpacity is 0, the window is completely
	 * transparent. When nOpacity is 255, the window is opaque.
	 */
	void SetFloatingFramesOpacity(int nOpacity);

	/**
	 * @brief
	 * Determines the opacity for inactive floating frames.
	 * @return
	 * The opacity for inactive floating frames.
	 */
	int GetFloatingFramesOpacity() const;

	/**
	 * @brief
	 * Call this member to keep the activation of floating frames windows
	 * in sync with the activation of the top-level frame window.
	 * @param bSyncActiveFloatingFrames TRUE to synchronizes the activation of
	 * the mini-frame window to the activation
	 * of its parent window.
	 */
	void SyncActiveFloatingFrames(BOOL bSyncActiveFloatingFrames);

	/**
	 * @brief
	 * Call this member to determine if the current layout is Right-to-Left (RTL).
	 * @return
	 * TRUE if the current layout is Right-to-Left (RTL),
	 * FALSE if the current layout is Left-to-Right.
	 */
	BOOL IsLayoutRTL() const;

	/**
	 * @brief
	 * Call this member to retrieve the Right-to-Left (RTL) docking direction
	 * equivalent to the docking direction passed in to this member. The return
	 * value for this member is dependent on the return value of IsLayoutRTL.
	 * @param direction Docking direction.
	 * @return
	 * If IsLayoutRTL returns TRUE, then this member returns the Right-to-Left
	 * (RTL) docking direction of the supplied direction. If IsLayoutRTL returns
	 * FALSE, then the direction passed in to this member remains the same.
	 */
	XTPDockingPaneDirection GetRTLDirection(XTPDockingPaneDirection direction) const;

	/**
	 * @brief
	 * Call this member to determine the XTPDockingPaneDirection of pPane.
	 * @param pPane Pointer to a CXTPDockingPaneBase object.
	 * @return
	 * The current XTPDockingPaneDirection of pPane.
	 */
	XTPDockingPaneDirection GetPaneDirection(const CXTPDockingPaneBase* pPane) const;

	/**
	 * @brief
	 * Retrieves the top-level virtual container for the site window.
	 * @details
	 * The top-level container is always the splitter container
	 * (xtpPaneTypeSplitterContainer).
	 * @return
	 * The top-level virtual container for the site window.
	 */
	CXTPDockingPaneBase* GetTopPane() const;

	/**
	 * @brief
	 * Call this method to use a custom docking context.
	 * @param pDockingContext Pointer to a CXTPDockingPaneContext object.
	 */
	void SetDockingContext(CXTPDockingPaneContext* pDockingContext);

	/**
	 * @brief
	 * Retrieves a pointer to the current docking context.
	 * @return
	 * A pointer to the current docking context.
	 */
	CXTPDockingPaneContext* GetDockingContext() const;

	/**
	 * @brief
	 * Call this member to determine if alpha docking context is used when
	 * panes are being dragged and dropped.
	 * @return
	 * TRUE if AlphaDockingContext is enabled, FALSE if it is disabled.
	 * @details
	 * AlphaDockingContext must be TRUE if docking context stickers will
	 * be used.
	 * @see
	 * SetAlphaDockingContext, IsShowDockingContextStickers,
	 * SetShowDockingContextStickers
	 */
	BOOL IsAlphaDockingContext() const;

	/**
	 * @brief
	 * Call this member to specify whether an alpha docking context is
	 * used to indicate where a pane can be docked while dragging the pane.
	 * @param bAlphaDockingContext TRUE to enable alpha colorization while docking.
	 * @details
	 * 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
	 * IsAlphaDockingContext, IsShowDockingContextStickers,
	 * SetShowDockingContextStickers
	 */
	void SetAlphaDockingContext(BOOL bAlphaDockingContext);

	/**
	 * @brief
	 * Call this member to determine whether docking context stickers are used.
	 * @return
	 * TRUE if docking context stickers are used, FALSE if they are not used.
	 * @see
	 * SetAlphaDockingContext, IsAlphaDockingContext, SetShowDockingContextStickers
	 */
	BOOL IsShowDockingContextStickers() const;

	/**
	 * @brief
	 * Call this member to specify whether Visual Studio 2005 style docking
	 * context stickers should be used while dragging a docking pane.
	 * @param bShowDockingContextStickers If TRUE, then 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.
	 * @details
	 * AlphaDockingContext must be TRUE if docking context stickers will
	 * be used.
	 * @see
	 * SetAlphaDockingContext, IsAlphaDockingContext, IsShowDockingContextStickers,
	 * SetDockingContextStickerStyle
	 */
	void SetShowDockingContextStickers(BOOL bShowDockingContextStickers);

	/**
	 * @brief
	 * Call this member to set the style for docking context stickers.
	 * @param style Style for docking context stickers.
	 * @details
	 * Call SetShowDockingContextStickers to enable Stickers.
	 * Style parameter can be one of the following:
	 * <b>xtpPaneStickerStyleVisualStudio2005Beta</b>: Visual Studio 2005 Beta stickers.
	 * <b>xtpPaneStickerStyleVisualStudio2005</b>: Visual Studio 2005 stickers.
	 * @see
	 * SetShowDockingContextStickers, GetDockingContextStickerStyle
	 */
	void SetDockingContextStickerStyle(XTPDockingContextStickerStyle style);

	/**
	 * @brief
	 * Call this member to get the style of docking context stickers.
	 * @return
	 * Style of docking context stickers.
	 * @details
	 * Call SetShowDockingContextStickers to enable docking context stickers.
	 * @see
	 * SetShowDockingContextStickers, SetDockingContextStickerStyle
	 */
	XTPDockingContextStickerStyle GetDockingContextStickerStyle() const;

	/**
	 * @brief
	 * Call this member to set the "Show window contents while dragging" option.
	 * @param bShow TRUE to enable the "Show window contents while dragging" option.
	 */
	void SetShowContentsWhileDragging(BOOL bShow = TRUE);

	/**
	 * @brief
	 * Determines if the "Show window contents while dragging" option is enabled.
	 * @return
	 * TRUE if the "Show window contents while dragging" option is enabled.
	 */
	BOOL GetShowContentsWhileDragging() const;

	/**
	 * @brief
	 * Call this method to show Maximize/Restore buttons for non-floating
	 * docking panes.
	 * @param bShowMaximizeButton TRUE to show Maximize/Restore buttons for non-floating
	 * docking panes.
	 * @see
	 * ShowFloatingCaptionMaximizeButton, IsCaptionMaximizeButtonsVisible,
	 * IsFloatingCaptionMaximizeButtonsVisible
	 */
	void ShowCaptionMaximizeButton(BOOL bShowMaximizeButton);

	/**
	 * @brief
	 * Call this method to show Maximize/Restore buttons for floating
	 * docking panes.
	 * @param bShowMaximizeButton TRUE to show Maximize/Restore buttons for floating
	 * docking panes.
	 * @see
	 * ShowCaptionMaximizeButton, IsFloatingCaptionMaximizeButtonsVisible,
	 * IsCaptionMaximizeButtonsVisible
	 */
	void ShowFloatingCaptionMaximizeButton(BOOL bShowMaximizeButton);

	/**
	 * @brief
	 * Determines if Maximize/Restore buttons for non-floating docking panes
	 * are visible.
	 * @return
	 * TRUE if Maximize/Restore buttons for non-floating docking panes are visible.
	 * @see
	 * ShowCaptionMaximizeButton, ShowFloatingCaptionMaximizeButton,
	 * IsFloatingCaptionMaximizeButtonsVisible
	 */
	BOOL IsCaptionMaximizeButtonsVisible() const;

	/**
	 * @brief
	 * Determines if Maximize/Restore buttons for floating docking panes
	 * are visible.
	 * @return
	 * TRUE if Maximize/Restore buttons for floating docking panes are visible.
	 * @see
	 * ShowCaptionMaximizeButton, ShowFloatingCaptionMaximizeButton,
	 * IsCaptionMaximizeButtonsVisible
	 */
	BOOL IsFloatingCaptionMaximizeButtonsVisible() const;

	/**
	 * @brief
	 * Call this method to save the current splitter positions for all
	 * splitter containers.
	 * @see
	 * CXTPDockingPaneSplitterContainer
	 */
	void NormalizeSplitters();

	/**
	 * @brief
	 * Call this method to recalculate the layout for all parent frames of panes.
	 */
	void RecalcFramesLayout();

	/**
	 * @brief
	 * This method updates the XTP_DOCKINGPANE_INFO structure for each pane filling
	 * its members.
	 */
	void SyncPanesState();

	/**
	 * @brief
	 * Call this method to set the default options used for each pane.
	 * @param dwOptions Options applied for each pane. Can be any of the values
	 * listed in the Remarks section.
	 * @details
	 * dwOptions parameter can be one or more of the following:
	 * <b>xtpPaneNoCloseable</b>: Indicates that the pane cannot be closed.
	 * <b>xtpPaneNoHideable</b>: Indicates that the pane cannot be hidden.
	 * <b>xtpPaneNoFloatable</b>: Indicates that the pane cannot be floated.
	 * <b>xtpPaneNoCaption</b>: Indicates that the pane has no caption.
	 * @see
	 * GetDefaultPaneOptions, CXTPDockingPane::SetOptions, XTPDockingPaneOptions
	 */
	void SetDefaultPaneOptions(DWORD dwOptions);

	/**
	 * @brief
	 * Call this method to retrieve the default options used for each pane.
	 * @return
	 * The default options used for each pane.
	 * @see
	 * SetDefaultPaneOptions, XTPDockingPaneOptions
	 */
	DWORD GetDefaultPaneOptions() const;

	/**
	 * @brief
	 * Call this member function to set the application's panes into and
	 * out of print-preview mode.
	 * @param bPreview Specifies whether or not to place the application in
	 * print-preview mode. TRUE to place in print preview,
	 * FALSE to cancel print preview mode.
	 */
	void OnSetPreviewMode(BOOL bPreview);

	/**
	 * @brief
	 * Call this member function to get the currently active (focused) pane.
	 * @return
	 * A pointer to the currently active (focused) pane.
	 */
	CXTPDockingPane* GetActivePane() const;

	/**
	 * @brief
	 * Call this method to get a pointer to the tooltip context.
	 * @return
	 * A pointer to the tooltip context.
	 */
	CXTPToolTipContext* GetToolTipContext() const;

	/**
	 * @brief
	 * Call this member function to save/restore the settings of the pane.
	 * @param pPX Pointer to a CXTPPropExchange object.
	 * @return
	 * TRUE if successful, otherwise FALSE.
	 */
	BOOL DoPropExchange(CXTPPropExchange* pPX);

	/**
	 * @brief
	 * This method is called to recalculate a pane's site layout.
	 * @param pPane Pane whose site layout must be recalculated.
	 * @param bDelay TRUE to recalculate after a small delay.
	 */
	void RecalcFrameLayout(CXTPDockingPaneBase* pPane, BOOL bDelay = FALSE);

	/**
	 * @brief
	 * This method is called to update panes state.
	 */
	virtual void UpdatePanes();

	/**
	 * @brief
	 * This member is called to notify the parent window that an event
	 * has occurred in the docking pane.
	 * @param nCode  Specifies the event that has occurred.
	 * @param lParam Additional message-specific information.
	 * @return Window message processing result.
	 */
	virtual LRESULT NotifyOwner(UINT nCode, LPARAM lParam);

	/**
	 * @brief
	 * Call this method to ensure that a specified pane is visible
	 * @param pPane Pointer to the CXTPDockingPaneBase object whose visibility
	 * must be ensured.
	 * @see
	 * ShowPane
	 */
	void EnsureVisible(CXTPDockingPaneBase* pPane);

	/**
	 * @brief
	 * Enables/disables side docking.
	 * @param bEnable TRUE to enable side docking, FALSE to disable side docking.
	 * @see
	 * SideDocking, SetSideDockingMargin
	 */
	void EnableSideDocking(BOOL bEnable = TRUE);

	/**
	 * @brief
	 * Determines if side docking is enabled.
	 * @return
	 * TRUE if side docking is enabled, FALSE if side docking is disabled.
	 * @see
	 * SideDocking, SetSideDockingMargin, EnableSideDocking
	 */
	BOOL IsSideDockingEnabled() const;

public:
	/**
	 * @brief
	 * This method is called when a pane is created.
	 * @param type    Type of pane that was created.
	 * @param pLayout Pointer to a CXTPDockingPaneLayout object.
	 * @return
	 * A pointer to the newly created pane.
	 */
	virtual CXTPDockingPaneBase* OnCreatePane(XTPDockingPaneType type,
											  CXTPDockingPaneLayout* pLayout);

	/**
	 * @brief
	 * This method is called when a pane is activated/deactivated.
	 * @param bActive TRUE if the pane was activated, FALSE if the pane was deactivated.
	 * @param pPane The pane that was activated/deactivated.
	 */
	virtual void OnActivatePane(BOOL bActive, CXTPDockingPane* pPane);

	/**
	 * @brief
	 * The framework calls this method when a docking pane is performing an action.
	 * @param action The action that the docking pane is performing.
	 * @param pPane The pane performing the action.
	 * @param pDockContainer Object used to provide additional information about where
	 * a pane will be/has been docked.
	 * @param dockDirection Specifies the direction where a pane is docking.
	 * @return
	 * 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);
#	ifndef _XTP_ACTIVEX
#		ifdef _XTP_INCLUDE_COMMANDBARS
	/**
	 * @brief
	 * This method is called when a pane need possibility to move to tabclient.
	 * @param pTabClient Pointer to a CXTPTabClientWnd object.
	 */
	void SetTabClient(CXTPTabClientWnd* pTabClient);

	/**
	 * @brief
	 * Determines if possibility to move to tabclient is enabled.
	 * @return
	 * Pointer to a CXTPTabClientWnd object.
	 */
	CXTPTabClientWnd* GetTabClient();

protected:
	BOOL AttachDockingPaneMiniWndToTabClientWnd(CXTPDockingPaneMiniWnd* pSource,
												CXTPTabClientWnd* pTarget);
	BOOL AttachTabbedContainerToTabClientWnd(CXTPDockingPaneBase* pTabbedContainer,
											 CXTPTabClientWnd* pTarget);
	BOOL AttachSplitterContainerToTabClientWnd(CXTPDockingPaneBase* pSplitterContainer,
											   CXTPTabClientWnd* pTarget);
	BOOL AttachDockingPaneToTabClientWnd(CXTPDockingPane* pSource, CXTPTabClientWnd* pTarget);
#		endif
#	endif

protected:
	/** @cond */
	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
	/** @endcond */

protected:
	/** @cond */

	// 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()
	XTP_DECLARE_CMDTARGETPROVIDER_INTERFACE()
	/** @endcond */

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, then 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,	  then only	  the currently visible pane in the
											group	  will be	  hidden. */
	BOOL m_bShowSizeCursorWhileDragging; /**< TRUE to show the 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 auto-hide 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 the docking manager. */
	CXTPDockingPaneLayout* m_pLayout;			  /**< Selected layout. */
	CXTPDockingPanePaintManager* m_pPaintManager; /**< Current paint manager. */
	CXTPDockingPane* m_pActivePane;				  /**< Current active pane. */

	CRect m_rcClientMargins;	  /**< Specifies each client margin individually. */
	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, then the client area is hidden so that only the docking panes
						   are visible and occupy the entire area. */
	BOOL m_bUseSplitterTracker; /**< If TRUE, then splitter trackers are used. When resizing a
								   docking pane, an outline of the pane is drawn as the splitter is
								   dragged. If FALSE, then the docking pane will be resized in
								   "real-time." */
	BOOL m_bShowMaximizeButton; /**< Allow non-floating panes to be maximized. */
	BOOL m_bShowFloatingMaximizeButton; /**< Allow floating panes to be maximized. */

	BOOL m_bLockSplitters; /**< If TRUE, then 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, then alpha docking context is used when dragging a
									pane. The shaded area indicates the panes new location if
									dropped. */
	BOOL m_bShowDockingContextStickers; /**< If TRUE, then docking context stickers are drawn when
										   the pane is being dragged and dropped.
										   m_bAlphaDockingContext must be TRUE. */
	BOOL m_bShowContentsWhileDragging;  /**< If TRUE, then window contents are visible while
										   dragging. */

	BOOL m_bThemedFloatingFrames; /**< If TRUE, then 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. */

#	ifndef _XTP_ACTIVEX
#		ifdef _XTP_INCLUDE_COMMANDBARS
	CXTPTabClientWnd* m_pTabClient;
#		endif
#	endif

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;

#	ifdef _XTP_ACTIVEX
	CXTPDockingPaneManager* GetDockingPaneManager()
	{
		return this;
	}
#	endif
};

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::IsFloatingFrameThemeEnabled() 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 void CXTPDockingPaneManager::ShowFloatingCaptionMaximizeButton(BOOL bShowMaximizeButton)
{
	m_bShowFloatingMaximizeButton = bShowMaximizeButton;
	RedrawPanes();
}

AFX_INLINE BOOL CXTPDockingPaneManager::IsCaptionMaximizeButtonsVisible() const
{
	return m_bShowMaximizeButton;
}

AFX_INLINE BOOL CXTPDockingPaneManager::IsFloatingCaptionMaximizeButtonsVisible() const
{
	return m_bShowFloatingMaximizeButton;
}

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)
{
	CRect rcClientMargins(nMargin, nMargin, nMargin, nMargin);
	SetClientMargins(rcClientMargins);
}

AFX_INLINE int CXTPDockingPaneManager::GetClientMargin() const
{
	return m_rcClientMargins.left;
}

AFX_INLINE void CXTPDockingPaneManager::SetClientMargins(CRect rcClientMargins)
{
	if (m_rcClientMargins != rcClientMargins)
	{
		m_rcClientMargins = rcClientMargins;
		RecalcFrameLayout(NULL, TRUE);
	}
}

AFX_INLINE CRect CXTPDockingPaneManager::GetClientMargins() const
{
	return m_rcClientMargins;
}

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 (BOOL)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;
}

#	ifndef _XTP_ACTIVEX
#		ifdef _XTP_INCLUDE_COMMANDBARS
AFX_INLINE void CXTPDockingPaneManager::SetTabClient(CXTPTabClientWnd* pTabClient)
{
	m_pTabClient = pTabClient;
}

AFX_INLINE CXTPTabClientWnd* CXTPDockingPaneManager::GetTabClient()
{
	return m_pTabClient;
}
#		endif
#	endif
/** @cond */
#	include "Common/Base/Diagnostic/XTPEnableNoisyWarnings.h"
#endif //#if !defined(__XTPDOCKINGPANEMANAGER_H__)
/** @endcond */