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

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

对话框与窗口

开发平台：

Visual C++

XTPShortcutBar.cpp：源码内容
  1. // XTPShortcutBarItem.cpp : implementation of the CXTPShortcutBar class.
  2. //
  3. // This file is a part of the XTREME SHORTCUTBAR 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"
  23. #include "Common/Resource.h"
  25. #include "Common/XTPResourceManager.h"
  26. #include "Common/XTPDrawHelpers.h"
  27. #include "Common/XTPToolTipContext.h"
  28. #include "Common/XTPImageManager.h"
  29. #include "Common/XTPSystemHelpers.h"
  31. #ifdef _XTP_INCLUDE_COMMANDBARS
  32. #include "CommandBars/Resource.h"
  33. #include "CommandBars/XTPToolBar.h"
  34. #include "CommandBars/XTPCommandBars.h"
  35. #include "CommandBars/XTPPopupBar.h"
  36. #include "CommandBars/XTPControls.h"
  37. #include "CommandBars/XTPControlButton.h"
  38. #include "CommandBars/XTPControlPopup.h"
  39. #include "CommandBars/XTPMouseManager.h"
  40. #endif
  42. #include "XTPShortcutBarPane.h"
  43. #include "XTPShortcutBar.h"
  45. #ifdef _DEBUG
  46. #define new DEBUG_NEW
  47. #undef THIS_FILE
  48. static char THIS_FILE[] = __FILE__;
  49. #endif
  51. #define XTP_ID_SHORTCUT_SELECTED 8000
  52. #define XTP_ID_SHORTCUT_CUSTOMIZE 8001
  55. CXTPShortcutBarItem::CXTPShortcutBarItem(CXTPShortcutBar* pShortcutBar, UINT nID, CWnd* pWnd)
  56. {
  58. CString strCaption;
  59. if (strCaption.LoadString(nID))
  60. {
  61. m_strCaption = m_strTooltip = strCaption;
  63. int nShortCutPos = strCaption.Find ('n');
  64. if (nShortCutPos != -1)
  65. {
  66. m_strTooltip = strCaption.Mid(nShortCutPos + 1);
  67. m_strCaption = strCaption.Left (nShortCutPos);
  68. }
  69. }
  72. m_pShortcutBar = pShortcutBar;
  73. m_bVisible = TRUE;
  75. m_rcItem.SetRectEmpty();
  76. m_hwndChild = pWnd->GetSafeHwnd();
  77. m_nID = nID;
  78. m_bExpandButton = FALSE;
  79. m_dwData = 0;
  80. m_bSelected = FALSE;
  81. m_nIconId = -1;
  82. m_bExpanded = FALSE;
  83. m_bHidden = FALSE;
  85. EnableAutomation();
  88. }
  89. CXTPShortcutBarItem::CXTPShortcutBarItem(CXTPShortcutBar* pShortcutBar)
  90. {
  91. m_pShortcutBar = pShortcutBar;
  92. m_bExpandButton = TRUE;
  93. m_nID = -1;
  94. m_nIconId = -1;
  95. XTPResourceManager()->LoadString(&m_strCaption, XTP_IDS_SHORTCUT_CONFIGURE);
  96. m_strTooltip = m_strCaption;
  97. m_hwndChild = NULL;
  98. m_bVisible = TRUE;
  99. m_bExpanded = FALSE;
  100. m_bHidden = FALSE;
  102. m_dwData = 0;
  103. m_bSelected = FALSE;
  105. EnableAutomation();
  107. }
  109. CXTPImageManagerIcon* CXTPShortcutBarItem::GetImage(int nWidth) const
  110. {
  111. return m_pShortcutBar->GetImageManager()->GetImage(GetIconId(), nWidth);
  112. }
  114. void CXTPShortcutBarItem::SetClientWindow(CWnd* pWnd)
  115. {
  116. if (m_hwndChild)
  117. {
  118. ::ShowWindow(m_hwndChild, SW_HIDE);
  119. }
  121. m_hwndChild = pWnd->GetSafeHwnd();
  122. m_pShortcutBar->Reposition();
  123. }
  126. void CXTPShortcutBarItem::SetCaption(LPCTSTR strCaption)
  127. {
  128. if (m_strCaption != strCaption)
  129. {
  130. m_strCaption = strCaption;
  131. m_pShortcutBar->RedrawControl();
  132. }
  133. }
  135. int CXTPShortcutBarItem::GetIconId() const
  136. {
  137. return m_nIconId <= 0 ? m_nID: m_nIconId;
  138. }
  140. void CXTPShortcutBarItem::SetIconId(int nId)
  141. {
  142. if (m_nIconId != nId)
  143. {
  144. m_nIconId = nId;
  145. m_pShortcutBar->RedrawControl();
  146. }
  147. }
  149. void CXTPShortcutBarItem::SetTooltip(LPCTSTR strTooltip)
  150. {
  151. m_strTooltip = strTooltip;
  152. m_pShortcutBar->Reposition();
  153. }
  155. void CXTPShortcutBarItem::SetID(int nID)
  156. {
  157. m_nID = nID;
  158. }
  160. int CXTPShortcutBarItem::GetID() const
  161. {
  162. return m_nID;
  163. }
  165. BOOL CXTPShortcutBarItem::IsSelected() const
  166. {
  167. if (m_pShortcutBar->IsSingleSelection())
  168. return m_pShortcutBar->GetSelectedItem() == this;
  170. return m_bSelected;
  171. }
  173. void CXTPShortcutBarItem::SetSelected(BOOL bSelected)
  174. {
  175. if (m_pShortcutBar->IsSingleSelection())
  176. {
  177. if (bSelected)
  178. {
  179. m_pShortcutBar->SelectItem(this);
  180. }
  181. }
  182. else
  183. {
  184. m_bSelected = bSelected;
  185. m_pShortcutBar->RedrawControl();
  187. }
  188. }
  190. void CXTPShortcutBarItem::SetVisible(BOOL bVisible)
  191. {
  192. if (m_bVisible != bVisible)
  193. {
  194. m_bVisible = bVisible;
  195. m_pShortcutBar->Reposition();
  196. }
  197. }
  199. BOOL CXTPShortcutBarItem::IsVisible() const
  200. {
  201. return m_bVisible;
  202. }
  204. BOOL CXTPShortcutBarItem::IsHidden() const
  205. {
  206. return m_bHidden;
  207. }
  208. /////////////////////////////////////////////////////////////////////////////
  209. // CXTPShortcutBar
  211. CXTPShortcutBar::CXTPShortcutBar()
  212. {
  213. m_pPaintManager = new CXTPShortcutBarOffice2003Theme;
  214. m_pPaintManager->RefreshMetrics();
  215. m_paintTheme = xtpShortcutThemeOffice2003;
  217. m_nExpandedLines = 1;
  219. m_nDesiredExpandedLinesHeight = 0;
  221. m_szItem = CSize(22, 32);
  222. m_rcClient.SetRectEmpty();
  224. // Add expand button
  225. m_arrItems.Add(new CXTPShortcutBarItem(this));
  227. m_hSizeCursor = AfxGetApp()->LoadStandardCursor(MAKEINTRESOURCE(IDC_SIZENS));
  229. m_bTrackingSize = FALSE;
  230. m_pPressedItem = m_pSelectedItem = m_pHotItem = NULL;
  232. m_hwndClient = NULL;
  234. m_nMinClientHeight = 200;
  235. m_bAllowResize = TRUE;
  237. m_bClientPaneVisible = TRUE;
  238. m_pImageManager = NULL;
  239. m_bSingleSelection = TRUE;
  240. m_bShowActiveItemOnTop = FALSE;
  241. m_bAllowFreeResize = FALSE;
  243. m_bAllowCollapse = TRUE;
  244. m_bShowGripper = TRUE;
  246. m_hHandCursor = AfxGetApp()->LoadStandardCursor(MAKEINTRESOURCE(32649));
  248. if (m_hHandCursor == 0)
  249. m_hHandCursor = XTPResourceManager()->LoadCursor(XTP_IDC_HAND);
  251. m_pToolTipContext = new CXTPToolTipContext;
  252. m_bPreSubclassWindow = TRUE;
  254. RegisterWindowClass();
  255. }
  257. CXTPShortcutBar::~CXTPShortcutBar()
  258. {
  259. CMDTARGET_RELEASE(m_pPaintManager);
  261. for (int i = 0; i < m_arrItems.GetSize(); i++)
  262. {
  263. m_arrItems[i]->InternalRelease();
  264. }
  266. CMDTARGET_RELEASE(m_pImageManager);
  268. CMDTARGET_RELEASE(m_pToolTipContext);
  269. }
  271. BOOL CXTPShortcutBar::RegisterWindowClass(HINSTANCE hInstance /*= NULL*/)
  272. {
  273. return XTPDrawHelpers()->RegisterWndClass(hInstance, _T("XTPShortcutBar"), 0);
  274. }
  276. void CXTPShortcutBar::RedrawControl()
  277. {
  278. if (GetSafeHwnd()) Invalidate(FALSE);
  279. }
  281. void CXTPShortcutBar::ShowExpandButton(BOOL bShow)
  282. {
  283. ASSERT(GetItemCount() > 0);
  284. ASSERT(GetItem(GetItemCount() - 1)->IsItemExpandButton());
  286. if (GetItemCount() > 0)
  287. {
  288. GetItem(GetItemCount() - 1)->SetVisible(bShow);
  289. Reposition();
  290. }
  291. }
  294. BOOL CXTPShortcutBar::IsExpandButtonVisible() const
  295. {
  296. ASSERT(GetItemCount() > 0);
  297. ASSERT(GetItem(GetItemCount() - 1)->IsItemExpandButton());
  299. return GetItemCount() > 0 && GetItem(GetItemCount() - 1)->IsVisible();
  300. }
  305. CXTPImageManager* CXTPShortcutBar::GetImageManager() const
  306. {
  307. return m_pImageManager ? m_pImageManager : XTPImageManager();
  308. }
  310. void CXTPShortcutBar::SetImageManager(CXTPImageManager* pImageManager)
  311. {
  312. if (m_pImageManager)
  313. m_pImageManager->InternalRelease();
  315. m_pImageManager = pImageManager;
  317. Reposition();
  318. }
  320. BOOL CXTPShortcutBar::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
  321. {
  322. if (!CreateEx(WS_EX_STATICEDGE, _T("XTPShortcutBar"),
  323. NULL, dwStyle, rect, pParentWnd, nID))
  324. {
  325. return FALSE;
  326. }
  328. return TRUE;
  329. }
  332. BOOL CXTPShortcutBar::PreCreateWindow(CREATESTRUCT& cs)
  333. {
  334. if (!CWnd::PreCreateWindow(cs))
  335. return FALSE;
  337. //
  338. // PreCreateWindow is called when a control is dynamically
  339. // created. We want to set m_bPreSubclassWindow to FALSE
  340. // here so the control is initialized from CWnd::Create and
  341. // not CWnd::PreSubclassWindow.
  342. //
  344. m_bPreSubclassWindow = FALSE;
  346. return TRUE;
  347. }
  349. void CXTPShortcutBar::PreSubclassWindow()
  350. {
  351. CWnd::PreSubclassWindow();
  353. if (m_bPreSubclassWindow) Reposition();
  354. }
  356. void CXTPShortcutBar::SetTheme(XTPShortcutBarPaintTheme paintTheme)
  357. {
  358. CMDTARGET_RELEASE(m_pPaintManager);
  360. if (paintTheme == xtpShortcutThemeOfficeXP) m_pPaintManager = new CXTPShortcutBarOfficeXPTheme();
  361. else if (paintTheme == xtpShortcutThemeOffice2003) m_pPaintManager = new CXTPShortcutBarOffice2003Theme();
  362. else if (paintTheme == xtpShortcutThemeOffice2007) m_pPaintManager = new CXTPShortcutBarOffice2007Theme();
  363. else m_pPaintManager = new CXTPShortcutBarOffice2000Theme();
  365. m_paintTheme = paintTheme;
  366. m_pPaintManager->RefreshMetrics();
  369. if (m_hWnd)
  370. {
  371. Reposition();
  372. RedrawWindow(0, 0, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ALLCHILDREN | RDW_FRAME);
  373. }
  374. }
  376. void CXTPShortcutBar::SetCustomTheme(CXTPShortcutBarPaintManager* pPaintManager)
  377. {
  378. if (!pPaintManager)
  379. return;
  381. CMDTARGET_RELEASE(m_pPaintManager);
  383. m_pPaintManager = pPaintManager;
  384. m_pPaintManager->RefreshMetrics();
  386. Reposition();
  387. RedrawWindow(0, 0, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ALLCHILDREN);
  388. }
  391. void CXTPShortcutBar::SetExpandedLinesCount(int nLinesCount)
  392. {
  393. m_nDesiredExpandedLinesHeight = nLinesCount * m_szItem.cy;
  394. Reposition();
  395. }
  397. void CXTPShortcutBar::SetExpandedLinesHeight(int nHeight)
  398. {
  399. m_nDesiredExpandedLinesHeight = nHeight;
  400. Reposition();
  401. }
  404. CXTPShortcutBarItem* CXTPShortcutBar::AddItem(UINT nID, CWnd* pWnd)
  405. {
  406. CXTPShortcutBarItem* pItem = new CXTPShortcutBarItem(this, nID, pWnd);
  407. m_arrItems.InsertAt(m_arrItems.GetSize() - 1, pItem);
  409. Reposition();
  411. return pItem;
  412. }
  416. int CXTPShortcutBar::GetVisibleItemsCount() const
  417. {
  418. int nCount = 0;
  419. for (int i = 0; i < m_arrItems.GetSize(); i++)
  420. {
  421. if (m_arrItems[i]->m_bVisible) nCount++;
  423. }
  424. return nCount;
  425. }
  427. int CXTPShortcutBar::GetCollapsedItemsCount() const
  428. {
  429. int nCount = 0;
  430. for (int i = 0; i < m_arrItems.GetSize(); i++)
  431. {
  432. if (m_arrItems[i]->m_bVisible && !m_arrItems[i]->m_bHidden && !m_arrItems[i]->m_bExpanded)
  433. nCount++;
  435. }
  436. return nCount;
  437. }
  440. void CXTPShortcutBar::Reposition()
  441. {
  442. if (!m_hWnd)
  443. return;
  445. static BOOL bReposition = FALSE;
  447. if (bReposition)
  448. return;
  450. bReposition = TRUE;
  453. CXTPClientRect rcShortcutBar(this);
  454. int nWidth = rcShortcutBar.Width();
  455. int nHeight = rcShortcutBar.Height();
  456. int nGripperHeight = m_bShowGripper ? m_pPaintManager->DrawGripper(NULL, this, FALSE) : 0;
  458. for (int nItem = 0; nItem < m_arrItems.GetSize(); nItem++)
  459. m_arrItems[nItem]->m_bHidden = FALSE;
  461. int nVisibleItemsCount = GetVisibleItemsCount();
  463. BOOL bShowActiveItemOnTop = m_bShowActiveItemOnTop && m_bClientPaneVisible;
  465. int nExpandedItem = 0;
  467. if (!m_bClientPaneVisible)
  468. {
  469. m_nExpandedLines = nVisibleItemsCount;
  470. nGripperHeight = 0;
  472. m_rcGripper.SetRectEmpty();
  473. m_rcClient.SetRectEmpty();
  475. nHeight = min(nHeight, m_nExpandedLines * m_szItem.cy);
  476. if (nHeight - m_nExpandedLines * m_szItem.cy < 0)
  477. {
  478. m_nExpandedLines = nHeight/ m_szItem.cy;
  479. nHeight = m_nExpandedLines * m_szItem.cy;
  480. }
  481. nHeight--;
  482. }
  483. else
  484. {
  486. int nTopItemHeight = 0;
  487. if (bShowActiveItemOnTop)
  488. {
  489. for (; nExpandedItem < m_arrItems.GetSize(); nExpandedItem++)
  490. {
  492. CXTPShortcutBarItem* pItem = GetItem(nExpandedItem);
  493. if (!pItem->m_bVisible)
  494. continue;
  496. pItem->m_bExpanded = TRUE;
  497. pItem->m_rcItem.SetRect(0, nTopItemHeight, nWidth, nTopItemHeight + m_szItem.cy);
  499. nVisibleItemsCount--;
  501. nTopItemHeight += m_szItem.cy;
  503. if (m_pSelectedItem == pItem)
  504. break;
  506. }
  507. }
  510. int nClientHeight = 0;
  512. int nMinClientHeight = m_nMinClientHeight;
  513. CXTPShortcutBarPane* pPaneClient = DYNAMIC_DOWNCAST(CXTPShortcutBarPane, CWnd::FromHandle(m_hwndClient));
  514. if (pPaneClient) nMinClientHeight = max(nMinClientHeight, pPaneClient->GetMinimumClientHeight());
  516. if (bShowActiveItemOnTop && m_hwndClient == NULL)
  517. {
  518. nGripperHeight = 0;
  519. nClientHeight = nTopItemHeight;
  520. nMinClientHeight = 0;
  522. m_nExpandedLines = (nHeight - nClientHeight - nGripperHeight) / m_szItem.cy;
  524. if (m_nExpandedLines > nVisibleItemsCount)
  525. {
  526. m_nExpandedLines = nVisibleItemsCount;
  527. }
  529. if ((m_nExpandedLines < nVisibleItemsCount) && !m_bAllowCollapse)
  530. {
  531. nClientHeight = nHeight - nGripperHeight - m_szItem.cy * nVisibleItemsCount;
  532. m_nExpandedLines = nVisibleItemsCount;
  533. }
  535. if (m_nExpandedLines < 1)
  536. {
  537. nClientHeight = nHeight - nGripperHeight - m_szItem.cy;
  538. m_nExpandedLines = 1;
  539. }
  540. }
  541. else if (m_bAllowFreeResize)
  542. {
  543. nClientHeight = nHeight - m_nDesiredExpandedLinesHeight - nGripperHeight;
  545. if (nClientHeight - nTopItemHeight < nMinClientHeight)
  546. {
  547. nClientHeight = nMinClientHeight + nTopItemHeight;
  548. }
  550. m_nExpandedLines = (nHeight - nClientHeight - nGripperHeight) / m_szItem.cy;
  552. if (m_nExpandedLines > nVisibleItemsCount)
  553. {
  554. m_nExpandedLines = nVisibleItemsCount;
  555. }
  557. if ((m_nExpandedLines < nVisibleItemsCount) && !m_bAllowCollapse)
  558. {
  559. nClientHeight = nHeight - nGripperHeight - m_szItem.cy * nVisibleItemsCount;
  560. m_nExpandedLines = nVisibleItemsCount;
  561. }
  563. if (m_nExpandedLines < 1)
  564. {
  565. nClientHeight = nHeight - nGripperHeight - m_szItem.cy;
  566. m_nExpandedLines = 1;
  567. }
  569. }
  570. else
  571. {
  572. m_nExpandedLines = m_nDesiredExpandedLinesHeight / m_szItem.cy;
  574. if (nHeight - nTopItemHeight - m_nExpandedLines * m_szItem.cy - nGripperHeight < nMinClientHeight)
  575. {
  576. m_nExpandedLines = (nHeight - nTopItemHeight - nGripperHeight - nMinClientHeight) / m_szItem.cy;
  578. }
  580. if (m_nExpandedLines > nVisibleItemsCount || !m_bAllowCollapse)
  581. m_nExpandedLines = nVisibleItemsCount;
  583. if (m_nExpandedLines < 1)
  584. m_nExpandedLines = 1;
  586. nClientHeight = nHeight - m_nExpandedLines * m_szItem.cy - nGripperHeight;
  587. }
  590. m_rcGripper.SetRect(0, nClientHeight, nWidth, nClientHeight + nGripperHeight);
  591. m_rcClient.SetRect(0, nTopItemHeight, nWidth, nClientHeight);
  593. if (bShowActiveItemOnTop && nVisibleItemsCount == 0)
  594. {
  595. m_rcClient.SetRect(0, nTopItemHeight, nWidth, nHeight);
  596. m_rcGripper.SetRectEmpty();
  597. }
  598. }
  601. BOOL bExpandButtonVisible = IsExpandButtonVisible();
  604. int nExpandedLines = m_nExpandedLines;
  606. for (; nExpandedItem < m_arrItems.GetSize(); nExpandedItem++)
  607. {
  609. CXTPShortcutBarItem* pItem = GetItem(nExpandedItem);
  610. if (!pItem->m_bVisible)
  611. continue;
  613. if (m_pSelectedItem == pItem && bShowActiveItemOnTop)
  614. continue;
  616. if ((!(nExpandedLines == 1 && !bExpandButtonVisible && nVisibleItemsCount == 1))
  617. && (nExpandedLines < 2)) break;
  619. pItem->m_bExpanded = TRUE;
  620. int nItemTop = m_rcGripper.bottom + (m_nExpandedLines - nExpandedLines) * m_szItem.cy;
  621. pItem->m_rcItem.SetRect(0, nItemTop, nWidth, nItemTop +  m_szItem.cy);
  623. nExpandedLines--;
  624. nVisibleItemsCount--;
  625. }
  627. int nCollapsedCount = min(nVisibleItemsCount, nWidth / m_szItem.cx) - 1;
  628. int nCollapsedPos = nWidth - m_szItem.cx * (nCollapsedCount + 1);
  630. for (int nCollapsedItem = nExpandedItem; nCollapsedItem < m_arrItems.GetSize(); nCollapsedItem++)
  631. {
  632. CXTPShortcutBarItem* pItem = GetItem(nCollapsedItem);
  633. if (!pItem->m_bVisible)
  634. continue;
  636. if (m_pSelectedItem == pItem && bShowActiveItemOnTop)
  637. continue;
  639. pItem->m_bExpanded = FALSE;
  641. if (pItem->IsItemExpandButton())
  642. pItem->m_rcItem.SetRect(nWidth - m_szItem.cx, rcShortcutBar.Height() - m_szItem.cy, nWidth, rcShortcutBar.Height());
  643. else if ((nCollapsedCount > 0) || ((nCollapsedCount == 0) && !bExpandButtonVisible))
  644. pItem->m_rcItem.SetRect(nCollapsedPos, rcShortcutBar.Height() - m_szItem.cy, nCollapsedPos + m_szItem.cx, rcShortcutBar.Height());
  645. else
  646. pItem->m_bHidden = TRUE;
  648. nCollapsedPos += m_szItem.cx;
  649. nCollapsedCount--;
  650. }
  653. if (m_hwndClient)
  654. {
  655. ::MoveWindow(m_hwndClient, m_rcClient.left, m_rcClient.top, m_rcClient.Width(), m_rcClient.Height(), TRUE);
  656. }
  658. Invalidate(FALSE);
  660. bReposition = FALSE;
  662. OnRepositionDone();
  663. }
  665. void CXTPShortcutBar::OnRepositionDone()
  666. {
  667. }
  669. INT_PTR CXTPShortcutBar::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  670. {
  672. ASSERT_VALID(this);
  673. ASSERT(::IsWindow(m_hWnd));
  675. // check child windows first by calling CControlBar
  676. INT_PTR nHit = CWnd::OnToolHitTest(point, pTI);
  677. if (nHit != -1)
  678. return nHit;
  680. #if !defined(_XTP_ACTIVEX) && defined(_XTP_INCLUDE_COMMANDBARS)
  681. if (XTPMouseManager()->IsTrackedLock(NULL) || XTPMouseManager()->IsMouseLocked())
  682. return -1;
  683. #endif
  685. CXTPShortcutBarItem* pItem = HitTest(point);
  686. if (!pItem)
  687. return -1;
  689. CClientDC dc(CWnd::FromHandle(m_hWnd));
  691. BOOL bShowToolTip = !pItem->IsExpanded() ||
  692. GetPaintManager()->IsShortcutItemTruncated(&dc, pItem);
  694. if (bShowToolTip)
  695. {
  696. nHit = pItem->GetID();
  698. if (pItem->IsItemExpandButton())
  699. nHit = XTP_IDS_SHORTCUT_CONFIGURE;
  701. CString strTip = pItem->GetTooltip();
  702. if (strTip.GetLength() == 0)
  703. return -1;
  705. CXTPToolTipContext::FillInToolInfo(pTI, m_hWnd, pItem->GetItemRect(),
  706. nHit, strTip, pItem->GetCaption(), strTip, GetImageManager());
  708. return nHit;
  709. }
  711. return -1;
  712. }
  715. CXTPShortcutBarItem* CXTPShortcutBar::HitTest(CPoint pt) const
  716. {
  717. for (int i = 0; i < m_arrItems.GetSize(); i++)
  718. {
  719. CXTPShortcutBarItem* pItem = m_arrItems[i];
  720. if (pItem->m_bVisible && !pItem->m_bHidden && pItem->m_rcItem.PtInRect(pt))
  721. return m_arrItems[i];
  722. }
  723. return NULL;
  724. }
  726. void CXTPShortcutBar::SetHotItem(CXTPShortcutBarItem* pItem)
  727. {
  728. if (m_pHotItem == pItem)
  729. return;
  731. m_pHotItem = pItem;
  732. Invalidate(FALSE);
  734. if (m_pHotItem)
  735. {
  736. TRACKMOUSEEVENT tme =
  737. {
  738. sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd, 0
  739. };
  740. _TrackMouseEvent(&tme);
  741. }
  744. }
  746. void CXTPShortcutBar::SelectItem(CXTPShortcutBarItem* pItem)
  747. {
  748. if (!pItem)
  749. return;
  751. if (pItem->IsItemExpandButton())
  752. {
  753. OnExpandButtonDown(pItem);
  754. return;
  755. }
  757. if ((m_pSelectedItem == pItem) && m_bSingleSelection)
  758. return;
  760. if (GetOwner()->SendMessage(XTPWM_SHORTCUTBAR_NOTIFY, XTP_SBN_SELECTION_CHANGING, (LPARAM)pItem) == -1)
  761. return;
  764. if (pItem->m_hwndChild != m_hwndClient)
  765. {
  766. if (m_hwndClient)
  767. {
  768. ::ShowWindow(m_hwndClient, SW_HIDE);
  769. }
  771. m_hwndClient = pItem->m_hwndChild;
  773. if (m_hwndClient)
  774. {
  775. ::ShowWindow(m_hwndClient, SW_SHOW);
  776. }
  777. }
  779. if (m_bSingleSelection)
  780. {
  781. m_pSelectedItem = pItem;
  782. }
  783. else
  784. {
  785. pItem->m_bSelected = !pItem->m_bSelected;
  786. }
  789. Reposition();
  791. GetOwner()->SendMessage(XTPWM_SHORTCUTBAR_NOTIFY, XTP_SBN_SELECTION_CHANGED, (LPARAM)pItem);
  792. }
  794. void CXTPShortcutBar::OnExpandButtonDown(CXTPShortcutBarItem* pExpandButton)
  795. {
  797. #ifdef _XTP_INCLUDE_COMMANDBARS
  799. CXTPPopupBar* pPopup = CXTPPopupBar::CreatePopupBar(NULL);
  801. if (m_bClientPaneVisible)
  802. {
  803. pPopup->GetControls()->Add(xtpControlButton, XTP_ID_SHORTCUT_SHOW_MORE);
  804. pPopup->GetControls()->Add(xtpControlButton, XTP_ID_SHORTCUT_SHOW_FEWER);
  805. }
  807. CXTPControlPopup* pControlAddOrRemove = (CXTPControlPopup*)pPopup->GetControls()->Add(xtpControlPopup, XTP_ID_CUSTOMIZE_ADDORREMOVE);
  808. pControlAddOrRemove->SetFlags(xtpFlagManualUpdate);
  810. for (int j = 0; j < m_arrItems.GetSize() - 1; j++)
  811. {
  812. CXTPShortcutBarItem* pItem = m_arrItems[j];
  814. CXTPControl* pControl = pControlAddOrRemove->GetCommandBar()->GetControls()->Add(xtpControlButton, XTP_ID_SHORTCUT_CUSTOMIZE);
  815. pControl->SetIconId(pItem->GetID());
  816. pControl->SetCaption(pItem->GetCaption());
  817. pControl->SetTag((DWORD_PTR)pItem);
  818. pControl->SetChecked(pItem->m_bVisible);
  819. pControl->SetFlags(xtpFlagManualUpdate);
  820. }
  824. BOOL bBeginGroup = TRUE;
  825. for (int i = 0; i < m_arrItems.GetSize(); i++)
  826. {
  827. CXTPShortcutBarItem* pItem = m_arrItems[i];
  828. if (pItem->m_bVisible && pItem->m_bHidden)
  829. {
  830. CXTPControl* pControl = pPopup->GetControls()->Add(xtpControlButton, XTP_ID_SHORTCUT_SELECTED);
  831. pControl->SetIconId(pItem->GetID());
  832. pControl->SetCaption(pItem->GetCaption());
  833. pControl->SetTag((DWORD_PTR)pItem);
  835. pControl->SetFlags(xtpFlagManualUpdate);
  837. pControl->SetBeginGroup(bBeginGroup);
  839. bBeginGroup = FALSE;
  840. }
  841. }
  843. CPoint pt(pExpandButton->GetItemRect().right, pExpandButton->GetItemRect().CenterPoint().y);
  844. ClientToScreen(&pt);
  846. CXTPCommandBars::TrackPopupMenu(pPopup, 0, pt.x, pt.y, this);
  848. pPopup->InternalRelease();
  850. SetHotItem(NULL);
  852. #else
  855. CMenu menu;
  856. menu.CreatePopupMenu();
  859. if (m_bClientPaneVisible)
  860. {
  861. CString str;
  862. XTPResourceManager()->LoadString(&str, XTP_ID_SHORTCUT_SHOW_MORE);
  863. menu.AppendMenu(MF_STRING, XTP_ID_SHORTCUT_SHOW_MORE, str);
  865. if (GetVisibleItemsCount() == m_nExpandedLines)
  866. menu.EnableMenuItem(XTP_ID_SHORTCUT_SHOW_MORE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  869. XTPResourceManager()->LoadString(&str, XTP_ID_SHORTCUT_SHOW_FEWER);
  871. menu.AppendMenu(MF_STRING, XTP_ID_SHORTCUT_SHOW_FEWER, str);
  872. if (m_nExpandedLines <= 1)
  873. menu.EnableMenuItem(XTP_ID_SHORTCUT_SHOW_FEWER, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  874. }
  877. BOOL bBeginGroup = m_bClientPaneVisible;
  879. for (int i = 0; i < m_arrItems.GetSize(); i++)
  880. {
  881. CXTPShortcutBarItem* pItem = m_arrItems[i];
  882. if (pItem->m_bVisible && pItem->m_bHidden)
  883. {
  884. if (bBeginGroup)
  885. {
  886. menu.AppendMenu(MF_SEPARATOR);
  887. }
  888. menu.AppendMenu(MF_STRING, i + 1, pItem->GetCaption());
  889. bBeginGroup = FALSE;
  890. }
  891. }
  893. CPoint pt(pExpandButton->GetItemRect().right, pExpandButton->GetItemRect().CenterPoint().y);
  894. ClientToScreen(&pt);
  896. int nCmd = menu.TrackPopupMenu(TPM_RETURNCMD, pt.x, pt.y, this);
  898. if (nCmd > 0)
  899. {
  900. if (nCmd > m_arrItems.GetSize())
  901. SendMessage(WM_COMMAND, nCmd);
  902. else
  903. {
  904. SelectItem(m_arrItems[nCmd - 1]);
  905. }
  906. }
  908. #endif
  909. }
  912. BEGIN_MESSAGE_MAP(CXTPShortcutBar, CWnd)
  913. //{{AFX_MSG_MAP(CXTPShortcutBar)
  914. ON_WM_PAINT()
  915. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  916. ON_WM_ERASEBKGND()
  917. ON_WM_SIZE()
  918. ON_WM_CREATE()
  919. ON_WM_NCPAINT()
  920. ON_WM_SETCURSOR()
  921. ON_WM_MOUSEMOVE()
  922. ON_WM_LBUTTONDOWN()
  923. ON_WM_LBUTTONUP()
  924. ON_WM_CAPTURECHANGED()
  925. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  926. ON_WM_SYSCOLORCHANGE()
  927. ON_COMMAND(XTP_ID_SHORTCUT_SHOW_MORE, OnShowMoreButtons)
  928. ON_COMMAND(XTP_ID_SHORTCUT_SHOW_FEWER, OnShowFewerButtons)
  929. ON_UPDATE_COMMAND_UI(XTP_ID_SHORTCUT_SHOW_MORE, OnUpdateShowMoreButtons)
  930. ON_UPDATE_COMMAND_UI(XTP_ID_SHORTCUT_SHOW_FEWER, OnUpdateShowFewerButtons)
  931. ON_WM_RBUTTONDOWN()
  932. ON_WM_RBUTTONUP()
  933. //}}AFX_MSG_MAP
  935. #ifdef _XTP_INCLUDE_COMMANDBARS
  936. ON_MESSAGE(WM_XTP_COMMAND, OnExpandPopupExecute)
  937. #endif
  939. END_MESSAGE_MAP()
  942. /////////////////////////////////////////////////////////////////////////////
  943. // CXTPShortcutBar message handlers
  945. void CXTPShortcutBar::OnPaint()
  946. {
  947. CPaintDC dcPaint(this); // device context for painting
  948. CXTPBufferDC dc(dcPaint);
  949. OnDraw(&dc);
  950. }
  952. LRESULT CXTPShortcutBar::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  953. {
  954. CDC* pDC = CDC::FromHandle((HDC)wParam);
  955. if (pDC)
  956. {
  957. OnDraw(pDC);
  958. }
  960. return TRUE;
  961. }
  963. void CXTPShortcutBar::OnDraw(CDC* pDC)
  964. {
  965. CXTPClientRect rc(this);
  966. m_pPaintManager->FillShortcutBar(pDC, this);
  968. if (m_bClientPaneVisible && m_bShowGripper && !m_rcGripper.IsRectEmpty())
  969. m_pPaintManager->DrawGripper(pDC, this, TRUE);
  971. for (int i = 0; i < m_arrItems.GetSize(); i++)
  972. {
  973. CXTPShortcutBarItem* pItem = m_arrItems[i];
  974. if (!pItem->m_bVisible || pItem->m_bHidden)
  975. continue;
  976. m_pPaintManager->DrawShortcutItem(pDC, pItem);
  977. }
  978. }
  980. BOOL CXTPShortcutBar::OnEraseBkgnd(CDC* /*pDC*/)
  981. {
  982. return TRUE;
  983. }
  985. void CXTPShortcutBar::OnSize(UINT nType, int cx, int cy)
  986. {
  987. CWnd::OnSize(nType, cx, cy);
  989. Reposition();
  990. }
  993. int CXTPShortcutBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
  994. {
  995. if (CWnd::OnCreate(lpCreateStruct) == -1)
  996. return -1;
  998. Reposition();
  1000. return 0;
  1001. }
  1003. void CXTPShortcutBar::OnNcPaint()
  1004. {
  1005. CWindowDC dc(this); // device context for painting
  1006. m_pPaintManager->DrawShortcutBarFrame(&dc, this);
  1007. }
  1009. BOOL CXTPShortcutBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  1010. {
  1011. CPoint pt;
  1012. GetCursorPos(&pt);
  1013. ScreenToClient(&pt);
  1015. if ((m_bTrackingSize || m_rcGripper.PtInRect(pt)) && m_bAllowResize && m_bShowGripper)
  1016. {
  1017. ::SetCursor(m_hSizeCursor);
  1018. return TRUE;
  1019. }
  1021. if (m_pHotItem != NULL && m_hHandCursor)
  1022. {
  1023. ::SetCursor(m_hHandCursor);
  1024. return TRUE;
  1025. }
  1027. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  1028. }
  1032. void CXTPShortcutBar::OnMouseMove(UINT nFlags, CPoint point)
  1033. {
  1034. #ifdef _XTP_INCLUDE_COMMANDBARS
  1035. if (XTPMouseManager()->IsTrackedLock(0))
  1036. return;
  1037. #endif
  1039. if (m_bTrackingSize)
  1040. {
  1041. CXTPClientRect rc(this);
  1043. SetExpandedLinesHeight(rc.Height() - point.y);
  1044. }
  1045. else
  1046. {
  1047. CXTPShortcutBarItem* pItem = HitTest(point);
  1048. if (pItem != m_pHotItem)
  1049. {
  1050. SetHotItem(pItem);
  1051. }
  1053. }
  1055. CWnd::OnMouseMove(nFlags, point);
  1056. }
  1059. void CXTPShortcutBar::OnLButtonDown(UINT nFlags, CPoint point)
  1060. {
  1061. if (m_rcGripper.PtInRect(point) && m_bAllowResize)
  1062. {
  1063. m_bTrackingSize = TRUE;
  1064. SetCapture();
  1065. return;
  1066. }
  1068. CXTPShortcutBarItem* pItem = HitTest(point);
  1070. if (pItem)
  1071. {
  1072. m_pPressedItem = pItem;
  1073. Invalidate(FALSE);
  1074. SetCapture();
  1075. return;
  1076. }
  1078. CWnd::OnLButtonDown(nFlags, point);
  1079. }
  1081. void CXTPShortcutBar::OnLButtonUp(UINT nFlags, CPoint point)
  1082. {
  1083. CWnd::OnLButtonUp(nFlags, point);
  1085. m_bTrackingSize = FALSE;
  1087. CXTPShortcutBarItem* pPressedItem = m_pPressedItem;
  1088. m_pPressedItem = NULL;
  1089. ReleaseCapture();
  1093. if (pPressedItem)
  1094. {
  1095. if (m_pHotItem == pPressedItem)
  1096. {
  1097. SelectItem(pPressedItem);
  1098. }
  1099. else
  1100. {
  1101. Invalidate(FALSE);
  1102. }
  1103. }
  1104. }
  1106. void CXTPShortcutBar::OnCaptureChanged(CWnd* pWnd)
  1107. {
  1108. m_bTrackingSize = FALSE;
  1110. if (m_pPressedItem)
  1111. {
  1112. m_pPressedItem = NULL;
  1113. Invalidate(FALSE);
  1114. }
  1116. CWnd::OnCaptureChanged(pWnd);
  1117. }
  1119. void CXTPShortcutBar::OnRButtonDown(UINT nFlags, CPoint point)
  1120. {
  1121. OnMouseMove(nFlags, point);
  1123. GetOwner()->SendMessage(XTPWM_SHORTCUTBAR_NOTIFY, XTP_SBN_RCLICK, MAKELONG(point.x, point.y));
  1125. GetCursorPos(&point);
  1126. ScreenToClient(&point);
  1127. OnMouseMove(nFlags, point);
  1129. CWnd::OnRButtonDown(nFlags, point);
  1130. }
  1132. void CXTPShortcutBar::OnRButtonUp(UINT nFlags, CPoint point)
  1133. {
  1134. CWnd::OnRButtonUp(nFlags, point);
  1136. }
  1139. void CXTPShortcutBar::OnMouseLeave()
  1140. {
  1141. #ifdef _XTP_INCLUDE_COMMANDBARS
  1142. if (!XTPMouseManager()->IsTrackedLock(0))
  1143. #endif
  1144. SetHotItem(NULL);
  1145. }
  1148. void CXTPShortcutBar::OnSysColorChange()
  1149. {
  1150. CWnd::OnSysColorChange();
  1152. m_pPaintManager->RefreshMetrics();
  1153. Reposition();
  1155. }
  1157. CXTPShortcutBarItem* CXTPShortcutBar::FindItem(int nID) const
  1158. {
  1159. for (int i = 0; i < m_arrItems.GetSize(); i++)
  1160. {
  1161. if (m_arrItems[i]->GetID() == nID)
  1162. return m_arrItems[i];
  1163. }
  1164. return NULL;
  1165. }
  1167. void CXTPShortcutBar::LoadState(LPCTSTR lpszProfileName)
  1168. {
  1169. m_nDesiredExpandedLinesHeight = AfxGetApp()->GetProfileInt(lpszProfileName, _T("DesiredExpandedLinesHeight"), m_nDesiredExpandedLinesHeight);
  1171. CDWordArray arrHiddenItems;
  1173. LPBYTE lpbData;
  1174. UINT dwDataSize;
  1175. if (AfxGetApp()->GetProfileBinary(lpszProfileName, _T("Hidden"), &lpbData, &dwDataSize))
  1176. {
  1177. try
  1178. {
  1179. CMemFile file(lpbData, dwDataSize);
  1180. CArchive ar (&file, CArchive::load);
  1181. arrHiddenItems.Serialize(ar);
  1183. for (int i = 0; i < arrHiddenItems.GetSize(); i++)
  1184. {
  1185. CXTPShortcutBarItem* pItem = FindItem(arrHiddenItems[i]);
  1186. if (pItem && !pItem->IsItemExpandButton()) pItem->m_bVisible = FALSE;
  1187. }
  1189. }
  1190. catch (CMemoryException* pEx)
  1191. {
  1192. pEx->Delete ();
  1193. }
  1194. catch (CArchiveException* pEx)
  1195. {
  1196. pEx->Delete ();
  1197. }
  1199. delete[] lpbData;
  1200. }
  1202. Reposition();
  1203. }
  1205. void CXTPShortcutBar::SaveState(LPCTSTR lpszProfileName)
  1206. {
  1207. AfxGetApp()->WriteProfileInt(lpszProfileName, _T("DesiredExpandedLinesHeight"), m_nDesiredExpandedLinesHeight);
  1209. CDWordArray arrHiddenItems;
  1211. for (int i = 0; i < m_arrItems.GetSize(); i++)
  1212. {
  1213. if (!m_arrItems[i]->IsVisible() && !m_arrItems[i]->IsItemExpandButton())
  1214. arrHiddenItems.Add(m_arrItems[i]->GetID());
  1215. }
  1217. try
  1218. {
  1219. CMemFile file;
  1220. CArchive ar (&file, CArchive::store);
  1221. arrHiddenItems.Serialize(ar);
  1222. ar.Flush ();
  1224. DWORD dwDataSize = (DWORD)file.GetPosition();
  1225. LPBYTE lpbData = file.Detach();
  1227. AfxGetApp()->WriteProfileBinary(lpszProfileName, _T("Hidden"), lpbData, dwDataSize);
  1229. ar.Close();
  1230. file.Close();
  1231. free (lpbData);
  1232. }
  1233. catch (CMemoryException* pEx)
  1234. {
  1235. pEx->Delete ();
  1236. }
  1237. catch (CArchiveException* pEx)
  1238. {
  1239. pEx->Delete ();
  1240. }
  1242. }
  1243. int CXTPShortcutBar::GetItemCount() const
  1244. {
  1245. return (int)m_arrItems.GetSize();
  1246. }
  1248. CXTPShortcutBarItem* CXTPShortcutBar::GetItem(int nIndex) const
  1249. {
  1250. if (nIndex >= 0 && nIndex < m_arrItems.GetSize())
  1251. return m_arrItems[nIndex];
  1252. return NULL;
  1253. }
  1255. void CXTPShortcutBar::RemoveItem(int nID)
  1256. {
  1257. m_pHotItem = NULL;
  1258. m_pPressedItem = NULL;
  1260. for (int i = 0; i < m_arrItems.GetSize(); i++)
  1261. {
  1262. CXTPShortcutBarItem* pItem = m_arrItems[i];
  1263. if (pItem->GetID() == nID)
  1264. {
  1265. if (pItem == m_pSelectedItem) m_pSelectedItem = NULL;
  1267. m_arrItems.RemoveAt(i);
  1268. pItem->InternalRelease();
  1269. Reposition();
  1270. return;
  1271. }
  1272. }
  1273. }
  1274. void CXTPShortcutBar::RemoveAllItems()
  1275. {
  1276. m_pHotItem = NULL;
  1277. m_pPressedItem = NULL;
  1278. m_pSelectedItem = NULL;
  1280. for (int i = (int)m_arrItems.GetSize() - 1; i >= 0 ; i--)
  1281. {
  1282. CXTPShortcutBarItem* pItem = m_arrItems[i];
  1284. if (!pItem->IsItemExpandButton())
  1285. {
  1286. m_arrItems.RemoveAt(i);
  1287. pItem->InternalRelease();
  1288. }
  1289. }
  1291. Reposition();
  1292. }
  1294. void CXTPShortcutBar::OnShowMoreButtons()
  1295. {
  1296. SetExpandedLinesCount(m_nExpandedLines + 1);
  1297. }
  1298. void CXTPShortcutBar::OnShowFewerButtons()
  1299. {
  1300. SetExpandedLinesCount(m_nExpandedLines - 1);
  1301. }
  1303. void CXTPShortcutBar::OnUpdateShowMoreButtons(CCmdUI* pCmdUI)
  1304. {
  1305. pCmdUI->Enable(GetVisibleItemsCount() != m_nExpandedLines);
  1307. }
  1308. void CXTPShortcutBar::OnUpdateShowFewerButtons(CCmdUI* pCmdUI)
  1309. {
  1310. pCmdUI->Enable(m_nExpandedLines > 1);
  1311. }
  1313. CXTPToolTipContext* CXTPShortcutBar::GetToolTipContext() const
  1314. {
  1315. return m_pToolTipContext;
  1316. }
  1318. BOOL CXTPShortcutBar::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  1319. {
  1320. if (m_pToolTipContext)
  1321. {
  1322. m_pToolTipContext->FilterToolTipMessage(this, message, wParam, lParam);
  1323. }
  1325. return CWnd::OnWndMsg(message, wParam, lParam, pResult);
  1326. }
  1328. LRESULT CXTPShortcutBar::OnExpandPopupExecute(WPARAM wParam, LPARAM lParam)
  1329. {
  1330. #ifdef _XTP_INCLUDE_COMMANDBARS
  1331. if (wParam == XTP_ID_SHORTCUT_SELECTED)
  1332. {
  1333. CXTPControl* pControl = ((NMXTPCONTROL*)lParam)->pControl;
  1334. SelectItem((CXTPShortcutBarItem*)pControl->GetTag());
  1335. return 1;
  1336. }
  1337. if (wParam == XTP_ID_SHORTCUT_CUSTOMIZE)
  1338. {
  1339. CXTPControl* pControl = ((NMXTPCONTROL*)lParam)->pControl;
  1340. CXTPShortcutBarItem* pItem = (CXTPShortcutBarItem*)pControl->GetTag();
  1342. pItem->m_bVisible = !pItem->m_bVisible;
  1343. Reposition();
  1346. return 1;
  1347. }
  1348. #else
  1349. wParam;
  1350. lParam;
  1351. #endif
  1352. return 0;
  1353. }
  1355. void CXTPShortcutBar::SetLayoutRTL(BOOL bRightToLeft)
  1356. {
  1357. if (!XTPSystemVersion()->IsLayoutRTLSupported())
  1358. return;
  1360. if (!m_hWnd)
  1361. return;
  1363. ModifyStyleEx(bRightToLeft ? 0 : WS_EX_LAYOUTRTL, !bRightToLeft ? 0 : WS_EX_LAYOUTRTL);
  1364. GetImageManager()->DrawReverted(bRightToLeft);
  1366. Reposition();
  1367. }