/**
 * @file XTPDockState.cpp
 *
 * @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
 *
 */

#include "stdafx.h"

#include "CommandBars/Resource.h"

#include "Common/XTPTypeId.h"
#include "Common/XTPCasting.h"
#include "Common/XTPFramework.h"
#include "Common/XTPSystemHelpers.h"
#include "Common/XTPSynchro.h"
#include "Common/XTPApplication.h"
#include "Common/XTPSingleton.h"
#include "Common/XTPGdiObjects.h"
#include "Common/XTPResourceManager.h"
#include "Common/XTPImageManager.h"
#include "Common/XTPDrawHelpers.h"
#include "Common/PropExchange/XTPPropExchangeSection.h"
#include "Common/XTPPropExchange.h"
#include "Common/PropExchange/XTPPropExchangeEnumerator.h"
#include "Common/PropExchange/XTPPropExchangeEnumeratorPtr.h"
#include "Common/PropExchange/XTPPropExchangeArchive.h"
#include "Common/XTPHookManager.h"
#include "Common/XTPColorManager.h"
#include "Common/XTPVC80Helpers.h"
#include "Common/XTPMaskEditT.h"
#include "Common/ScrollBar/XTPScrollInfo.h"
#include "Common/ScrollBar/XTPScrollBase.h"
#include "Common/ScrollBar/XTPScrollBarCtrl.h"
#include "Common/ScrollBar/XTPScrollable.h"

#ifdef _XTP_INCLUDE_CONTROLS
#	include "Controls/Util/XTPControlTheme.h"
#	include "Controls/Edit/XTPEdit.h"
#endif

#include "CommandBars/XTPCommandBarsDefines.h"
#include "CommandBars/XTPPaintManager.h"
#include "CommandBars/XTPCommandBarList.h"
#include "CommandBars/XTPCommandBarsContextMenus.h"
#include "CommandBars/XTPCommandBarsOptions.h"
#include "CommandBars/XTPCommandBar.h"
#include "CommandBars/XTPToolBar.h"
#include "CommandBars/XTPMenuBar.h"
#include "CommandBars/XTPMenuTitleBar.h"
#include "CommandBars/XTPPopupBar.h"
#include "CommandBars/XTPDockBar.h"
#include "CommandBars/XTPDialogBar.h"
#include "CommandBars/XTPShortcutManager.h"
#include "CommandBars/XTPDockState.h"
#include "CommandBars/XTPCommandBars.h"
#include "CommandBars/XTPDockContext.h"
#include "CommandBars/XTPControls.h"
#include "CommandBars/XTPControl.h"
#include "CommandBars/XTPControlButton.h"
#include "CommandBars/XTPControlPopup.h"
#include "CommandBars/XTPControlEdit.h"
#include "CommandBars/XTPControlComboBox.h"
#include "CommandBars/StatusBar/XTPStatusBar.h"

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

#ifdef _DEBUG
#	define new DEBUG_NEW
#	undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

const TCHAR _xtpVisible[]		   = _T("Visible");
const TCHAR _xtpBarSection[]	   = _T("%s-Bar%d");
const TCHAR _xtpDockBarSection[]   = _T("%s-DockBar%d");
const TCHAR _xtpSummarySection[]   = _T("%s-Summary");
const TCHAR _xtpXPos[]			   = _T("XPos");
const TCHAR _xtpYPos[]			   = _T("YPos");
const TCHAR _xtpMRUWidth[]		   = _T("MRUWidth");
const TCHAR _xtpMRUDockID[]		   = _T("MRUDockID");
const TCHAR _xtpMRUDockLeftPos[]   = _T("MRUDockLeftPos");
const TCHAR _xtpMRUDockRightPos[]  = _T("MRUDockRightPos");
const TCHAR _xtpMRUDockTopPos[]	= _T("MRUDockTopPos");
const TCHAR _xtpMRUDockBottomPos[] = _T("MRUDockBottomPos");
const TCHAR _xtpMRUFloatXPos[]	 = _T("MRUFloatXPos");
const TCHAR _xtpMRUFloatYPos[]	 = _T("MRUFloatYPos");

const TCHAR _xtpBarID[]	= _T("BarID");
const TCHAR _xtpFloating[] = _T("Floating");
const TCHAR _xtpBars[]	 = _T("Bars");
const TCHAR _xtpScreenCX[] = _T("ScreenCX");
const TCHAR _xtpScreenCY[] = _T("ScreenCY");
const TCHAR _xtpBar[]	  = _T("Bar#%d");

const TCHAR _xtpCommandBarControlsSection[] = _T("%s-Controls");
const TCHAR _xtpCommandBarControls[]		= _T("Controls");
const TCHAR _xtpCommandBarLoadFromFile[]	= _T("LoadFromFile");
const TCHAR _xtpDialogBar[]					= _T("DialogBar");

class CXTPToolBar::CToolBarInfo
{
public:
	CToolBarInfo();
	~CToolBarInfo();

	BOOL SaveState(LPCTSTR lpszProfileName, int nIndex);
	BOOL LoadState(LPCTSTR lpszProfileName, int nIndex, CXTPDockState* pDockState);

	void DoPropExchange(CXTPPropExchange* pPX, CXTPDockState* pDockState);

	// Attributes
	UINT m_nBarID;					   // ID of this bar
	BOOL m_bVisible;				   // visibility of this bar
	BOOL m_bFloating;				   // whether floating or not
	CPoint m_pointPos;				   // topleft point of window
	UINT m_nMRUWidth;				   // MRUWidth for Dynamic Toolbars
	XTPBarPosition m_uMRUDockPosition; // most recent docked dockbar
	CRect m_rectMRUDockPos;			   // most recent docked position
	DWORD m_dwMRUFloatStyle;		   // most recent floating orientation
	CPoint m_ptMRUFloatPos;			   // most recent floating position
	CXTPToolBar* m_pBar;			   // bar which this refers to (transient)

	BOOL m_bDialogBar;
	CSize m_szDialogBarDockingClient;
	CSize m_szDialogBarFloatingClient;
};

CXTPToolBar::CToolBarInfo::CToolBarInfo()
{
	m_nBarID   = 0;
	m_bVisible = m_bFloating = FALSE;
	m_pBar					 = NULL;
	m_pointPos.x = m_pointPos.y = -1;
	m_nMRUWidth					= 32767;

	m_uMRUDockPosition = xtpBarTop;
	m_rectMRUDockPos.SetRectEmpty();
	m_dwMRUFloatStyle = 0;
	m_ptMRUFloatPos   = CPoint(0, 0);

	m_bDialogBar				= FALSE;
	m_szDialogBarFloatingClient = m_szDialogBarDockingClient = XTP_DPI(CSize(200, 200));
}

CXTPToolBar::CToolBarInfo::~CToolBarInfo()
{
}

void CXTPToolBar::CToolBarInfo::DoPropExchange(CXTPPropExchange* pPX, CXTPDockState* pDockState)
{
	_ASSERTE(pDockState != NULL);
	if (!pDockState)
		return;

	PX_Long(pPX, _T("BarId"), (long&)m_nBarID, 0);
	PX_Bool(pPX, _T("Visible"), m_bVisible, TRUE);
	PX_Bool(pPX, _T("Floating"), m_bFloating, FALSE);
	PX_Long(pPX, _T("MRUWidth"), (long&)m_nMRUWidth);
	PX_Enum(pPX, _T("MRUDockPosition"), m_uMRUDockPosition, xtpBarTop);
	PX_Point(pPX, _T("PointPos"), m_pointPos, CPoint(0, 0));
	PX_DPI_Rect(pPX, _T("MRUDockPos"), m_rectMRUDockPos, CRect(0, 0, 0, 0));
	PX_DPI_Point(pPX, _T("MRUFloatPos"), m_ptMRUFloatPos, CPoint(0, 0));

	if (pDockState->GetVersion() > _XTP_SCHEMA_87)
	{
		PX_Bool(pPX, _T("DialogBar"), m_bDialogBar, FALSE);

		if (m_bDialogBar)
		{
			PX_DPI_Size(pPX, _T("DialogBarDockingClientSize"), m_szDialogBarDockingClient,
						CSize(0, 0));
			PX_DPI_Size(pPX, _T("DialogBarFloatingClientSize"), m_szDialogBarFloatingClient,
						CSize(0, 0));
		}
	}
}

