开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPDockState.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：56k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPDockState.cpp：源码内容
  1. // XTPDockState.cpp : implementation of the CXTPDockState class.
  2. //
  3. // This file is a part of the XTREME COMMANDBARS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "Resource.h"
  24. #include "Common/XTPResourceManager.h"
  25. #include "Common/XTPImageManager.h"
  26. #include "Common/XTPDrawHelpers.h"
  27. #include "Common/XTPSystemHelpers.h"
  28. #include "Common/XTPPropExchange.h"
  29. #include "Common/XTPVC50Helpers.h"
  30. #include "Common/XTPVC80Helpers.h"
  32. #ifdef _XTP_INCLUDE_GRAPHICLIBRARY
  33. #include "GraphicLibrary/zlib/zlib.h"
  34. #endif
  36. #include "XTPShortcutManager.h"
  37. #include "XTPDockState.h"
  38. #include "XTPCommandBars.h"
  39. #include "XTPDockBar.h"
  40. #include "XTPDockContext.h"
  41. #include "XTPControls.h"
  42. #include "XTPControl.h"
  43. #include "XTPControlPopup.h"
  44. #include "XTPControlButton.h"
  45. #include "XTPControlComboBox.h"
  46. #include "XTPControlEdit.h"
  47. #include "XTPPopupbar.h"
  48. #include "XTPMenuBar.h"
  49. #include "XTPToolBar.h"
  50. #include "XTPDialogBar.h"
  51. #include "XTPPaintManager.h"
  52. #include "XTPStatusBar.h"
  55. #ifdef _DEBUG
  56. #define new DEBUG_NEW
  57. #undef THIS_FILE
  58. static char THIS_FILE[] = __FILE__;
  59. #endif
  61. const TCHAR _xtpVisible[] = _T("Visible");
  62. const TCHAR _xtpBarSection[] = _T("%s-Bar%d");
  63. const TCHAR _xtpDockBarSection[] = _T("%s-DockBar%d");
  64. const TCHAR _xtpSummarySection[] = _T("%s-Summary");
  65. const TCHAR _xtpXPos[] = _T("XPos");
  66. const TCHAR _xtpYPos[] = _T("YPos");
  67. const TCHAR _xtpMRUWidth[] = _T("MRUWidth");
  68. const TCHAR _xtpMRUDockID[] = _T("MRUDockID");
  69. const TCHAR _xtpMRUDockLeftPos[] = _T("MRUDockLeftPos");
  70. const TCHAR _xtpMRUDockRightPos[] = _T("MRUDockRightPos");
  71. const TCHAR _xtpMRUDockTopPos[] = _T("MRUDockTopPos");
  72. const TCHAR _xtpMRUDockBottomPos[] = _T("MRUDockBottomPos");
  73. const TCHAR _xtpMRUFloatXPos[] = _T("MRUFloatXPos");
  74. const TCHAR _xtpMRUFloatYPos[] = _T("MRUFloatYPos");
  76. const TCHAR _xtpBarID[] = _T("BarID");
  77. const TCHAR _xtpFloating[] = _T("Floating");
  78. const TCHAR _xtpBars[] = _T("Bars");
  79. const TCHAR _xtpScreenCX[] = _T("ScreenCX");
  80. const TCHAR _xtpScreenCY[] = _T("ScreenCY");
  81. const TCHAR _xtpBar[] = _T("Bar#%d");
  83. const TCHAR _xtpCommandBarControlsSection[] = _T("%s-Controls");
  84. const TCHAR _xtpCommandBarControls[] = _T("Controls");
  85. const TCHAR _xtpCommandBarLoadFromFile[] = _T("LoadFromFile");
  86. const TCHAR _xtpDialogBar[] = _T("DialogBar");
  89. class CXTPToolBar::CToolBarInfo
  90. {
  91. public:
  92. CToolBarInfo();
  93. ~CToolBarInfo();
  95. BOOL SaveState(LPCTSTR lpszProfileName, int nIndex);
  96. BOOL LoadState(LPCTSTR lpszProfileName, int nIndex, CXTPDockState* pDockState);
  98. void DoPropExchange(CXTPPropExchange* pPX, CXTPDockState* pDockState);
  101. // Attributes
  102. UINT m_nBarID;      // ID of this bar
  103. BOOL m_bVisible;    // visibility of this bar
  104. BOOL m_bFloating;   // whether floating or not
  105. CPoint m_pointPos;  // topleft point of window
  106. UINT m_nMRUWidth;   // MRUWidth for Dynamic Toolbars
  107. XTPBarPosition m_uMRUDockPosition;  // most recent docked dockbar
  108. CRect m_rectMRUDockPos; // most recent docked position
  109. DWORD m_dwMRUFloatStyle; // most recent floating orientation
  110. CPoint m_ptMRUFloatPos; // most recent floating position
  111. CXTPToolBar* m_pBar;    // bar which this refers to (transient)
  113. BOOL m_bDialogBar;
  114. CSize m_szDialogBarDockingClient;
  115. CSize m_szDialogBarFloatingClient;
  116. };
  118. CXTPToolBar::CToolBarInfo::CToolBarInfo()
  119. {
  120. m_nBarID = 0;
  121. m_bVisible = m_bFloating = FALSE;
  122. m_pBar = NULL;
  123. m_pointPos.x = m_pointPos.y = -1;
  124. m_nMRUWidth = 32767;
  126. m_uMRUDockPosition = xtpBarTop;
  127. m_rectMRUDockPos.SetRectEmpty();
  128. m_dwMRUFloatStyle = 0;
  129. m_ptMRUFloatPos = CPoint(0, 0);
  131. m_bDialogBar = FALSE;
  132. m_szDialogBarFloatingClient = m_szDialogBarDockingClient = CSize(200, 200);
  133. }
  135. CXTPToolBar::CToolBarInfo::~CToolBarInfo()
  136. {
  137. }
  139. void CXTPToolBar::CToolBarInfo::DoPropExchange(CXTPPropExchange* pPX, CXTPDockState* pDockState)
  140. {
  141. ASSERT(pDockState != NULL);
  142. if (!pDockState)
  143. return;
  145. PX_Long(pPX, _T("BarId"), (long&)m_nBarID, 0);
  146. PX_Bool(pPX, _T("Visible"), m_bVisible, TRUE);
  147. PX_Bool(pPX, _T("Floating"), m_bFloating, FALSE);
  148. PX_Long(pPX, _T("MRUWidth"), (long&)m_nMRUWidth);
  149. PX_Enum(pPX, _T("MRUDockPosition"), m_uMRUDockPosition, xtpBarTop);
  150. PX_Point(pPX, _T("PointPos"), m_pointPos, CPoint(0, 0));
  151. PX_Rect(pPX, _T("MRUDockPos"), m_rectMRUDockPos, CRect(0, 0, 0, 0));
  152. PX_Point(pPX, _T("MRUFloatPos"), m_ptMRUFloatPos, CPoint(0, 0));
  154. if (pDockState->GetVersion() > _XTP_SCHEMA_87)
  155. {
  156. PX_Bool(pPX, _T("DialogBar"), m_bDialogBar, FALSE);
  158. if (m_bDialogBar)
  159. {
  160. PX_Size(pPX, _T("DialogBarDockingClientSize"), m_szDialogBarDockingClient, CSize(0, 0));
  161. PX_Size(pPX, _T("DialogBarFloatingClientSize"), m_szDialogBarFloatingClient, CSize(0, 0));
  162. }
  163. }
  164. }
  166. BOOL CXTPToolBar::CToolBarInfo::SaveState(LPCTSTR lpszProfileName, int nIndex)
  167. {
  168. TCHAR szSection[256];
  169. wsprintf(szSection, _xtpBarSection, lpszProfileName, nIndex);
  171. // delete the section
  172. CWinApp* pApp = AfxGetApp();
  173. pApp->WriteProfileString(szSection, NULL, NULL);
  175. pApp->WriteProfileInt(szSection, _xtpBarID, m_nBarID);
  176. if (!m_bVisible)
  177. pApp->WriteProfileInt(szSection, _xtpVisible, m_bVisible);
  178. if (m_bFloating)
  179. {
  180. pApp->WriteProfileInt(szSection, _xtpFloating, m_bFloating);
  181. }
  182. if (m_pointPos.x != -1)
  183. pApp->WriteProfileInt(szSection, _xtpXPos, m_pointPos.x);
  184. if (m_pointPos.y != -1)
  185. pApp->WriteProfileInt(szSection, _xtpYPos, m_pointPos.y);
  186. if (m_nMRUWidth != 32767)
  187. pApp->WriteProfileInt(szSection, _xtpMRUWidth, m_nMRUWidth);
  189. pApp->WriteProfileInt(szSection, _xtpMRUDockID, m_uMRUDockPosition);
  190. pApp->WriteProfileInt(szSection, _xtpMRUDockLeftPos, m_rectMRUDockPos.left);
  191. pApp->WriteProfileInt(szSection, _xtpMRUDockTopPos, m_rectMRUDockPos.top);
  192. pApp->WriteProfileInt(szSection, _xtpMRUDockRightPos, m_rectMRUDockPos.right);
  193. pApp->WriteProfileInt(szSection, _xtpMRUDockBottomPos, m_rectMRUDockPos.bottom);
  194. pApp->WriteProfileInt(szSection, _xtpMRUFloatXPos, m_ptMRUFloatPos.x);
  195. pApp->WriteProfileInt(szSection, _xtpMRUFloatYPos, m_ptMRUFloatPos.y);
  197. pApp->WriteProfileInt(szSection, _xtpDialogBar, m_bDialogBar);
  198. if (m_bDialogBar)
  199. {
  200. pApp->WriteProfileInt(szSection, _T("DialogBarDockingClientCx"), m_szDialogBarDockingClient.cx);
  201. pApp->WriteProfileInt(szSection, _T("DialogBarDockingClientCy"), m_szDialogBarDockingClient.cy);
  202. pApp->WriteProfileInt(szSection, _T("DialogBarFloatingClientCx"), m_szDialogBarFloatingClient.cx);
  203. pApp->WriteProfileInt(szSection, _T("DialogBarFloatingClientCy"), m_szDialogBarFloatingClient.cy);
  204. }
  206. //m_pBar->m_pControls->SaveState(szSection);
  208. return TRUE;
  210. }
  211. BOOL CXTPToolBar::CToolBarInfo::LoadState(LPCTSTR lpszProfileName, int nIndex, CXTPDockState* pDockState)
  212. {
  213. ASSERT(pDockState != NULL);
  214. if (!pDockState)
  215. return FALSE;
  217. CWinApp* pApp = AfxGetApp();
  218. TCHAR szSection[256];
  219. wsprintf(szSection, _xtpBarSection, lpszProfileName, nIndex);
  221. m_nBarID = pApp->GetProfileInt(szSection, _xtpBarID, 0);
  222. m_bVisible = (BOOL) pApp->GetProfileInt(szSection, _xtpVisible, TRUE);
  223. m_bFloating = (BOOL) pApp->GetProfileInt(szSection, _xtpFloating, FALSE);
  224. m_pointPos = CPoint(
  225. pApp->GetProfileInt(szSection, _xtpXPos, -1),
  226. pApp->GetProfileInt(szSection, _xtpYPos, -1));
  228. pDockState->ScalePoint(m_pointPos);
  230. m_nMRUWidth = pApp->GetProfileInt(szSection, _xtpMRUWidth, 32767);
  232. m_uMRUDockPosition = (XTPBarPosition)pApp->GetProfileInt(szSection, _xtpMRUDockID, 0);
  234. m_rectMRUDockPos = CRect(
  235. pApp->GetProfileInt(szSection, _xtpMRUDockLeftPos, 0),
  236. pApp->GetProfileInt(szSection, _xtpMRUDockTopPos, 0),
  237. pApp->GetProfileInt(szSection, _xtpMRUDockRightPos, 0),
  238. pApp->GetProfileInt(szSection, _xtpMRUDockBottomPos, 0));
  239. pDockState->ScaleRectPos(m_rectMRUDockPos);
  241. m_ptMRUFloatPos = CPoint(
  242. pApp->GetProfileInt(szSection, _xtpMRUFloatXPos, 0),
  243. pApp->GetProfileInt(szSection, _xtpMRUFloatYPos, 0));
  244. pDockState->ScalePoint(m_ptMRUFloatPos);
  246. m_bDialogBar = pApp->GetProfileInt(szSection, _xtpDialogBar, FALSE);
  247. if (m_bDialogBar)
  248. {
  249. m_szDialogBarDockingClient.cx = pApp->GetProfileInt(szSection, _T("DialogBarDockingClientCx"), m_szDialogBarDockingClient.cx);
  250. m_szDialogBarDockingClient.cy = pApp->GetProfileInt(szSection, _T("DialogBarDockingClientCy"), m_szDialogBarDockingClient.cy);
  251. m_szDialogBarFloatingClient.cx = pApp->GetProfileInt(szSection, _T("DialogBarFloatingClientCx"), m_szDialogBarFloatingClient.cx);
  252. m_szDialogBarFloatingClient.cy = pApp->GetProfileInt(szSection, _T("DialogBarFloatingClientCy"), m_szDialogBarFloatingClient.cy);
  253. }
  256. return TRUE;
  257. }
  260. void CXTPDockState::ScalePoint(CPoint& pt)
  261. {
  262. if (m_bScaling)
  263. {
  264. pt.x = MulDiv(pt.x, m_sizeDevice.cx, m_sizeLogical.cx);
  265. pt.y = MulDiv(pt.y, m_sizeDevice.cy, m_sizeLogical.cy);
  266. }
  268. CRect rectClip = XTPMultiMonitor()->GetWorkArea(pt);
  269. rectClip.right -= GetSystemMetrics(SM_CXICON);
  270. rectClip.bottom -= GetSystemMetrics(SM_CYICON);
  272. if (pt.x > rectClip.right)
  273. pt.x = rectClip.right;
  274. if (pt.y > rectClip.bottom)
  275. pt.y = rectClip.bottom;
  276. }
  278. void CXTPDockState::ScaleRectPos(CRect& rect)
  279. {
  280. CPoint pt;
  282. if (m_bScaling)
  283. {
  284. pt = rect.TopLeft();
  286. pt.x = MulDiv(pt.x, m_sizeDevice.cx, m_sizeLogical.cx) - rect.left;
  287. pt.y = MulDiv(pt.y, m_sizeDevice.cy, m_sizeLogical.cy) - rect.top;
  288. rect.OffsetRect(pt);
  289. }
  290. pt.x = pt.y = 0;
  292. CRect rectClip = XTPMultiMonitor()->GetWorkArea(rect);
  294. if (rect.left > rectClip.right)
  295. pt.x = rectClip.right - rect.left;
  296. if (rect.top > rectClip.bottom)
  297. pt.y = rectClip.bottom - rect.top;
  299. if (!((pt.x == 0) && (pt.y == 0)))
  300. rect.OffsetRect(pt);
  301. }
  303. CXTPDockState::CXTPDockState()
  304. {
  305. m_dwVersion = _XTP_SCHEMA_CURRENT;
  307. m_bScaling = FALSE;
  309. m_sizeDevice = CSize(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
  310. }
  312. CXTPDockState::~CXTPDockState()
  313. {
  314. Clear();
  315. }
  317. void CXTPDockState::Clear()
  318. {
  319. for (int i = 0; i < m_arrBarInfo.GetSize(); i++)
  320. delete m_arrBarInfo[i];
  321. m_arrBarInfo.RemoveAll();
  323. }
  325. void CXTPDockState::SaveState(LPCTSTR lpszProfileName)
  326. {
  327. int nIndex = 0;
  328. for (int i = 0; i < m_arrBarInfo.GetSize(); i++)
  329. {
  330. TOOLBARINFO* pInfo = m_arrBarInfo[i];
  331. ASSERT(pInfo != NULL);
  332. if (!pInfo)
  333. continue;
  334. if (pInfo->SaveState(lpszProfileName, nIndex))
  335. nIndex++;
  336. }
  339. CWinApp* pApp = AfxGetApp();
  340. TCHAR szSection[256];
  341. wsprintf(szSection, _xtpSummarySection, lpszProfileName);
  342. pApp->WriteProfileInt(szSection, _xtpBars, nIndex);
  344. CSize size = GetScreenSize();
  345. pApp->WriteProfileInt(szSection, _xtpScreenCX, size.cx);
  346. pApp->WriteProfileInt(szSection, _xtpScreenCY, size.cy);
  347. }
  349. void CXTPDockState::LoadState(LPCTSTR lpszProfileName)
  350. {
  351. CWinApp* pApp = AfxGetApp();
  352. TCHAR szSection[256];
  353. wsprintf(szSection, _xtpSummarySection, lpszProfileName);
  354. int nBars = pApp->GetProfileInt(szSection, _xtpBars, 0);
  356. CSize size;
  357. size.cx = pApp->GetProfileInt(szSection, _xtpScreenCX, 0);
  358. size.cy = pApp->GetProfileInt(szSection, _xtpScreenCY, 0);
  359. SetScreenSize(size);
  361. for (int i = 0; i < nBars; i++)
  362. {
  363. TOOLBARINFO* pInfo = new TOOLBARINFO;
  364. m_arrBarInfo.Add(pInfo);
  365. pInfo->LoadState(lpszProfileName, i, this);
  366. }
  367. }
  369. void CXTPDockState::DoPropExchange(CXTPPropExchange* pPX)
  370. {
  371. CXTPPropExchangeSection secDockState(pPX->GetSection(_T("DockState")));
  372. // read/write version info
  373. if (pPX->IsStoring())
  374. {
  375. PX_DWord(&secDockState, _T("Version"), m_dwVersion, 0);
  377. CSize sz = GetScreenSize();
  378. PX_Size(&secDockState, _T("ScreenSize"), sz, CSize(0, 0));
  380. WORD nCount = (WORD)m_arrBarInfo.GetSize();
  381. PX_UShort(&secDockState, _T("Count"), nCount, 0);
  384. for (int i = 0; i < m_arrBarInfo.GetSize(); i++)
  385. {
  386. CString strSection;
  387. strSection.Format(_T("BarInfo%i"), i);
  389. CXTPPropExchangeSection secBarInfo(secDockState->GetSection(strSection));
  390. m_arrBarInfo[i]->DoPropExchange(&secBarInfo, this);
  391. }
  392. }
  393. else
  394. {
  395. Clear(); //empty out dockstate
  397. PX_DWord(&secDockState, _T("Version"), m_dwVersion, 0);
  399. CSize size;
  400. PX_Size(&secDockState, _T("ScreenSize"), size, CSize(0, 0));
  401. SetScreenSize(size);
  403. WORD nOldSize = 0;
  404. PX_UShort(&secDockState, _T("Count"), nOldSize, 0);
  406. m_arrBarInfo.SetSize(nOldSize);
  407. for (int i = 0; i < nOldSize; i++)
  408. {
  409. m_arrBarInfo[i] = new TOOLBARINFO;
  411. CString strSection;
  412. strSection.Format(_T("BarInfo%i"), i);
  414. CXTPPropExchangeSection secBarInfo(secDockState->GetSection(strSection));
  416. m_arrBarInfo[i]->DoPropExchange(&secBarInfo, this);
  417. }
  418. m_dwVersion = _XTP_SCHEMA_CURRENT;
  419. }
  420. }
  422. CSize CXTPDockState::GetScreenSize()
  423. {
  424. return m_sizeDevice;
  425. }
  427. void CXTPDockState::SetScreenSize(CSize& size)
  428. {
  429. m_sizeLogical = size;
  430. m_bScaling = (size != m_sizeDevice && size.cx != 0 && size.cy != 0);
  431. }
  433. void CXTPToolBar::GetBarInfo(CToolBarInfo* pInfo)
  434. {
  435. // get state info
  436. pInfo->m_nBarID = m_nBarID;
  437. pInfo->m_pBar = this;
  438. pInfo->m_bVisible = IsVisible(); // handles delayed showing and hiding
  440. pInfo->m_nMRUWidth = m_nMRUWidth;
  442. CXTPWindowRect rect(this);
  443. if (m_pDockBar != NULL) m_pDockBar->ScreenToClient(&rect);
  445. pInfo->m_pointPos = m_hWnd ? rect.TopLeft() : m_pDockContext->m_ptMRUFloatPos;
  447. pInfo->m_bFloating = m_barPosition == xtpBarFloating;
  449. pInfo->m_uMRUDockPosition = m_pDockContext->m_uMRUDockPosition;
  450. pInfo->m_rectMRUDockPos = m_pDockContext->m_rectMRUDockPos;
  451. pInfo->m_ptMRUFloatPos = m_pDockContext->m_ptMRUFloatPos;
  453. pInfo->m_bDialogBar = IsDialogBar();
  454. pInfo->m_szDialogBarDockingClient = CSize(0, 0);
  455. pInfo->m_szDialogBarFloatingClient = CSize(0, 0);
  457. if (pInfo->m_bDialogBar)
  458. {
  459. pInfo->m_szDialogBarDockingClient = ((CXTPDialogBar*)this)->m_szDockingClient;
  460. pInfo->m_szDialogBarFloatingClient = ((CXTPDialogBar*)this)->m_szFloatingClient;
  461. }
  462. }
  464. void CXTPToolBar::SetBarInfo(CToolBarInfo* pInfo)
  465. {
  466. UINT nFlags = (pInfo->m_bFloating ? 0 : SWP_NOSIZE) | SWP_NOACTIVATE | SWP_NOZORDER;
  468. if (!pInfo->m_bFloating && GetDockBar() == NULL)
  469. nFlags |= SWP_NOMOVE;
  471. m_nMRUWidth = pInfo->m_nMRUWidth;
  473. if (pInfo->m_bDialogBar && IsDialogBar())
  474. {
  475. ((CXTPDialogBar*)this)->m_szDockingClient = pInfo->m_szDialogBarDockingClient;
  476. ((CXTPDialogBar*)this)->m_szFloatingClient = pInfo->m_szDialogBarFloatingClient;
  477. }
  479. ASSERT(m_pDockContext != NULL);
  480. if (!m_pDockContext)
  481. return;
  483. // You need to call EnableDocking before calling LoadBarState
  484. m_pDockContext->m_uMRUDockPosition = pInfo->m_uMRUDockPosition;
  485. m_pDockContext->m_rectMRUDockPos = pInfo->m_rectMRUDockPos;
  486. m_pDockContext->m_ptMRUFloatPos = pInfo->m_ptMRUFloatPos;
  488. // move and show/hide the window
  489. SetWindowPos(NULL, pInfo->m_pointPos.x, pInfo->m_pointPos.y, 0, 0,
  490. nFlags | (pInfo->m_bVisible ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));
  492. m_bVisible = pInfo->m_bVisible;
  494. if (pInfo->m_bFloating) OnRecalcLayout();
  495. }
  497. CString CXTPCommandBars::GetIsolatedFileName(const CString& strPrifileName)
  498. {
  499. if (!XTPSystemVersion()->IsWin2KOrGreater())
  500. return _T("");
  502. LPITEMIDLIST pidlAppData = NULL;
  503. IMalloc* pMalloc = NULL;
  504. CString strAppDataFolder;
  506. HRESULT hr = SHGetMalloc(&pMalloc);
  507. if (SUCCEEDED(hr))
  508. {
  509. if (SHGetSpecialFolderLocation(NULL, CSIDL_APPDATA, &pidlAppData) == NOERROR)
  510. {
  511. TCHAR   szPath[MAX_PATH];
  513. if (SHGetPathFromIDList(pidlAppData, szPath))
  514. {
  515. strAppDataFolder = szPath;
  516. }
  517. }
  519. pMalloc->Free(pidlAppData);
  520. pMalloc->Release();
  521. }
  523. if (strAppDataFolder.IsEmpty())
  524. return _T("");
  526. strAppDataFolder += CString(_T("\")) + AfxGetApp()->m_pszAppName;
  527. CreateDirectory(strAppDataFolder, NULL);
  529. if (!DIRECTORYEXISTS_S(strAppDataFolder))
  530. return _T("");
  532. // Set customization path as "Documents and SettingsuserApplication DataAppNamePrifileName"
  533. return strAppDataFolder + _T("\") + strPrifileName;
  534. }
  536. BOOL CXTPCommandBars::GetControlsFileName(CString& strFileName, LPCTSTR lpszProfileName)
  537. {
  538. if (!m_strControlsFileName.IsEmpty())
  539. {
  540. strFileName = m_strControlsFileName;
  541. return TRUE;
  542. }
  544. CString strProfileName(lpszProfileName);
  545. REPLACE_S(strProfileName, _T("\"), _T("_"));
  547. strFileName = GetIsolatedFileName(strProfileName);
  548. if (!strFileName.IsEmpty())
  549. return TRUE;
  551. TCHAR szBuff[_MAX_PATH];
  554. VERIFY(::GetModuleFileName(AfxGetApp()->m_hInstance, szBuff, _MAX_PATH));
  555. strFileName.Format(_T("%s-%s"), szBuff, (LPCTSTR)strProfileName);
  557. return TRUE;
  558. }
  560. #define ZIP_HEADER ('Z' + ('I' << 8) + ('P' << 16) + ('!' << 24))
  562. class CXTPZipMemFile : public CMemFile
  563. {
  564. struct ZIPBUFFERHEADER
  565. {
  566. DWORD    dwType;
  567. DWORD    dwSize;
  568. };
  570. struct ZIPBUFFERINFO
  571. {
  572. ZIPBUFFERHEADER bh;
  573. BYTE     bBuffer[1];
  574. };
  575. public:
  576. CXTPZipMemFile()
  577. {
  578. }
  579. CXTPZipMemFile(BYTE* lpBuffer, UINT nBufferSize)
  580. {
  581. AttachCompressedBuffer(lpBuffer, nBufferSize);
  582. }
  583. void AttachCompressedBuffer(BYTE* lpBuffer, UINT nBufferSize, BOOL bAutoDelete = FALSE)
  584. {
  585. #ifdef ZLIB_H
  586. ZIPBUFFERINFO* pbi = (ZIPBUFFERINFO*)lpBuffer;
  588. if (nBufferSize < sizeof(ZIPBUFFERINFO) ||
  589. pbi->bh.dwType != ZIP_HEADER)
  590. {
  591. Attach(lpBuffer, nBufferSize);
  592. m_bAutoDelete = bAutoDelete;
  593. return;
  594. }
  596. DWORD dwDestCount = pbi->bh.dwSize;
  598. BYTE* lpBufferDest = (BYTE*)malloc(dwDestCount);
  599. uncompress(lpBufferDest, &dwDestCount, (LPBYTE)&pbi->bBuffer, nBufferSize - sizeof(ZIPBUFFERHEADER));
  601. ASSERT(dwDestCount == pbi->bh.dwSize);
  603. Attach(lpBufferDest, dwDestCount);
  604. m_bAutoDelete = TRUE;
  606. if (bAutoDelete)
  607. {
  608. free(lpBuffer);
  609. }
  610. #else
  611. Attach(lpBuffer, nBufferSize);
  612. m_bAutoDelete = bAutoDelete;
  613. #endif
  614. }
  616. BOOL OpenCompressedFile(LPCTSTR lpszFileName)
  617. {
  618. CFile file;
  619. if (!file.Open(lpszFileName, CFile::modeRead))
  620. return FALSE;
  622. UINT nSize = (UINT)file.GetLength();
  623. LPBYTE lpBuffer = (LPBYTE)malloc(nSize);
  624. file.Read(lpBuffer, nSize);
  626. file.Close();
  628. AttachCompressedBuffer(lpBuffer, nSize, TRUE);
  630. return TRUE;
  631. }
  633. ~CXTPZipMemFile()
  634. {
  635. }
  637. public:
  638. void DetachCompressedBuffer(BYTE*& lpBuffer, DWORD& dwCount)
  639. {
  640. dwCount = (DWORD)GetPosition();
  641. lpBuffer = Detach();
  643. #ifdef ZLIB_H
  644. if (dwCount < 20)
  645. return;
  647. ZIPBUFFERINFO* pbi = (ZIPBUFFERINFO*)malloc(dwCount + sizeof(ZIPBUFFERHEADER));
  648. if (!pbi)
  649. return;
  651. DWORD dwDestCount = dwCount;
  653. if (compress((LPBYTE)&pbi->bBuffer, &dwDestCount, lpBuffer, dwCount) != Z_OK)
  654. {
  655. free(pbi);
  656. return;
  657. }
  659. pbi->bh.dwType = ZIP_HEADER;
  660. pbi->bh.dwSize = dwCount;
  662. free(lpBuffer);
  663. dwCount = dwDestCount + sizeof(ZIPBUFFERHEADER);
  664. lpBuffer = (LPBYTE)pbi;
  665. #endif
  666. }
  667. };
  669. void CXTPCommandBars::SaveBarState(LPCTSTR lpszProfileName, BOOL bOnlyCustomized /*= TRUE*/)
  670. {
  671. OnSetPreviewMode(FALSE); // Lets be sure we not in preview mode.
  673. CXTPDockState state;
  674. GetDockState(state);
  675. state.SaveState(lpszProfileName);
  676. SaveDockBarsState(lpszProfileName);
  678. XTP_COMMANDBARS_PROPEXCHANGE_PARAM param;
  679. param.pCommandBars = this;
  680. param.bSaveOnlyCustomized = bOnlyCustomized;
  682. if (m_bCustomizeAvail)
  683. {
  684. CXTPCommandBarList lstCommandBars(this);
  685. GenerateCommandBarList(&lstCommandBars, &param);
  687. CXTPZipMemFile memFile;
  688. CArchive ar (&memFile, CArchive::store);
  690. TCHAR szSection[256];
  691. wsprintf(szSection, _xtpCommandBarControlsSection, lpszProfileName);
  693. CXTPPropExchangeArchive px(ar);
  695. px.m_dwData = (DWORD_PTR)&param;
  697. if (SaveCommandBarList(&px, &lstCommandBars))
  698. {
  699. ar.Flush();
  701. DWORD dwCount = 0;
  702. BYTE* pControls = 0;
  704. memFile.DetachCompressedBuffer(pControls, dwCount);
  706. CString strFileName;
  707. BOOL bSaveToFile = dwCount > 16000;
  709. if (bSaveToFile)
  710. {
  711. bSaveToFile = GetControlsFileName(strFileName, lpszProfileName);
  712. }
  714. if (bSaveToFile)
  715. {
  716. ::DeleteFile((LPCTSTR)strFileName);
  717. }
  719. if (bSaveToFile)
  720. {
  721. try
  722. {
  723. CFile file;
  724. if (file.Open(strFileName, CFile::modeWrite | CFile::modeCreate))
  725. {
  726. file.Write(pControls, dwCount);
  727. AfxGetApp()->WriteProfileString(szSection, _xtpCommandBarControls, strFileName);
  728. AfxGetApp()->WriteProfileInt(szSection, _xtpCommandBarLoadFromFile, TRUE);
  729. file.Close();
  730. SetFileAttributes(strFileName, FILE_ATTRIBUTE_HIDDEN);
  731. }
  732. }
  733. catch (CFileException* pEx)
  734. {
  735. TRACE(_T("CXTPCommandBars::SaveBarState. File exceptionrn"));
  736. pEx->Delete ();
  737. }
  738. }
  739. else
  740. {
  741. AfxGetApp()->WriteProfileBinary(szSection, _xtpCommandBarControls, pControls, dwCount);
  742. AfxGetApp()->WriteProfileInt(szSection, _xtpCommandBarLoadFromFile, FALSE);
  743. }
  746. ar.Abort();
  747. memFile.Close();
  748. free(pControls);
  749. }
  750. else
  751. {
  752. AfxGetApp()->WriteProfileString(szSection, NULL, NULL);
  753. }
  754. }
  756. if (GetMenuBar() && GetMenuBar()->m_bDirtyMenu)
  757. {
  758. GetMenuBar()->SwitchActiveMenu();
  759. }
  760. m_pOptions->bDirtyState = FALSE;
  761. }
  763. void CXTPCommandBars::_LoadControlsPart(CFile& file, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
  764. {
  765. CArchive ar (&file, CArchive::load);
  767. CXTPPropExchangeArchive px(ar);
  768. px.m_dwData = (DWORD_PTR)pParam;
  770. CXTPCommandBarList lstCommandBars(this);
  771. if (LoadCommandBarList(&px, &lstCommandBars))
  772. {
  773. RestoreCommandBarList(&lstCommandBars, pParam->bLoadSilent);
  774. }
  776. ar.Close();
  777. }
  779. void CXTPCommandBars::LoadBarState(LPCTSTR lpszProfileName, BOOL bSilent)
  780. {
  782. XTP_COMMANDBARS_PROPEXCHANGE_PARAM paramT;
  783. paramT.pCommandBars = this;
  784. paramT.bLoadSilent = bSilent;
  786. if (m_bCustomizeAvail)
  787. {
  788. TCHAR szSection[256];
  789. wsprintf(szSection, _xtpCommandBarControlsSection, lpszProfileName);
  791. if (AfxGetApp()->GetProfileInt(szSection, _xtpCommandBarLoadFromFile, FALSE))
  792. {
  793. CString strFileName = AfxGetApp()->GetProfileString(szSection, _xtpCommandBarControls);
  794. CXTPZipMemFile file;
  795. if (file.OpenCompressedFile(strFileName))
  796. {
  797. _LoadControlsPart(file, &paramT);
  798. }
  800. }
  801. else
  802. {
  803. BYTE* pControls = NULL;
  804. DWORD dwCount = 0;
  806. CXTPPropExchangeSection sec(TRUE, szSection);
  808. // PX_Blob support 16000 characters for ini file (MFC - 4096)
  809. if (PX_Blob(&sec, _xtpCommandBarControls, pControls, dwCount))
  810. {
  811. CXTPZipMemFile memFile(pControls, dwCount);
  813. _LoadControlsPart(memFile, &paramT);
  815. memFile.Close();
  816. }
  818. if (pControls) free(pControls);
  819. }
  820. }
  823. CXTPDockState state;
  824. state.LoadState(lpszProfileName);
  826. LoadDockBarsState(lpszProfileName);
  827. SetDockState(state);
  829. RecalcFrameLayout(TRUE);
  830. m_pOptions->bDirtyState = FALSE;
  832. }
  834. CXTPStatusBar* CXTPCommandBars::GetStatusBar() const
  835. {
  836. CWnd* pBar = m_pFrame->GetDlgItem(AFX_IDW_STATUS_BAR);
  838. return DYNAMIC_DOWNCAST(CXTPStatusBar, pBar);
  839. }
  841. void CXTPCommandBars::SaveDockBarsState(LPCTSTR lpszProfileName)
  842. {
  843. CWinApp* pApp = AfxGetApp();
  844. TCHAR szSection[256];
  846. for (int nIndex = 0; nIndex < 4; nIndex++)
  847. {
  848. wsprintf(szSection, _xtpDockBarSection, lpszProfileName, nIndex);
  849. pApp->WriteProfileString(szSection, NULL, NULL);
  851. CXTPDockBar* pDock = m_pDocks[nIndex];
  852. int nSize = (int)pDock->m_arrBars.GetSize();
  853. if (nSize > 1)
  854. {
  855. int nCount = 0;
  856. DWORD dwIDPrev = (DWORD)-1;
  857. for (int i = 0; i < nSize; i++)
  858. {
  859. CXTPToolBar* pBar = (CXTPToolBar*)pDock->m_arrBars[i];
  860. DWORD dwID = pBar ? pBar->m_nBarID : 0;
  861. if (dwIDPrev == 0 && dwID == 0)
  862. continue;
  863. dwIDPrev = dwID;
  865. TCHAR buf[16];
  866. wsprintf(buf, _xtpBar, nCount++);
  867. pApp->WriteProfileInt(szSection, buf, (int)dwID);
  868. }
  869. pApp->WriteProfileInt(szSection, _xtpBars, nCount);
  870. }
  871. }
  874. CXTPStatusBar* pBar = GetStatusBar();
  876. if (pBar != NULL)
  877. {
  878. pBar->SaveState(lpszProfileName);
  879. }
  880. else
  881. {
  882. pApp->WriteProfileString(lpszProfileName, _T("StatusBar"), NULL);
  883. }
  884. }
  886. void CXTPCommandBars::LoadDockBarsState(LPCTSTR lpszProfileName)
  887. {
  888. CWinApp* pApp = AfxGetApp();
  889. TCHAR szSection[256];
  890. for (int nIndex = 0; nIndex < 4; nIndex++)
  891. {
  892. wsprintf(szSection, _xtpDockBarSection, lpszProfileName, nIndex);
  894. CXTPDockBar* pDock = m_pDocks[nIndex];
  896. int nBars = pApp->GetProfileInt(szSection, _xtpBars, 0);
  897. if (nBars > 1)
  898. {
  899. for (int i = 0; i < nBars; i++)
  900. {
  901. TCHAR buf[16];
  902. wsprintf(buf, _xtpBar, i);
  903. DWORD dwID = pApp->GetProfileInt(szSection, buf, 0);
  905. CXTPToolBar* pBar = GetToolBar(dwID);
  906. if (pBar)
  907. {
  908. if (pBar->m_hWnd && pBar->GetParent() != pDock)
  909. pBar->SetParent(pDock);
  910. if (pBar->m_pDockBar != NULL)
  911. pBar->m_pDockBar->RemoveCommandBar(pBar);
  912. pBar->m_pDockBar = pDock;
  913. pBar->m_barPosition = pDock->GetPosition();
  914. }
  915. pDock->m_arrBars.InsertAt(i, pBar);
  917. }
  918. }
  919. }
  921. CXTPStatusBar* pBar = GetStatusBar();
  922. if (pBar != NULL) pBar->LoadState(lpszProfileName);
  923. }
  925. void CXTPCommandBars::DoPropExchange(CXTPPropExchange* pPX, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
  926. {
  927. if (pPX->IsStoring())
  928. OnSetPreviewMode(FALSE); // Lets be sure we not in preview mode.
  930. XTP_COMMANDBARS_PROPEXCHANGE_PARAM paramT;
  931. if (pParam == NULL)
  932. pParam = &paramT;
  934. pParam->pCommandBars = this;
  936. pPX->m_dwData = (DWORD_PTR)pParam;
  938. CXTPDockState state;
  940. pPX->ExchangeSchemaSafe();
  942. if (pPX->IsStoring())
  943. {
  944. CXTPToolBar* pDesignerBar = 0;
  946. if (pParam->bSerializeActions)
  947. {
  948. CXTPPropExchangeSection secActions(pPX->GetSection(_T("Actions")));
  949. PX_Bool(&secActions, _T("Enabled"), m_bEnableActions, FALSE);
  951. m_pActions->DoPropExchange(&secActions);
  952. }
  954. if (pParam->bSerializeDesignerControls && m_pDesignerControls)
  955. {
  956. pDesignerBar = (CXTPToolBar*)Add(_T("Controls"), xtpBarFloating);
  957. if (pDesignerBar->m_pControls != NULL)
  958. {
  959. pDesignerBar->m_pControls->InternalRelease();
  960. }
  961. pDesignerBar->m_pControls = m_pDesignerControls;
  962. m_pDesignerControls->InternalAddRef();
  964. pDesignerBar->SetBarID(0xFFEEFF);
  965. pDesignerBar->SetVisible(FALSE);
  967. }
  969. if (pParam->bSerializeControls)
  970. {
  971. CXTPCommandBarList lstCommandBars(this);
  972. GenerateCommandBarList(&lstCommandBars, pParam);
  974. VERIFY(SaveCommandBarList(pPX, &lstCommandBars));
  975. }
  976. if (pDesignerBar)
  977. {
  978. Remove(pDesignerBar);
  979. }
  981. if (pParam->bSerializeLayout)
  982. {
  983. GetDockState(state);
  984. CXTPPropExchangeSection secLayout(pPX->GetSection(_T("Layout")));
  985. state.DoPropExchange(&secLayout);
  986. SerializeDockBarsState(&secLayout);
  987. }
  989. if (GetMenuBar() && GetMenuBar()->m_bDirtyMenu)
  990. {
  991. GetMenuBar()->SwitchActiveMenu();
  992. }
  993. }
  994. else
  995. {
  996. if (pParam->bSerializeActions && pPX->GetSchema() > _XTP_SCHEMA_100)
  997. {
  998. CXTPPropExchangeSection secActions(pPX->GetSection(_T("Actions")));
  999. PX_Bool(&secActions, _T("Enabled"), m_bEnableActions, FALSE);
  1001. m_pActions->DoPropExchange(&secActions);
  1002. }
  1004. if (pParam->bSerializeControls)
  1005. {
  1006. CXTPCommandBarList lstCommandBars(this);
  1007. if (LoadCommandBarList(pPX, &lstCommandBars))
  1008. {
  1009. RestoreCommandBarList(&lstCommandBars, pParam->bLoadSilent);
  1011. CXTPMenuBar* pMenuBar = GetMenuBar();
  1012. if (pMenuBar)
  1013. {
  1014. pMenuBar->SetupHook();
  1015. pMenuBar->RefreshMenu();
  1016. }
  1017. }
  1018. else
  1019. {
  1020. return;
  1021. }
  1022. }
  1024. if (pParam->bSerializeLayout)
  1025. {
  1026. CXTPPropExchangeSection secLayout(pPX->GetSection(_T("Layout")));
  1027. state.DoPropExchange(&secLayout);
  1028. SerializeDockBarsState(&secLayout);
  1029. SetDockState(state);
  1030. }
  1032. CXTPToolBar* pCommandBar = GetToolBar(0xFFEEFF);
  1034. if (pCommandBar)
  1035. {
  1036. if (pParam->bSerializeDesignerControls)
  1037. {
  1039. if (m_pDesignerControls)
  1040. m_pDesignerControls->InternalRelease();
  1042. m_pDesignerControls = pCommandBar->GetControls();
  1043. pCommandBar->m_pControls = NULL;
  1045. Remove(pCommandBar);
  1047. m_pDesignerControls->SetParent(NULL);
  1048. m_pDesignerControls->Remove(m_pDesignerControls->FindControl(xtpControlError, XTP_ID_TOOLBAR_EXPAND, TRUE, FALSE));
  1049. m_pDesignerControls->Remove(m_pDesignerControls->FindControl(xtpControlError, XTP_ID_TOOLBAR_HIDE, TRUE, FALSE));
  1050. m_pDesignerControls->SetCommandBars(this);
  1051. }
  1052. else
  1053. {
  1054. Remove(pCommandBar);
  1055. }
  1056. }
  1058. RecalcFrameLayout(TRUE);
  1059. }
  1061. if (pParam->bSerializeImages)
  1062. {
  1063. CXTPPropExchangeSection secImages(pPX->GetSection(_T("Images")));
  1064. GetImageManager()->DoPropExchange(&secImages);
  1065. }
  1067. if (pParam->bSerializeOptions)
  1068. {
  1069. CXTPPropExchangeSection secShortcuts(pPX->GetSection(_T("Shortcuts")));
  1070. m_pShortcutManager->DoPropExchange(&secShortcuts);
  1072. CXTPPropExchangeSection secOptions(pPX->GetSection(_T("Options")));
  1074. XTPPaintTheme theme = GetPaintManager()->BaseTheme();
  1075. PX_Enum(&secOptions, _T("Theme"), theme, xtpThemeOffice2000);
  1076. if (pPX->IsLoading()) SetPaintManager(CXTPPaintManager::CreateTheme(theme));
  1078. m_pOptions->DoPropExchange(&secOptions);
  1079. PX_Bool(&secOptions, _T("Customizable"), m_bCustomizeAvail, TRUE);
  1082. }
  1084. if (pParam->bSerializeDesignerControls && pPX->IsLoading())
  1085. {
  1086. m_pShortcutManager->CreateOriginalAccelTable();
  1088. if (m_bCustomizeAvail)
  1089. {
  1090. for (int i = 0; i < GetCount(); i++)
  1091. {
  1092. CXTPToolBar* pToolBar = GetAt(i);
  1093. pToolBar->GetControls()->CreateOriginalControls();
  1094. }
  1095. }
  1096. }
  1099. m_pOptions->bDirtyState = FALSE;
  1101. }
  1103. void CXTPCommandBars::SerializeBarState(CArchive& ar, BOOL bSerializeControls, BOOL bOnlyCustomized, BOOL bSilent)
  1104. {
  1105. CXTPPropExchangeArchive px(ar);
  1107. XTP_COMMANDBARS_PROPEXCHANGE_PARAM paramT;
  1108. paramT.bSaveOnlyCustomized = bOnlyCustomized;
  1109. paramT.bSerializeControls = bSerializeControls;
  1110. paramT.bLoadSilent = bSilent;
  1112. DoPropExchange(&px, &paramT);
  1113. }
  1116. void CXTPCommandBars::SerializeDockBarsState(CXTPPropExchange* pPX)
  1117. {
  1118. CXTPPropExchangeSection secDockBars(pPX->GetSection(_T("DockBars")));
  1120. for (int nIndex = 0; nIndex < 4; nIndex++)
  1121. {
  1122. CXTPDockBar* pDock = m_pDocks[nIndex];
  1124. CString strSection;
  1125. strSection.Format(_T("DockBar%i"), nIndex);
  1126. CXTPPropExchangeSection secDockBar(secDockBars->GetSection(strSection));
  1128. if (pPX->IsStoring())
  1129. {
  1131. int nSize = (int)pDock->m_arrBars.GetSize();
  1132. DWORD nCount = 0;
  1133. DWORD dwIDPrev = (DWORD)-1;
  1134. int i;
  1136. for (i = 0; i < nSize; i++)
  1137. {
  1138. CXTPToolBar* pBar = (CXTPToolBar*)pDock->m_arrBars[i];
  1139. DWORD dwID = pBar ? pBar->m_nBarID : 0;
  1140. if (dwIDPrev == 0 && dwID == 0) continue;
  1141. dwIDPrev = dwID;
  1142. nCount++;
  1143. }
  1144. if (nCount > 1)
  1145. {
  1146. PX_DWord(&secDockBar, _T("Count"), nCount, 0);
  1147. int j = 0;
  1149. dwIDPrev = (DWORD)-1;
  1150. for (i = 0; i < nSize; i++)
  1151. {
  1152. CXTPToolBar* pBar = (CXTPToolBar*)pDock->m_arrBars[i];
  1153. DWORD dwID = pBar ? pBar->m_nBarID : 0;
  1154. if (dwIDPrev == 0 && dwID == 0)
  1155. continue;
  1156. dwIDPrev = dwID;
  1158. CString strDockBarSection;
  1159. strDockBarSection.Format(_T("Id%i"), j++);
  1160. PX_DWord(&secDockBar, strDockBarSection, dwID, 0);
  1161. }
  1162. }
  1163. else
  1164. {
  1165. nCount = 0;
  1166. PX_DWord(&secDockBar, _T("Count"), nCount, 0);
  1167. }
  1168. }
  1169. else
  1170. {
  1171. DWORD dwID = 0;
  1172. DWORD nBars = 0;
  1173. PX_DWord(&secDockBar, _T("Count"), nBars, 0);
  1175. if (nBars > 1)
  1176. {
  1177. for (int i = 0; i < (int)nBars; i++)
  1178. {
  1179. CString strDockBarSection;
  1180. strDockBarSection.Format(_T("Id%i"), i);
  1181. PX_DWord(&secDockBar, strDockBarSection, dwID, 0);
  1183. CXTPToolBar* pBar = GetToolBar(dwID);
  1185. if (pBar)
  1186. {
  1187. if (pBar->m_hWnd && pBar->GetParent() != pDock)
  1188. pBar->SetParent(pDock);
  1189. if (pBar->m_pDockBar != NULL)
  1190. pBar->m_pDockBar->RemoveCommandBar(pBar);
  1191. pBar->m_pDockBar = pDock;
  1192. pBar->m_barPosition = pDock->GetPosition();
  1193. }
  1194. pDock->m_arrBars.InsertAt(i, pBar);
  1195. }
  1196. }
  1197. }
  1198. }
  1200. }
  1202. void CXTPCommandBars::GetDockState(CXTPDockState& state)
  1203. {
  1204. state.Clear(); //make sure dockstate is empty
  1205. // get state info for each bar
  1206. for (int i = 0; i < GetCount(); i++)
  1207. {
  1208. CXTPToolBar* pBar = GetAt(i);
  1209. ASSERT(pBar != NULL);
  1210. if (!pBar)
  1211. continue;
  1212. CXTPToolBar::CToolBarInfo* pInfo = new CXTPToolBar::CToolBarInfo;
  1213. pBar->GetBarInfo(pInfo);
  1215. state.m_arrBarInfo.Add(pInfo);
  1216. }
  1217. }
  1219. void CXTPCommandBars::SetDockState(CXTPDockState& state)
  1220. {
  1221. for (int i = 0; i < state.m_arrBarInfo.GetSize(); i++)
  1222. {
  1223. CXTPToolBar::CToolBarInfo* pInfo = state.m_arrBarInfo[i];
  1224. ASSERT(pInfo != NULL);
  1225. if (!pInfo)
  1226. continue;
  1228. pInfo->m_pBar = GetToolBar(pInfo->m_nBarID);
  1230. if (pInfo->m_pBar != NULL)
  1231. {
  1232. if (pInfo->m_bFloating)
  1233. {
  1234. FloatCommandBar(pInfo->m_pBar);
  1235. }
  1236. else
  1237. {
  1238. VERIFY(pInfo->m_pBar->Create(m_pFrame, FALSE));
  1239. }
  1241. pInfo->m_pBar->SetBarInfo(pInfo);
  1242. }
  1243. }
  1244. }
  1247. void CXTPCommandBars::GenerateCommandBarList(CXTPCommandBarList* pCommandBarList, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
  1248. {
  1249. DWORD nID = 0x1000000;
  1250. int i;
  1252. for (i = 0; i < GetCount(); i++)
  1253. {
  1254. CXTPToolBar* pBar = GetAt(i);
  1256. if (pBar->IsTemporary())
  1257. continue;
  1259. if (pParam->bSaveOnlyCustomized && pBar->IsBuiltIn())
  1260. {
  1261. if (!pBar->ShouldSerializeBar())
  1262. continue;
  1263. }
  1265. pBar->GenerateCommandBarList(nID, pCommandBarList, pParam);
  1266. }
  1268. for (i = 0; i < m_pContextMenus->GetCount(); i++)
  1269. {
  1270. CXTPCommandBar* pBar = m_pContextMenus->GetAt(i);
  1272. if (pParam->bSaveOnlyCustomized)
  1273. {
  1274. if (!pBar->GetControls()->IsChanged())
  1275. continue;
  1276. }
  1278. pBar->GenerateCommandBarList(nID, pCommandBarList, pParam);
  1279. }
  1280. }
  1282. void CXTPCommandBar::GenerateCommandBarList(DWORD& nID, CXTPCommandBarList* pCommandBarList, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
  1283. {
  1284. if (!pCommandBarList->Lookup(this))
  1285. {
  1286. pCommandBarList->Add(this);
  1287. InternalAddRef();
  1290. if (!IsKindOf(RUNTIME_CLASS(CXTPToolBar)))
  1291. {
  1292. if (m_nBarID == 0 || m_nBarID >= 0x1000000)
  1293. m_nBarID = nID++;
  1294. }
  1295. else ASSERT(m_nBarID != 0);
  1297. m_pControls->GenerateCommandBarList(nID, pCommandBarList, pParam);
  1298. }
  1299. }
  1301. void CXTPMenuBar::GenerateCommandBarList(DWORD& nID, CXTPCommandBarList* pCommandBarList, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
  1302. {
  1303. if (!pCommandBarList->Lookup(this))
  1304. {
  1305. CXTPToolBar::GenerateCommandBarList(nID, pCommandBarList, pParam);
  1307. POSITION pos = m_pMDIMenus->GetStartPosition();
  1308. while (pos)
  1309. {
  1310. CXTPMenuBarMDIMenuInfo* pInfo;
  1311. m_pMDIMenus->GetNextMenu(pos, pInfo);
  1313. pInfo->m_pControls->GenerateCommandBarList(nID, pCommandBarList, pParam);
  1314. }
  1315. }
  1316. }
  1318. void CXTPControl::GenerateCommandBarList(DWORD& nID, CXTPCommandBarList* pCommandBarList, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
  1319. {
  1320. CXTPCommandBar* pCommandBar = GetCommandBar();
  1321. if (pCommandBar)
  1322. {
  1323. pCommandBar->GenerateCommandBarList(nID, pCommandBarList, pParam);
  1324. }
  1325. }
  1327. void CXTPControls::GenerateCommandBarList(DWORD& nID, CXTPCommandBarList* pCommandBarList, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
  1328. {
  1329. for (int i = 0; i < GetCount(); i++)
  1330. {
  1331. CXTPControl* pControl = GetAt(i);
  1333. if (pControl && !pControl->m_bTemporary)
  1334. {
  1335. pControl->GenerateCommandBarList(nID, pCommandBarList, pParam);
  1336. }
  1337. }
  1339. if (m_pOriginalControls && pParam->bSaveOriginalControls)
  1340. m_pOriginalControls->GenerateCommandBarList(nID, pCommandBarList, pParam);
  1341. }
  1343. BOOL CXTPCommandBars::SaveCommandBarList(CXTPPropExchange* pPX, CXTPCommandBarList* pCommandBarList)
  1344. {
  1345. try
  1346. {
  1347. CXTPPropExchangeSection secCommandBars(pPX->GetSection(_T("CommandBars")));
  1349. long nCount = (long)pCommandBarList->GetCount();
  1351. CXTPPropExchangeEnumeratorPtr pEnumerator(secCommandBars->GetEnumerator(_T("CommandBar")));
  1352. POSITION posEnum = pEnumerator->GetPosition(nCount, FALSE);
  1354. for (int i = 0; i < nCount; i++)
  1355. {
  1356. CXTPCommandBar* pCommandBar = pCommandBarList->GetAt(i);
  1357. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1358. PX_Object(&secItem, pCommandBar, RUNTIME_CLASS(CXTPCommandBar));
  1359. }
  1362. }
  1363. catch (COleException* pEx)
  1364. {
  1365. TRACE(_T("CXTPCommandBars::SaveCommandBarList. OLE exception: %xrn"),
  1366. pEx->m_sc);
  1367. pEx->Delete ();
  1368. return FALSE;
  1369. }
  1370. catch (CArchiveException* pEx)
  1371. {
  1372. TRACE(_T("CXTPCommandBars::SaveCommandBarList. Archive exceptionrn"));
  1373. pEx->Delete ();
  1374. return FALSE;
  1375. }
  1376. return TRUE;
  1378. }
  1381. BOOL CXTPCommandBars::LoadCommandBarList(CXTPPropExchange* pPX, CXTPCommandBarList* pCommandBarList)
  1382. {
  1383. try
  1384. {
  1385. CXTPPropExchangeSection secCommandBars(pPX->GetSection(_T("CommandBars")));
  1387. CXTPPropExchangeEnumeratorPtr pEnumerator(secCommandBars->GetEnumerator(_T("CommandBar")));
  1388. POSITION posEnum = pEnumerator->GetPosition(0, FALSE);
  1390. while (posEnum)
  1391. {
  1392. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1394. CXTPCommandBar* pCommandBar = NULL;
  1395. PX_Object(&secItem, pCommandBar, RUNTIME_CLASS(CXTPCommandBar));
  1397. if (!pCommandBar)
  1398. {
  1399. return FALSE;
  1400. }
  1402. pCommandBar->GetControls()->RefreshIndexes();
  1404. pCommandBarList->Add(pCommandBar);
  1405. }
  1410. }
  1411. catch (COleException* pEx)
  1412. {
  1413. TRACE(_T("CXTPCommandBars::LoadCommandBarList. OLE exception: %xrn"),
  1414. pEx->m_sc);
  1415. pEx->Delete ();
  1416. return FALSE;
  1417. }
  1418. catch (CArchiveException* pEx)
  1419. {
  1420. TRACE(_T("CXTPCommandBars::LoadCommandBarList. Archive exceptionrn"));
  1421. pEx->Delete ();
  1422. return FALSE;
  1423. }
  1424. return TRUE;
  1426. }
  1428. void CXTPToolBar::MergeToolBar(CXTPCommandBar* pCommandBar, BOOL bSilent)
  1429. {
  1430. CXTPControls* pLastControls = pCommandBar->GetControls()->GetOriginalControls();
  1432. if (pLastControls && GetControls()->GetOriginalControls()
  1433. && GetControls()->GetOriginalControls()->Compare(pLastControls) == FALSE)
  1434. {
  1435. //silent restore if not customized
  1436. if (!bSilent && pLastControls->Compare(pCommandBar->GetControls()) == FALSE)
  1437. {
  1438. CString strMessage, strUpdate;
  1439. VERIFY(XTPResourceManager()->LoadString(&strUpdate, XTP_IDS_CONFIRM_UPDATE));
  1440. strMessage.Format(strUpdate, (LPCTSTR)m_strTitle);
  1442. if (XTPResourceManager()->ShowMessageBox(strMessage, MB_YESNO | MB_ICONQUESTION) == IDNO)
  1443. {
  1444. CXTPOriginalControls* pControls = GetControls()->GetOriginalControls();
  1445. CMDTARGET_ADDREF(pControls);
  1447. Copy(pCommandBar, FALSE);
  1449. m_pControls->SetOriginalControls(pControls);
  1450. }
  1451. }
  1452. }
  1453. else
  1454. {
  1455. CXTPOriginalControls* pOriginalControls = pCommandBar->m_pControls->m_pOriginalControls ? NULL :
  1456. m_pControls->m_pOriginalControls;
  1457. CMDTARGET_ADDREF(pOriginalControls);
  1459. Copy(pCommandBar, FALSE);
  1461. if (pOriginalControls)
  1462. {
  1463. ASSERT(m_pControls->m_pOriginalControls == NULL);
  1464. m_pControls->SetOriginalControls(pOriginalControls);
  1465. }
  1466. }
  1467. }
  1469. void CXTPCommandBars::RestoreCommandBarList(CXTPCommandBarList* pCommandBarList, BOOL bSilent)
  1470. {
  1471. for (int i = 0; i < pCommandBarList->GetCount(); i++)
  1472. {
  1473. CXTPCommandBar* pCommandBar = pCommandBarList->GetAt(i);
  1474. CXTPToolBar* pToolBar = DYNAMIC_DOWNCAST(CXTPToolBar, pCommandBar);
  1476. if (pToolBar)
  1477. {
  1478. CXTPToolBar* pExistsBar = GetToolBar(pToolBar->GetBarID());
  1480. pCommandBar->RestoreCommandBarList(pCommandBarList);
  1482. if (pExistsBar)
  1483. {
  1484. pExistsBar->MergeToolBar(pCommandBar, bSilent);
  1485. }
  1486. else
  1487. {
  1488. m_arrBars.Add(pToolBar);
  1489. pToolBar->InternalAddRef();
  1490. pToolBar->Create(m_pFrame, FALSE);
  1491. pToolBar->EnableDocking(pToolBar->m_dwFlags);
  1493. OnToolBarAdded(pToolBar);
  1494. }
  1496. }
  1497. else if (pCommandBar->IsPopupBar() && ((CXTPPopupBar*)pCommandBar)->IsContextMenu())
  1498. {
  1499. CXTPCommandBar* pExistsBar = m_pContextMenus->FindCommandBar(pCommandBar->GetBarID());
  1501. pCommandBar->RestoreCommandBarList(pCommandBarList);
  1503. if (pExistsBar)
  1504. {
  1505. CXTPControls* pControls = pCommandBar->GetControls();
  1506. CMDTARGET_ADDREF(pControls)
  1508. CXTPOriginalControls* pOriginalControls = pExistsBar->GetControls()->GetOriginalControls();
  1509. CMDTARGET_ADDREF(pOriginalControls);
  1511. pExistsBar->SetControls(pControls);
  1512. pCommandBar->SetControls(NULL);
  1514. if (pOriginalControls)
  1515. {
  1516. pExistsBar->GetControls()->SetOriginalControls(pOriginalControls);
  1517. }
  1518. }
  1519. else
  1520. {
  1521. m_pContextMenus->Add(pCommandBar);
  1522. pCommandBar->InternalAddRef();
  1524. if (pCommandBar->GetControls()->GetOriginalControls() == NULL)
  1525. pCommandBar->GetControls()->CreateOriginalControls();
  1526. }
  1527. }
  1528. }
  1529. }
  1532. void CXTPCommandBar::RestoreCommandBarList(CXTPCommandBarList* pCommandBarList)
  1533. {
  1534. m_pControls->RestoreCommandBarList(pCommandBarList);
  1535. }
  1537. void CXTPMenuBar::RestoreCommandBarList(CXTPCommandBarList* pCommandBarList)
  1538. {
  1539. CXTPToolBar::RestoreCommandBarList(pCommandBarList);
  1541. POSITION pos = m_pMDIMenus->GetStartPosition();
  1542. while (pos)
  1543. {
  1544. CXTPMenuBarMDIMenuInfo* pInfo;
  1545. m_pMDIMenus->GetNextMenu(pos, pInfo);
  1547. pInfo->m_pControls->RestoreCommandBarList(pCommandBarList);
  1548. }
  1549. }
  1553. void CXTPControl::RestoreCommandBarList(CXTPCommandBarList* /*pCommandBarList*/)
  1554. {
  1556. }
  1557. void CXTPControlPopup::RestoreCommandBarList(CXTPCommandBarList* pCommandBarList)
  1558. {
  1559. if (m_dwCommandBarID != 0)
  1560. {
  1561. CXTPCommandBar* pCommandBar = pCommandBarList->FindCommandBar(m_dwCommandBarID);
  1562. ASSERT(pCommandBar);
  1564. if (pCommandBar)
  1565. {
  1566. SetCommandBar(pCommandBar);
  1567. m_dwCommandBarID = 0;
  1568. pCommandBar->RestoreCommandBarList(pCommandBarList);
  1569. }
  1570. }
  1571. }
  1573. void CXTPControls::RestoreCommandBarList(CXTPCommandBarList* pCommandBarList)
  1574. {
  1575. for (int i = 0; i < GetCount(); i++)
  1576. {
  1577. CXTPControl* pControl = GetAt(i);
  1579. pControl->RestoreCommandBarList(pCommandBarList);
  1580. }
  1582. if (m_pOriginalControls)
  1583. m_pOriginalControls->RestoreCommandBarList(pCommandBarList);
  1584. }
  1586. void CXTPCommandBar::DoPropExchange(CXTPPropExchange* pPX)
  1587. {
  1588. PX_Enum(pPX, _T("Type"), m_barType, xtpBarTypeNormal);
  1589. PX_Enum(pPX, _T("Position"), m_barPosition, xtpBarTop);
  1590. PX_Long(pPX, _T("BarID"), (long&)m_nBarID, 0);
  1591. PX_Long(pPX, _T("Flags"), (long&)m_dwFlags, 0);
  1592. PX_Long(pPX, _T("Style"), (long&)m_dwStyle, 0);
  1593. PX_String(pPX, _T("Title"), m_strTitle, _T(""));
  1594. PX_Bool(pPX, _T("Customizable"), m_bCustomizable, TRUE);
  1595. PX_Int(pPX, _T("MRUWidth"), m_nMRUWidth, 0);
  1597. if (pPX->GetSchema() > _XTP_SCHEMA_80)
  1598. PX_Size(pPX, _T("IconSize"), m_szIcons, CSize(0, 0));
  1600. if (pPX->IsLoading())
  1601. {
  1602. ASSERT(pPX->m_dwData != 0);
  1603. if (pPX->m_dwData) SetCommandBars(((XTP_COMMANDBARS_PROPEXCHANGE_PARAM*)pPX->m_dwData)->pCommandBars);
  1604. }
  1606. if (pPX->GetSchema() > _XTP_SCHEMA_100)
  1607. {
  1608. PX_Size(pPX, _T("ButtonSize"), m_szButtons, CSize(0, 0));
  1609. PX_Bool(pPX, _T("ShowTextBelowIcons"), m_bTextBelow, XTP_BOOL_DEFAULT);
  1611. BOOL bAnimation = IsAnimationEnabled();
  1612. PX_Bool(pPX, _T("EnableAnimation"), bAnimation, FALSE);
  1613. if (pPX->IsLoading())
  1614. {
  1615. EnableAnimation(bAnimation);
  1616. }
  1617. }
  1619. if (pPX->GetSchema() > _XTP_SCHEMA_103)
  1620. {
  1621. PX_Enum(pPX, _T("DefaultButtonStyle"), m_buttonStyle, xtpButtonAutomatic);
  1623. }
  1625. CXTPPropExchangeSection secControls(pPX->GetSection(_T("Controls")));
  1626. m_pControls->DoPropExchange(&secControls);
  1627. }
  1630. void CXTPToolBar::DoPropExchange(CXTPPropExchange* pPX)
  1631. {
  1632. CXTPCommandBar::DoPropExchange(pPX);
  1634. PX_Bool(pPX, _T("BuiltIn"), m_bBuiltIn, TRUE);
  1635. PX_Bool(pPX, _T("TearOff"), m_bTearOff, FALSE);
  1637. if (pPX->GetSchema() > _XTP_SCHEMA_87)
  1638. PX_Bool(pPX, _T("Closeable"), m_bCloseable, TRUE);
  1640. if (pPX->GetSchema() > _XTP_SCHEMA_875)
  1641. PX_Bool(pPX, _T("ContextMenuPresent"), m_bContextMenuPresent, TRUE);
  1643. if (pPX->GetSchema() > _XTP_SCHEMA_98)
  1644. PX_Bool(pPX, _T("CustomizeDialogPresent"), m_bCustomizeDialogPresent, TRUE);
  1646. if (pPX->GetSchema() <= _XTP_SCHEMA_98 && pPX->IsLoading() && m_barType == xtpBarTypeMenuBar)
  1647. {
  1648. m_bCloseable = FALSE;
  1649. }
  1650. }
  1653. void CXTPMenuBar::DoPropExchange(CXTPPropExchange* pPX)
  1654. {
  1655. if (pPX->IsStoring())
  1656. {
  1657. if (m_pMDIMenus->GetCount() > 0)
  1658. {
  1659. SwitchMDIMenu(GetDefaultMenuResource());
  1660. m_bDirtyMenu = TRUE;
  1661. }
  1662. }
  1664. CXTPToolBar::DoPropExchange(pPX);
  1665. PX_Long(pPX, _T("ResourceId"), (long&)m_nIDResource, 0);
  1667. if (pPX->IsStoring())
  1668. {
  1669. //_XTP_SCHEMA_861
  1670. DWORD dwCount = 0;
  1672. POSITION pos = m_pMDIMenus->GetStartPosition();
  1673. while (pos)
  1674. {
  1675. CXTPMenuBarMDIMenuInfo* pInfo;
  1676. m_pMDIMenus->GetNextMenu(pos, pInfo);
  1677. if (pInfo->m_bChanged)
  1678. dwCount++;
  1679. }
  1681. int i = 0;
  1682. pPX->WriteCount(dwCount);
  1684. pos = m_pMDIMenus->GetStartPosition();
  1685. while (pos)
  1686. {
  1687. CXTPMenuBarMDIMenuInfo* pInfo;
  1688. m_pMDIMenus->GetNextMenu(pos, pInfo);
  1689. if (!pInfo->m_bChanged)
  1690. continue;
  1692. long nIDCommand = (long)pInfo->m_nIDResource;
  1694. CString strSection;
  1695. strSection.Format(_T("%s%i"), _T("MDIMenu"), i++);
  1697. CXTPPropExchangeSection sec(pPX->GetSection(strSection));
  1698. PX_Long(&sec, _T("Id"), nIDCommand, 0);
  1699. pInfo->m_pControls->DoPropExchange(&sec);
  1700. }
  1701. }
  1702. else
  1703. {
  1704. if (pPX->GetSchema() > _XTP_SCHEMA_86)
  1705. {
  1706. DWORD nCount = (DWORD)pPX->ReadCount();
  1708. for (DWORD i = 0; i < nCount; i++)
  1709. {
  1710. UINT nIDCommand = 0;
  1712. CString strSection;
  1713. strSection.Format(_T("%s%i"), _T("MDIMenu"), i);
  1715. CXTPPropExchangeSection sec(pPX->GetSection(strSection));
  1716. PX_Long(&sec, _T("Id"), (long&)nIDCommand, 0);
  1718. CXTPMenuBarMDIMenuInfo* pInfo = NULL;
  1719. if (!m_pMDIMenus->Lookup(nIDCommand))
  1720. {
  1721. pInfo = new CXTPMenuBarMDIMenuInfo(GetCommandBars(), nIDCommand);
  1722. m_pMDIMenus->SetAt(nIDCommand, pInfo);
  1724. }
  1725. if (pInfo) pInfo->m_pControls->DoPropExchange(&sec);
  1726. }
  1727. }
  1728. }
  1730. }
  1733. void CXTPPopupBar::DoPropExchange(CXTPPropExchange* pPX)
  1734. {
  1735. CXTPCommandBar::DoPropExchange(pPX);
  1737. PX_Bool(pPX, _T("TearOffPopup"), m_bTearOffPopup, FALSE);
  1738. PX_String(pPX, _T("TearOffCaption"), m_strTearOffCaption, _T(""));
  1739. PX_Long(pPX, _T("TearOffId"), (long&)m_nTearOffID, 0);
  1740. PX_Int(pPX, _T("TearOffWidth"), m_nTearOffWidth, 0);
  1742. if (pPX->GetSchema() > _XTP_SCHEMA_85)
  1743. {
  1744. PX_Rect(pPX, _T("Borders"), m_rcBorders, CRect(2, 4, 2, 4));
  1745. PX_Bool(pPX, _T("ShowShadow"), m_bShowShadow, TRUE);
  1746. }
  1748. if (pPX->GetSchema() > _XTP_SCHEMA_95)
  1749. {
  1750. PX_Bool(pPX, _T("DoubleGripper"), m_bDoubleGripper, FALSE);
  1751. }
  1753. if (pPX->GetSchema() < _XTP_SCHEMA_104)
  1754. {
  1755. SetShowGripper(TRUE);
  1756. }
  1758. if (pPX->GetSchema() > _XTP_SCHEMA_103)
  1759. {
  1760. PX_Bool(pPX, _T("ContextMenu"), m_bContextMenu, FALSE);
  1761. }
  1763. }
  1765. BOOL CXTPControls::ShouldSerializeControl(CXTPControl* pControl)
  1766. {
  1767. return !pControl->m_bTemporary;
  1768. }
  1770. void CXTPControls::DoPropExchange(CXTPPropExchange* pPX)
  1771. {
  1772. ASSERT(pPX->m_dwData != 0);
  1773. XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam = (XTP_COMMANDBARS_PROPEXCHANGE_PARAM*)pPX->m_dwData;
  1776. if (pPX->IsStoring())
  1777. {
  1778. long nCount = 0;
  1779. int i;
  1780. for (i = 0; i < m_arrControls.GetSize(); i++)
  1781. {
  1782. CXTPControl* pControl = GetAt(i);
  1783. if (ShouldSerializeControl(pControl)) nCount++;
  1784. }
  1786. CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Control")));
  1787. POSITION posEnum = pEnumerator->GetPosition(nCount, FALSE);
  1789. for (i = 0; i < (int)m_arrControls.GetSize(); i++)
  1790. {
  1791. CXTPControl* pControl = GetAt(i);
  1792. if (ShouldSerializeControl(pControl))
  1793. {
  1794. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1795. PX_Object(&secItem, pControl, RUNTIME_CLASS(CXTPControl));
  1796. }
  1797. }
  1799. BOOL bOriginalControls = pParam && m_pOriginalControls && pParam->bSaveOriginalControls ? TRUE : FALSE;
  1800. PX_Bool(pPX, _T("OriginalControls"), bOriginalControls, FALSE);
  1802. if (bOriginalControls && m_pOriginalControls)
  1803. {
  1804. CXTPPropExchangeSection secControls(pPX->GetSection(_T("OriginalControls")));
  1805. m_pOriginalControls->DoPropExchange(&secControls);
  1806. }
  1808. BOOL bCustomizedControls = FALSE;
  1809. PX_Bool(pPX, _T("CustomizedControls"), bCustomizedControls, FALSE);
  1811. }
  1812. else
  1813. {
  1814. CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Control")));
  1815. POSITION posEnum = pEnumerator->GetPosition(0, FALSE);
  1817. RemoveAll();
  1819. while (posEnum)
  1820. {
  1821. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1823. CXTPControl* pControl = NULL;
  1824. PX_Object(&secItem, pControl, RUNTIME_CLASS(CXTPControl));
  1826. if (!pControl)
  1827. AfxThrowArchiveException(CArchiveException::badClass);
  1829. m_arrControls.Add(pControl);
  1830. OnControlAdded(pControl);
  1831. }
  1833. RefreshIndexes();
  1834. if (pPX->GetSchema() > _XTP_SCHEMA_80)
  1835. {
  1836. BOOL bOriginalControls = FALSE;
  1837. PX_Bool(pPX, _T("OriginalControls"), bOriginalControls, FALSE);
  1839. if (bOriginalControls)
  1840. {
  1841. CXTPOriginalControls* pOriginalControls = new CXTPOriginalControls();
  1842. SetOriginalControls(pOriginalControls);
  1844. CXTPPropExchangeSection secControls(pPX->GetSection(_T("OriginalControls")));
  1845. pOriginalControls->DoPropExchange(&secControls);
  1846. }
  1848. BOOL bCustomizedControls = FALSE;
  1849. PX_Bool(pPX, _T("CustomizedControls"), bCustomizedControls, FALSE);
  1851. if (bCustomizedControls)
  1852. {
  1853. // _XTP_SCHEMA_80 compatibility.
  1854. CXTPControls* pCustomizedControls = new CXTPControls;
  1855. CXTPPropExchangeSection secControls(pPX->GetSection(_T("CustomizedControls")));
  1856. pCustomizedControls->DoPropExchange(&secControls);
  1857. pCustomizedControls->InternalRelease();
  1858. }
  1859. }
  1860. }
  1861. }
  1864. void CXTPControlActions::DoPropExchange(CXTPPropExchange* pPX)
  1865. {
  1866. if (pPX->IsStoring())
  1867. {
  1868. long nCount = GetCount();
  1870. CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Action")));
  1871. POSITION posEnum = pEnumerator->GetPosition(nCount, FALSE);
  1873. for (int i = 0; i < nCount; i++)
  1874. {
  1875. CXTPControlAction* pAction = GetAt(i);
  1876. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1878. int nId = pAction->GetID();
  1879. PX_Int(&secItem, _T("Id"), nId);
  1880. pAction->DoPropExchange(&secItem);
  1881. }
  1882. }
  1883. else
  1884. {
  1885. CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Action")));
  1886. POSITION posEnum = pEnumerator->GetPosition(0, FALSE);
  1888. while (posEnum)
  1889. {
  1890. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1892. int nId = 0;
  1893. PX_Int(&secItem, _T("Id"), nId);
  1895. CXTPControlAction* pAction = FindAction(nId);
  1897. if (!pAction)
  1898. {
  1899. pAction = new CXTPControlAction(this);
  1900. pAction->m_nId = nId;
  1901. Insert(pAction);
  1902. }
  1904. pAction->DoPropExchange(&secItem);
  1905. }
  1906. }
  1907. }
  1909. void CXTPControlAction::DoPropExchange(CXTPPropExchange* pPX)
  1910. {
  1911. PX_Int(pPX, _T("IconId"), m_nIconId, 0);
  1912. PX_Int(pPX, _T("HelpId"), m_nHelpId, 0);
  1913. PX_String(pPX, _T("Caption"), m_strCaption, _T(""));
  1914. PX_String(pPX, _T("ShortcutText"), m_strShortcutText, _T(""));
  1915. PX_String(pPX, _T("TooltipText"), m_strTooltipText, _T(""));
  1916. PX_String(pPX, _T("DescriptionText"), m_strDescriptionText, _T(""));
  1917. PX_String(pPX, _T("Category"), m_strCategory, _T(""));
  1919. if (pPX->GetSchema() > _XTP_SCHEMA_1122)
  1920. {
  1921. PX_String(pPX, _T("Key"), m_strKey, _T(""));
  1922. }
  1923. }
  1927. void CXTPControl::DoPropExchange(CXTPPropExchange* pPX)
  1928. {
  1929. ASSERT(sizeof(long) == sizeof(DWORD));
  1930. CXTPCommandBars* pCommandBars = ((XTP_COMMANDBARS_PROPEXCHANGE_PARAM*)pPX->m_dwData)->pCommandBars;
  1932. PX_Enum(pPX, _T("Type"), m_controlType, xtpControlButton);
  1933. PX_Int(pPX, _T("Id"), m_nId, -1);
  1935. if (pPX->IsLoading())
  1936. {
  1937. CXTPControlAction* pAction = pCommandBars->GetActions()->FindAction(m_nId);
  1938. if (pAction)
  1939. {
  1940. SetAction(pAction);
  1941. }
  1942. }
  1944. PX_Int(pPX, _T("IconId"), m_nIconId, 0);
  1945. PX_Bool(pPX, _T("BeginGroup"), m_bBeginGroup, FALSE);
  1946. PX_Long(pPX, _T("Tag"), (long&)m_nTag, 0);
  1947. PX_Long(pPX, _T("Flags"), (long&)m_dwFlags, 0);
  1948. PX_Long(pPX, _T("HideFlags"), (long&)m_dwHideFlags, 0);
  1949. PX_String(pPX, _T("Caption"), m_strCaption, _T(""));
  1950. PX_String(pPX, _T("ShortcutText"), m_strShortcutText, _T(""));
  1951. PX_String(pPX, _T("TooltipText"), m_strTooltipText, _T(""));
  1952. PX_String(pPX, _T("DescriptionText"), m_strDescriptionText, _T(""));
  1953. PX_String(pPX, _T("Parameter"), m_strParameter, _T(""));
  1954. PX_Int(pPX, _T("CustomIconId"), m_nCustomIconId, 0);
  1955. PX_String(pPX, _T("CustomCaption"), m_strCustomCaption, _T(""));
  1958. if (pPX->GetSchema() > _XTP_SCHEMA_71)
  1959. PX_String(pPX, _T("Category"), m_strCategory, _T(""));
  1961. if (m_nCustomIconId > 0)
  1962. {
  1963. ASSERT(pCommandBars->IsKindOf(RUNTIME_CLASS(CXTPCommandBars)));
  1965. CXTPPropExchangeSection secCustomIcon(pPX->GetSection(_T("CustomIcon")));
  1966. pCommandBars->GetImageManager()->DoPropExchange(m_nCustomIconId, &secCustomIcon);
  1967. }
  1969. if (pPX->GetSchema() > _XTP_SCHEMA_85)
  1970. {
  1971. if (!(pPX->IsStoring() && pPX->IsAllowDefaultValues() && m_mapDocTemplatesExcluded.IsEmpty()))
  1972. PX_Serialize(pPX, _T("DocTemplatesExcluded"), &m_mapDocTemplatesExcluded);
  1974. if (!(pPX->IsStoring() && pPX->IsAllowDefaultValues() && m_mapDocTemplatesAssigned.IsEmpty()))
  1975. PX_Serialize(pPX, _T("DocTemplatesAssigned"), &m_mapDocTemplatesAssigned);
  1977. PX_Bool(pPX, _T("DefaultItem"), m_bDefaultItem, FALSE);
  1978. }
  1980. if (pPX->GetSchema() > _XTP_SCHEMA_87)
  1981. PX_Bool(pPX, _T("CloseSubMenuOnClick"), m_bCloseSubMenuOnClick, TRUE);
  1983. if (pPX->GetSchema() > _XTP_SCHEMA_875)
  1984. PX_Enum(pPX, _T("CustomStyle"), m_buttonCustomStyle, xtpButtonUndefined);
  1986. if (pPX->GetSchema() < _XTP_SCHEMA_103 && m_buttonCustomStyle == xtpButtonAutomatic)
  1987. m_buttonCustomStyle = xtpButtonUndefined;
  1989. if (pPX->GetSchema() > _XTP_SCHEMA_98)
  1990. PX_Int(pPX, _T("HelpId"), m_nHelpId, 0);
  1992. if (pPX->GetSchema() > _XTP_SCHEMA_100)
  1993. PX_Enum(pPX, _T("Style"), m_buttonStyle, xtpButtonAutomatic);
  1996. if (pPX->GetSchema() > _XTP_SCHEMA_103)
  1997. {
  1998. PX_Int(pPX, _T("Width"), m_nWidth, 0);
  1999. PX_Int(pPX, _T("Height"), m_nHeight, 0);
  2000. PX_Int(pPX, _T("ExecuteOnPressInterval"), m_nExecuteOnPressInterval, 0);
  2001. }
  2002. if (pPX->GetSchema() > _XTP_SCHEMA_1042)
  2003. {
  2004. PX_String(pPX, _T("ShortcutTextAuto"), m_strShortcutTextAuto, _T(""));
  2005. }
  2007. if (pPX->GetSchema() > _XTP_SCHEMA_110)
  2008. PX_String(pPX, _T("KeyboardTip"), m_strKeyboardTip, _T(""));
  2010. if (pPX->GetSchema() > _XTP_SCHEMA_1121)
  2011. PX_Size(pPX, _T("IconSize"), m_szIcon, CSize(0, 0));
  2013. if (pPX->IsLoading())
  2014. {
  2015. OnCaptionChanged();
  2016. }
  2017. }
  2020. void CXTPControlButton::DoPropExchange(CXTPPropExchange* pPX)
  2021. {
  2022. CXTPControl::DoPropExchange(pPX);
  2024. if (pPX->GetSchema() < _XTP_SCHEMA_103)
  2025. PX_Enum(pPX, _T("Style"), m_buttonStyle, xtpButtonAutomatic);
  2026. }
  2028. void CXTPControlPopup::DoPropExchange(CXTPPropExchange* pPX)
  2029. {
  2030. CXTPControl::DoPropExchange(pPX);
  2032. if (pPX->IsStoring())
  2033. {
  2034. long dwCommandBarID = m_pCommandBar ? m_pCommandBar->m_nBarID : 0;
  2035. PX_Long(pPX, _T("CommandBarId"), dwCommandBarID, 0);
  2036. }
  2037. else
  2038. {
  2039. PX_Long(pPX, _T("CommandBarId"), (long&)m_dwCommandBarID, 0);
  2040. }
  2042. if (pPX->GetSchema() > _XTP_SCHEMA_86 && pPX->GetSchema() < _XTP_SCHEMA_103)
  2043. PX_Enum(pPX, _T("Style"), m_buttonStyle, xtpButtonAutomatic);
  2044. }
  2046. void CXTPControlComboBox::DoPropExchange(CXTPPropExchange* pPX)
  2047. {
  2048. CXTPControlPopup::DoPropExchange(pPX);
  2050. PX_Bool(pPX, _T("DropDown"), m_bDropDown, TRUE);
  2051. PX_Int(pPX, _T("Width"), m_nWidth, 0);
  2052. PX_Enum(pPX, _T("ComboStyle"), m_comboStyle, xtpComboNormal);
  2054. if (pPX->GetSchema() > _XTP_SCHEMA_95)
  2055. {
  2056. PX_String(pPX, _T("EditHint"), m_strEditHint, _T(""));
  2057. PX_DWord(pPX, _T("ShellAutoCompleteFlags"), m_dwShellAutoCompleteFlags, 0);
  2058. PX_Bool(pPX, _T("AutoComplete"), m_bAutoComplete, FALSE);
  2059. PX_Int(pPX, _T("EditIconId"), m_nEditIconId, 0);
  2060. PX_Int(pPX, _T("DropDownItemCount"), m_nDropDownItemCount, 12);
  2061. }
  2063. if (pPX->GetSchema() > _XTP_SCHEMA_98)
  2064. {
  2065. PX_DWord(pPX, _T("EditStyle"), m_dwEditStyle, 0);
  2066. }
  2068. if (pPX->IsLoading())
  2069. {
  2070. SetDropDownListStyle(m_bDropDown);
  2071. EnableShellAutoComplete(m_dwShellAutoCompleteFlags);
  2072. }
  2074. }
  2076. void CXTPControlEdit::DoPropExchange(CXTPPropExchange* pPX)
  2077. {
  2078. CXTPControl::DoPropExchange(pPX);
  2080. if (pPX->GetSchema() > _XTP_SCHEMA_861)
  2081. {
  2082. PX_Bool(pPX, _T("HasLabel"), m_bLabel, FALSE);
  2083. PX_Int(pPX, _T("Width"), m_nWidth, 0);
  2084. }
  2085. if (pPX->GetSchema() > _XTP_SCHEMA_875)
  2086. {
  2087. PX_Bool(pPX, _T("ReadOnly"), m_bReadOnly, FALSE);
  2088. }
  2089. if (pPX->GetSchema() > _XTP_SCHEMA_95)
  2090. {
  2091. PX_String(pPX, _T("EditHint"), m_strEditHint, _T(""));
  2092. PX_DWord(pPX, _T("ShellAutoCompleteFlags"), m_dwShellAutoCompleteFlags, 0);
  2093. }
  2094. if (pPX->GetSchema() > _XTP_SCHEMA_98)
  2095. {
  2096. PX_DWord(pPX, _T("EditStyle"), m_dwEditStyle, 0);
  2097. }
  2099. if (pPX->GetSchema() > _XTP_SCHEMA_103)
  2100. {
  2101. PX_Bool(pPX, _T("ShowSpinButtons"), m_bShowSpinButtons, FALSE);
  2102. }
  2104. if (pPX->IsLoading())
  2105. {
  2106. EnableShellAutoComplete(m_dwShellAutoCompleteFlags);
  2107. }
  2108. }