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

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

对话框与窗口

开发平台：

Visual C++

XTPTaskPanelGroup.cpp：源码内容
  1. // XTPTaskPanelGroup.cpp : implementation of the CXTPTaskPanelGroup class.
  2. //
  3. // This file is a part of the XTREME TASKPANEL 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 "Common/XTPImageManager.h"
  23. #include "Common/XTPPropExchange.h"
  25. #include "XTPTaskPanelGroup.h"
  26. #include "XTPTaskPanelGroupItem.h"
  27. #include "XTPTaskPanelItems.h"
  28. #include "XTPTaskPanel.h"
  29. #include "XTPTaskPanelPaintManager.h"
  31. #ifdef _DEBUG
  32. #define new DEBUG_NEW
  33. #undef THIS_FILE
  34. static char THIS_FILE[] = __FILE__;
  35. #endif
  37. /////////////////////////////////////////////////////////////////////////////
  38. // CXTPTaskPanelGroup
  40. IMPLEMENT_SERIAL(CXTPTaskPanelGroup, CXTPTaskPanelItem, VERSIONABLE_SCHEMA | _XTP_SCHEMA_CURRENT)
  42. CXTPTaskPanelGroup::CXTPTaskPanelGroup(CXTPTaskPanel* pPanel)
  43. {
  44. m_typeItem = xtpTaskItemTypeGroup;
  46. m_bSpecial = FALSE;
  48. m_rcMarginsOuter = CXTPTaskPanelPaintManager::rectDefault;
  49. m_rcMarginsInner = CXTPTaskPanelPaintManager::rectDefault;
  52. m_rcGroupTarget.SetRectEmpty();
  53. m_rcGroupCurrent.SetRectEmpty();
  55. m_pItems = new CXTPTaskPanelGroupItems(pPanel);
  56. m_pItems->m_pOwner = this;
  58. m_nCaptionHeight = 0;
  59. m_nExpandedClientHeight = 0;
  60. m_bCaptionVisible = TRUE;
  62. m_bExpandable = TRUE;
  63. m_bExpanded = TRUE;
  64. m_bExpanding = FALSE;
  65. m_itemLayout = xtpTaskItemLayoutDefault;
  67. m_nScrollOffset = 0;
  68. m_nItemsInRow = 1;
  70. m_szItemIcon = CSize(0);
  71. m_szClientBitmap = CSize(0);
  73. m_nMinClientHeight = 0;
  75. EnableAutomation();
  76. }
  78. CXTPTaskPanelGroup::~CXTPTaskPanelGroup()
  79. {
  80. m_pItems->InternalRelease();
  81. }
  83. void CXTPTaskPanelGroup::OnRemoved()
  84. {
  85. m_pItems->Clear(FALSE);
  86. m_pItems->m_pPanel = NULL;
  87. }
  89. int CXTPTaskPanelGroup::GetMinimumClientHeight() const
  90. {
  91. return max(m_nMinClientHeight, GetTaskPanel()->GetMinimumGroupClientHeight());
  92. }
  94. void CXTPTaskPanelGroup::SetMinimumClientHeight(int nMinClientHeight)
  95. {
  96. m_nMinClientHeight = nMinClientHeight;
  97. }
  100. CXTPTaskPanelGroupItem* CXTPTaskPanelGroup::AddLinkItem(UINT nID, int nImage)
  101. {
  102. CXTPTaskPanel::CRepositionContext context(m_pPanel);
  104. CXTPTaskPanelGroupItem* pItem = (CXTPTaskPanelGroupItem*)m_pItems->Add(new CXTPTaskPanelGroupItem(), nID);
  105. pItem->SetIconIndex(nImage);
  106. pItem->SetType(xtpTaskItemTypeLink);
  108. return pItem;
  109. }
  110. CXTPTaskPanelGroupItem* CXTPTaskPanelGroup::AddTextItem(LPCTSTR strText)
  111. {
  112. CXTPTaskPanel::CRepositionContext context(m_pPanel);
  114. CXTPTaskPanelGroupItem* pItem = (CXTPTaskPanelGroupItem*)m_pItems->Add(new CXTPTaskPanelGroupItem(), 0);
  115. pItem->SetCaption(strText);
  117. return pItem;
  118. }
  120. CXTPTaskPanelGroupItem* CXTPTaskPanelGroup::AddControlItem(HWND hWnd)
  121. {
  122. CXTPTaskPanel::CRepositionContext context(m_pPanel);
  124. CXTPTaskPanelGroupItem* pItem = (CXTPTaskPanelGroupItem*)m_pItems->Add(new CXTPTaskPanelGroupItem(), 0);
  125. pItem->SetControlHandle(hWnd);
  127. return pItem;
  128. }
  131. CXTPTaskPanelGroupItem* CXTPTaskPanelGroup::GetAt(int nIndex) const
  132. {
  133. return (CXTPTaskPanelGroupItem*)m_pItems->GetAt(nIndex);
  134. }
  135. CXTPTaskPanelGroupItem* CXTPTaskPanelGroup::FindItem(int nID) const
  136. {
  137. return (CXTPTaskPanelGroupItem*)m_pItems->Find(nID);
  138. }
  140. BOOL CXTPTaskPanelGroup::IsDirty() const
  141. {
  142. return (m_rcGroupCurrent != m_rcGroupTarget) && IsVisible();
  143. }
  145. int CXTPTaskPanelGroup::CalcInsideHeight()
  146. {
  147. CRect rc;
  148. m_pPanel->GetClientRect(&rc);
  149. int nInsideHeight = rc.Height();
  151. CXTPTaskPanelPaintManager* pPaintManager = GetPaintManager();
  153. int nGroupSpacing = pPaintManager->GetGroupSpacing(m_pPanel);
  154. CRect rcMargins = pPaintManager->GetControlMargins(m_pPanel);
  156. int nGroupCount = m_pPanel->GetGroupCount();
  157. int nVisibleCount = 0;
  159. for (int i = 0; i < nGroupCount; i++)
  160. {
  161. CXTPTaskPanelGroup* pGroup = m_pPanel->GetAt(i);
  162. if (!pGroup->IsVisible())
  163. continue;
  165. nVisibleCount++;
  167. CRect rcMarginsOuter = pPaintManager->GetGroupOuterMargins(pGroup);
  169. nInsideHeight -= pGroup->m_nCaptionHeight + rcMarginsOuter.top + rcMarginsOuter.bottom;
  170. if (pGroup->IsExpanded() && pGroup != m_pPanel->GetActiveGroup())
  171. nInsideHeight -= pGroup->m_nExpandedClientHeight;
  172. }
  173. nInsideHeight -= nVisibleCount > 0 ? nGroupSpacing * (nVisibleCount - 1) : 0;
  174. nInsideHeight -= rcMargins.top + rcMargins.bottom;
  176. return nInsideHeight;
  177. }
  179. CSize CXTPTaskPanelGroup::GetItemIconSize() const
  180. {
  181. return m_szItemIcon == CSize(0) ? GetTaskPanel()->GetItemIconSize() : m_szItemIcon;
  183. }
  185. void CXTPTaskPanelGroup::SetIconSize(CSize szItemIcon)
  186. {
  187. m_szItemIcon = szItemIcon;
  188. GetTaskPanel()->Reposition();
  189. }
  192. void CXTPTaskPanelGroup::OnCalcClientHeight(CDC* pDC, CRect rc)
  193. {
  194. CXTPTaskPanelPaintManager* pPaintManager = GetPaintManager();
  195. CRect rcMarginsOuter = pPaintManager->GetGroupOuterMargins(this);
  196. CRect rcMarginsInner = pPaintManager->GetGroupInnerMargins(this);
  198. rc.DeflateRect(rcMarginsOuter);
  199. CRect rcItems(rc);
  201. rcItems.DeflateRect(rcMarginsInner);
  202. m_nItemsInRow = 1;
  203. int nItemCount = GetItemCount();
  205. if (GetItemLayout() == xtpTaskItemLayoutImages)
  206. {
  207. CSize szIcon = GetItemIconSize();
  208. CRect rcInnerMargins(pPaintManager->m_rcImageLayoutIconPadding);
  209. CSize szButton(szIcon.cx + rcInnerMargins.right + rcInnerMargins.left,
  210. szIcon.cy + rcInnerMargins.top + rcInnerMargins.bottom);
  212. int nRowIcons = max(1, rcItems.Width() / szButton.cx), x = 0, y = 0;
  213. BOOL bWrap = FALSE;
  215. for (int i = 0; i < nItemCount; i++)
  216. {
  217. CXTPTaskPanelGroupItem* pItem = GetAt(i);
  219. if (!pItem->IsVisible())
  220. continue;
  222. if (bWrap)
  223. {
  224. x = 0;
  225. y++;
  226. bWrap = FALSE;
  227. }
  229. CRect rcItem(CPoint(rcItems.left + x * szButton.cx, rcItems.top + y * szButton.cy), szButton);
  230. pItem->OnReposition(rcItem);
  232. if (++x == nRowIcons)
  233. bWrap = TRUE;
  234. }
  235. rcItems.bottom = rcItems.top + rcMarginsInner.bottom + szButton.cy * (y + 1);
  236. m_nItemsInRow = nRowIcons;
  238. SetOffsetItem(m_nScrollOffset);
  239. }
  240. else
  241. {
  242. BOOL bMultiColumn = m_pPanel->IsMultiColumn();
  243. int nRowHeight = 0;
  244. CRect rcItemOuterMargins(0, 0, 0, 0);
  245. int nColumnWidth = m_pPanel->GetColumnWidth();
  246. ASSERT(nColumnWidth > 0);
  247. int x = 0;
  248. BOOL bWrap = FALSE;
  250. int nRowIcons = max(1, rcItems.Width() / nColumnWidth);
  252. for (int i = 0; i < nItemCount; i++)
  253. {
  254. CXTPTaskPanelGroupItem* pItem = GetAt(i);
  256. if (!pItem->IsVisible())
  257. continue;
  259. if (bMultiColumn)
  260. {
  261. if (bWrap)
  262. {
  263. rcItems.top += nRowHeight;
  265. nRowHeight = 0;
  266. x = 0;
  267. bWrap = FALSE;
  268. }
  270. CRect rcItem = pItem->OnReposition(CRect(rcItems.left + x * nColumnWidth, rcItems.top, rcItems.left + (x + 1) * nColumnWidth, rcItems.bottom));
  273. rcItemOuterMargins = pPaintManager->GetItemOuterMargins(pItem);
  275. nRowHeight = max(nRowHeight, rcItem.Height() + rcItemOuterMargins.bottom);
  277. if (++x == nRowIcons)
  278. bWrap = TRUE;
  279. }
  280. else
  281. {
  282. CRect rcItem = pItem->OnReposition(rcItems);
  283. rcItems.top = rcItem.bottom + pPaintManager->GetItemOuterMargins(pItem).bottom;
  284. }
  285. }
  286. if (bMultiColumn)
  287. {
  288. rcItems.top += nRowHeight;
  289. m_nItemsInRow = nRowIcons;
  290. }
  291. rcItems.bottom = rcItems.top + rcMarginsInner.bottom;
  292. }
  294. int nMinClientHeight = GetMinimumClientHeight();
  295. if (rcItems.bottom - rc.top < nMinClientHeight)
  296. rcItems.bottom = rc.top + nMinClientHeight;
  298. m_nExpandedClientHeight = rcItems.bottom - rc.top;
  300. m_nCaptionHeight = pPaintManager->DrawGroupCaption(pDC, this, FALSE);
  301. }
  303. CXTPTaskPanelGroupItem* CXTPTaskPanelGroup::GetNextVisibleItem(int nIndex, int nDirection) const
  304. {
  305. return GetAt(m_pItems->GetNextVisibleIndex(nIndex, nDirection));
  306. }
  308. void CXTPTaskPanelGroup::RepositionScrollOffset()
  309. {
  310. int nItemCount = GetItemCount();
  311. int nLastVisibleItem = m_pItems->GetNextVisibleIndex(nItemCount, -1);
  313. int nScrollOffset = min(GetOffsetItem(), nLastVisibleItem);
  315. if (nScrollOffset > 0)
  316. {
  317. CRect rcItem(GetAt(nLastVisibleItem)->GetItemRect());
  319. int nTopMargin = GetPaintManager()->GetGroupInnerMargins(this).top;
  321. while ((nScrollOffset > 0) && ((rcItem.bottom - GetAt(nScrollOffset - 1)->GetItemRect().top + nTopMargin
  322. < m_nExpandedClientHeight) || !GetAt(nScrollOffset - 1)->IsVisible()))
  323. {
  324. nScrollOffset--;
  325. }
  326. }
  327. SetOffsetItem(nScrollOffset, FALSE);
  329. for (int i = 0; i < nItemCount; i++)
  330. {
  331. CXTPTaskPanelGroupItem* pItem = GetAt(i);
  333. if (pItem->IsItemFocused() || (pItem->IsItemSelected() && GetTaskPanel()->m_bSelectItemOnFocus))
  334. {
  335. EnsureVisible(pItem, FALSE);
  336. break;
  337. }
  338. }
  339. }
  341. void CXTPTaskPanelGroup::RepositionAutoHeightControls(int nHeightOffset)
  342. {
  343. if (GetItemLayout() == xtpTaskItemLayoutImages)
  344. return;
  346. int nCount = 0, i, nTotalHeight = 0, nItemCount = GetItemCount(), nOffset = 0;
  348. for (i = 0; i < nItemCount; i++)
  349. {
  350. CXTPTaskPanelGroupItem* pItem = GetAt(i);
  351. if (pItem->IsAutoHeight() && pItem->IsVisible())
  352. {
  353. nCount++;
  354. nTotalHeight += max(1, pItem->GetSize().cy);
  355. }
  356. }
  358. if (nCount == 0)
  359. return;
  361. for (i = 0; i < nItemCount; i++)
  362. {
  363. CXTPTaskPanelGroupItem* pItem = GetAt(i);
  364. pItem->m_rcItem.OffsetRect(0, nOffset);
  366. if (pItem->IsAutoHeight() && pItem->IsVisible())
  367. {
  368. int nItemHeight = max(1, pItem->GetSize().cy);
  369. int nItemHeightOffset = nCount > 1 ? (int)(nItemHeight* nHeightOffset / nTotalHeight) : nHeightOffset;
  371. nCount--;
  372. nTotalHeight -= nItemHeight;
  373. nHeightOffset -= nItemHeightOffset;
  375. pItem->m_rcItem.bottom += nItemHeightOffset;
  376. nOffset += nItemHeightOffset;
  377. }
  378. }
  381. }
  384. CRect CXTPTaskPanelGroup::OnReposition(CRect rc, BOOL bRecalcOnly)
  385. {
  386. if (m_pPanel->IsExplorerBehaviour())
  387. SetOffsetItem(0, FALSE);
  389. CXTPTaskPanelPaintManager* pPaintManager = GetPaintManager();
  390. CRect rcMarginsOuter = pPaintManager->GetGroupOuterMargins(this);
  392. rc.DeflateRect(rcMarginsOuter);
  394. m_rcGroupTarget = rc;
  396. if (!m_pPanel->IsExplorerBehaviour() && (m_pPanel->GetActiveGroup() == this || IsExpanding()))
  397. {
  398. CRect rcMarginsInner = pPaintManager->GetGroupInnerMargins(this);
  399. int nInsideHeight = CalcInsideHeight();
  400. int nButtonHeight = max(32, GetItemIconSize().cy + rcMarginsInner.bottom);
  402. int nExpandedClientHeight = max(nButtonHeight + rcMarginsInner.top + 2, nInsideHeight);
  404. int nMinClientHeight = GetMinimumClientHeight();
  405. nExpandedClientHeight = max(nMinClientHeight, nExpandedClientHeight);
  407. if (nExpandedClientHeight > m_nExpandedClientHeight)
  408. {
  409. RepositionAutoHeightControls(nExpandedClientHeight - m_nExpandedClientHeight);
  410. }
  412. m_nExpandedClientHeight = nExpandedClientHeight;
  413. RepositionScrollOffset();
  414. }
  416. int nClientHeight = IsExpanded() ? m_nExpandedClientHeight : 0;
  418. m_rcGroupTarget.bottom = m_rcGroupTarget.top + m_nCaptionHeight + nClientHeight;
  420. m_rcGroupCurrent.left = m_rcGroupTarget.left;
  421. m_rcGroupCurrent.right = m_rcGroupTarget.right;
  423. if (!bRecalcOnly || !m_pPanel->m_bAnimation) OnAnimate(0);
  424. else if (!IsDirty()) OnAnimate(0);
  427. return m_rcGroupTarget;
  428. }
  430. #define MOVETO(A, B, Step) if (A != B) A += max(1, abs(A - B)/Step) * (A > B ? -1 : 1);
  432. void CXTPTaskPanelGroup::OnAnimate(int nStep)
  433. {
  434. if (nStep < 1)
  435. {
  436. m_rcGroupCurrent = m_rcGroupTarget;
  437. }
  438. else
  439. {
  440. MOVETO(m_rcGroupCurrent.top, m_rcGroupTarget.top, nStep);
  441. MOVETO(m_rcGroupCurrent.bottom, m_rcGroupTarget.bottom, nStep);
  442. }
  444. if (!IsDirty() && m_bExpanding)
  445. {
  446. m_bExpanding = FALSE;
  447. m_pPanel->NotifyOwner(XTP_TPN_GROUPEXPANDED, (LPARAM)this);
  448. }
  450. for (int i = 0; i < GetItemCount(); i++)
  451. {
  452. CXTPTaskPanelGroupItem* pItem = GetAt(i);
  454. pItem->OnAnimate(nStep);
  455. }
  456. }
  458. void CXTPTaskPanelGroup::OnPaint(CDC* pDC)
  459. {
  460. GetPaintManager()->DrawGroupCaption(pDC, this, TRUE);
  462. GetPaintManager()->DrawGroupClient(pDC, this);
  463. }
  465. CRect CXTPTaskPanelGroup::GetCaptionRect() const
  466. {
  467. int nCaptionRight = m_rcGroupCurrent.right;
  468. if (m_pPanel->GetScrollButton(TRUE)->pGroupCaption == this)
  469. nCaptionRight = m_pPanel->GetScrollButton(TRUE)->rcButton.left - GetPaintManager()->GetGroupSpacing(m_pPanel) - 1;
  470. if (m_pPanel->GetScrollButton(FALSE)->pGroupCaption == this)
  471. nCaptionRight = m_pPanel->GetScrollButton(FALSE)->rcButton.left - GetPaintManager()->GetGroupSpacing(m_pPanel) - 1;
  473. return CRect(m_rcGroupCurrent.left, m_rcGroupCurrent.top, nCaptionRight, m_rcGroupCurrent.top + m_nCaptionHeight);
  474. }
  476. CRect CXTPTaskPanelGroup::GetTargetCaptionRect() const
  477. {
  478. int nCaptionRight = m_rcGroupTarget.right;
  479. if (m_pPanel->GetScrollButton(TRUE)->pGroupCaption == this)
  480. nCaptionRight = m_pPanel->GetScrollButton(TRUE)->rcButton.left - GetPaintManager()->GetGroupSpacing(m_pPanel) - 1;
  481. if (m_pPanel->GetScrollButton(FALSE)->pGroupCaption == this)
  482. nCaptionRight = m_pPanel->GetScrollButton(FALSE)->rcButton.left - GetPaintManager()->GetGroupSpacing(m_pPanel) - 1;
  484. return CRect(m_rcGroupTarget.left, m_rcGroupTarget.top, nCaptionRight, m_rcGroupTarget.top + m_nCaptionHeight);
  485. }
  487. CRect CXTPTaskPanelGroup::GetClientRect() const
  488. {
  489. return CRect(m_rcGroupCurrent.left, m_rcGroupCurrent.top + m_nCaptionHeight, m_rcGroupCurrent.right, m_rcGroupCurrent.bottom);
  490. }
  492. CRect CXTPTaskPanelGroup::GetTargetClientRect() const
  493. {
  494. return CRect(m_rcGroupTarget.left, m_rcGroupTarget.top + m_nCaptionHeight, m_rcGroupTarget.right, m_rcGroupTarget.bottom);
  495. }
  497. BOOL CXTPTaskPanelGroup::IsAcceptFocus() const
  498. {
  499. return CXTPTaskPanelItem::IsAcceptFocus() && IsExpandable();
  500. }
  502. void CXTPTaskPanelGroup::SetSpecialGroup(BOOL bSpecial)
  503. {
  504. m_bSpecial = bSpecial;
  505. RedrawPanel();
  506. }
  507. BOOL CXTPTaskPanelGroup::IsSpecialGroup() const
  508. {
  509. return m_bSpecial;
  510. }
  512. void CXTPTaskPanelGroup::SetExpandable(BOOL bExpandable)
  513. {
  514. m_bExpandable = bExpandable;
  516. RedrawPanel();
  517. }
  518. BOOL CXTPTaskPanelGroup::IsExpandable() const
  519. {
  520. return m_bExpandable && m_pPanel->m_bExpandable && m_bEnabled;
  521. }
  523. void CXTPTaskPanelGroup::SetExpanded(BOOL bExpanded)
  524. {
  525. if (m_pPanel)
  526. m_pPanel->ExpandGroup(this, bExpanded);
  527. }
  529. BOOL CXTPTaskPanelGroup::IsExpanded() const
  530. {
  531. return m_pPanel ? m_pPanel->IsGroupExpanded(this) : FALSE;
  532. }
  534. BOOL CXTPTaskPanelGroup::IsExpanding() const
  535. {
  536. return m_bExpanding;
  537. }
  539. void CXTPTaskPanelGroup::ShowCaption(BOOL bShow)
  540. {
  541. if (m_bCaptionVisible != bShow)
  542. {
  543. m_bCaptionVisible = bShow;
  544. RepositionPanel();
  545. }
  546. }
  548. BOOL CXTPTaskPanelGroup::IsCaptionVisible() const
  549. {
  550. return m_bCaptionVisible;
  551. }
  553. void CXTPTaskPanelGroup::SetClientBitmap(UINT nID, COLORREF clrTransparent, BOOL bAlpha /*= FALSE*/)
  554. {
  555. m_ilClient.DeleteImageList();
  557. CBitmap bmp;
  558. bmp.LoadBitmap(nID);
  560. BITMAP bmpInfo;
  561. bmp.GetBitmap(&bmpInfo);
  562. CSize szBitmap(bmpInfo.bmWidth, bmpInfo.bmHeight);
  565. if (bAlpha)
  566. {
  567. m_ilClient.Create(szBitmap.cx, szBitmap.cy, ILC_COLOR32 | ILC_MASK, 0, 1);
  568. m_ilClient.Add(&bmp, (CBitmap*)NULL);
  569. }
  570. else
  571. {
  572. m_ilClient.Create(szBitmap.cx, szBitmap.cy, ILC_COLOR24 | ILC_MASK, 0, 1);
  573. m_ilClient.Add(&bmp, clrTransparent);
  574. }
  575. m_szClientBitmap = szBitmap;
  576. }
  577. void CXTPTaskPanelGroup::OnFillClient(CDC* pDC, CRect rc)
  578. {
  579. if (m_ilClient.GetSafeHandle() && m_ilClient.GetImageCount() == 1)
  580. {
  581. CPoint pt(rc.right - m_szClientBitmap.cx, rc.bottom - m_szClientBitmap.cy);
  582. m_ilClient.Draw(pDC, 0, pt, ILD_NORMAL);
  584. }
  585. }
  587. CRect CXTPTaskPanelGroup::GetHitTestRect() const
  588. {
  589. if (!m_pPanel)
  590. return CRect(0, 0, 0, 0);
  592. CRect rc = GetCaptionRect();
  593. rc.OffsetRect(0, -m_pPanel->GetScrollOffset());
  595. return rc;
  596. }
  598. CRect CXTPTaskPanelGroup::GetInvalidateRect() const
  599. {
  600. if (!m_pPanel)
  601. return CRect(0, 0, 0, 0);
  603. CRect rc = m_rcGroupCurrent;
  604. rc.OffsetRect(0, -m_pPanel->GetScrollOffset());
  606. return rc;
  607. }
  609. CXTPTaskPanelGroupItem* CXTPTaskPanelGroup::HitTest(CPoint pt, CRect* lpRect) const
  610. {
  611. if (!IsExpanded())
  612. return NULL;
  614. int nOffset = m_pPanel->GetScrollOffset() - m_nCaptionHeight - m_rcGroupCurrent.top + GetScrollOffsetPos();
  615. pt.y += nOffset;
  617. for (int i = 0; i < GetItemCount(); i++)
  618. {
  619. CXTPTaskPanelGroupItem* pItem = GetAt(i);
  620. CRect rcItem = pItem->GetItemRect();
  622. if (rcItem.PtInRect(pt) && pItem->IsVisible())
  623. {
  624. if (lpRect)
  625. {
  626. rcItem.OffsetRect(0, -nOffset);
  627. *lpRect = rcItem;
  628. }
  629. return pItem;
  630. }
  631. }
  632. return NULL;
  633. }
  635. XTPTaskPanelItemLayout CXTPTaskPanelGroup::GetItemLayout() const
  636. {
  637. if (m_itemLayout != xtpTaskItemLayoutDefault)
  638. return m_itemLayout;
  640. return m_pPanel->GetItemLayout();
  641. }
  643. void CXTPTaskPanelGroup::SetItemLayout(XTPTaskPanelItemLayout itemLayout)
  644. {
  645. if (itemLayout != m_itemLayout)
  646. {
  647. m_itemLayout = itemLayout;
  648. RepositionPanel();
  649. }
  650. }
  653. void CXTPTaskPanelGroup::SetSelectedItem(CXTPTaskPanelGroupItem* pSelectedItem)
  654. {
  655. int nCount = GetItemCount();
  657. for (int i = 0; i < nCount; i++)
  658. {
  659. CXTPTaskPanelGroupItem* pItem = GetAt(i);
  660. pItem->SetItemSelected(pSelectedItem == pItem);
  661. }
  662. }
  664. BOOL CXTPTaskPanelGroup::IsChildItemDragOver() const
  665. {
  666. return m_pPanel && m_pPanel->m_pItemDragOver &&
  667. m_pPanel->m_pItemDragOver->GetParentItems() == m_pItems;
  668. }
  670. int CXTPTaskPanelGroup::GetItemCount() const
  671. {
  672. return m_pItems->GetCount();
  673. }
  675. BOOL CXTPTaskPanelGroup::IsScrollButtonEnabled(BOOL bScrollButtonUp) const
  676. {
  677. CXTPTaskPanelGroupItem* pLastVisibleItem = (CXTPTaskPanelGroupItem*)m_pItems->GetLastVisibleItem();
  679. if (pLastVisibleItem == NULL)
  680. return FALSE;
  682. if (bScrollButtonUp)
  683. return m_nScrollOffset != 0;
  685. CRect rcItem(pLastVisibleItem->GetItemRect());
  687. return rcItem.bottom - GetScrollOffsetPos() > m_rcGroupTarget.Height() - m_nCaptionHeight;
  688. }
  690. int CXTPTaskPanelGroup::GetOffsetItem() const
  691. {
  692. if (m_nScrollOffset == 0)
  693. return 0;
  695. if (m_nScrollOffset < GetItemCount())
  696. {
  697. CXTPTaskPanelGroupItem* pItem = GetAt(m_nScrollOffset);
  699. if (pItem->IsVisible())
  700. return m_nScrollOffset;
  702. int nScrollOffset = m_pItems->GetNextVisibleIndex(m_nScrollOffset, +1);
  704. if (nScrollOffset != -1)
  705. return nScrollOffset;
  707. nScrollOffset = m_pItems->GetNextVisibleIndex(m_nScrollOffset, -1);
  708. if (nScrollOffset != -1)
  709. return nScrollOffset;
  710. }
  712. return 0;
  713. }
  715. int CXTPTaskPanelGroup::GetScrollOffsetPos() const
  716. {
  717. int nScrollOffset = GetOffsetItem();
  719. if (nScrollOffset > 0 && nScrollOffset < GetItemCount())
  720. {
  721. return GetAt(nScrollOffset)->GetItemRect().top - GetPaintManager()->GetGroupInnerMargins(this).top;
  722. }
  723. return 0;
  724. }
  726. void CXTPTaskPanelGroup::SetOffsetItem(int nScrollOffset, BOOL bUpdateScrollButtons /*= TRUE*/)
  727. {
  728. nScrollOffset = nScrollOffset - (nScrollOffset % m_nItemsInRow);
  730. if (nScrollOffset > GetItemCount() - 1)
  731. nScrollOffset = GetItemCount() - 1;
  733. if (nScrollOffset < 0)
  734. nScrollOffset = 0;
  736. if (m_nScrollOffset != nScrollOffset)
  737. {
  738. m_nScrollOffset = nScrollOffset;
  740. if (bUpdateScrollButtons)
  741. {
  742. OnAnimate(0);
  743. m_pPanel->UpdateScrollButtons();
  744. }
  745. RedrawPanel(FALSE);
  746. }
  747. }
  749. void CXTPTaskPanelGroup::Scroll(int nDelta)
  750. {
  751. SetOffsetItem(m_pItems->GetNextVisibleIndex(GetOffsetItem(), nDelta));
  752. }
  754. BOOL CXTPTaskPanelGroup::IsItemVisible(CXTPTaskPanelGroupItem* pItem, BOOL bAllowPart) const
  755. {
  756. if (!IsExpanded())
  757. return FALSE;
  759. if (!pItem || pItem->GetItemGroup() != this || !pItem->IsVisible())
  760. return FALSE;
  762. if (m_pPanel->IsExplorerBehaviour())
  763. return TRUE;
  765. int nIndex = pItem->GetIndex();
  767. if (m_nScrollOffset > nIndex)
  768. return FALSE;
  770. CRect rcItem(pItem->GetItemRect());
  771. if ((bAllowPart ? rcItem.top : rcItem.bottom) - GetScrollOffsetPos() > m_rcGroupTarget.Height() - m_nCaptionHeight)
  772. return FALSE;
  774. return TRUE;
  775. }
  777. void CXTPTaskPanelGroup::EnsureVisible(CXTPTaskPanelGroupItem* pItem, BOOL bUpdateScrollButtons /*= TRUE*/)
  778. {
  779. if (m_pPanel->IsExplorerBehaviour() || GetItemCount() == 0 || !IsExpanded())
  780. return;
  782. if (!pItem || pItem->GetItemGroup() != this || !pItem->IsVisible())
  783. return;
  785. int nIndex = pItem->GetIndex();
  787. if (m_nScrollOffset > nIndex)
  788. {
  789. SetOffsetItem(nIndex, bUpdateScrollButtons);
  790. return;
  791. }
  793. CRect rcItem(pItem->GetItemRect());
  794. if (rcItem.bottom - GetScrollOffsetPos() > m_nExpandedClientHeight)
  795. {
  796. int nTopMargin = GetPaintManager()->GetGroupInnerMargins(this).top;
  797. if (rcItem.top - GetScrollOffsetPos() <= nTopMargin)
  798. return;
  800. int nScrollOffset = m_nScrollOffset + 1;
  801. for (; nScrollOffset <= nIndex; nScrollOffset++)
  802. {
  803. CXTPTaskPanelGroupItem* pItemScroll = GetAt(nScrollOffset);
  804. if (!pItemScroll || !pItemScroll->IsVisible())
  805. continue;
  807. int nScrollOffsetPos = pItemScroll->GetItemRect().top - nTopMargin;
  809. if (rcItem.bottom - nScrollOffsetPos <= m_nExpandedClientHeight)
  810. break;
  812. if (rcItem.top - nScrollOffsetPos <= nTopMargin)
  813. break;
  814. }
  815. SetOffsetItem(nScrollOffset, bUpdateScrollButtons);
  816. }
  817. }
  819. void CXTPTaskPanelGroup::DoPropExchange(CXTPPropExchange* pPX)
  820. {
  821. CXTPTaskPanelItem::DoPropExchange(pPX);
  823. BOOL bExpanded = IsExpanded();
  825. PX_Bool(pPX, _T("CaptionVisible"), m_bCaptionVisible, TRUE);
  826. PX_Bool(pPX, _T("Expandable"), m_bExpandable, TRUE);
  827. PX_Bool(pPX, _T("Expanded"), bExpanded, FALSE);
  828. PX_Bool(pPX, _T("Special"), m_bSpecial, FALSE);
  829. PX_Enum(pPX, _T("Layout"), m_itemLayout, xtpTaskItemLayoutDefault);
  830. PX_Rect(pPX, _T("MarginsInner"), m_rcMarginsInner, CXTPTaskPanelPaintManager::rectDefault);
  831. PX_Rect(pPX, _T("MarginsOuter"), m_rcMarginsOuter, CXTPTaskPanelPaintManager::rectDefault);
  832. PX_Size(pPX, _T("IconSize"), m_szItemIcon, CSize(0));
  834. if (pPX->IsLoading())
  835. {
  836. m_pItems->m_pPanel = m_pPanel;
  837. SetExpanded(bExpanded);
  838. }
  840. CXTPPropExchangeSection secItems(pPX->GetSection(_T("Items")));
  841. m_pItems->DoPropExchange(&secItems);
  842. }
  844. HRESULT CXTPTaskPanelGroup::GetAccessibleState(VARIANT varChild, VARIANT* pvarState)
  845. {
  846. if (GetChildIndex(&varChild) != CHILDID_SELF)
  847. return E_INVALIDARG;
  849. CXTPTaskPanelItem::GetAccessibleState(varChild, pvarState);
  851. if (IsExpanded())
  852. pvarState->lVal |= STATE_SYSTEM_EXPANDED;
  853. else
  854. pvarState->lVal |= STATE_SYSTEM_COLLAPSED;
  856. return S_OK;
  857. }
  859. HRESULT CXTPTaskPanelGroup::GetAccessibleDefaultAction(VARIANT varChild, BSTR* pszDefaultAction)
  860. {
  861. if (GetChildIndex(&varChild) != CHILDID_SELF)
  862. return E_INVALIDARG;
  864. *pszDefaultAction = SysAllocString(L"Expand");
  866. return S_OK;
  867. }
  869. HRESULT CXTPTaskPanelGroup::AccessibleDoDefaultAction(VARIANT varChild)
  870. {
  871. SAFE_MANAGE_STATE(m_pModuleState);
  873. if (GetChildIndex(&varChild) != CHILDID_SELF)
  874. return E_INVALIDARG;
  876. SetExpanded(!IsExpanded());
  878. return S_OK;
  879. }
  881. /////////////////////////////////////////////////////////////////////////////
  882. // CXTPTaskPanelGroup message handlers