BOOL CXTPToolBar::CToolBarInfo::SaveState(LPCTSTR lpszProfileName, int nIndex)
{
	TCHAR szSection[256];
	wsprintf(szSection, _xtpBarSection, lpszProfileName, nIndex);

	// delete the section
	CWinApp* pApp = AfxGetApp();
	pApp->WriteProfileString(szSection, NULL, NULL);

	pApp->WriteProfileInt(szSection, _xtpBarID, XTPToInt(m_nBarID));
	if (!m_bVisible)
		pApp->WriteProfileInt(szSection, _xtpVisible, m_bVisible);
	if (m_bFloating)
	{
		pApp->WriteProfileInt(szSection, _xtpFloating, m_bFloating);
	}
	if (m_pointPos.x != -1)
		pApp->WriteProfileInt(szSection, _xtpXPos, m_pointPos.x);
	if (m_pointPos.y != -1)
		pApp->WriteProfileInt(szSection, _xtpYPos, m_pointPos.y);
	if (m_nMRUWidth != 32767)
		pApp->WriteProfileInt(szSection, _xtpMRUWidth, XTPToInt(m_nMRUWidth));

	pApp->WriteProfileInt(szSection, _xtpMRUDockID, m_uMRUDockPosition);
	pApp->WriteProfileInt(szSection, _xtpMRUDockLeftPos, m_rectMRUDockPos.left);
	pApp->WriteProfileInt(szSection, _xtpMRUDockTopPos, m_rectMRUDockPos.top);
	pApp->WriteProfileInt(szSection, _xtpMRUDockRightPos, m_rectMRUDockPos.right);
	pApp->WriteProfileInt(szSection, _xtpMRUDockBottomPos, m_rectMRUDockPos.bottom);
	pApp->WriteProfileInt(szSection, _xtpMRUFloatXPos, m_ptMRUFloatPos.x);
	pApp->WriteProfileInt(szSection, _xtpMRUFloatYPos, m_ptMRUFloatPos.y);

	pApp->WriteProfileInt(szSection, _xtpDialogBar, m_bDialogBar);
	if (m_bDialogBar)
	{
		pApp->WriteProfileInt(szSection, _T("DialogBarDockingClientCx"),
							  m_szDialogBarDockingClient.cx);
		pApp->WriteProfileInt(szSection, _T("DialogBarDockingClientCy"),
							  m_szDialogBarDockingClient.cy);
		pApp->WriteProfileInt(szSection, _T("DialogBarFloatingClientCx"),
							  m_szDialogBarFloatingClient.cx);
		pApp->WriteProfileInt(szSection, _T("DialogBarFloatingClientCy"),
							  m_szDialogBarFloatingClient.cy);
	}

	// m_pBar->m_pControls->SaveState(szSection);

	return TRUE;
}
BOOL CXTPToolBar::CToolBarInfo::LoadState(LPCTSTR lpszProfileName, int nIndex,
										  CXTPDockState* pDockState)
{
	_ASSERTE(pDockState != NULL);
	if (!pDockState)
		return FALSE;

	CWinApp* pApp = AfxGetApp();
	TCHAR szSection[256];
	wsprintf(szSection, _xtpBarSection, lpszProfileName, nIndex);

	m_nBarID	= pApp->GetProfileInt(szSection, _xtpBarID, 0);
	m_bVisible  = !!pApp->GetProfileInt(szSection, _xtpVisible, TRUE);
	m_bFloating = !!pApp->GetProfileInt(szSection, _xtpFloating, FALSE);
	m_pointPos  = CPoint(XTPToInt(pApp->GetProfileInt(szSection, _xtpXPos, -1)),
						 XTPToInt(pApp->GetProfileInt(szSection, _xtpYPos, -1)));

	pDockState->ScalePoint(m_pointPos);

	m_nMRUWidth = pApp->GetProfileInt(szSection, _xtpMRUWidth, 32767);

	m_uMRUDockPosition = (XTPBarPosition)pApp->GetProfileInt(szSection, _xtpMRUDockID, 0);

	m_rectMRUDockPos = CRect(XTPToInt(pApp->GetProfileInt(szSection, _xtpMRUDockLeftPos, 0)),
							 XTPToInt(pApp->GetProfileInt(szSection, _xtpMRUDockTopPos, 0)),
							 XTPToInt(pApp->GetProfileInt(szSection, _xtpMRUDockRightPos, 0)),
							 XTPToInt(pApp->GetProfileInt(szSection, _xtpMRUDockBottomPos, 0)));
	pDockState->ScaleRectPos(m_rectMRUDockPos);

	m_ptMRUFloatPos = CPoint(XTPToInt(pApp->GetProfileInt(szSection, _xtpMRUFloatXPos, 0)),
							 XTPToInt(pApp->GetProfileInt(szSection, _xtpMRUFloatYPos, 0)));
	pDockState->ScalePoint(m_ptMRUFloatPos);

	m_bDialogBar = (0 != pApp->GetProfileInt(szSection, _xtpDialogBar, FALSE));
	if (m_bDialogBar)
	{
		m_szDialogBarDockingClient.cx = XTPToLong(
			pApp->GetProfileInt(szSection, _T("DialogBarDockingClientCx"),
								m_szDialogBarDockingClient.cx));
		m_szDialogBarDockingClient.cy = XTPToLong(
			pApp->GetProfileInt(szSection, _T("DialogBarDockingClientCy"),
								m_szDialogBarDockingClient.cy));
		m_szDialogBarFloatingClient.cx = XTPToLong(
			pApp->GetProfileInt(szSection, _T("DialogBarFloatingClientCx"),
								m_szDialogBarFloatingClient.cx));
		m_szDialogBarFloatingClient.cy = XTPToLong(
			pApp->GetProfileInt(szSection, _T("DialogBarFloatingClientCy"),
								m_szDialogBarFloatingClient.cy));
	}

	return TRUE;
}

void CXTPDockState::ScalePoint(CPoint& pt)
{
	if (m_bScaling)
	{
		pt.x = MulDiv(pt.x, m_sizeDevice.cx, m_sizeLogical.cx);
		pt.y = MulDiv(pt.y, m_sizeDevice.cy, m_sizeLogical.cy);
	}

	CRect rectClip = XTPMultiMonitor()->GetWorkArea(pt);
	rectClip.right -= GetSystemMetrics(SM_CXICON);
	rectClip.bottom -= GetSystemMetrics(SM_CYICON);

	if (pt.x > rectClip.right)
		pt.x = rectClip.right;
	if (pt.y > rectClip.bottom)
		pt.y = rectClip.bottom;
}

void CXTPDockState::ScaleRectPos(CRect& rect)
{
	CPoint pt;

	if (m_bScaling)
	{
		pt = rect.TopLeft();

		pt.x = MulDiv(pt.x, m_sizeDevice.cx, m_sizeLogical.cx) - rect.left;
		pt.y = MulDiv(pt.y, m_sizeDevice.cy, m_sizeLogical.cy) - rect.top;
		rect.OffsetRect(pt);
	}
	pt.x = pt.y = 0;

	CRect rectClip = XTPMultiMonitor()->GetWorkArea(rect);

	if (rect.left > rectClip.right)
		pt.x = rectClip.right - rect.left;
	if (rect.top > rectClip.bottom)
		pt.y = rectClip.bottom - rect.top;

	if (!((pt.x == 0) && (pt.y == 0)))
		rect.OffsetRect(pt);
}

CXTPDockState::CXTPDockState()
{
	m_dwVersion = _XTP_SCHEMA_CURRENT;

	m_bScaling = FALSE;

	m_sizeDevice = CSize(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
}

CXTPDockState::~CXTPDockState()
{
	Clear();
}

void CXTPDockState::Clear()
{
	for (int i = 0; i < m_arrBarInfo.GetSize(); i++)
		delete m_arrBarInfo[i];
	m_arrBarInfo.RemoveAll();
}

void CXTPDockState::SaveState(LPCTSTR lpszProfileName)
{
	int nIndex = 0;
	for (int i = 0; i < m_arrBarInfo.GetSize(); i++)
	{
		TOOLBARINFO* pInfo = m_arrBarInfo[i];
		_ASSERTE(pInfo != NULL);
		if (!pInfo)
			continue;
		if (pInfo->SaveState(lpszProfileName, nIndex))
			nIndex++;
	}

	CWinApp* pApp = AfxGetApp();
	TCHAR szSection[256];
	wsprintf(szSection, _xtpSummarySection, lpszProfileName);
	pApp->WriteProfileInt(szSection, _xtpBars, nIndex);

	CSize size = GetScreenSize();
	pApp->WriteProfileInt(szSection, _xtpScreenCX, size.cx);
	pApp->WriteProfileInt(szSection, _xtpScreenCY, size.cy);
}

void CXTPDockState::LoadState(LPCTSTR lpszProfileName)
{
	CWinApp* pApp = AfxGetApp();
	TCHAR szSection[256];
	wsprintf(szSection, _xtpSummarySection, lpszProfileName);
	UINT nBars = pApp->GetProfileInt(szSection, _xtpBars, 0);

	CSize size;
	size.cx = XTPToLongChecked(pApp->GetProfileInt(szSection, _xtpScreenCX, 0));
	size.cy = XTPToLongChecked(pApp->GetProfileInt(szSection, _xtpScreenCY, 0));
	SetScreenSize(size);

	for (UINT i = 0; i < nBars; i++)
	{
		TOOLBARINFO* pInfo = new TOOLBARINFO;
		m_arrBarInfo.Add(pInfo);
		pInfo->LoadState(lpszProfileName, XTPToInt(i), this);
	}
}

void CXTPDockState::DoPropExchange(CXTPPropExchange* pPX)
{
	CXTPPropExchangeSection secDockState(pPX->GetSection(_T("DockState")));
	// read/write version info
	if (pPX->IsStoring())
	{
		PX_DWord(&secDockState, _T("Version"), m_dwVersion, 0);

		CSize sz = GetScreenSize();
		PX_DPI_Size(&secDockState, _T("ScreenSize"), sz, CSize(0, 0));

		WORD nCount = (WORD)m_arrBarInfo.GetSize();
		PX_UShort(&secDockState, _T("Count"), nCount, 0);

		for (int i = 0; i < m_arrBarInfo.GetSize(); i++)
		{
			CString strSection;
			strSection.Format(_T("BarInfo%i"), i);

			CXTPPropExchangeSection secBarInfo(secDockState->GetSection(strSection));
			m_arrBarInfo[i]->DoPropExchange(&secBarInfo, this);
		}
	}
	else
	{
		Clear(); // empty out dockstate

		PX_DWord(&secDockState, _T("Version"), m_dwVersion, 0);

		CSize size;
		PX_DPI_Size(&secDockState, _T("ScreenSize"), size, CSize(0, 0));
		SetScreenSize(size);

		WORD nOldSize = 0;
		PX_UShort(&secDockState, _T("Count"), nOldSize, 0);

		m_arrBarInfo.SetSize(nOldSize);
		for (int i = 0; i < nOldSize; i++)
		{
			m_arrBarInfo[i] = new TOOLBARINFO;

			CString strSection;
			strSection.Format(_T("BarInfo%i"), i);

			CXTPPropExchangeSection secBarInfo(secDockState->GetSection(strSection));

			m_arrBarInfo[i]->DoPropExchange(&secBarInfo, this);
		}
		m_dwVersion = _XTP_SCHEMA_CURRENT;
	}
}

CSize CXTPDockState::GetScreenSize()
{
	return m_sizeDevice;
}

void CXTPDockState::SetScreenSize(CSize& size)
{
	m_sizeLogical = size;
	m_bScaling	= (size != m_sizeDevice && size.cx != 0 && size.cy != 0);
}

void CXTPToolBar::GetBarInfo(CToolBarInfo* pInfo)
{
	// get state info
	pInfo->m_nBarID   = m_nBarID;
	pInfo->m_pBar	 = this;
	pInfo->m_bVisible = IsVisible(); // handles delayed showing and hiding

	pInfo->m_nMRUWidth = XTPToUIntChecked(m_nMRUWidth);

	CXTPWindowRect rect(this);
	if (m_pDockBar != NULL)
		m_pDockBar->ScreenToClient(&rect);

	pInfo->m_pointPos = m_hWnd ? rect.TopLeft() : m_pDockContext->m_ptMRUFloatPos;

	pInfo->m_bFloating = m_barPosition == xtpBarFloating;

	pInfo->m_uMRUDockPosition = m_pDockContext->m_uMRUDockPosition;
	pInfo->m_rectMRUDockPos   = m_pDockContext->m_rectMRUDockPos;
	pInfo->m_ptMRUFloatPos	= m_pDockContext->m_ptMRUFloatPos;

	pInfo->m_bDialogBar				   = IsDialogBar();
	pInfo->m_szDialogBarDockingClient  = CSize(0, 0);
	pInfo->m_szDialogBarFloatingClient = CSize(0, 0);

	if (pInfo->m_bDialogBar)
	{
		pInfo->m_szDialogBarDockingClient  = ((CXTPDialogBar*)this)->m_szDockingClient;
		pInfo->m_szDialogBarFloatingClient = ((CXTPDialogBar*)this)->m_szFloatingClient;
	}
}

void CXTPToolBar::SetBarInfo(CToolBarInfo* pInfo)
{
	UINT nFlags = UINT((pInfo->m_bFloating ? 0 : SWP_NOSIZE) | SWP_NOACTIVATE | SWP_NOZORDER);

	if (!pInfo->m_bFloating && GetDockBar() == NULL)
		nFlags |= SWP_NOMOVE;

	m_nMRUWidth = XTPToIntChecked(pInfo->m_nMRUWidth);

	if (pInfo->m_bDialogBar && IsDialogBar())
	{
		((CXTPDialogBar*)this)->m_szDockingClient  = pInfo->m_szDialogBarDockingClient;
		((CXTPDialogBar*)this)->m_szFloatingClient = pInfo->m_szDialogBarFloatingClient;
	}

	_ASSERTE(m_pDockContext != NULL);
	if (!m_pDockContext)
		return;

	// You need to call EnableDocking before calling LoadBarState
	m_pDockContext->m_uMRUDockPosition = pInfo->m_uMRUDockPosition;
	m_pDockContext->m_rectMRUDockPos   = pInfo->m_rectMRUDockPos;
	m_pDockContext->m_ptMRUFloatPos	= pInfo->m_ptMRUFloatPos;

	// move and show/hide the window
	SetWindowPos(NULL, pInfo->m_pointPos.x, pInfo->m_pointPos.y, 0, 0,
				 nFlags | (pInfo->m_bVisible ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));

	m_bVisible = pInfo->m_bVisible;

	if (pInfo->m_bFloating)
		OnRecalcLayout();
}

CString CXTPCommandBars::GetIsolatedFileName(const CString& strPrifileName)
{
	if (!XTPSystemVersion()->IsWin2KOrGreater())
		return _T("");

	LPITEMIDLIST pidlAppData = NULL;
	IMalloc* pMalloc		 = NULL;
	CString strAppDataFolder;

	HRESULT hr = SHGetMalloc(&pMalloc);
	if (SUCCEEDED(hr))
	{
		if (SHGetSpecialFolderLocation(NULL, CSIDL_APPDATA, &pidlAppData) == NOERROR)
		{
			TCHAR szPath[MAX_PATH];

			if (SHGetPathFromIDList(pidlAppData, szPath))
			{
				strAppDataFolder = szPath;
			}
		}

		pMalloc->Free(pidlAppData);
		pMalloc->Release();
	}

	if (strAppDataFolder.IsEmpty())
		return _T("");

	strAppDataFolder += CString(_T("\\")) + AfxGetApp()->m_pszAppName;
	CreateDirectory(strAppDataFolder, NULL);

	if (!DIRECTORYEXISTS_S(strAppDataFolder))
		return _T("");

	// Set customization path as "\Documents and Settings\user\Application Data\AppName\PrifileName"
	return strAppDataFolder + _T("\\") + strPrifileName;
}

BOOL CXTPCommandBars::GetControlsFileName(CString& strFileName, LPCTSTR lpszProfileName)
{
	if (!m_strControlsFileName.IsEmpty())
	{
		strFileName = m_strControlsFileName;
		return TRUE;
	}

	CString strProfileName(lpszProfileName);
	strProfileName.Replace(_T("\\"), _T("_"));

	strFileName = GetIsolatedFileName(strProfileName);
	if (!strFileName.IsEmpty())
		return TRUE;

	TCHAR szBuff[_MAX_PATH];
	(void)szBuff;

#ifndef _XTP_COMMANDBARS_ACTIVEX

	VERIFY(::GetModuleFileName(AfxGetApp()->m_hInstance, szBuff, _MAX_PATH));
	strFileName.Format(_T("%s-%s"), szBuff, (LPCTSTR)strProfileName);

#endif
#ifdef _XTP_COMMANDBARS_ACTIVEX
	if (g_pGlobalSettings == 0
		|| ((CCommandBarsGlobalSettings*)g_pGlobalSettings)->m_strEXEName.IsEmpty())
	{
		VERIFY(::GetModuleFileName(GetModuleHandle(0), szBuff, _MAX_PATH));

		CString strLower(strFileName);
		strLower.MakeLower();
		if (strLower.Find(_T("vb6.exe")) != -1)
			return FALSE;

		strFileName.Format(_T("%s-%s"), szBuff, lpszProfileName);
	}
	else
	{
		strFileName = ((CCommandBarsGlobalSettings*)g_pGlobalSettings)->m_strPath + _T("\\")
					  + ((CCommandBarsGlobalSettings*)g_pGlobalSettings)->m_strEXEName + _T(".exe-")
					  + lpszProfileName;
	}

#endif
	return TRUE;
}

void CXTPCommandBars::SaveBarState(LPCTSTR lpszProfileName, BOOL bOnlyCustomized /*= TRUE*/)
{
	OnSetPreviewMode(FALSE); // Lets be sure we not in preview mode.

	CXTPDockState state;
	GetDockState(state);
	state.SaveState(lpszProfileName);
	SaveDockBarsState(lpszProfileName);

	XTP_COMMANDBARS_PROPEXCHANGE_PARAM param;
	param.pCommandBars		  = this;
	param.bSaveOnlyCustomized = bOnlyCustomized;

	if (m_bCustomizeAvail)
	{
		CXTPCommandBarList lstCommandBars(this);
		GenerateCommandBarList(&lstCommandBars, &param);

		CXTPZipMemFile memFile;
		CArchive ar(&memFile, CArchive::store);

		TCHAR szSection[256];
		wsprintf(szSection, _xtpCommandBarControlsSection, lpszProfileName);

		CXTPPropExchangeArchive px(ar);

		px.m_dwData = (DWORD_PTR)&param;

		if (SaveCommandBarList(&px, &lstCommandBars))
		{
			ar.Flush();

			DWORD dwCount   = 0;
			BYTE* pControls = 0;

			memFile.DetachCompressedBuffer(pControls, dwCount);

			CString strFileName;
			BOOL bSaveToFile = dwCount > 16000;

			if (bSaveToFile)
			{
				bSaveToFile = GetControlsFileName(strFileName, lpszProfileName);
			}

			if (bSaveToFile)
			{
				::DeleteFile((LPCTSTR)strFileName);
			}

			if (bSaveToFile)
			{
				try
				{
					CFile file;
					if (file.Open(strFileName, CFile::modeWrite | CFile::modeCreate))
					{
						file.Write(pControls, dwCount);
						AfxGetApp()->WriteProfileString(szSection, _xtpCommandBarControls,
														strFileName);
						AfxGetApp()->WriteProfileInt(szSection, _xtpCommandBarLoadFromFile, TRUE);
						file.Close();
						SetFileAttributes(strFileName, FILE_ATTRIBUTE_HIDDEN);
					}
				}
				catch (CFileException* pEx)
				{
					TRACE(_T("CXTPCommandBars::SaveBarState. File exception\r\n"));
					pEx->Delete();
				}
			}
			else
			{
				AfxGetApp()->WriteProfileBinary(szSection, _xtpCommandBarControls, pControls,
												dwCount);
				AfxGetApp()->WriteProfileInt(szSection, _xtpCommandBarLoadFromFile, FALSE);
			}

			ar.Abort();
			memFile.Close();
			free(pControls);
		}
		else
		{
			AfxGetApp()->WriteProfileString(szSection, NULL, NULL);
		}
	}

	if (GetMenuBar() && GetMenuBar()->m_bDirtyMenu)
	{
		GetMenuBar()->SwitchActiveMenu();
	}
	m_pOptions->bDirtyState = FALSE;
}

void CXTPCommandBars::_LoadControlsPart(CFile& file, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
{
	CArchive ar(&file, CArchive::load);

	CXTPPropExchangeArchive px(ar);
	px.m_dwData = (DWORD_PTR)pParam;

	CXTPCommandBarList lstCommandBars(this);
	if (LoadCommandBarList(&px, &lstCommandBars))
	{
		RestoreCommandBarList(&lstCommandBars, pParam->bLoadSilent);
	}

	ar.Close();
}

void CXTPCommandBars::LoadBarState(LPCTSTR lpszProfileName, BOOL bSilent)
{
	XTP_COMMANDBARS_PROPEXCHANGE_PARAM paramT;
	paramT.pCommandBars = this;
	paramT.bLoadSilent  = bSilent;

	if (m_bCustomizeAvail)
	{
		TCHAR szSection[256];
		wsprintf(szSection, _xtpCommandBarControlsSection, lpszProfileName);

		if (AfxGetApp()->GetProfileInt(szSection, _xtpCommandBarLoadFromFile, FALSE))
		{
			CString strFileName = AfxGetApp()->GetProfileString(szSection, _xtpCommandBarControls);
			CXTPZipMemFile file;
			if (file.OpenCompressedFile(strFileName))
			{
				_LoadControlsPart(file, &paramT);
			}
		}
		else
		{
			BYTE* pControls = NULL;
			DWORD dwCount   = 0;

			CXTPPropExchangeSection sec(TRUE, szSection);

			// PX_Blob support 16000 characters for ini file (MFC - 4096)
			if (PX_Blob(&sec, _xtpCommandBarControls, pControls, dwCount))
			{
				CXTPZipMemFile memFile(pControls, dwCount);

				_LoadControlsPart(memFile, &paramT);

				memFile.Close();
			}

			if (pControls)
				free(pControls);
		}
	}

	CXTPDockState state;
	state.LoadState(lpszProfileName);

	LoadDockBarsState(lpszProfileName);
	SetDockState(state);

	RecalcFrameLayout(TRUE);
	m_pOptions->bDirtyState = FALSE;
}

CXTPStatusBar* CXTPCommandBars::GetStatusBar() const
{
	CWnd* pBar = m_pFrame->GetDlgItem(AFX_IDW_STATUS_BAR);

	return DYNAMIC_DOWNCAST(CXTPStatusBar, pBar);
}

void CXTPCommandBars::SaveDockBarsState(LPCTSTR lpszProfileName)
{
	CWinApp* pApp = AfxGetApp();
	TCHAR szSection[256];

	for (int nIndex = 0; nIndex < 4; nIndex++)
	{
		wsprintf(szSection, _xtpDockBarSection, lpszProfileName, nIndex);
		pApp->WriteProfileString(szSection, NULL, NULL);

		CXTPDockBar* pDock = m_pDocks[nIndex];
		int nSize		   = (int)pDock->m_arrBars.GetSize();
		if (nSize > 1)
		{
			int nCount	 = 0;
			DWORD dwIDPrev = (DWORD)-1;
			for (int i = 0; i < nSize; i++)
			{
				CXTPToolBar* pBar = (CXTPToolBar*)pDock->m_arrBars[i];
				DWORD dwID		  = pBar ? pBar->m_nBarID : 0;
				if (dwIDPrev == 0 && dwID == 0)
					continue;
				dwIDPrev = dwID;

				TCHAR buf[16];
				wsprintf(buf, _xtpBar, nCount++);
				pApp->WriteProfileInt(szSection, buf, (int)dwID);
			}
			pApp->WriteProfileInt(szSection, _xtpBars, nCount);
		}
	}

	CXTPStatusBar* pBar = GetStatusBar();

	if (pBar != NULL)
	{
		pBar->SaveState(lpszProfileName);
	}
	else
	{
		pApp->WriteProfileString(lpszProfileName, _T("StatusBar"), NULL);
	}
}

void CXTPCommandBars::LoadDockBarsState(LPCTSTR lpszProfileName)
{
	CWinApp* pApp = AfxGetApp();
	TCHAR szSection[256];
	for (int nIndex = 0; nIndex < 4; nIndex++)
	{
		wsprintf(szSection, _xtpDockBarSection, lpszProfileName, nIndex);

		CXTPDockBar* pDock = m_pDocks[nIndex];

		UINT nBars = pApp->GetProfileInt(szSection, _xtpBars, 0);
		if (nBars > 1)
		{
			for (UINT i = 0; i < nBars; i++)
			{
				TCHAR buf[16];
				wsprintf(buf, _xtpBar, XTPToInt(i));
				DWORD dwID = pApp->GetProfileInt(szSection, buf, 0);

				CXTPToolBar* pBar = GetToolBar(dwID);
				if (pBar)
				{
					if (pBar->m_hWnd && pBar->GetParent() != pDock)
					{
						pBar->ModifyStyle(WS_POPUP, WS_CHILD);
						pBar->SetParent(pDock);
					}
					if (pBar->m_pDockBar != NULL)
						pBar->m_pDockBar->RemoveCommandBar(pBar);
					pBar->m_pDockBar	= pDock;
					pBar->m_barPosition = pDock->GetPosition();
				}

				pDock->m_arrBars.InsertAt(XTPToInt(i), pBar);
			}
		}
	}

	CXTPStatusBar* pBar = GetStatusBar();
	if (pBar != NULL)
		pBar->LoadState(lpszProfileName);
}

void CXTPCommandBars::DoPropExchange(CXTPPropExchange* pPX,
									 XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
{
	if (pPX->IsStoring())
		OnSetPreviewMode(FALSE); // Lets be sure we not in preview mode.

	XTP_COMMANDBARS_PROPEXCHANGE_PARAM paramT;
	if (pParam == NULL)
		pParam = &paramT;

	pParam->pCommandBars = this;

	pPX->m_dwData = (DWORD_PTR)pParam;

	CXTPDockState state;

	pPX->ExchangeSchemaSafe();

	BOOL bExplicitlyDirty = FALSE;
	if (pPX->IsStoring())
	{
		CXTPToolBar* pDesignerBar = 0;

		if (pParam->bSerializeActions)
		{
			CXTPPropExchangeSection secActions(pPX->GetSection(_T("Actions")));
			PX_Bool(&secActions, _T("Enabled"), m_bEnableActions, FALSE);

			m_pActions->DoPropExchange(&secActions);
		}

		if (pParam->bSerializeDesignerControls && m_pDesignerControls)
		{
			pDesignerBar = (CXTPToolBar*)Add(_T("Controls"), xtpBarFloating);
			if (pDesignerBar->m_pControls != NULL)
			{
				pDesignerBar->m_pControls->InternalRelease();
			}
			pDesignerBar->m_pControls = m_pDesignerControls;
			m_pDesignerControls->InternalAddRef();

			pDesignerBar->SetBarID(0xFFEEFF);
			pDesignerBar->SetVisible(FALSE);
		}

		if (pParam->bSerializeControls)
		{
			CXTPCommandBarList lstCommandBars(this);
			GenerateCommandBarList(&lstCommandBars, pParam);

			VERIFY(SaveCommandBarList(pPX, &lstCommandBars));
		}
		if (pDesignerBar)
		{
			Remove(pDesignerBar);
		}

		if (pParam->bSerializeLayout)
		{
			GetDockState(state);
			CXTPPropExchangeSection secLayout(pPX->GetSection(_T("Layout")));
			state.DoPropExchange(&secLayout);
			SerializeDockBarsState(&secLayout);
		}

		if (GetMenuBar() && GetMenuBar()->m_bDirtyMenu)
		{
			GetMenuBar()->SwitchActiveMenu();
		}
	}
	else
	{
		if (pParam->bSerializeActions && pPX->GetSchema() > _XTP_SCHEMA_100)
		{
			CXTPPropExchangeSection secActions(pPX->GetSection(_T("Actions")));
			PX_Bool(&secActions, _T("Enabled"), m_bEnableActions, FALSE);

			m_pActions->DoPropExchange(&secActions);
		}

		if (pParam->bSerializeControls)
		{
			CXTPCommandBarList lstCommandBars(this);
			if (LoadCommandBarList(pPX, &lstCommandBars))
			{
				BOOL bDirtyStateBeforeRestore = m_pOptions->bDirtyState;

				RestoreCommandBarList(&lstCommandBars, pParam->bLoadSilent);

				if (!bDirtyStateBeforeRestore && m_pOptions->bDirtyState)
				{
					bExplicitlyDirty = TRUE;
				}

				CXTPMenuBar* pMenuBar = GetMenuBar();
				if (pMenuBar)
				{
					pMenuBar->SetupMenu();
					pMenuBar->RefreshMenu();
				}
			}
			else
			{
				return;
			}
		}

		if (pParam->bSerializeLayout)
		{
			CXTPPropExchangeSection secLayout(pPX->GetSection(_T("Layout")));
			state.DoPropExchange(&secLayout);
			SerializeDockBarsState(&secLayout);
			SetDockState(state);
		}

		CXTPToolBar* pCommandBar = GetToolBar(0xFFEEFF);

		if (pCommandBar)
		{
			if (pParam->bSerializeDesignerControls)
			{
				if (m_pDesignerControls)
					m_pDesignerControls->InternalRelease();

				m_pDesignerControls		 = pCommandBar->GetControls();
				pCommandBar->m_pControls = NULL;

				Remove(pCommandBar);

				m_pDesignerControls->SetParent(NULL);
				m_pDesignerControls->Remove(m_pDesignerControls->FindControl(xtpControlError,
																			 XTP_ID_TOOLBAR_EXPAND,
																			 TRUE, FALSE));
				m_pDesignerControls->Remove(m_pDesignerControls->FindControl(xtpControlError,
																			 XTP_ID_TOOLBAR_HIDE,
																			 TRUE, FALSE));
				m_pDesignerControls->SetCommandBars(this);
			}
			else
			{
				Remove(pCommandBar);
			}
		}

		RecalcFrameLayout(TRUE);
	}

	if (pParam->bSerializeImages)
	{
		CXTPPropExchangeSection secImages(pPX->GetSection(_T("Images")));
		GetImageManager()->DoPropExchange(&secImages);
	}

	if (pParam->bSerializeOptions)
	{
		CXTPPropExchangeSection secShortcuts(pPX->GetSection(_T("Shortcuts")));
		m_pShortcutManager->DoPropExchange(&secShortcuts);

		CXTPPropExchangeSection secOptions(pPX->GetSection(_T("Options")));

		XTPPaintTheme theme = GetPaintManager()->BaseTheme();
		PX_Enum(&secOptions, _T("Theme"), theme, xtpThemeOffice2000);
		if (pPX->IsLoading())
			SetPaintManager(CXTPPaintManager::CreateTheme(theme));

		m_pOptions->DoPropExchange(&secOptions);
		PX_Bool(&secOptions, _T("Customizable"), m_bCustomizeAvail, TRUE);
	}

	if (pParam->bSerializeDesignerControls && pPX->IsLoading())
	{
		m_pShortcutManager->CreateOriginalAccelTable();

		if (m_bCustomizeAvail)
		{
			for (int i = 0; i < GetCount(); i++)
			{
				CXTPToolBar* pToolBar = GetAt(i);
				pToolBar->GetControls()->CreateOriginalControls();
			}
		}
	}

	if (!bExplicitlyDirty)
	{
		m_pOptions->bDirtyState = FALSE;
	}
}

void CXTPCommandBars::SerializeBarState(CArchive& ar, BOOL bSerializeControls, BOOL bOnlyCustomized,
										BOOL bSilent)
{
	CXTPPropExchangeArchive px(ar);

	XTP_COMMANDBARS_PROPEXCHANGE_PARAM paramT;
	paramT.bSaveOnlyCustomized = bOnlyCustomized;
	paramT.bSerializeControls  = bSerializeControls;
	paramT.bLoadSilent		   = bSilent;

	DoPropExchange(&px, &paramT);
}

void CXTPCommandBars::SerializeDockBarsState(CXTPPropExchange* pPX)
{
	CXTPPropExchangeSection secDockBars(pPX->GetSection(_T("DockBars")));

	for (int nIndex = 0; nIndex < 4; nIndex++)
	{
		CXTPDockBar* pDock = m_pDocks[nIndex];

		CString strSection;
		strSection.Format(_T("DockBar%i"), nIndex);
		CXTPPropExchangeSection secDockBar(secDockBars->GetSection(strSection));

		if (pPX->IsStoring())
		{
			int nSize	  = (int)pDock->m_arrBars.GetSize();
			DWORD nCount   = 0;
			DWORD dwIDPrev = (DWORD)-1;
			int i;

			for (i = 0; i < nSize; i++)
			{
				CXTPToolBar* pBar = (CXTPToolBar*)pDock->m_arrBars[i];
				DWORD dwID		  = pBar ? pBar->m_nBarID : 0;
				if (dwIDPrev == 0 && dwID == 0)
					continue;
				dwIDPrev = dwID;
				nCount++;
			}
			if (nCount > 1)
			{
				PX_DWord(&secDockBar, _T("Count"), nCount, 0);
				int j = 0;

				dwIDPrev = (DWORD)-1;
				for (i = 0; i < nSize; i++)
				{
					CXTPToolBar* pBar = (CXTPToolBar*)pDock->m_arrBars[i];
					DWORD dwID		  = pBar ? pBar->m_nBarID : 0;
					if (dwIDPrev == 0 && dwID == 0)
						continue;
					dwIDPrev = dwID;

					CString strDockBarSection;
					strDockBarSection.Format(_T("Id%i"), j++);
					PX_DWord(&secDockBar, strDockBarSection, dwID, 0);
				}
			}
			else
			{
				nCount = 0;
				PX_DWord(&secDockBar, _T("Count"), nCount, 0);
			}
		}
		else
		{
			DWORD dwID  = 0;
			DWORD nBars = 0;
			PX_DWord(&secDockBar, _T("Count"), nBars, 0);

			if (nBars > 1)
			{
				for (int i = 0; i < (int)nBars; i++)
				{
					CString strDockBarSection;
					strDockBarSection.Format(_T("Id%i"), i);
					PX_DWord(&secDockBar, strDockBarSection, dwID, 0);

					CXTPToolBar* pBar = GetToolBar(dwID);

					if (pBar)
					{
						if (pBar->m_hWnd && pBar->GetParent() != pDock)
						{
							pBar->ModifyStyle(WS_POPUP, WS_CHILD);
							pBar->SetParent(pDock);
						}
						if (pBar->m_pDockBar != NULL)
							pBar->m_pDockBar->RemoveCommandBar(pBar);
						pBar->m_pDockBar	= pDock;
						pBar->m_barPosition = pDock->GetPosition();
					}
					pDock->m_arrBars.InsertAt(i, pBar);
				}
			}
		}
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_1200)
	{
		CXTPPropExchangeSection secStatusBar(pPX->GetSection(_T("StatusBar")));
		CXTPStatusBar* pStatusBar = GetStatusBar();
		if (pStatusBar)
		{
			pStatusBar->DoPropExchange(&secStatusBar);
		}
		else
		{
			BOOL bVisible = FALSE;
			PX_Bool(pPX, _T("Visible"), bVisible, TRUE);

			CString strValue;
			PX_String(pPX, _T("Panes"), strValue, _T(""));
		}
	}
}

void CXTPCommandBars::GetDockState(CXTPDockState& state)
{
	state.Clear(); // make sure dockstate is empty
	// get state info for each bar
	for (int i = 0; i < GetCount(); i++)
	{
		CXTPToolBar* pBar = GetAt(i);
		_ASSERTE(pBar != NULL);
		if (!pBar)
			continue;
		CXTPToolBar::CToolBarInfo* pInfo = new CXTPToolBar::CToolBarInfo;
		pBar->GetBarInfo(pInfo);

		state.m_arrBarInfo.Add(pInfo);
	}
}

void CXTPCommandBars::SetDockState(CXTPDockState& state)
{
	for (int i = 0; i < state.m_arrBarInfo.GetSize(); i++)
	{
		CXTPToolBar::CToolBarInfo* pInfo = state.m_arrBarInfo[i];
		_ASSERTE(pInfo != NULL);
		if (!pInfo)
			continue;

		pInfo->m_pBar = GetToolBar(pInfo->m_nBarID);

		if (pInfo->m_pBar != NULL)
		{
			if (pInfo->m_bFloating)
			{
				FloatCommandBar(pInfo->m_pBar);
			}
			else
			{
				VERIFY(pInfo->m_pBar->Create(m_pFrame, FALSE));
			}

			pInfo->m_pBar->SetBarInfo(pInfo);
		}
	}
}

void CXTPCommandBars::GenerateCommandBarList(CXTPCommandBarList* pCommandBarList,
											 XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
{
	DWORD nID = 0x1000000;
	int i;

	for (i = 0; i < GetCount(); i++)
	{
		CXTPToolBar* pBar = GetAt(i);

		if (pBar->IsTemporary())
			continue;

		if (pParam->bSaveOnlyCustomized && pBar->IsBuiltIn())
		{
			if (!pBar->ShouldSerializeBar())
				continue;
		}

		pBar->GenerateCommandBarList(nID, pCommandBarList, pParam);
	}

	for (i = 0; i < m_pContextMenus->GetCount(); i++)
	{
		CXTPCommandBar* pBar = m_pContextMenus->GetAt(i);

		if (pParam->bSaveOnlyCustomized)
		{
			if (!pBar->GetControls()->IsChanged())
				continue;
		}

		pBar->GenerateCommandBarList(nID, pCommandBarList, pParam);
	}
}

void CXTPCommandBar::GenerateCommandBarList(DWORD& nID, CXTPCommandBarList* pCommandBarList,
											XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
{
	if (!pCommandBarList->Lookup(this))
	{
		pCommandBarList->Add(this);
		InternalAddRef();

		if (!IsKindOf(RUNTIME_CLASS(CXTPToolBar)))
		{
			if (m_nBarID == 0 || m_nBarID >= 0x1000000)
				m_nBarID = nID++;
		}
		else
			_ASSERTE(m_nBarID != 0);

		m_pControls->GenerateCommandBarList(nID, pCommandBarList, pParam);
	}
}

void CXTPMenuBar::GenerateCommandBarList(DWORD& nID, CXTPCommandBarList* pCommandBarList,
										 XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
{
	if (!pCommandBarList->Lookup(this))
	{
		CXTPToolBar::GenerateCommandBarList(nID, pCommandBarList, pParam);

		POSITION pos = m_pMDIMenus->GetStartPosition();
		while (pos)
		{
			CXTPMenuBarMDIMenuInfo* pInfo;
			m_pMDIMenus->GetNextMenu(pos, pInfo);

			pInfo->m_pControls->GenerateCommandBarList(nID, pCommandBarList, pParam);
		}
	}
}

void CXTPControl::GenerateCommandBarList(DWORD& nID, CXTPCommandBarList* pCommandBarList,
										 XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
{
	CXTPCommandBar* pCommandBar = GetCommandBar();
	if (pCommandBar)
	{
		pCommandBar->GenerateCommandBarList(nID, pCommandBarList, pParam);
	}
}

void CXTPControls::GenerateCommandBarList(DWORD& nID, CXTPCommandBarList* pCommandBarList,
										  XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
{
	for (int i = 0; i < GetCount(); i++)
	{
		CXTPControl* pControl = GetAt(i);

		if (pControl && !pControl->m_bTemporary)
		{
			pControl->GenerateCommandBarList(nID, pCommandBarList, pParam);
		}
	}

	if (m_pOriginalControls && pParam->bSaveOriginalControls)
		m_pOriginalControls->GenerateCommandBarList(nID, pCommandBarList, pParam);
}

BOOL CXTPCommandBars::SaveCommandBarList(CXTPPropExchange* pPX, CXTPCommandBarList* pCommandBarList)
{
	try
	{
		CXTPPropExchangeSection secCommandBars(pPX->GetSection(_T("CommandBars")));

		long nCount = pCommandBarList->GetCount();

		CXTPPropExchangeEnumeratorPtr pEnumerator(secCommandBars->GetEnumerator(_T("CommandBar")));
		POSITION posEnum = pEnumerator->GetPosition(XTPToDWORDChecked(nCount), FALSE);

		for (long i = 0; i < nCount; i++)
		{
			CXTPCommandBar* pCommandBar = pCommandBarList->GetAt(i);
			CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
			PX_Object(&secItem, pCommandBar, RUNTIME_CLASS(CXTPCommandBar));
		}
	}
	catch (COleException* pEx)
	{
		TRACE(_T("CXTPCommandBars::SaveCommandBarList. OLE exception: %x\r\n"), pEx->m_sc);
		pEx->Delete();
		return FALSE;
	}
	catch (CArchiveException* pEx)
	{
		TRACE(_T("CXTPCommandBars::SaveCommandBarList. Archive exception\r\n"));
		pEx->Delete();
		return FALSE;
	}
	return TRUE;
}

BOOL CXTPCommandBars::LoadCommandBarList(CXTPPropExchange* pPX, CXTPCommandBarList* pCommandBarList)
{
	try
	{
		CXTPPropExchangeSection secCommandBars(pPX->GetSection(_T("CommandBars")));

		CXTPPropExchangeEnumeratorPtr pEnumerator(secCommandBars->GetEnumerator(_T("CommandBar")));
		POSITION posEnum = pEnumerator->GetPosition(0, FALSE);

		while (posEnum)
		{
			CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));

			CXTPCommandBar* pCommandBar = NULL;
			PX_Object(&secItem, pCommandBar, RUNTIME_CLASS(CXTPCommandBar));

			if (!pCommandBar)
			{
				return FALSE;
			}

			pCommandBar->GetControls()->RefreshIndexes();

			pCommandBarList->Add(pCommandBar);
		}
	}
	catch (COleException* pEx)
	{
		TRACE(_T("CXTPCommandBars::LoadCommandBarList. OLE exception: %x\r\n"), pEx->m_sc);
		pEx->Delete();
		return FALSE;
	}
	catch (CArchiveException* pEx)
	{
		TRACE(_T("CXTPCommandBars::LoadCommandBarList. Archive exception\r\n"));
		pEx->Delete();
		return FALSE;
	}
	return TRUE;
}

void CXTPToolBar::MergeToolBar(CXTPCommandBar* pCommandBar, BOOL bSilent)
{
	// Call detailed implementation
	MergeToolBar(pCommandBar, bSilent, 0);
}

void CXTPToolBar::MergeToolBar(CXTPCommandBar* pCommandBar, BOOL bSilent,
							   int nDefaultConfirmationChoice)
{
	CXTPControls* pLastControls = pCommandBar->GetControls()->GetOriginalControls();

	if (pLastControls && GetControls()->GetOriginalControls()
		&& GetControls()->GetOriginalControls()->Compare(pLastControls) == FALSE)
	{
		// silent restore if not customized
		if (pLastControls->Compare(pCommandBar->GetControls()) == FALSE)
		{
			int nChoice = nDefaultConfirmationChoice;
			if (!bSilent && IDYES != nChoice && IDNO != nChoice)
			{
				CString strMessage, strUpdate;
				CXTPResourceManager::AssertValid(
					XTPResourceManager()->LoadString(&strUpdate, XTP_IDS_CONFIRM_UPDATE));
				strMessage.Format(strUpdate, (LPCTSTR)m_strTitle);
				nChoice = XTPResourceManager()->ShowMessageBox(strMessage,
															   MB_YESNO | MB_ICONQUESTION);
			}

			if (IDNO == nChoice)
			{
				CXTPOriginalControls* pControls = GetControls()->GetOriginalControls();
				CMDTARGET_ADDREF(pControls);

				Copy(pCommandBar, FALSE);

				m_pControls->SetOriginalControls(pControls);
			}
		}
	}
	else
	{
		CXTPOriginalControls* pOriginalControls = pCommandBar->m_pControls->m_pOriginalControls
													  ? NULL
													  : m_pControls->m_pOriginalControls;
		CMDTARGET_ADDREF(pOriginalControls);

		Copy(pCommandBar, FALSE);

		if (pOriginalControls)
		{
			_ASSERTE(m_pControls->m_pOriginalControls == NULL);
			m_pControls->SetOriginalControls(pOriginalControls);
		}
	}
}

void CXTPCommandBars::RestoreCommandBarList(CXTPCommandBarList* pCommandBarList, BOOL bSilent)
{
	for (int i = 0; i < pCommandBarList->GetCount(); i++)
	{
		CXTPCommandBar* pCommandBar = pCommandBarList->GetAt(i);
		CXTPToolBar* pToolBar		= DYNAMIC_DOWNCAST(CXTPToolBar, pCommandBar);

		if (pToolBar)
		{
			CXTPToolBar* pExistsBar = GetToolBar(pToolBar->GetBarID());

			pCommandBar->RestoreCommandBarList(pCommandBarList);

			if (pExistsBar)
			{
				int nDefaultConfirmationChoice = 0;
				if (m_bDefaultResetCustomizedToolbarChoiceEnabled)
				{
					nDefaultConfirmationChoice = (m_bDefaultResetCustomizedToolbarChoice ? IDYES
																						 : IDNO);
				}
				pExistsBar->MergeToolBar(pCommandBar, bSilent, nDefaultConfirmationChoice);
			}
			else
			{
				m_arrBars.Add(pToolBar);
				pToolBar->InternalAddRef();
				pToolBar->Create(m_pFrame, FALSE);
				pToolBar->EnableDocking(pToolBar->m_dwFlags);

				OnToolBarAdded(pToolBar);
			}
		}
		else if (pCommandBar->IsPopupBar() && ((CXTPPopupBar*)pCommandBar)->IsContextMenu())
		{
			CXTPCommandBar* pExistsBar = m_pContextMenus->FindCommandBar(pCommandBar->GetBarID());

			pCommandBar->RestoreCommandBarList(pCommandBarList);

			if (pExistsBar)
			{
				CXTPControls* pControls = pCommandBar->GetControls();
				CMDTARGET_ADDREF(pControls)

				CXTPOriginalControls* pOriginalControls =
					pExistsBar->GetControls()->GetOriginalControls();
				CMDTARGET_ADDREF(pOriginalControls);

				pExistsBar->SetControls(pControls);
				pCommandBar->SetControls(NULL);

				if (pOriginalControls)
				{
					pExistsBar->GetControls()->SetOriginalControls(pOriginalControls);
				}
			}
			else
			{
				m_pContextMenus->Add(pCommandBar);
				pCommandBar->InternalAddRef();

				if (pCommandBar->GetControls()->GetOriginalControls() == NULL)
					pCommandBar->GetControls()->CreateOriginalControls();
			}
		}
	}
}

void CXTPCommandBar::RestoreCommandBarList(CXTPCommandBarList* pCommandBarList)
{
	m_pControls->RestoreCommandBarList(pCommandBarList);
}

void CXTPMenuBar::RestoreCommandBarList(CXTPCommandBarList* pCommandBarList)
{
	CXTPToolBar::RestoreCommandBarList(pCommandBarList);

	POSITION pos = m_pMDIMenus->GetStartPosition();
	while (pos)
	{
		CXTPMenuBarMDIMenuInfo* pInfo;
		m_pMDIMenus->GetNextMenu(pos, pInfo);

		pInfo->m_pControls->RestoreCommandBarList(pCommandBarList);
	}
}

void CXTPControl::RestoreCommandBarList(CXTPCommandBarList* /*pCommandBarList*/)
{
}
void CXTPControlPopup::RestoreCommandBarList(CXTPCommandBarList* pCommandBarList)
{
	if (m_dwCommandBarID != 0)
	{
		CXTPCommandBar* pCommandBar = pCommandBarList->FindCommandBar(m_dwCommandBarID);
		_ASSERTE(pCommandBar);

		if (pCommandBar)
		{
			SetCommandBar(pCommandBar);
			m_dwCommandBarID = 0;
			pCommandBar->RestoreCommandBarList(pCommandBarList);
		}
	}
}

void CXTPControls::RestoreCommandBarList(CXTPCommandBarList* pCommandBarList)
{
	for (int i = 0; i < GetCount(); i++)
	{
		CXTPControl* pControl = GetAt(i);

		pControl->RestoreCommandBarList(pCommandBarList);
	}

	if (m_pOriginalControls)
		m_pOriginalControls->RestoreCommandBarList(pCommandBarList);
}

void CXTPCommandBar::DoPropExchange(CXTPPropExchange* pPX)
{
	PX_Enum(pPX, _T("Type"), m_barType, xtpBarTypeNormal);
	PX_Enum(pPX, _T("Position"), m_barPosition, xtpBarTop);
	PX_Long(pPX, _T("BarID"), (long&)m_nBarID, 0);
	PX_Long(pPX, _T("Flags"), (long&)m_dwFlags, 0);
	PX_Long(pPX, _T("Style"), (long&)m_dwStyle, 0);
	PX_String(pPX, _T("Title"), m_strTitle, _T(""));
	PX_Bool(pPX, _T("Customizable"), m_bCustomizable, TRUE);
	PX_DPI_X_Int(pPX, _T("MRUWidth"), m_nMRUWidth, 0);

	if (pPX->GetSchema() > _XTP_SCHEMA_80)
		PX_Size(pPX, _T("IconSize"), m_szIcons, CSize(0, 0));

	if (pPX->IsLoading())
	{
		_ASSERTE(pPX->m_dwData != 0);
		if (pPX->m_dwData)
			SetCommandBars(((XTP_COMMANDBARS_PROPEXCHANGE_PARAM*)pPX->m_dwData)->pCommandBars);
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_100)
	{
		PX_DPI_Size(pPX, _T("ButtonSize"), m_szButtons, CSize(0, 0));
		PX_Bool(pPX, _T("ShowTextBelowIcons"), m_bTextBelow, XTP_BOOL_DEFAULT);

		BOOL bAnimation = IsAnimationEnabled();
		PX_Bool(pPX, _T("EnableAnimation"), bAnimation, FALSE);
		if (pPX->IsLoading())
		{
			EnableAnimation(bAnimation);
		}
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_103)
	{
		PX_Enum(pPX, _T("DefaultButtonStyle"), m_buttonStyle, xtpButtonAutomatic);
	}

	CXTPPropExchangeSection secControls(pPX->GetSection(_T("Controls")));
	m_pControls->DoPropExchange(&secControls);
}

void CXTPToolBar::DoPropExchange(CXTPPropExchange* pPX)
{
	CXTPCommandBar::DoPropExchange(pPX);

	PX_Bool(pPX, _T("BuiltIn"), m_bBuiltIn, TRUE);
	PX_Bool(pPX, _T("TearOff"), m_bTearOff, FALSE);

	if (pPX->GetSchema() > _XTP_SCHEMA_87)
		PX_Bool(pPX, _T("Closeable"), m_bCloseable, TRUE);

	if (pPX->GetSchema() > _XTP_SCHEMA_875)
		PX_Bool(pPX, _T("ContextMenuPresent"), m_bContextMenuPresent, TRUE);

	if (pPX->GetSchema() > _XTP_SCHEMA_98)
		PX_Bool(pPX, _T("CustomizeDialogPresent"), m_bCustomizeDialogPresent, TRUE);

	if (pPX->GetSchema() <= _XTP_SCHEMA_98 && pPX->IsLoading() && m_barType == xtpBarTypeMenuBar)
	{
		m_bCloseable = FALSE;
	}
}

void CXTPMenuBar::DoPropExchange(CXTPPropExchange* pPX)
{
	if (pPX->IsStoring())
	{
		if (m_pMDIMenus->GetCount() > 0)
		{
			SwitchMDIMenu(GetDefaultMenuResource());
			m_bDirtyMenu = TRUE;
		}
	}

	CXTPToolBar::DoPropExchange(pPX);
	PX_Long(pPX, _T("ResourceId"), (long&)m_nIDResource, 0);

	if (pPX->IsStoring())
	{
		//_XTP_SCHEMA_861
		DWORD dwCount = 0;

		POSITION pos = m_pMDIMenus->GetStartPosition();
		while (pos)
		{
			CXTPMenuBarMDIMenuInfo* pInfo;
			m_pMDIMenus->GetNextMenu(pos, pInfo);
			if (pInfo->m_bChanged)
				dwCount++;
		}

		int i = 0;
		pPX->WriteCount(dwCount);

		pos = m_pMDIMenus->GetStartPosition();
		while (pos)
		{
			CXTPMenuBarMDIMenuInfo* pInfo;
			m_pMDIMenus->GetNextMenu(pos, pInfo);
			if (!pInfo->m_bChanged)
				continue;

			long nIDCommand = (long)pInfo->m_nIDResource;

			CString strSection;
			strSection.Format(_T("%s%i"), _T("MDIMenu"), i++);

			CXTPPropExchangeSection sec(pPX->GetSection(strSection));
			PX_Long(&sec, _T("Id"), nIDCommand, 0);
			pInfo->m_pControls->DoPropExchange(&sec);
		}
	}
	else
	{
		if (pPX->GetSchema() > _XTP_SCHEMA_86)
		{
			DWORD nCount = (DWORD)pPX->ReadCount();

			for (DWORD i = 0; i < nCount; i++)
			{
				UINT nIDCommand = 0;

				CString strSection;
				strSection.Format(_T("%s%i"), _T("MDIMenu"), i);

				CXTPPropExchangeSection sec(pPX->GetSection(strSection));
				PX_Long(&sec, _T("Id"), (long&)nIDCommand, 0);

				CXTPMenuBarMDIMenuInfo* pInfo = NULL;
				if (!m_pMDIMenus->Lookup(nIDCommand))
				{
					pInfo = new CXTPMenuBarMDIMenuInfo(GetCommandBars(), nIDCommand);
					m_pMDIMenus->SetAt(nIDCommand, pInfo);
				}
				if (pInfo)
					pInfo->m_pControls->DoPropExchange(&sec);
			}
		}
	}
}

void CXTPPopupBar::DoPropExchange(CXTPPropExchange* pPX)
{
	CXTPCommandBar::DoPropExchange(pPX);

	PX_Bool(pPX, _T("TearOffPopup"), m_bTearOffPopup, FALSE);
	PX_String(pPX, _T("TearOffCaption"), m_strTearOffCaption, _T(""));
	PX_Long(pPX, _T("TearOffId"), (long&)m_nTearOffID, 0);
	PX_DPI_X_Int(pPX, _T("TearOffWidth"), m_nTearOffWidth, 0);

	if (pPX->GetSchema() > _XTP_SCHEMA_85)
	{
		PX_DPI_Rect(pPX, _T("Borders"), m_rcBorders, CRect(2, 4, 2, 4));
		PX_Bool(pPX, _T("ShowShadow"), m_bShowShadow, TRUE);
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_95)
	{
		PX_Bool(pPX, _T("DoubleGripper"), m_bDoubleGripper, FALSE);
	}

	if (pPX->GetSchema() < _XTP_SCHEMA_104)
	{
		SetShowGripper(TRUE);
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_103)
	{
		PX_Bool(pPX, _T("ContextMenu"), m_bContextMenu, FALSE);
	}
}

BOOL CXTPControls::ShouldSerializeControl(CXTPControl* pControl)
{
	return !pControl->m_bTemporary;
}

void CXTPControls::DoPropExchange(CXTPPropExchange* pPX)
{
	_ASSERTE(pPX->m_dwData != 0);
	XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam = (XTP_COMMANDBARS_PROPEXCHANGE_PARAM*)pPX->m_dwData;

	if (pPX->IsStoring())
	{
		DWORD nCount = 0;
		int i;
		for (i = 0; i < m_arrControls.GetSize(); i++)
		{
			CXTPControl* pControl = GetAt(i);
			if (ShouldSerializeControl(pControl))
				nCount++;
		}

		CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Control")));
		POSITION posEnum = pEnumerator->GetPosition(nCount, FALSE);

		for (i = 0; i < (int)m_arrControls.GetSize(); i++)
		{
			CXTPControl* pControl = GetAt(i);
			if (ShouldSerializeControl(pControl))
			{
				CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
				PX_Object(&secItem, pControl, RUNTIME_CLASS(CXTPControl));
			}
		}

		BOOL bOriginalControls = pParam && m_pOriginalControls && pParam->bSaveOriginalControls
									 ? TRUE
									 : FALSE;
		PX_Bool(pPX, _T("OriginalControls"), bOriginalControls, FALSE);

		if (bOriginalControls && m_pOriginalControls)
		{
			CXTPPropExchangeSection secControls(pPX->GetSection(_T("OriginalControls")));
			m_pOriginalControls->DoPropExchange(&secControls);
		}

		BOOL bCustomizedControls = FALSE;
		PX_Bool(pPX, _T("CustomizedControls"), bCustomizedControls, FALSE);
	}
	else
	{
		CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Control")));
		POSITION posEnum = pEnumerator->GetPosition(0, FALSE);

		RemoveAll();

		while (posEnum)
		{
			CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));

			CXTPControl* pControl = NULL;
			PX_Object(&secItem, pControl, RUNTIME_CLASS(CXTPControl));

			if (!pControl)
				AfxThrowArchiveException(CArchiveException::badClass);

			m_arrControls.Add(pControl);
			OnControlAdded(pControl);
		}

		RefreshIndexes();
		if (pPX->GetSchema() > _XTP_SCHEMA_80)
		{
			BOOL bOriginalControls = FALSE;
			PX_Bool(pPX, _T("OriginalControls"), bOriginalControls, FALSE);

			if (bOriginalControls)
			{
				CXTPOriginalControls* pOriginalControls = new CXTPOriginalControls();
				SetOriginalControls(pOriginalControls);

				CXTPPropExchangeSection secControls(pPX->GetSection(_T("OriginalControls")));
				pOriginalControls->DoPropExchange(&secControls);
			}

			BOOL bCustomizedControls = FALSE;
			PX_Bool(pPX, _T("CustomizedControls"), bCustomizedControls, FALSE);

			if (bCustomizedControls)
			{
				// _XTP_SCHEMA_80 compatibility.
				CXTPControls* pCustomizedControls = new CXTPControls;
				CXTPPropExchangeSection secControls(pPX->GetSection(_T("CustomizedControls")));
				pCustomizedControls->DoPropExchange(&secControls);
				pCustomizedControls->InternalRelease();
			}
		}
	}
}

void CXTPControlActions::DoPropExchange(CXTPPropExchange* pPX)
{
	if (pPX->IsStoring())
	{
		long nCount = GetCount();

		CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Action")));
		POSITION posEnum = pEnumerator->GetPosition(XTPToDWORDChecked(nCount), FALSE);

		for (int i = 0; i < nCount; i++)
		{
			CXTPControlAction* pAction = GetAt(i);
			CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));

			int nId = pAction->GetID();
			PX_Int(&secItem, _T("Id"), nId);
			pAction->DoPropExchange(&secItem);
		}
	}
	else
	{
		CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Action")));
		POSITION posEnum = pEnumerator->GetPosition(0, FALSE);

		while (posEnum)
		{
			CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));

			int nId = 0;
			PX_Int(&secItem, _T("Id"), nId);

			CXTPControlAction* pAction = FindAction(nId);

			if (!pAction)
			{
				pAction		   = new CXTPControlAction(this);
				pAction->m_nId = nId;
				Insert(pAction);
			}

			pAction->DoPropExchange(&secItem);
		}
	}
}

void CXTPControlAction::DoPropExchange(CXTPPropExchange* pPX)
{
	PX_Int(pPX, _T("IconId"), m_nIconId, 0);
	PX_Int(pPX, _T("HelpId"), m_nHelpId, 0);
	PX_String(pPX, _T("Caption"), m_strCaption, _T(""));
	PX_String(pPX, _T("ShortcutText"), m_strShortcutText, _T(""));
	PX_String(pPX, _T("TooltipText"), m_strTooltipText, _T(""));
	PX_String(pPX, _T("DescriptionText"), m_strDescriptionText, _T(""));
	PX_String(pPX, _T("Category"), m_strCategory, _T(""));

	if (pPX->GetSchema() > _XTP_SCHEMA_1122)
	{
		PX_String(pPX, _T("Key"), m_strKey, _T(""));
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_1624)
	{
		PX_String(pPX, _T("CustomShortcutText"), m_strCustomShortcutText, _T(""));
	}
	else
	{
		m_strCustomShortcutText = _T("");
	}

	if (pPX->GetSchema() >= _XTP_SCHEMA_2030)
	{
		PX_Bool(pPX, _T("Visible"), m_bVisible, TRUE);
		PX_Bool(pPX, _T("Enabled"), m_bEnabled, TRUE);
		PX_Bool(pPX, _T("Checked"), m_bChecked, FALSE);
	}
}

void CXTPControl::DoPropExchange(CXTPPropExchange* pPX)
{
	_ASSERTE(sizeof(long) == sizeof(DWORD));
	CXTPCommandBars* pCommandBars =
		((XTP_COMMANDBARS_PROPEXCHANGE_PARAM*)pPX->m_dwData)->pCommandBars;

	PX_Enum(pPX, _T("Type"), m_controlType, xtpControlButton);
	PX_Int(pPX, _T("Id"), m_nId, -1);

	if (pPX->IsLoading())
	{
		CXTPControlAction* pAction = pCommandBars->GetActions()->FindAction(m_nId);
		if (pAction)
		{
			SetAction(pAction);
		}
	}

	PX_Int(pPX, _T("IconId"), m_nIconId, 0);
	PX_Bool(pPX, _T("BeginGroup"), m_bBeginGroup, FALSE);
	PX_Long(pPX, _T("Tag"), (long&)m_nTag, 0);
	PX_Long(pPX, _T("Flags"), (long&)m_dwFlags, 0);
	PX_Long(pPX, _T("HideFlags"), (long&)m_dwHideFlags, 0);
	PX_String(pPX, _T("Caption"), m_strCaption, _T(""));
	PX_String(pPX, _T("ShortcutText"), m_strShortcutText, _T(""));
	PX_String(pPX, _T("TooltipText"), m_strTooltipText, _T(""));
	PX_String(pPX, _T("DescriptionText"), m_strDescriptionText, _T(""));
	PX_String(pPX, _T("Parameter"), m_strParameter, _T(""));
	PX_Int(pPX, _T("CustomIconId"), m_nCustomIconId, 0);
	PX_String(pPX, _T("CustomCaption"), m_strCustomCaption, _T(""));

	if (pPX->GetSchema() > _XTP_SCHEMA_71)
		PX_String(pPX, _T("Category"), m_strCategory, _T(""));

	if (m_nCustomIconId > 0)
	{
		_ASSERTE(pCommandBars->IsKindOf(RUNTIME_CLASS(CXTPCommandBars)));

		CXTPPropExchangeSection secCustomIcon(pPX->GetSection(_T("CustomIcon")));
		pCommandBars->GetImageManager()->DoPropExchange(XTPToUInt(m_nCustomIconId), &secCustomIcon);
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_85)
	{
		if (!(pPX->IsStoring() && pPX->IsAllowDefaultValues()
			  && m_mapDocTemplatesExcluded.IsEmpty()))
			PX_Serialize(pPX, _T("DocTemplatesExcluded"), &m_mapDocTemplatesExcluded);

		if (!(pPX->IsStoring() && pPX->IsAllowDefaultValues()
			  && m_mapDocTemplatesAssigned.IsEmpty()))
			PX_Serialize(pPX, _T("DocTemplatesAssigned"), &m_mapDocTemplatesAssigned);

		PX_Bool(pPX, _T("DefaultItem"), m_bDefaultItem, FALSE);
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_87)
		PX_Bool(pPX, _T("CloseSubMenuOnClick"), m_bCloseSubMenuOnClick, TRUE);

	if (pPX->GetSchema() > _XTP_SCHEMA_875)
		PX_Enum(pPX, _T("CustomStyle"), m_buttonCustomStyle, xtpButtonUndefined);

	if (pPX->GetSchema() < _XTP_SCHEMA_103 && m_buttonCustomStyle == xtpButtonAutomatic)
		m_buttonCustomStyle = xtpButtonUndefined;

	if (pPX->GetSchema() > _XTP_SCHEMA_98)
		PX_Int(pPX, _T("HelpId"), m_nHelpId, 0);

	if (pPX->GetSchema() > _XTP_SCHEMA_100)
		PX_Enum(pPX, _T("Style"), m_buttonStyle, xtpButtonAutomatic);

	if (pPX->GetSchema() > _XTP_SCHEMA_103)
	{
		PX_DPI_X_Int(pPX, _T("Width"), m_nWidth, 0);
		PX_DPI_Y_Int(pPX, _T("Height"), m_nHeight, 0);
		PX_Int(pPX, _T("ExecuteOnPressInterval"), m_nExecuteOnPressInterval, 0);
	}
	if (pPX->GetSchema() > _XTP_SCHEMA_1042)
	{
		PX_String(pPX, _T("ShortcutTextAuto"), m_strShortcutTextAuto, _T(""));
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_110)
		PX_String(pPX, _T("KeyboardTip"), m_strKeyboardTip, _T(""));

	if (pPX->GetSchema() > _XTP_SCHEMA_1121)
		PX_Size(pPX, _T("IconSize"), m_szIcon, CSize(0, 0));

	if (pPX->GetSchema() > _XTP_SCHEMA_1624)
	{
		PX_String(pPX, _T("CustomShortcutText"), m_strCustomShortcutText, _T(""));
	}
	else
	{
		m_strCustomShortcutText = _T("");
	}

	if (pPX->IsLoading())
	{
		OnCaptionChanged();
	}
}

void CXTPControlButton::DoPropExchange(CXTPPropExchange* pPX)
{
	CXTPControl::DoPropExchange(pPX);

	if (pPX->GetSchema() < _XTP_SCHEMA_103)
		PX_Enum(pPX, _T("Style"), m_buttonStyle, xtpButtonAutomatic);

	if (pPX->GetSchema() >= _XTP_SCHEMA_2030)
		PX_Enum(pPX, _T("StyleEx"), m_buttonStyleEx, xtpButtonAutomatic);
}

void CXTPControlPopup::DoPropExchange(CXTPPropExchange* pPX)
{
	CXTPControl::DoPropExchange(pPX);

	if (pPX->IsStoring())
	{
		long dwCommandBarID = m_pCommandBar ? XTPToLong(m_pCommandBar->m_nBarID) : 0;
		PX_Long(pPX, _T("CommandBarId"), dwCommandBarID, 0);
	}
	else
	{
		PX_Long(pPX, _T("CommandBarId"), (long&)m_dwCommandBarID, 0);
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_86 && pPX->GetSchema() < _XTP_SCHEMA_103)
		PX_Enum(pPX, _T("Style"), m_buttonStyle, xtpButtonAutomatic);

	if (pPX->GetSchema() >= _XTP_SCHEMA_2030)
		PX_Enum(pPX, _T("StyleEx"), m_buttonStyleEx, xtpButtonAutomatic);
}

void CXTPControlComboBox::DoPropExchange(CXTPPropExchange* pPX)
{
	CXTPControlPopup::DoPropExchange(pPX);

	PX_Bool(pPX, _T("DropDown"), m_bDropDown, TRUE);

	// The Width property is already serialized in CXTPControl
	// so in order to avoid double DPI scaling it must not be read twice (ticket 35575),
	// however the value still must be read out to provide format backward compatibility (ticket
	// 36079).
	int nUnusedWidth = m_nWidth;
	PX_DPI_X_Int(pPX, _T("Width"), nUnusedWidth, 0);
	UNUSED(nUnusedWidth);

	PX_Enum(pPX, _T("ComboStyle"), m_comboStyle, xtpComboNormal);

	if (pPX->GetSchema() > _XTP_SCHEMA_95)
	{
		PX_String(pPX, _T("EditHint"), m_strEditHint, _T(""));
		PX_DWord(pPX, _T("ShellAutoCompleteFlags"), m_dwShellAutoCompleteFlags, 0);
		PX_Bool(pPX, _T("AutoComplete"), m_bAutoComplete, FALSE);
		PX_Int(pPX, _T("EditIconId"), m_nEditIconId, 0);
		PX_Int(pPX, _T("DropDownItemCount"), m_nDropDownItemCount, 12);
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_98)
	{
		PX_DWord(pPX, _T("EditStyle"), m_dwEditStyle, 0);
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_1210)
	{
		PX_Int(pPX, _T("TextLimit"), m_nTextLimit, 0);
	}

	if (pPX->IsLoading())
	{
		SetDropDownListStyle(m_bDropDown);
		EnableShellAutoComplete(m_dwShellAutoCompleteFlags);
	}
}

void CXTPControlEdit::DoPropExchange(CXTPPropExchange* pPX)
{
	CXTPControl::DoPropExchange(pPX);

	if (pPX->GetSchema() > _XTP_SCHEMA_861)
	{
		PX_Bool(pPX, _T("HasLabel"), m_bLabel, FALSE);
		PX_DPI_X_Int(pPX, _T("Width"), m_nWidth, 0);
	}
	if (pPX->GetSchema() > _XTP_SCHEMA_875)
	{
		PX_Bool(pPX, _T("ReadOnly"), m_bReadOnly, FALSE);
	}
	if (pPX->GetSchema() > _XTP_SCHEMA_95)
	{
		PX_String(pPX, _T("EditHint"), m_strEditHint, _T(""));
		PX_DWord(pPX, _T("ShellAutoCompleteFlags"), m_dwShellAutoCompleteFlags, 0);
	}
	if (pPX->GetSchema() > _XTP_SCHEMA_98)
	{
		PX_DWord(pPX, _T("EditStyle"), m_dwEditStyle, 0);
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_103)
	{
		PX_Bool(pPX, _T("ShowSpinButtons"), m_bShowSpinButtons, FALSE);
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_1210)
	{
		PX_Int(pPX, _T("TextLimit"), m_nTextLimit, 0);
	}

	if (pPX->GetSchema() > _XTP_SCHEMA_1310)
	{
		PX_Int(pPX, _T("EditIconId"), m_nEditIconId, 0);
	}

	if (pPX->GetSchema() >= _XTP_SCHEMA_1500)
	{
		PX_Int(pPX, _T("BuddyButtonId"), m_nBuddyButtonId, 0);
	}

	if (pPX->IsLoading())
	{
		EnableShellAutoComplete(m_dwShellAutoCompleteFlags);
	}
}