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

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

对话框与窗口

开发平台：

Visual C++

XTPTaskPanel.cpp：源码内容
  1. // XTPTaskPanel.cpp : implementation of the CXTPTaskPanel 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 "Resource.h"
  23. #include "Common/Resource.h"
  25. #include "Common/XTPVC80Helpers.h"
  26. #include "Common/XTPDrawHelpers.h"
  27. #include "Common/XTPImageManager.h"
  28. #include "Common/XTPToolTipContext.h"
  29. #include "Common/XTPResourceManager.h"
  30. #include "Common/XTPMarkupRender.h"
  32. #if !defined(_XTP_ACTIVEX) && defined(_XTP_INCLUDE_COMMANDBARS)
  33. #include "CommandBars/XTPCommandBar.h"
  34. #include "CommandBars/XTPMouseManager.h"
  35. #endif
  37. #include "XTPTaskPanelItems.h"
  38. #include "XTPTaskPanelGroup.h"
  39. #include "XTPTaskPanel.h"
  40. #include "XTPTaskPanelPaintManager.h"
  41. #include "XTPTaskPanelGroupItem.h"
  42. #include "XTPTaskPanelAnimation.h"
  44. #ifdef _DEBUG
  45. #define new DEBUG_NEW
  46. #undef THIS_FILE
  47. static char THIS_FILE[] = __FILE__;
  48. #endif
  50. #ifndef SPI_GETMOUSEHOVERTIME
  51. #define SPI_GETMOUSEHOVERTIME 102
  52. #endif
  54. #define TID_REPOSITION 200
  55. #define TID_SCROLLBARS 201
  56. #define TID_SCROLLGROUP 202
  57. #define TID_GROUPHOVER 203
  59. #define IsItemLink(pItem) (pItem && pItem->GetType() == xtpTaskItemTypeLink)
  60. #define IsItemGroup(pItem) (pItem && pItem->GetType() == xtpTaskItemTypeGroup)
  62. CLIPFORMAT CXTPTaskPanel::m_cfItem = (CLIPFORMAT)::RegisterClipboardFormat(_T("TaskPanelGroupItem"));
  64. BOOL CXTPTaskPanel::GetMessageExt(MSG& msg)
  65. {
  66. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  67. {
  68. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  69. break;
  70. DispatchMessage(&msg);
  71. }
  73. if (!::GetMessage(&msg, NULL, 0, 0))
  74. {
  75. AfxPostQuitMessage((int)msg.wParam);
  76. return FALSE;
  77. }
  78. return TRUE;
  79. }
  81. //////////////////////////////////////////////////////////////////////////
  82. // CPanelDropTarget
  83. class CXTPTaskPanel::CPanelDropTarget : public COleDropTarget
  84. {
  85. public:
  86. virtual DROPEFFECT OnDragOver(CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point)
  87. {
  88. CXTPTaskPanel* pPanel = DYNAMIC_DOWNCAST(CXTPTaskPanel, pWnd);
  89. if (!pPanel)
  90. return DROPEFFECT_NONE;
  92. return pPanel->OnDragOver(pDataObject, dwKeyState, point);
  93. }
  95. virtual void OnDragLeave(CWnd* pWnd)
  96. {
  97. CXTPTaskPanel* pPanel = DYNAMIC_DOWNCAST(CXTPTaskPanel, pWnd);
  99. if (pPanel)
  100. {
  101. pPanel->OnDragOver(NULL, 0, CPoint(-1, -1));
  102. }
  103. }
  104. virtual BOOL OnDrop(CWnd* pWnd, COleDataObject* pDataObject,
  105. DROPEFFECT dropEffect, CPoint point)
  106. {
  107. CXTPTaskPanel* pPanel = DYNAMIC_DOWNCAST(CXTPTaskPanel, pWnd);
  109. if (pPanel)
  110. {
  111. return pPanel->OnDrop(pDataObject, dropEffect, point);
  112. }
  113. return FALSE;
  114. }
  115. };
  117. //////////////////////////////////////////////////////////////////////////
  118. // CXTPTaskPanelScrollButton
  120. CXTPTaskPanelScrollButton::CXTPTaskPanelScrollButton(BOOL bScrollUp)
  121. {
  122. this->bScrollUp = bScrollUp;
  123. bEnabled = FALSE;
  124. bPressed = FALSE;
  125. bHot = FALSE;
  126. rcButton.SetRectEmpty();
  127. pGroupScroll = pGroupCaption = NULL;
  128. }
  130. BOOL CXTPTaskPanelScrollButton::IsVisible() const
  131. {
  132. if (rcButton.IsRectEmpty())
  133. return FALSE;
  134. if (pGroupScroll == NULL)
  135. return FALSE;
  136. if (!bEnabled && !pGroupScroll->GetTaskPanel()->GetPaintManager()->m_bCaptionScrollButton)
  137. return FALSE;
  139. return TRUE;
  140. }
  143. //////////////////////////////////////////////////////////////////////////
  144. // CXTPTaskPanelEditItem
  146. class CXTPTaskPanelEditItem : public CEdit
  147. {
  148. public:
  149. CXTPTaskPanelEditItem();
  151. public:
  152. BOOL Create(CXTPTaskPanelItem* pItem);
  154. protected:
  155. virtual void PostNcDestroy();
  157. protected:
  158. afx_msg void OnKillFocus(CWnd* pNewWnd);
  159. afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
  160. afx_msg UINT OnGetDlgCode();
  162. protected:
  163. BOOL m_bEscapeKey;
  164. CXTPTaskPanelItem* m_pItem;
  166. private:
  167. BOOL Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext = NULL);
  168. BOOL Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID);
  170. protected:
  171. DECLARE_MESSAGE_MAP()
  172. DECLARE_DYNAMIC(CXTPTaskPanelEditItem)
  174. };
  176. AFX_INLINE BOOL CXTPTaskPanelEditItem::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext)
  177. {
  178. return CWnd::Create(lpszClassName, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext);
  179. }
  180. AFX_INLINE BOOL CXTPTaskPanelEditItem::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
  181. {
  182. return CEdit::Create(dwStyle, rect, pParentWnd, nID);
  183. }
  185. IMPLEMENT_DYNAMIC(CXTPTaskPanelEditItem, CEdit)
  187. CXTPTaskPanelEditItem::CXTPTaskPanelEditItem()
  188. {
  189. m_bEscapeKey = FALSE;
  190. m_pItem = NULL;
  191. }
  193. BEGIN_MESSAGE_MAP(CXTPTaskPanelEditItem, CEdit)
  194. //{{AFX_MSG_MAP(CXTPTaskPanelEditItem)
  195. ON_WM_KILLFOCUS()
  196. ON_WM_CHAR()
  197. ON_WM_GETDLGCODE()
  198. //}}AFX_MSG_MAP
  199. END_MESSAGE_MAP()
  201. UINT CXTPTaskPanelEditItem::OnGetDlgCode()
  202. {
  203. return DLGC_WANTALLKEYS;
  204. }
  206. void CXTPTaskPanelEditItem::OnKillFocus(CWnd* /*pNewWnd*/)
  207. {
  208. PostMessage(WM_CLOSE);
  210. if (!m_pItem)
  211. return;
  213. if (!m_bEscapeKey)
  214. {
  215. CString str;
  216. GetWindowText(str);
  218. m_pItem->GetTaskPanel()->OnEndLabelEdit(m_pItem, str);
  219. }
  220. else
  221. {
  222. m_pItem->GetTaskPanel()->OnEndLabelEdit(m_pItem, m_pItem->GetCaption());
  223. }
  224. m_pItem = NULL;
  225. }
  227. void CXTPTaskPanelEditItem::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  228. {
  229. if (nChar == VK_ESCAPE || nChar == VK_RETURN)
  230. {
  231. m_bEscapeKey = (nChar == VK_ESCAPE);
  232. OnKillFocus(NULL);
  234. return;
  235. }
  236. CEdit::OnChar(nChar, nRepCnt, nFlags);
  237. }
  239. void CXTPTaskPanelEditItem::PostNcDestroy()
  240. {
  241. delete this;
  242. }
  244. BOOL CXTPTaskPanelEditItem::Create(CXTPTaskPanelItem* pItem)
  245. {
  246. m_pItem = pItem;
  248. CXTPTaskPanel* pPanel = pItem->GetTaskPanel();
  249. CFont* pFont = m_pItem->GetItemFont();
  251. UINT nFormat = 0;
  252. CRect rc = pItem->GetTextRect(&nFormat);
  253. rc.OffsetRect(0, -pPanel->GetScrollOffset());
  255. CString strText = pItem->GetCaption();
  256. UINT nCenter = nFormat & DT_CENTER ? ES_CENTER : 0;
  258. if (!CEdit::Create(WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | nCenter, rc, pPanel, 0))
  259. return FALSE;
  261. SetFont(pFont);
  262. SetMargins(0, 0);
  263. SetWindowText(strText);
  264. SetFocus();
  265. SetSel(0, -1);
  267. return TRUE;
  268. }
  270. void CXTPTaskPanel::EnableMarkup(BOOL bEnable)
  271. {
  272. XTPMarkupReleaseContext(m_pMarkupContext);
  274. if (bEnable)
  275. {
  276. m_pMarkupContext = XTPMarkupCreateContext();
  277. }
  278. }
  280. void CXTPTaskPanel::RenameItem(CXTPTaskPanelItem* pItem)
  281. {
  282. Reposition(FALSE);
  283. EnsureVisible(pItem);
  284. UpdateWindow();
  286. CXTPTaskPanelEditItem* pEditItem = new CXTPTaskPanelEditItem;
  287. pEditItem->Create(pItem);
  288. }
  290. void CXTPTaskPanel::OnEndLabelEdit(CXTPTaskPanelItem* pItem, LPCTSTR str)
  291. {
  292. XTP_TPNENDLABELEDIT ele;
  293. ele.pItem = pItem;
  294. ele.strNewString = str;
  296. if (NotifyOwner(XTP_TPN_ENDLABELEDIT, (LPARAM)&ele) == XTP_ACTION_CANCEL)
  297. return;
  299. pItem->SetCaption(ele.strNewString);
  300. }
  303. /////////////////////////////////////////////////////////////////////////////
  304. // CXTPTaskPanel
  306. IMPLEMENT_DYNAMIC(CXTPTaskPanel, CWnd)
  308. CXTPTaskPanel::CXTPTaskPanel()
  309. {
  310. RegisterWindowClass();
  312. m_pPaintManager = NULL;
  313. SetTheme(xtpTaskPanelThemeNativeWinXP);
  315. m_pGroups = new CXTPTaskPanelGroups(this);
  316. m_pGroups->m_pOwner = this;
  318. m_nClientHeight = m_nOldClientHeight = 0;
  320. m_rcMargins = CXTPTaskPanelPaintManager::rectDefault;
  321. m_nGroupSpacing = CW_USEDEFAULT;
  323. m_szItemIcon = CSize(16, 16);
  324. m_szGroupIcon = CSize(32, 32);
  326. m_bGrabbingFocus = FALSE;
  327. m_pItemHot = 0;
  328. m_pItemFocused = 0;
  329. m_pItemPressed = 0;
  331. m_nAnimateTimer = 0;
  332. m_bScrollVisible = FALSE;
  334. m_bPreSubclassWindow = TRUE;
  336. m_hHandCursor = AfxGetApp()->LoadStandardCursor(MAKEINTRESOURCE(32649));
  338. if (m_hHandCursor == 0)
  339. m_hHandCursor = XTPResourceManager()->LoadCursor(XTP_IDC_HAND);
  341. m_bExpandable = TRUE;
  343. SetAnimation(xtpTaskPanelAnimationYes);
  345. m_nLockRedraw = 0;
  346. m_nOLEDropMode = 0;
  348. m_bAcceptFocus = TRUE;
  349. m_bDrawFocusRect = FALSE;
  351. m_pImageManager = new CXTPImageManager();
  353. m_itemLayout = xtpTaskItemLayoutDefault;
  354. m_hotTrackStyle = xtpTaskPanelHighlightDefault;
  356. m_panelBehaviour = xtpTaskPanelBehaviourExplorer;
  358. m_pActiveGroup = NULL;
  359. m_bSelectItemOnFocus = FALSE;
  360. m_bSingleSelection = FALSE;
  362. m_nAllowDrag = xtpTaskItemAllowDragNone;
  363. m_bAllowDrop = TRUE;
  365. m_ptPressed = CPoint(0, 0);
  367. m_pItemDragging = m_pItemDragOver = NULL;
  369. OleInitialize(NULL);
  370. m_pDropTarget = new CPanelDropTarget();
  372. m_pScrollButton[TRUE] = new CXTPTaskPanelScrollButton(TRUE);
  373. m_pScrollButton[FALSE] = new CXTPTaskPanelScrollButton(FALSE);
  375. m_bTimerGroupHover = FALSE;
  377. m_pToolTipContext = new CXTPToolTipContext;
  379. m_bMultiColumn = FALSE;
  380. m_nColumnWidth = 100;
  381. m_nGroupMinClientHeight = 0;
  383. m_bInUpdateScrollBar = FALSE;
  385. m_bTabItems = FALSE;
  387. m_pAnimation = new CXTPTaskPanelAnimation(this);
  389. m_pMarkupContext = NULL;
  391. EnableAutomation();
  392. }
  394. BOOL CXTPTaskPanel::RegisterWindowClass(HINSTANCE hInstance /*= NULL*/)
  395. {
  396. return XTPDrawHelpers()->RegisterWndClass(hInstance, _T("XTPTaskPanel"), CS_DBLCLKS);
  397. }
  399. CXTPTaskPanel::~CXTPTaskPanel()
  400. {
  401. CMDTARGET_RELEASE(m_pItemHot);
  403. CMDTARGET_RELEASE(m_pItemFocused);
  405. CMDTARGET_RELEASE(m_pActiveGroup);
  407. if (m_pGroups)
  408. {
  409. m_pGroups->Clear(FALSE);
  410. CMDTARGET_RELEASE(m_pGroups);
  411. }
  413. CMDTARGET_RELEASE(m_pImageManager);
  415. CMDTARGET_RELEASE(m_pToolTipContext);
  417. delete m_pPaintManager;
  418. delete m_pDropTarget;
  420. delete m_pScrollButton[TRUE];
  421. delete m_pScrollButton[FALSE];
  423. delete m_pAnimation;
  425. XTPMarkupReleaseContext(m_pMarkupContext);
  427. OleUninitialize();
  428. }
  430. void CXTPTaskPanel::EnableAnimation(BOOL bEnable)
  431. {
  432. m_pAnimation->m_bAnimation = bEnable;
  433. Redraw();
  434. }
  436. void CXTPTaskPanel::AllowDrag(long nAllowDrag /* = xtpTaskItemAllowDragDefault */)
  437. {
  438. m_nAllowDrag = nAllowDrag;
  439. }
  441. void CXTPTaskPanel::SetImageList(CImageList* pImageList, CSize szItemIcon)
  442. {
  443. if (pImageList)
  444. {
  445. m_pImageManager->SetIcons(*pImageList, 0, 0, 0, xtpImageNormal);
  446. }
  448. m_szItemIcon = szItemIcon;
  449. }
  451. void CXTPTaskPanel::SetGroupImageList(CImageList* pImageList, CSize szGroupIcon /* = CSize */)
  452. {
  453. if (pImageList)
  454. {
  455. m_pImageManager->SetIcons(*pImageList, 0, 0, 0, xtpImageNormal);
  456. }
  458. m_szGroupIcon = szGroupIcon;
  459. }
  460. CXTPImageManager* CXTPTaskPanel::GetImageManager() const
  461. {
  462. return m_pImageManager ? m_pImageManager : XTPImageManager();
  463. }
  465. void CXTPTaskPanel::SetImageManager(CXTPImageManager* pImageManager)
  466. {
  467. if (m_pImageManager)
  468. m_pImageManager->InternalRelease();
  470. m_pImageManager = pImageManager;
  472. Reposition();
  473. }
  476. void CXTPTaskPanel::SetHotItem(CXTPTaskPanelItem* pItem)
  477. {
  478. if (m_pItemHot == pItem)
  479. return;
  481. CXTPTaskPanelItem* pItemHot = m_pItemHot;
  482. m_pItemHot = pItem;
  484. if (pItemHot)
  485. {
  486. pItemHot->RedrawPanel(TRUE);
  487. pItemHot->InternalRelease();
  488. }
  490. if (m_pItemHot)
  491. {
  492. m_pItemHot->RedrawPanel(FALSE);
  493. m_pItemHot->InternalAddRef();
  494. }
  496. if (m_pItemHot)
  497. {
  498. TRACKMOUSEEVENT tme =
  499. {
  500. sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd
  501. };
  502. _TrackMouseEvent(&tme);
  503. }
  505. NotifyOwner(XTP_TPN_HOTITEMCHANGED, 0);
  507. }
  509. void CXTPTaskPanel::EnsureVisibleRect(const CRect& rc)
  510. {
  511. CXTPClientRect rcClient(this);
  512. if (rc.bottom > rcClient.bottom + GetScrollOffset())
  513. {
  514. OnSrollChanged(min(rc.top, rc.bottom - rcClient.Height()));
  515. }
  516. else if (rc.top < GetScrollOffset())
  517. {
  518. OnSrollChanged(rc.top);
  519. }
  520. }
  523. void CXTPTaskPanel::EnsureVisible(CXTPTaskPanelItem* pItem)
  524. {
  525. if (!pItem || !pItem->IsVisible())
  526. return;
  528. CXTPTaskPanelGroup* pGroup = pItem->GetItemGroup();
  529. if (!pGroup)
  530. return;
  532. if (pItem->IsGroup())
  533. {
  534. CRect rc = pGroup->GetCaptionRect();
  535. EnsureVisibleRect(rc);
  536. }
  537. else
  538. {
  539. if (!pGroup->IsExpanded())
  540. pGroup->SetExpanded(TRUE);
  542. CRect rc = pGroup->GetTargetClientRect();
  544. if (IsExplorerBehaviour())
  545. {
  546. CRect rcItem(((CXTPTaskPanelGroupItem*)pItem)->GetItemRect());
  547. rcItem.OffsetRect(0, rc.top);
  549. EnsureVisibleRect(rcItem);
  550. }
  551. else
  552. {
  553. rc.top -= pGroup->GetTargetCaptionRect().Height();
  554. EnsureVisibleRect(rc);
  556. pGroup->EnsureVisible((CXTPTaskPanelGroupItem*)pItem);
  557. }
  558. }
  560. }
  562. void CXTPTaskPanel::GrabFocus()
  563. {
  564. if (m_bAcceptFocus && ::GetFocus() != m_hWnd && m_hWnd)
  565. {
  566. m_bGrabbingFocus = TRUE;
  567. SetFocus();
  568. m_bGrabbingFocus = FALSE;
  569. }
  571. }
  573. void CXTPTaskPanel::SetFocusedItem(CXTPTaskPanelItem* pItem, BOOL bDrawFocusRect, BOOL bSetFocus)
  574. {
  575. if (bDrawFocusRect)
  576. m_bDrawFocusRect = m_bAcceptFocus;
  578. if (bSetFocus) GrabFocus();
  580. if (m_pItemFocused == pItem)
  581. return;
  583. if (m_hWnd) EnsureVisible(pItem);
  586. CXTPTaskPanelItem* pItemFocused = m_pItemFocused;
  587. m_pItemFocused = pItem;
  589. if (pItemFocused)
  590. {
  591. pItemFocused->RedrawPanel(FALSE);
  592. pItemFocused->InternalRelease();
  593. }
  595. if (m_pItemFocused)
  596. {
  597. m_pItemFocused->RedrawPanel(FALSE);
  598. m_pItemFocused->InternalAddRef();
  599. }
  601. if (m_bSelectItemOnFocus && IsItemLink(pItem) && !m_bSingleSelection)
  602. {
  603. pItem->GetItemGroup()->SetSelectedItem(((CXTPTaskPanelGroupItem*)pItem));
  604. }
  606. if (!GetSafeHwnd())
  607. return;
  609. NotifyOwner(XTP_TPN_FOCUSEDITEMCHANGED, 0);
  611. if (m_pItemFocused)
  612. {
  613. AccessibleNotifyWinEvent(EVENT_OBJECT_FOCUS, m_hWnd, OBJID_CLIENT, GetAccessibleIndex(m_pItemFocused));
  614. }
  616. if (bSetFocus && m_pItemFocused && m_pItemFocused->GetType() == xtpTaskItemTypeControl)
  617. {
  618. ::SetFocus(((CXTPTaskPanelGroupItem*)m_pItemFocused)->GetControlHandle());
  619. }
  620. }
  622. int CXTPTaskPanel::GetGroupCount() const
  623. {
  624. return m_pGroups->GetCount();
  625. }
  627. BOOL CXTPTaskPanel::IsDirty() const
  628. {
  629. for (int i = 0; i < GetGroupCount(); i++)
  630. {
  631. if (GetAt(i)->IsDirty())
  632. return TRUE;
  633. }
  634. return FALSE;
  635. }
  637. void CXTPTaskPanel::SetMargins(long nLeft, long nTop, long nRight, long nBottom, long nMiddle)
  638. {
  639. m_rcMargins.SetRect(nLeft, nTop, nRight, nBottom);
  640. m_nGroupSpacing = nMiddle;
  641. Reposition();
  642. }
  645. BOOL CXTPTaskPanel::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
  646. {
  647. if (!CreateEx(0, _T("XTPTaskPanel"), NULL, dwStyle, rect, pParentWnd, nID))
  648. {
  649. return FALSE;
  650. }
  652. m_pDropTarget->Register(this);
  653. m_nAnimateTimer = 0;
  655. return TRUE;
  656. }
  659. CXTPTaskPanelGroup* CXTPTaskPanel::AddGroup(UINT nID, int nImage)
  660. {
  661. CXTPTaskPanelGroup* pGroup = (CXTPTaskPanelGroup*)m_pGroups->Add(new CXTPTaskPanelGroup(this), nID);
  662. pGroup->SetIconIndex(nImage);
  663. return pGroup;
  664. }
  666. CXTPTaskPanelGroup* CXTPTaskPanel::FindGroup(UINT nID) const
  667. {
  668. return (CXTPTaskPanelGroup*)m_pGroups->Find(nID);
  669. }
  671. CXTPTaskPanelGroupItem* CXTPTaskPanel::FindItem(UINT nID) const
  672. {
  673. for (int i = 0; i < GetGroupCount(); i++)
  674. {
  675. CXTPTaskPanelGroupItem* pItem = GetAt(i)->FindItem(nID);
  676. if (pItem)
  677. {
  678. return pItem;
  679. }
  680. }
  681. return NULL;
  682. }
  684. CXTPTaskPanelGroup* CXTPTaskPanel::GetAt(int nIndex) const
  685. {
  686. return (CXTPTaskPanelGroup*)m_pGroups->GetAt(nIndex);
  687. }
  689. void CXTPTaskPanel::SetTheme(XTPTaskPanelPaintTheme paintTheme)
  690. {
  691. if (m_pPaintManager)
  692. {
  693. delete m_pPaintManager;
  694. }
  696. if (paintTheme == xtpTaskPanelThemeOfficeXPPlain) m_pPaintManager = new CXTPTaskPanelOfficeXPThemePlain();
  697. else if (paintTheme == xtpTaskPanelThemeToolbox) m_pPaintManager = new CXTPTaskPanelToolboxTheme();
  698. else if (paintTheme == xtpTaskPanelThemeToolboxWhidbey) m_pPaintManager = new CXTPTaskPanelToolboxWhidbeyTheme();
  699. else if (paintTheme == xtpTaskPanelThemeListView) m_pPaintManager = new CXTPTaskPanelListViewTheme();
  700. else if (paintTheme == xtpTaskPanelThemeListViewOfficeXP) m_pPaintManager = new CXTPTaskPanelListViewOfficeXPTheme();
  701. else if (paintTheme == xtpTaskPanelThemeListViewOffice2003) m_pPaintManager = new CXTPTaskPanelListViewOffice2003Theme();
  702. else if (paintTheme == xtpTaskPanelThemeOffice2000Plain) m_pPaintManager = new CXTPTaskPanelPaintManagerPlain();
  703. else if (paintTheme == xtpTaskPanelThemeOffice2003Plain) m_pPaintManager = new CXTPTaskPanelOffice2003ThemePlain();
  704. else if (paintTheme == xtpTaskPanelThemeNativeWinXPPlain) m_pPaintManager = new CXTPTaskPanelExplorerThemePlain();
  705. else if (paintTheme == xtpTaskPanelThemeOffice2000) m_pPaintManager = new CXTPTaskPanelPaintManager();
  706. else if (paintTheme == xtpTaskPanelThemeOffice2003) m_pPaintManager = new CXTPTaskPanelOffice2003Theme();
  707. else if (paintTheme == xtpTaskPanelThemeShortcutBarOffice2003) m_pPaintManager = new CXTPTaskPanelShortcutBarOffice2003Theme();
  708. else if (paintTheme == xtpTaskPanelThemeShortcutBarOffice2007) m_pPaintManager = new CXTPTaskPanelShortcutBarOffice2007Theme();
  709. else m_pPaintManager = new CXTPTaskPanelExplorerTheme();
  711. m_paintTheme = paintTheme;
  713. m_pPaintManager->RefreshMetrics();
  715. Reposition();
  717. }
  718. void CXTPTaskPanel::SetCustomTheme(CXTPTaskPanelPaintManager* pPaintManager)
  719. {
  720. delete m_pPaintManager;
  721. m_pPaintManager = pPaintManager;
  723. if (m_pPaintManager)
  724. {
  725. m_pPaintManager->RefreshMetrics();
  726. }
  728. m_paintTheme = xtpTaskPanelThemeCustom;
  730. Reposition();
  731. }
  735. BEGIN_MESSAGE_MAP(CXTPTaskPanel, CWnd)
  736. //{{AFX_MSG_MAP(CXTPTaskPanel)
  737. ON_WM_ERASEBKGND()
  738. ON_WM_PAINT()
  739. ON_WM_SIZE()
  740. ON_WM_VSCROLL()
  741. ON_WM_MOUSEMOVE()
  742. ON_WM_SETCURSOR()
  743. ON_WM_LBUTTONUP()
  744. ON_WM_DESTROY()
  745. ON_WM_TIMER()
  746. ON_WM_SYSCOLORCHANGE()
  747. ON_WM_SETTINGCHANGE()
  748. ON_WM_RBUTTONDOWN()
  749. ON_WM_RBUTTONUP()
  750. ON_WM_SETFOCUS()
  751. ON_WM_KILLFOCUS()
  752. ON_WM_KEYDOWN()
  753. ON_WM_KEYUP()
  754. ON_WM_SYSKEYDOWN()
  755. ON_WM_SYSKEYUP()
  756. ON_WM_LBUTTONDOWN()
  757. ON_WM_LBUTTONDBLCLK()
  758. ON_WM_MOUSEWHEEL()
  759. ON_WM_GETDLGCODE()
  760. ON_WM_CAPTURECHANGED()
  761. //}}AFX_MSG_MAP
  762. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  763. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  764. ON_MESSAGE(WM_GETOBJECT, OnGetObject)
  766. END_MESSAGE_MAP()
  769. /////////////////////////////////////////////////////////////////////////////
  770. // CXTPTaskPanel message handlers
  772. BOOL CXTPTaskPanel::OnEraseBkgnd(CDC* /*pDC*/)
  773. {
  774. return TRUE;
  775. }
  777. void CXTPTaskPanel::OnPaint()
  778. {
  779. CPaintDC paintDC(this);
  780. m_pAnimation->OnPaint(paintDC);
  781. }
  783. LRESULT CXTPTaskPanel::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  784. {
  785. CDC* pDC = CDC::FromHandle((HDC)wParam);
  786. if (pDC)
  787. {
  788. OnDraw(pDC, CXTPClientRect(this));
  789. }
  791. return TRUE;
  792. }
  794. void CXTPTaskPanel::Redraw(LPCRECT lpRect, BOOL bAnimate)
  795. {
  796. if (m_nLockRedraw > 0)
  797. {
  798. return;
  799. }
  801. if (m_hWnd && IsWindowVisible())
  802. {
  803. m_pAnimation->RedrawRect(lpRect, bAnimate);
  804. }
  805. }
  807. void CXTPTaskPanel::OnDraw(CDC* pDC, CRect rcClipBox)
  808. {
  809. CPoint pt = pDC->GetViewportOrg();
  810. pDC->SetViewportOrg(pt.x, pt.y - GetScrollOffset());
  812. m_pPaintManager->FillTaskPanel(pDC, this);
  814. for (int i = 0; i < GetGroupCount(); i++)
  815. {
  816. CXTPTaskPanelGroup* pGroup = GetAt(i);
  817. if (!pGroup->IsVisible())
  818. continue;
  820. if (CRect().IntersectRect(pGroup->GetInvalidateRect(), rcClipBox))
  821. {
  822. pGroup->OnPaint(pDC);
  823. }
  824. }
  826. m_pPaintManager->DrawScrollButton(pDC, m_pScrollButton[TRUE]);
  827. m_pPaintManager->DrawScrollButton(pDC, m_pScrollButton[FALSE]);
  829. pDC->SetViewportOrg(pt);
  830. }
  833. void CXTPTaskPanel::SetLockRedraw(BOOL bLockRedraw)
  834. {
  835. m_nLockRedraw += bLockRedraw ? +1 : -1;
  836. ASSERT(m_nLockRedraw >= 0);
  838. if (m_nLockRedraw == 0)
  839. Reposition();
  840. }
  842. void CXTPTaskPanel::UpdateScrollButtons()
  843. {
  845. m_pScrollButton[TRUE]->bEnabled = m_pScrollButton[TRUE]->pGroupScroll ? m_pScrollButton[TRUE]->pGroupScroll->IsScrollButtonEnabled(TRUE) : FALSE;
  846. m_pScrollButton[FALSE]->bEnabled = m_pScrollButton[FALSE]->pGroupScroll ? m_pScrollButton[FALSE]->pGroupScroll->IsScrollButtonEnabled(FALSE) : FALSE;
  847. }
  849. void CXTPTaskPanel::OnClickScrollButton(CXTPTaskPanelScrollButton* pScrollButton)
  850. {
  851. if (!pScrollButton->bEnabled)
  852. return;
  854. pScrollButton->bPressed = TRUE;
  856. SetCapture();
  858. CXTPTaskPanelGroup* pActiveGroup = m_pActiveGroup;
  860. int nScrollOffset = (pScrollButton->bScrollUp ? -1 : +1) * pActiveGroup->GetItemsInRow();
  861. pActiveGroup->Scroll(nScrollOffset);
  863. Redraw();
  865. SetTimer(TID_SCROLLGROUP, 500, NULL);
  866. BOOL bQuick = FALSE;
  868. while (CWnd::GetCapture() == this && pScrollButton->bEnabled)
  869. {
  870. MSG msg;
  872. if (!GetMessageExt(msg))
  873. break;
  875. if (msg.message == WM_TIMER && msg.wParam == TID_SCROLLGROUP)
  876. {
  877. pActiveGroup->Scroll(nScrollOffset);
  878. Redraw();
  880. if (!bQuick)
  881. {
  882. KillTimer(TID_SCROLLGROUP);
  883. SetTimer(TID_SCROLLGROUP, 50, NULL);
  884. bQuick = TRUE;
  885. }
  886. }
  887. else if (msg.message == WM_LBUTTONUP) break;
  888. else if (msg.message == WM_MOUSEMOVE)
  889. {
  890. }
  891. else if (msg.message == WM_KEYDOWN)
  892. {
  893. if (msg.wParam == VK_ESCAPE)
  894. break;
  895. }
  896. else
  897. DispatchMessage(&msg);
  899. }
  900. pScrollButton->bPressed = FALSE;
  902. ReleaseCapture();
  903. Redraw();
  904. }
  907. void CXTPTaskPanel::RepositionScrollButtons()
  908. {
  909. m_pScrollButton[FALSE]->rcButton.SetRectEmpty();
  910. m_pScrollButton[TRUE]->rcButton.SetRectEmpty();
  911. m_pScrollButton[TRUE]->pGroupCaption = m_pScrollButton[FALSE]->pGroupCaption = NULL;
  913. if (IsExplorerBehaviour() || !m_pActiveGroup || !m_pActiveGroup->IsVisible())
  914. return;
  916. m_pScrollButton[TRUE]->pGroupScroll = m_pScrollButton[FALSE]->pGroupScroll = m_pActiveGroup;
  918. if (GetPaintManager()->m_bCaptionScrollButton)
  919. {
  920. CXTPClientRect rc(this);
  921. rc.bottom = max(rc.bottom, m_nClientHeight);
  922. CRect rcMargins = GetPaintManager()->GetControlMargins(this);
  924. m_pScrollButton[TRUE]->pGroupCaption = m_pActiveGroup;
  926. CRect rcCaption = m_pActiveGroup->GetCaptionRect();
  927. int nRight = rc.right - rcMargins.right - GetPaintManager()->GetGroupOuterMargins(m_pActiveGroup).right;
  929. int nHeight = rcCaption.Height();
  930. m_pScrollButton[TRUE]->rcButton.SetRect(nRight - nHeight, rcCaption.top, nRight, rcCaption.bottom);
  932. CXTPTaskPanelGroup* pGroupNext = GetNextVisibleGroup(m_pActiveGroup->GetIndex());
  933. if (pGroupNext == 0)
  934. {
  935. m_pScrollButton[FALSE]->rcButton.SetRect(nRight - nHeight, rc.bottom - rcMargins.bottom - nHeight,
  936. nRight, rc.bottom - rcMargins.bottom);
  937. }
  938. else
  939. {
  940. m_pScrollButton[FALSE]->pGroupCaption = pGroupNext;
  942. CRect rcNextCaption = pGroupNext->GetCaptionRect();
  943. int nButtonRight = rc.right - rcMargins.right - GetPaintManager()->GetGroupOuterMargins(pGroupNext).right;
  945. m_pScrollButton[FALSE]->rcButton.SetRect(nButtonRight - rcNextCaption.Height(), rcNextCaption.top, nButtonRight, rcNextCaption.bottom);
  946. }
  947. }
  948. else
  949. {
  950. CRect rc = m_pActiveGroup->GetClientRect();
  951. rc.DeflateRect(4, 4);
  952. int nHeight = 16;
  954. m_pScrollButton[TRUE]->rcButton.SetRect(rc.right - nHeight, rc.top, rc.right, rc.top + nHeight);
  955. m_pScrollButton[FALSE]->rcButton.SetRect(rc.right - nHeight, rc.bottom - nHeight, rc.right, rc.bottom);
  957. }
  959. UpdateScrollButtons();
  960. }
  962. void CXTPTaskPanel::Reposition(BOOL bRecalcOnly)
  963. {
  964. if (!GetSafeHwnd())
  965. return;
  967. if (m_nLockRedraw > 0)
  968. return;
  970. CXTPClientRect rc(this);
  972. CRect rcMargins = GetPaintManager()->GetControlMargins(this);
  973. int nGroupSpacing = GetPaintManager()->GetGroupSpacing(this);
  975. int nCurPos = rcMargins.top, nGroupCount = GetGroupCount(), i;
  976. rc.DeflateRect(rcMargins.left, 0, rcMargins.right, 0);
  978. {
  979. CClientDC dc(this);
  980. for (i = 0; i < nGroupCount; i++)
  981. {
  982. CXTPTaskPanelGroup* pGroup = GetAt(i);
  983. if (!pGroup->IsVisible())
  984. continue;
  986. pGroup->OnCalcClientHeight(&dc, rc);
  987. }
  988. }
  991. BOOL bFirstVisbleGroup = TRUE;
  993. for (i = 0; i < nGroupCount; i++)
  994. {
  995. CXTPTaskPanelGroup* pGroup = GetAt(i);
  996. if (!pGroup->IsVisible())
  997. {
  998. pGroup->OnAnimate(0);
  999. continue;
  1000. }
  1002. if (!bFirstVisbleGroup)
  1003. {
  1004. nCurPos += nGroupSpacing;
  1005. }
  1006. else bFirstVisbleGroup = FALSE;
  1008. CRect rcGroup = pGroup->OnReposition(CRect(rc.left, nCurPos, rc.right, nCurPos), bRecalcOnly);
  1010. nCurPos = rcGroup.bottom + GetPaintManager()->GetGroupOuterMargins(pGroup).bottom;
  1011. }
  1012. nCurPos += rcMargins.bottom;
  1014. m_nClientHeight = nCurPos;
  1016. RepositionScrollButtons();
  1018. m_nAnimationStep = 10;
  1020. BOOL bDirty = IsDirty();
  1021. if (m_nAnimateTimer == 0 && bDirty)
  1022. {
  1023. m_nAnimateTimer = SetTimer(TID_REPOSITION, 30, NULL);
  1024. }
  1025. else if (m_nAnimateTimer != 0 && !bDirty)
  1026. {
  1027. KillTimer(m_nAnimateTimer);
  1028. m_nAnimateTimer = 0;
  1029. }
  1031. UpdateScrollBar();
  1033. if (!m_bAnimation)
  1034. AnimateGroups(FALSE);
  1036. Redraw();
  1037. }
  1039. void CXTPTaskPanel::OnClientHeightChanged()
  1040. {
  1042. }
  1044. void CXTPTaskPanel::UpdateScrollBar()
  1045. {
  1046. if (m_bInUpdateScrollBar)
  1047. return;
  1049. m_bInUpdateScrollBar = TRUE;
  1050. if (m_nClientHeight != m_nOldClientHeight)
  1051. {
  1052. m_nOldClientHeight = m_nClientHeight;
  1053. OnClientHeightChanged();
  1054. }
  1057. CXTPClientRect rc(this);
  1058. m_bScrollVisible = rc.Height() < m_nClientHeight;
  1060. ShowScrollBar(SB_VERT, m_bScrollVisible);
  1062. if (m_bScrollVisible)
  1063. {
  1064. SCROLLINFO  si ;
  1066. si.cbSize = sizeof(SCROLLINFO) ;
  1067. si.fMask = SIF_PAGE | SIF_RANGE ;
  1069. GetScrollInfo(SB_VERT, &si, si.fMask);
  1071. UINT nControlHeight = (UINT)rc.Height();
  1073. if (si.nPage != nControlHeight || si.nMax != m_nClientHeight - 1 || si.nMin != 0)
  1074. {
  1075. si.nPage = nControlHeight ;
  1076. si.nMax = m_nClientHeight - 1;
  1077. si.nMin = 0 ;
  1078. si.fMask = SIF_PAGE | SIF_RANGE ;
  1079. SetScrollInfo(SB_VERT, &si) ;
  1080. AnimateGroups(FALSE);
  1081. }
  1082. EnableScrollBarCtrl(SB_VERT, TRUE);
  1083. }
  1085. m_bInUpdateScrollBar = FALSE;
  1087. if (::GetWindow(m_hWnd, GW_CHILD))
  1088. {
  1089. RedrawWindow(0, 0, RDW_INVALIDATE | RDW_ALLCHILDREN);
  1090. }
  1091. }
  1093. void CXTPTaskPanel::OnSize(UINT nType, int cx, int cy)
  1094. {
  1095. Reposition(IsExplorerBehaviour());
  1098. CWnd::OnSize(nType, cx, cy);
  1100. }
  1102. int CXTPTaskPanel::GetScrollOffset() const
  1103. {
  1104. if (!m_bScrollVisible)
  1105. return 0;
  1107. return GetScrollPos(SB_VERT);
  1108. }
  1110. int CXTPTaskPanel::GetClientHeight() const
  1111. {
  1112. return m_nClientHeight;
  1113. }
  1115. void CXTPTaskPanel::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  1116. {
  1117. if (pScrollBar != NULL)
  1118. {
  1119. CWnd::OnVScroll(nSBCode, nPos, pScrollBar);
  1120. return;
  1121. }
  1123. // its horizontal scroll bar
  1124. int nCurPos = GetScrollPos(SB_VERT);
  1126. // decide what to do for each diffrent scroll event
  1127. switch (nSBCode)
  1128. {
  1129. case SB_LEFT: nCurPos = 0; break;
  1130. case SB_RIGHT: nCurPos = GetScrollLimit(SB_VERT); break;
  1131. case SB_LINELEFT: nCurPos = max(nCurPos - 6, 0); break;
  1132. case SB_LINERIGHT: nCurPos = min(nCurPos + 6, GetScrollLimit(SB_VERT)); break;
  1133. case SB_PAGELEFT: nCurPos = max(nCurPos - CXTPClientRect(this).Height(), 0); break;
  1134. case SB_PAGERIGHT: nCurPos = min(nCurPos + CXTPClientRect(this).Height(), GetScrollLimit(SB_VERT)); break;
  1136. case SB_THUMBTRACK:
  1137. case SB_THUMBPOSITION:  nCurPos = nPos; break;
  1138. }
  1140. OnSrollChanged(nCurPos);
  1141. }
  1143. void CXTPTaskPanel::OnSrollChanged(int nCurPos)
  1144. {
  1145. SetScrollPos(SB_VERT, nCurPos);
  1146. AnimateGroups(FALSE);
  1148. Redraw();
  1150. if (::GetWindow(m_hWnd, GW_CHILD))
  1151. {
  1152. RedrawWindow(0, 0, RDW_INVALIDATE | RDW_ALLCHILDREN);
  1153. }
  1154. }
  1156. CXTPTaskPanelScrollButton* CXTPTaskPanel::HitTestScrollButton(CPoint point) const
  1157. {
  1158. point.y += GetScrollOffset();
  1160. for (int i = 0; i < 2; i++)
  1161. {
  1162. if (m_pScrollButton[i]->IsVisible() && m_pScrollButton[i]->rcButton.PtInRect(point))
  1163. return m_pScrollButton[i];
  1164. }
  1166. return 0;
  1167. }
  1169. CXTPTaskPanelGroup* CXTPTaskPanel::HitTestGroup(CPoint point, BOOL* pbCaption) const
  1170. {
  1171. if (HitTestScrollButton(point))
  1172. return 0;
  1174. point.y += GetScrollOffset();
  1176. int nGroupCount = GetGroupCount();
  1178. for (int i = 0; i < nGroupCount; i++)
  1179. {
  1180. CXTPTaskPanelGroup* pGroup = GetAt(i);
  1181. if (!pGroup->IsVisible())
  1182. continue;
  1184. if (pGroup->GetClientRect().PtInRect(point))
  1185. {
  1186. if (pbCaption) *pbCaption = FALSE;
  1187. return pGroup;
  1188. }
  1189. if (pGroup->IsCaptionVisible() && pGroup->GetCaptionRect().PtInRect(point))
  1190. {
  1191. if (pbCaption) *pbCaption = TRUE;
  1192. return pGroup;
  1193. }
  1195. }
  1196. return NULL;
  1197. }
  1199. CXTPTaskPanelItem* CXTPTaskPanel::HitTestItem(CPoint point, BOOL bClientAvail) const
  1200. {
  1201. BOOL bCaption;
  1202. CXTPTaskPanelGroup* pGroup = HitTestGroup(point, &bCaption);
  1204. if (!pGroup)
  1205. return NULL;
  1207. if (bCaption)
  1208. return pGroup;
  1210. CXTPTaskPanelGroupItem* pItem = pGroup->HitTest(point);
  1211. if (pItem)
  1212. return pItem;
  1214. if (bClientAvail)
  1215. return pGroup;
  1217. return NULL;
  1218. }
  1220. void CXTPTaskPanel::OnClick(CXTPTaskPanelGroupItem* pItem)
  1221. {
  1222. ASSERT(pItem);
  1223. NotifyOwner(XTP_TPN_CLICK, (LPARAM)pItem);
  1224. }
  1226. void CXTPTaskPanel::OnRButtonDown(UINT nFlags, CPoint point)
  1227. {
  1228. CXTPTaskPanelItem* pItem = HitTestItem(point);
  1230. if (pItem && pItem->IsAcceptFocus())
  1231. {
  1232. SetFocusedItem(pItem);
  1233. }
  1235. if (pItem)
  1236. {
  1237. NotifyOwner(XTP_TPN_RCLICK, (LPARAM)pItem);
  1238. }
  1241. CWnd::OnRButtonDown(nFlags, point);
  1242. }
  1244. void CXTPTaskPanel::OnRButtonUp(UINT nFlags, CPoint point)
  1245. {
  1247. CWnd::OnRButtonUp(nFlags, point);
  1248. }
  1250. void CXTPTaskPanel::OnLButtonDown(UINT nFlags, CPoint point)
  1251. {
  1252. CXTPTaskPanelItem* pItem = HitTestItem(point);
  1254. if (pItem && pItem->IsAcceptFocus())
  1255. {
  1256. SetFocusedItem(pItem);
  1257. }
  1258. else
  1259. {
  1260. GrabFocus();
  1262. }
  1264. if (pItem && pItem->IsAcceptFocus())
  1265. {
  1266. SetCapture();
  1267. m_pItemPressed = pItem;
  1268. m_ptPressed = point;
  1269. m_pItemPressed->RedrawPanel();
  1270. }
  1272. CXTPTaskPanelScrollButton* pScrollButton = HitTestScrollButton(point);
  1274. if (pScrollButton)
  1275. {
  1276. OnClickScrollButton(pScrollButton);
  1277. }
  1280. CWnd::OnLButtonDown(nFlags, point);
  1281. }
  1283. void CXTPTaskPanel::OnLButtonDblClk(UINT nFlags, CPoint point)
  1284. {
  1285. OnLButtonDown(nFlags, point);
  1287. if (m_pItemHot && m_pItemPressed == m_pItemHot && !m_pItemHot->IsGroup())
  1288. {
  1289. NotifyOwner(XTP_TPN_DBLCLICK, (LPARAM)(CXTPTaskPanelGroupItem*)m_pItemPressed);
  1290. }
  1291. }
  1293. void CXTPTaskPanel::OnLButtonUp(UINT /*nFlags*/, CPoint point)
  1294. {
  1295. UNREFERENCED_PARAMETER(point);
  1297. if (m_pItemPressed == NULL)
  1298. {
  1299. return;
  1300. }
  1302. CXTPTaskPanelItem* pItemPressed = m_pItemPressed;
  1303. m_pItemPressed = NULL;
  1305. ReleaseCapture();
  1306. pItemPressed->RedrawPanel();
  1310. if (pItemPressed == m_pItemHot)
  1311. {
  1312. if (IsItemGroup(pItemPressed))
  1313. {
  1314. CXTPTaskPanelGroup* pGroup = (CXTPTaskPanelGroup*)pItemPressed;
  1315. pGroup->SetExpanded(!pGroup->IsExpanded());
  1316. }
  1317. else
  1318. {
  1319. OnClick((CXTPTaskPanelGroupItem*)pItemPressed);
  1320. }
  1321. }
  1322. }
  1324. void CXTPTaskPanel::OnCaptureChanged(CWnd* pWnd)
  1325. {
  1326. if (m_pItemPressed)
  1327. {
  1328. m_pItemPressed = NULL;
  1329. Redraw();
  1330. }
  1332. CWnd::OnCaptureChanged(pWnd);
  1333. }
  1335. void CXTPTaskPanel::OnStartItemDrag(CXTPTaskPanelGroupItem* pItem)
  1336. {
  1337. BOOL bAllowDrag = pItem->IsAllowDrag();
  1338. if (bAllowDrag == xtpTaskItemAllowDragNone)
  1339. return;
  1341. ASSERT(pItem);
  1342. ReleaseCapture();
  1344. BOOL bAllowDragOutsideControl = (bAllowDrag & xtpTaskItemAllowDragMoveOutsideControl) ||
  1345. (bAllowDrag & xtpTaskItemAllowDragCopyOutsideControl);
  1347. if (NotifyOwner(XTP_TPN_STARTDRAG, (LPARAM)pItem) == XTP_ACTION_CANCEL)
  1348. return;
  1350. COleDataSource ds;
  1351. if (!pItem->PrepareDrag(ds, bAllowDragOutsideControl))
  1352. return;
  1354. m_pItemDragging = pItem;
  1356. DROPEFFECT dropEffectMask =
  1357. ((bAllowDrag & xtpTaskItemAllowDragCopyWithinGroup) ||
  1358. (bAllowDrag & xtpTaskItemAllowDragCopy) ? DROPEFFECT_COPY : 0) +
  1359. ((bAllowDrag & xtpTaskItemAllowDragMoveWithinGroup) ||
  1360. (bAllowDrag & xtpTaskItemAllowDragMove) ? DROPEFFECT_MOVE : 0);
  1362. DROPEFFECT dropEffect = ds.DoDragDrop(dropEffectMask);
  1364. if ((dropEffect == DROPEFFECT_MOVE) && (dropEffectMask & DROPEFFECT_MOVE))
  1365. {
  1366. m_pItemDragging->Remove();
  1367. }
  1369. m_pItemDragOver = m_pItemDragging = NULL;
  1370. }
  1372. DROPEFFECT CXTPTaskPanel::OnDragOver(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point)
  1373. {
  1374. DROPEFFECT dropEffectMask = DROPEFFECT_COPY + DROPEFFECT_MOVE;
  1376. BOOL bCaption;
  1377. CXTPTaskPanelGroup* pGroup = HitTestGroup(point, &bCaption);
  1379. CXTPTaskPanelItem* pItemDragOverOld = m_pItemDragOver;
  1381. if (pGroup && pGroup->IsAllowDrop())
  1382. {
  1383. m_pItemDragOver = pGroup;
  1385. if (!bCaption)
  1386. {
  1387. CRect rcItem;
  1388. CXTPTaskPanelItem* pItem = pGroup->HitTest(point, &rcItem);
  1390. if (pItem && pItem->IsAllowDrop())
  1391. {
  1392. if (!GetPaintManager()->m_bInvertDragRect)
  1393. {
  1394. pItem = rcItem.CenterPoint().y > point.y ? pItem : pGroup->GetNextVisibleItem(pItem->GetIndex());
  1395. }
  1397. if (pItem)
  1398. {
  1399. m_pItemDragOver = pItem;
  1400. }
  1401. }
  1402. }
  1403. }
  1404. else
  1405. {
  1406. m_pItemDragOver = NULL;
  1407. }
  1409. DROPEFFECT dropEffect = DROPEFFECT_NONE;
  1411. if (m_pItemDragOver && m_nOLEDropMode)
  1412. {
  1413. dropEffect = DROPEFFECT_MOVE;
  1415. if (dropEffect == DROPEFFECT_NONE)
  1416. m_pItemDragOver = 0;
  1417. }
  1418. else
  1419. {
  1420. if (!pDataObject || !pDataObject->IsDataAvailable(GetClipboardFormat()))
  1421. m_pItemDragOver = NULL;
  1423. if (pDataObject && !pDataObject->IsDataAvailable(CF_TEXT) && (m_pItemDragging == 0))
  1424. m_pItemDragOver = NULL;
  1427. if (m_pItemDragging)
  1428. {
  1429. BOOL bAllowDrag = m_pItemDragging->IsAllowDrag();
  1431. if (((bAllowDrag & xtpTaskItemAllowDragMoveWithinGroup) == 0) &&
  1432. ((bAllowDrag & xtpTaskItemAllowDragMoveWithinControl) == 0))
  1433. dropEffectMask &= ~DROPEFFECT_MOVE;
  1435. if (((bAllowDrag & xtpTaskItemAllowDragCopyWithinGroup) == 0) &&
  1436. ((bAllowDrag & xtpTaskItemAllowDragCopyWithinControl) == 0))
  1437. dropEffectMask &= ~DROPEFFECT_COPY;
  1439. if (m_pItemDragOver && m_pItemDragging->GetItemGroup() != pGroup)
  1440. {
  1441. if (bAllowDrag & xtpTaskItemAllowDragMoveWithinGroup)
  1442. dropEffectMask &= ~DROPEFFECT_MOVE;
  1444. if (bAllowDrag & xtpTaskItemAllowDragCopyWithinGroup)
  1445. dropEffectMask &= ~DROPEFFECT_COPY;
  1446. }
  1448. if (m_pItemDragOver)
  1449. {
  1450. if (((bAllowDrag & xtpTaskItemAllowDragMoveWithinControl) == 0) &&
  1451. ((bAllowDrag & xtpTaskItemAllowDragMoveWithinGroup) == 0))
  1452. dropEffectMask &= ~DROPEFFECT_MOVE;
  1454. if (((bAllowDrag & xtpTaskItemAllowDragCopyWithinControl) == 0) &&
  1455. ((bAllowDrag & xtpTaskItemAllowDragCopyWithinGroup) == 0))
  1456. dropEffectMask &= ~DROPEFFECT_COPY;
  1457. }
  1459. if (dropEffectMask == 0)
  1460. m_pItemDragOver = 0;
  1461. }
  1462. }
  1465. if (pItemDragOverOld != m_pItemDragOver)
  1466. {
  1467. Redraw();
  1468. }
  1470. BOOL bGroupHover = IsItemGroup(m_pItemDragOver) && !((CXTPTaskPanelGroup*)m_pItemDragOver)->IsExpanded();
  1472. if (bGroupHover && !m_bTimerGroupHover)
  1473. {
  1474. UINT nHoverTime = 500;
  1475. SystemParametersInfo(SPI_GETMOUSEHOVERTIME, 0, &nHoverTime, 0);
  1477. SetTimer(TID_GROUPHOVER, nHoverTime, NULL);
  1478. m_bTimerGroupHover = TRUE;
  1479. }
  1480. if (!bGroupHover && m_bTimerGroupHover)
  1481. {
  1482. KillTimer(TID_GROUPHOVER);
  1483. m_bTimerGroupHover = FALSE;
  1484. }
  1487. if (!m_pItemDragOver)
  1488. return DROPEFFECT_NONE;
  1490. if (dropEffect != DROPEFFECT_NONE)
  1491. return dropEffect;
  1493. if (dropEffectMask & DROPEFFECT_COPY)
  1494. {
  1495. if (((dwKeyState & MK_CONTROL) == MK_CONTROL) || ((dropEffectMask & DROPEFFECT_MOVE) == 0))
  1496. return DROPEFFECT_COPY;
  1497. }
  1499. return dropEffectMask & DROPEFFECT_MOVE ? DROPEFFECT_MOVE : DROPEFFECT_NONE;
  1500. }
  1502. BOOL CXTPTaskPanel::OnDrop(COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point)
  1503. {
  1504. point;
  1506. if (!m_pItemDragOver)
  1507. return FALSE;
  1509. CXTPTaskPanelItem* pItemDragOver = m_pItemDragOver;
  1510. m_pItemDragOver = NULL;
  1512. Redraw();
  1514. if (dropEffect != DROPEFFECT_COPY && dropEffect != DROPEFFECT_MOVE)
  1515. return FALSE;
  1517. if (m_nOLEDropMode && pDataObject)
  1518. {
  1520. return dropEffect != DROPEFFECT_NONE;
  1521. }
  1523. if (!pDataObject || !pDataObject->IsDataAvailable(GetClipboardFormat()))
  1524. return FALSE;
  1526. CXTPTaskPanelItem* pItemDrop = CXTPTaskPanelItem::CreateFromOleData(pDataObject);
  1528. if (!pItemDrop)
  1529. return FALSE;
  1531. if (IsItemGroup(pItemDragOver))
  1532. {
  1533. CXTPTaskPanelItems* pItems = ((CXTPTaskPanelGroup*)pItemDragOver)->GetItems();
  1534. pItems->InsertAt(pItems->GetCount(), pItemDrop);
  1535. }
  1536. else
  1537. {
  1538. CXTPTaskPanelItems* pItems = pItemDragOver->GetParentItems();
  1540. int nIndex = pItemDragOver->GetIndex();
  1542. if (GetPaintManager()->m_bInvertDragRect)
  1543. {
  1544. nIndex++;
  1546. if (m_pItemDragging && m_pItemDragging->GetParentItems() == pItems)
  1547. {
  1548. if (m_pItemDragging->GetIndex() >= nIndex)
  1549. nIndex--;
  1550. }
  1551. }
  1553. pItems->InsertAt(nIndex, pItemDrop);
  1554. }
  1556. if (pItemDrop->IsAcceptFocus())
  1557. {
  1558. SetFocusedItem(pItemDrop);
  1559. }
  1561. NotifyOwner(XTP_TPN_ITEMDROP, (LPARAM)pItemDrop);
  1562. return TRUE;
  1563. }
  1565. void CXTPTaskPanel::OnStartGroupDrag(CXTPTaskPanelItem* pItem)
  1566. {
  1567. if (!pItem->IsAllowDrag())
  1568. return;
  1570. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZENS));
  1572. m_pItemDragging = pItem;
  1574. Redraw();
  1576. while (CWnd::GetCapture() == this)
  1577. {
  1578. MSG msg;
  1580. if (!GetMessageExt(msg))
  1581. break;
  1583. if (msg.message == WM_LBUTTONUP)
  1584. break;
  1585. else if (msg.message == WM_MOUSEMOVE)
  1586. {
  1587. CPoint pt(msg.pt);
  1588. ScreenToClient(&pt);
  1590. BOOL bCaption;
  1591. CXTPTaskPanelGroup* pHTGroup = HitTestGroup(pt, &bCaption);
  1593. if (pHTGroup && bCaption && pHTGroup != pItem)
  1594. {
  1595. m_pGroups->Move(pItem, pHTGroup->GetIndex());
  1596. }
  1597. }
  1598. else if (msg.message == WM_KEYDOWN)
  1599. {
  1600. if (msg.wParam == VK_ESCAPE)
  1601. {
  1602. break;
  1603. }
  1604. }
  1605. else
  1606. DispatchMessage(&msg);
  1608. }
  1609. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  1610. m_pItemDragging = NULL;
  1612. ReleaseCapture();
  1613. }
  1615. void CXTPTaskPanel::CheckScrollButtonMouseOver(CPoint point)
  1616. {
  1617. CXTPTaskPanelScrollButton* pButtonHot = HitTestScrollButton(point);
  1619. for (int i = 0; i < 2; i++)
  1620. {
  1621. BOOL bHot = (pButtonHot == m_pScrollButton[i]);
  1623. if ((m_pScrollButton[i]->bHot && !bHot) || (!m_pScrollButton[i]->bHot && bHot))
  1624. {
  1625. m_pScrollButton[i]->bHot = bHot;
  1626. Redraw();
  1628. if (bHot)
  1629. {
  1630. TRACKMOUSEEVENT tme =
  1631. {
  1632. sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd
  1633. };
  1634. _TrackMouseEvent(&tme);
  1635. }
  1636. }
  1637. }
  1638. }
  1640. void CXTPTaskPanel::OnMouseMove(UINT nFlags, CPoint point)
  1641. {
  1642. CWnd::OnMouseMove(nFlags, point);
  1645. #if !defined(_XTP_ACTIVEX) && defined(_XTP_INCLUDE_COMMANDBARS)
  1646. if (XTPMouseManager()->IsTrackedLock(NULL) || XTPMouseManager()->IsMouseLocked())
  1647. return;
  1648. #endif
  1650. CXTPTaskPanelItem* pItem = HitTestItem(point);
  1652. BOOL bAccept = pItem && pItem->IsAcceptFocus() && CXTPDrawHelpers::IsTopParentActive(m_hWnd) &&
  1653. ((m_pItemPressed == NULL) || (m_pItemPressed == pItem));
  1655. SetHotItem(bAccept ? pItem : NULL);
  1657. if (m_pItemPressed && (abs(m_ptPressed.x - point.x) + abs(m_ptPressed.y - point.y) > 4))
  1658. {
  1659. if (IsItemGroup(m_pItemPressed)) OnStartGroupDrag(m_pItemPressed);
  1660. else OnStartItemDrag((CXTPTaskPanelGroupItem*)m_pItemPressed);
  1661. }
  1663. CheckScrollButtonMouseOver(point);
  1664. }
  1667. void CXTPTaskPanel::OnMouseLeave()
  1668. {
  1669. SetHotItem(NULL);
  1670. CheckScrollButtonMouseOver(CPoint(-1, -1));
  1671. }
  1673. BOOL CXTPTaskPanel::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  1674. {
  1675. if (m_pItemHot)
  1676. {
  1677. ::SetCursor(m_hHandCursor);
  1678. return TRUE;
  1679. }
  1681. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  1682. }
  1685. void CXTPTaskPanel::OnDestroy()
  1686. {
  1687. m_pAnimation->OnDestroy();
  1689. CWnd::OnDestroy();
  1690. }
  1692. BOOL CXTPTaskPanel::AnimateGroups(BOOL bCheckDirty)
  1693. {
  1694. BOOL bDirty = FALSE;
  1696. for (int i = 0; i < GetGroupCount(); i++)
  1697. {
  1698. CXTPTaskPanelGroup* pGroup = GetAt(i);
  1699. if (!bCheckDirty || pGroup->IsDirty())
  1700. {
  1701. bDirty = TRUE;
  1702. pGroup->OnAnimate(m_nAnimationStep);
  1703. }
  1704. }
  1705. RepositionScrollButtons();
  1707. if (DYNAMIC_DOWNCAST(CXTPTaskPanelEditItem, GetFocus()) != 0)
  1708. GrabFocus();
  1710. return bDirty;
  1711. }
  1713. void CXTPTaskPanel::OnTimer(UINT_PTR nIDEvent)
  1714. {
  1715. switch (nIDEvent)
  1716. {
  1717. case TID_REPOSITION:
  1718. {
  1719. BOOL bDirty = AnimateGroups();
  1721. Redraw();
  1723. m_nAnimationStep--;
  1725. if (!bDirty)
  1726. {
  1727. KillTimer(m_nAnimateTimer);
  1728. m_nAnimateTimer = 0;
  1729. }
  1730. }
  1731. break;
  1733. case TID_GROUPHOVER:
  1734. if (IsItemGroup(m_pItemDragOver) && m_bTimerGroupHover)
  1735. {
  1736. ((CXTPTaskPanelGroup*)m_pItemDragOver)->SetExpanded(TRUE);
  1737. }
  1738. m_bTimerGroupHover = FALSE;
  1739. KillTimer(TID_GROUPHOVER);
  1740. break;
  1742. case XTP_TID_ANIMATION:
  1743. m_pAnimation->OnAnimate();
  1744. return;
  1745. }
  1747. CWnd::OnTimer(nIDEvent);
  1748. }
  1750. void CXTPTaskPanel::OnSysColorChange()
  1751. {
  1752. m_pPaintManager->RefreshMetrics();
  1753. Reposition();
  1756. CWnd::OnSysColorChange();
  1757. }
  1759. #ifndef SPI_GETMENUANIMATION
  1760. #define SPI_GETMENUANIMATION 0x1002
  1761. #endif
  1763. void CXTPTaskPanel::SetAnimation(XTPTaskPanelAnimation panelAnimation)
  1764. {
  1765. m_eAnimation = panelAnimation;
  1767. if (m_eAnimation == xtpTaskPanelAnimationYes) m_bAnimation = TRUE;
  1768. else if (m_eAnimation == xtpTaskPanelAnimationNo) m_bAnimation = FALSE;
  1769. else
  1770. {
  1771. m_bAnimation = FALSE;
  1772. ::SystemParametersInfo(SPI_GETMENUANIMATION, 0, &m_bAnimation, 0);
  1773. }
  1774. }
  1776. void CXTPTaskPanel::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
  1777. {
  1778. CWnd::OnSettingChange(uFlags, lpszSection);
  1780. if (m_eAnimation == xtpTaskPanelAnimationSystem)
  1781. SetAnimation(xtpTaskPanelAnimationSystem);
  1783. m_pPaintManager->RefreshMetrics();
  1784. Reposition();
  1785. }
  1788. CXTPTaskPanelItem* CXTPTaskPanel::GetFocusedItem() const
  1789. {
  1790. return m_pItemFocused;
  1791. }
  1793. BOOL CXTPTaskPanel::IsDrawFocusRect() const
  1794. {
  1795. return m_bDrawFocusRect && (::GetFocus() == m_hWnd);
  1796. }
  1799. HWND CXTPTaskPanel::GetNextControl(BOOL bForward) const
  1800. {
  1801. HWND hWnd = m_hWnd;
  1802. HWND hWndParent = ::GetParent(hWnd);
  1804. if (!hWnd || !hWndParent)
  1805. {
  1806. ASSERT(FALSE);
  1807. return 0;
  1808. }
  1809. if ((GetWindowLong(hWndParent, GWL_EXSTYLE) & WS_EX_CONTROLPARENT) &&
  1810. (GetWindowLong(hWndParent, GWL_STYLE) & WS_CHILD))
  1811. {
  1812. hWndParent = ::GetParent(hWndParent);
  1813. }
  1815. HWND hwndNextItem = ::GetNextDlgTabItem(hWndParent, hWnd, bForward);
  1817. if (hwndNextItem == hWnd)
  1818. return 0;
  1820. return hwndNextItem;
  1821. }
  1823. void CXTPTaskPanel::CheckOldFocus(CWnd* pOldWnd)
  1824. {
  1826. if (!m_bGrabbingFocus && pOldWnd)
  1827. {
  1828. BOOL bShiftPressed = GetKeyState(VK_SHIFT) < 0;
  1830. if (pOldWnd->m_hWnd == GetNextControl(!bShiftPressed))
  1831. {
  1832. CXTPTaskPanelItem* pItem = GetNextItem(0, bShiftPressed ? -1 : 1, !m_bTabItems);
  1833. if (pItem)
  1834. {
  1835. SetFocusedItem(pItem, TRUE);
  1836. }
  1837. }
  1838. }
  1839. }
  1841. void CXTPTaskPanel::OnSetFocus(CWnd* pOldWnd)
  1842. {
  1843. CWnd::OnSetFocus(pOldWnd);
  1845. CheckOldFocus(pOldWnd);
  1848. Redraw();
  1851. }
  1853. void CXTPTaskPanel::OnKillFocus(CWnd* pNewWnd)
  1854. {
  1855. CWnd::OnKillFocus(pNewWnd);
  1857. m_bDrawFocusRect = FALSE;
  1859. Redraw();
  1861. }
  1863. CXTPTaskPanelGroup* CXTPTaskPanel::GetNextVisibleGroup(int nIndex, int nDirection) const
  1864. {
  1865. return GetAt(m_pGroups->GetNextVisibleIndex(nIndex, nDirection));
  1866. }
  1868. CXTPTaskPanelItem* CXTPTaskPanel::GetNextItem(CXTPTaskPanelItem* pItem, int nDirection, BOOL bTab, BOOL bSkipRowItems) const
  1869. {
  1870. if (GetGroupCount() == 0)
  1871. return NULL;
  1873. CXTPTaskPanelGroup* pGroupCheck = NULL;
  1875. do
  1876. {
  1877. if (nDirection > 0)
  1878. {
  1879. if (pItem)
  1880. {
  1881. pGroupCheck = pItem->GetItemGroup();
  1883. if (IsItemGroup(pItem))
  1884. pItem = pGroupCheck->GetItems()->GetFirstVisibleItem();
  1885. else
  1886. {
  1887. if (bTab) pItem = NULL; else pItem = pGroupCheck->GetNextVisibleItem(pItem->GetIndex(), bSkipRowItems ? pGroupCheck->GetItemsInRow() : 1);
  1888. }
  1889. }
  1891. if (!pItem)
  1892. {
  1893. pItem = GetNextVisibleGroup(pGroupCheck ? pGroupCheck->GetIndex() : -1);
  1894. }
  1895. }
  1896. else
  1897. {
  1898. if (!pItem && !pGroupCheck)
  1899. {
  1900. pGroupCheck = GetNextVisibleGroup(GetGroupCount(), - 1);
  1901. pItem = pGroupCheck ? pGroupCheck->GetItems()->GetLastVisibleItem() : 0;
  1902. }
  1903. else if (IsItemGroup(pItem))
  1904. {
  1905. pGroupCheck = GetNextVisibleGroup(pItem->GetIndex(), - 1);
  1906. pItem = pGroupCheck ? pGroupCheck->GetItems()->GetLastVisibleItem() : NULL;
  1907. }
  1908. else if (pItem)
  1909. {
  1910. pGroupCheck = pItem->GetItemGroup();
  1911. if (bTab) pItem = NULL; else pItem = pGroupCheck->GetNextVisibleItem(pItem->GetIndex(), -(bSkipRowItems ? pGroupCheck->GetItemsInRow() : 1));
  1913. }
  1915. if (!pItem) pItem = pGroupCheck;
  1916. }
  1918. if (!(IsItemLink(pItem) && pGroupCheck && !pGroupCheck->IsExpanded()))
  1919. if (pItem && pItem->IsAcceptFocus())
  1920. return pItem;
  1923. }
  1924. while (pItem);
  1927. return NULL;
  1928. }
  1930. void CXTPTaskPanel::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  1931. {
  1932. CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  1935. CXTPDrawHelpers::KeyToLayout(this, nChar);
  1937. switch (nChar)
  1938. {
  1939. case VK_HOME:
  1940. case VK_END:
  1941. if (m_pItemFocused)
  1942. {
  1943. CXTPTaskPanelItems* pItems = m_pItemFocused->GetParentItems();
  1944. CXTPTaskPanelItem* pItem = nChar == VK_HOME ? pItems->GetFirstVisibleItem() : pItems->GetLastVisibleItem();
  1945. if (pItem && pItem->IsAcceptFocus()) SetFocusedItem(pItem, TRUE);
  1946. }
  1947. break;
  1949. case VK_DOWN:
  1950. case VK_UP:
  1951. case VK_RIGHT:
  1952. case VK_LEFT:
  1953. {
  1954. BOOL bSkipRowItems = (nChar == VK_DOWN || nChar == VK_UP);
  1955. int nDirection = (nChar == VK_DOWN || nChar == VK_RIGHT ? +1 : -1);
  1957. if (!IsExplorerBehaviour() && GetKeyState(VK_CONTROL) < 0 && m_pActiveGroup)
  1958. {
  1959. CXTPTaskPanelGroup* pActiveGroup = GetNextVisibleGroup(m_pActiveGroup->GetIndex(), nDirection);
  1960. if (pActiveGroup && pActiveGroup->IsAcceptFocus())
  1961. {
  1962. pActiveGroup->SetExpanded(TRUE);
  1963. SetFocusedItem(pActiveGroup);
  1964. }
  1965. return;
  1966. }
  1968. CXTPTaskPanelItem* pItem = GetNextItem(m_pItemFocused, nDirection, FALSE, bSkipRowItems);
  1969. if (pItem) SetFocusedItem(pItem, TRUE);
  1970. }
  1971. break;
  1973. case VK_TAB:
  1974. {
  1975. BOOL bShiftPressed = GetKeyState(VK_SHIFT) < 0;
  1977. CXTPTaskPanelItem* pItem = GetNextItem(m_pItemFocused, bShiftPressed ? -1 : +1, !m_bTabItems);
  1978. if (pItem)
  1979. {
  1980. SetFocusedItem(pItem, TRUE);
  1981. }
  1982. else
  1983. {
  1984. HWND hWnd = GetNextControl(bShiftPressed);
  1986. if (hWnd)
  1987. {
  1988. ::SetFocus(hWnd);
  1989. }
  1990. }
  1991. }
  1992. break;
  1994. case VK_RETURN:
  1995. case VK_SPACE:
  1996. if (m_pItemFocused && m_pItemFocused->IsAcceptFocus())
  1997. {
  1998. if (IsItemGroup(m_pItemFocused))
  1999. {
  2000. ((CXTPTaskPanelGroup*)m_pItemFocused)->SetExpanded(!((CXTPTaskPanelGroup*)m_pItemFocused)->IsExpanded());
  2001. }
  2002. else if (IsItemLink(m_pItemFocused))
  2003. {
  2004. OnClick((CXTPTaskPanelGroupItem*)m_pItemFocused);
  2005. }
  2007. }
  2008. break;
  2009. }
  2011. }
  2013. void CXTPTaskPanel::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  2014. {
  2015. CWnd::OnKeyUp(nChar, nRepCnt, nFlags);
  2016. }
  2019. void CXTPTaskPanel::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
  2020. {
  2021. CWnd::OnSysKeyUp(nChar, nRepCnt, nFlags);
  2022. }
  2024. void CXTPTaskPanel::OnSysKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
  2025. {
  2026. CWnd::OnSysKeyUp(nChar, nRepCnt, nFlags);
  2027. }
  2030. BOOL CXTPTaskPanel::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
  2031. {
  2032. if (m_bScrollVisible)
  2033. {
  2034. // its horizontal scroll bar
  2035. int nCurPos = GetScrollPos(SB_VERT);
  2037. if (zDelta > 0) nCurPos = max(nCurPos - 10, 0);
  2038. else nCurPos = min(nCurPos + 10, GetScrollLimit(SB_VERT));
  2040. OnSrollChanged(nCurPos);
  2042. Redraw();
  2043. }
  2044. else if (GetBehaviour() != xtpTaskPanelBehaviourExplorer && m_pActiveGroup)
  2045. {
  2046. BOOL bScrollButtonUp = zDelta > 0;
  2048. for (int i = 0; i < 3; i++)
  2049. {
  2050. if (!m_pActiveGroup->IsScrollButtonEnabled(bScrollButtonUp))
  2051. break;
  2053. int nScrollOffset = (bScrollButtonUp ? -1 : +1) * m_pActiveGroup->GetItemsInRow();
  2054. m_pActiveGroup->Scroll(nScrollOffset);
  2055. }
  2056. Redraw();
  2057. }
  2058. return CWnd::OnMouseWheel(nFlags, zDelta, pt);
  2059. }
  2061. BOOL CXTPTaskPanel::PreCreateWindow(CREATESTRUCT& cs)
  2062. {
  2063. if (!CWnd::PreCreateWindow(cs))
  2064. return FALSE;
  2066. //
  2067. // PreCreateWindow is called when a control is dynamically
  2068. // created. We want to set m_bPreSubclassWindow to FALSE
  2069. // here so the control is initialized from CWnd::Create and
  2070. // not CWnd::PreSubclassWindow.
  2071. //
  2073. m_bPreSubclassWindow = FALSE;
  2075. return TRUE;
  2076. }
  2078. void CXTPTaskPanel::PreSubclassWindow()
  2079. {
  2080. if (m_bPreSubclassWindow)
  2081. {
  2082. m_pDropTarget->Register(this);
  2083. }
  2084. }
  2086. INT_PTR CXTPTaskPanel::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  2087. {
  2089. ASSERT_VALID(this);
  2090. ASSERT(::IsWindow(m_hWnd));
  2092. // check child windows first by calling CControlBar
  2093. INT_PTR nHit = CWnd::OnToolHitTest(point, pTI);
  2094. if (nHit != -1)
  2095. return nHit;
  2097. #if !defined(_XTP_ACTIVEX) && defined(_XTP_INCLUDE_COMMANDBARS)
  2098. if (XTPMouseManager()->IsTrackedLock(NULL) || XTPMouseManager()->IsMouseLocked())
  2099. return -1;
  2100. #endif
  2102. if (m_pItemHot)
  2103. {
  2104. nHit = m_pItemHot->GetID();
  2106. CString strTip = m_pItemHot->GetTooltip();
  2107. if (strTip.GetLength() == 0)
  2108. return -1;
  2110. CXTPToolTipContext::FillInToolInfo(pTI, m_hWnd, m_pItemHot->GetHitTestRect(),
  2111. nHit, strTip, m_pItemHot->GetCaption(), strTip, GetImageManager());
  2113. return nHit;
  2114. }
  2115. return -1;
  2116. }
  2118. UINT CXTPTaskPanel::OnGetDlgCode()
  2119. {
  2120. return DLGC_WANTARROWS | DLGC_WANTTAB | DLGC_WANTCHARS;
  2121. }
  2123. LRESULT CXTPTaskPanel::NotifyOwner(WPARAM wParam, LPARAM lParam)
  2124. {
  2125. if (!m_hWnd)
  2126. return 0;
  2128. return GetOwner()->SendMessage(XTPWM_TASKPANEL_NOTIFY, wParam, lParam);
  2129. }
  2131. void CXTPTaskPanel::ExpandGroup(CXTPTaskPanelGroup* pGroup, BOOL bExpanded)
  2132. {
  2133. ASSERT(pGroup);
  2134. if (!pGroup)
  2135. return;
  2137. if (IsExplorerBehaviour())
  2138. {
  2139. XTP_TPNGROUPEXPANDING NMGROUPEXPANDING;
  2140. NMGROUPEXPANDING.bExpanding = bExpanded;
  2141. NMGROUPEXPANDING.pGroup = pGroup;
  2143. if (NotifyOwner(XTP_TPN_GROUPEXPANDING, (LPARAM)&NMGROUPEXPANDING) == XTP_ACTION_CANCEL)
  2144. return;
  2146. pGroup->m_bExpanded = bExpanded;
  2147. pGroup->m_bExpanding = TRUE;
  2148. }
  2149. else if (bExpanded)
  2150. {
  2151. XTP_TPNGROUPEXPANDING NMGROUPEXPANDING;
  2152. NMGROUPEXPANDING.bExpanding = TRUE;
  2153. NMGROUPEXPANDING.pGroup = pGroup;
  2155. if (NotifyOwner(XTP_TPN_GROUPEXPANDING, (LPARAM)&NMGROUPEXPANDING) == XTP_ACTION_CANCEL)
  2156. return;
  2158. if (m_pActiveGroup)
  2159. {
  2160. if (m_pActiveGroup->IsExpandable())
  2161. {
  2162. m_pActiveGroup->m_bExpanded = FALSE;
  2163. m_pActiveGroup->m_bExpanding = TRUE;
  2164. }
  2165. m_pActiveGroup->InternalRelease();
  2166. }
  2168. m_pActiveGroup = pGroup;
  2169. m_pActiveGroup->InternalAddRef();
  2170. m_pActiveGroup->m_bExpanding = TRUE;
  2171. m_pActiveGroup->m_bExpanded = TRUE;
  2172. }
  2174. Reposition();
  2175. }
  2177. BOOL CXTPTaskPanel::IsGroupExpanded(const CXTPTaskPanelGroup* pGroup) const
  2178. {
  2179. return IsExplorerBehaviour() ? pGroup->m_bExpanded :
  2180. (m_pActiveGroup == pGroup) || (pGroup->m_bExpanded && !pGroup->m_bExpandable);
  2181. }
  2183. XTPTaskPanelHotTrackStyle CXTPTaskPanel::GetHotTrackStyle() const
  2184. {
  2185. if (m_hotTrackStyle != xtpTaskPanelHighlightDefault)
  2186. return m_hotTrackStyle;
  2188. if (m_panelBehaviour == xtpTaskPanelBehaviourExplorer)
  2189. return xtpTaskPanelHighlightText;
  2191. if (m_panelBehaviour == xtpTaskPanelBehaviourToolbox)
  2192. return xtpTaskPanelHighlightItem;
  2194. return xtpTaskPanelHighlightImage;
  2195. }
  2197. void CXTPTaskPanel::SetHotTrackStyle(XTPTaskPanelHotTrackStyle hotTrackStyle)
  2198. {
  2199. m_hotTrackStyle = hotTrackStyle;
  2200. Reposition();
  2201. }
  2203. XTPTaskPanelItemLayout CXTPTaskPanel::GetItemLayout() const
  2204. {
  2205. if (m_itemLayout != xtpTaskItemLayoutDefault)
  2206. return m_itemLayout;
  2208. if (m_panelBehaviour == xtpTaskPanelBehaviourList)
  2209. return xtpTaskItemLayoutImagesWithTextBelow;
  2211. return xtpTaskItemLayoutImagesWithText;
  2212. }
  2214. void CXTPTaskPanel::SetItemLayout(XTPTaskPanelItemLayout itemLayout)
  2215. {
  2216. m_itemLayout = itemLayout;
  2217. Reposition();
  2218. }
  2220. void CXTPTaskPanel::SetBehaviour(XTPTaskPanelBehaviour panelBehaviour)
  2221. {
  2222. m_panelBehaviour = panelBehaviour;
  2223. Reposition();
  2224. }
  2226. XTPTaskPanelBehaviour CXTPTaskPanel::GetBehaviour() const
  2227. {
  2228. return m_panelBehaviour;
  2229. }
  2231. void CXTPTaskPanel::OnItemRemoved(CXTPTaskPanelItem* pItem)
  2232. {
  2233. ASSERT(pItem);
  2234. if (!pItem)
  2235. return;
  2237. if (m_pActiveGroup == pItem)
  2238. {
  2239. m_pActiveGroup->InternalRelease();
  2240. m_pActiveGroup = NULL;
  2241. }
  2243. if (m_pItemHot == pItem)
  2244. {
  2245. m_pItemHot->InternalRelease();
  2246. m_pItemHot = NULL;
  2247. }
  2249. if (m_pItemFocused == pItem)
  2250. {
  2251. m_pItemFocused->InternalRelease();
  2252. m_pItemFocused = NULL;
  2253. }
  2256. if (m_pScrollButton[TRUE]->pGroupCaption == pItem)
  2257. m_pScrollButton[TRUE]->pGroupCaption = NULL;
  2259. if (m_pScrollButton[TRUE]->pGroupScroll == pItem)
  2260. m_pScrollButton[TRUE]->pGroupScroll = NULL;
  2262. if (m_pScrollButton[FALSE]->pGroupCaption == pItem)
  2263. m_pScrollButton[FALSE]->pGroupCaption = NULL;
  2265. if (m_pScrollButton[FALSE]->pGroupScroll == pItem)
  2266. m_pScrollButton[FALSE]->pGroupScroll = NULL;
  2268. NotifyOwner(XTP_TPN_ITEMREMOVED, (LPARAM)pItem);
  2269. }
  2272. BOOL CXTPTaskPanel::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  2273. {
  2274. if (m_pToolTipContext)
  2275. {
  2276. m_pToolTipContext->FilterToolTipMessage(this, message, wParam, lParam);
  2277. }
  2279. return CWnd::OnWndMsg(message, wParam, lParam, pResult);
  2280. }
  2282. HWND CXTPTaskPanel::GetRootChild(HWND hWndTaskPanel, HWND hWnd)
  2283. {
  2284. HWND hwndParent = ::GetParent(hWnd);
  2286. while (hwndParent != hWndTaskPanel)
  2287. {
  2288. hWnd = hwndParent;
  2289. hwndParent = ::GetParent(hWnd);
  2291. if (hwndParent == NULL)
  2292. return NULL;
  2293. }
  2295. return hWnd;
  2296. }
  2298. CXTPTaskPanelGroupItem* CXTPTaskPanel::FindControlItem(HWND hWnd)
  2299. {
  2300. for (int i = 0; i < GetGroupCount(); i++)
  2301. {
  2302. CXTPTaskPanelGroup* pGroup = GetAt(i);
  2304. for (int j = 0; j < pGroup->GetItemCount(); j++)
  2305. {
  2306. if (pGroup->GetAt(j)->GetControlHandle() == hWnd)
  2307. return pGroup->GetAt(j);
  2308. }
  2309. }
  2311. return NULL;
  2312. }
  2314. BOOL CXTPTaskPanel::PreTranslateMessage(MSG* pMsg)
  2315. {
  2316. if (pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_TAB && m_bTabItems)
  2317. {
  2318. HWND hWnd = ::GetFocus();
  2320. if (hWnd && hWnd != m_hWnd && ::IsChild(m_hWnd, hWnd))
  2321. {
  2322. HWND hWndDlg = GetRootChild(m_hWnd, hWnd);
  2323. if (!hWndDlg)
  2324. return CWnd::PreTranslateMessage(pMsg);
  2326. BOOL bShiftPressed = GetKeyState(VK_SHIFT) < 0;
  2328. HWND hWndFirst = ::GetNextDlgTabItem(hWndDlg, NULL, FALSE);
  2329. if (bShiftPressed) hWndFirst = ::GetNextDlgTabItem(hWndDlg, hWndFirst, TRUE);
  2331. HWND hWndNext = ::GetNextDlgTabItem(hWndDlg, hWnd, bShiftPressed);
  2333. if (hWndNext && hWndNext != hWnd && hWndNext != hWndDlg && hWndNext != hWndFirst)
  2334. {
  2335. ::SetFocus(hWndNext);
  2336. return TRUE;
  2337. }
  2339. CXTPTaskPanelGroupItem* pItemFocused = FindControlItem(hWndDlg);
  2340. if (pItemFocused)
  2341. {
  2342. CXTPTaskPanelItem* pItem = GetNextItem(pItemFocused, bShiftPressed ? -1 : +1, !m_bTabItems);
  2343. if (pItem)
  2344. {
  2345. SetFocusedItem(pItem, TRUE);
  2346. }
  2347. else
  2348. {
  2349. hWndNext = GetNextControl(bShiftPressed);
  2351. if (hWndNext)
  2352. {
  2353. ::SetFocus(hWndNext);
  2354. }
  2355. }
  2356. return TRUE;
  2357. }
  2358. }
  2359. }
  2361. return CWnd::PreTranslateMessage(pMsg);
  2362. }
  2364. CXTPToolTipContext* CXTPTaskPanel::GetToolTipContext() const
  2365. {
  2366. return m_pToolTipContext;
  2367. }
  2369. void CXTPTaskPanel::SetLayoutRTL(BOOL bRightToLeft)
  2370. {
  2371. if (!XTPSystemVersion()->IsLayoutRTLSupported())
  2372. return;
  2374. if (!m_hWnd)
  2375. return;
  2377. ModifyStyleEx(bRightToLeft ? 0 : WS_EX_LAYOUTRTL, !bRightToLeft ? 0 : WS_EX_LAYOUTRTL);
  2378. GetImageManager()->DrawReverted(bRightToLeft);
  2380. Reposition();
  2381. }
  2384. LRESULT CXTPTaskPanel::OnGetObject(WPARAM wParam, LPARAM lParam)
  2385. {
  2386. if (lParam != OBJID_CLIENT)
  2387. return (LRESULT)Default();
  2389. LPUNKNOWN lpUnknown = GetInterface(&IID_IAccessible);
  2390. if (!lpUnknown)
  2391. return E_FAIL;
  2393. return LresultFromObject(IID_IAccessible, wParam, lpUnknown);
  2394. }
  2396. BEGIN_INTERFACE_MAP(CXTPTaskPanel, CCmdTarget)
  2397. INTERFACE_PART(CXTPTaskPanel, IID_IAccessible, ExternalAccessible)
  2398. END_INTERFACE_MAP()
  2400. CCmdTarget* CXTPTaskPanel::GetAccessible()
  2401. {
  2402. return this;
  2403. }
  2405. HRESULT CXTPTaskPanel::GetAccessibleParent(IDispatch* FAR* ppdispParent)
  2406. {
  2407. *ppdispParent = NULL;
  2409. if (GetSafeHwnd())
  2410. {
  2411. return AccessibleObjectFromWindow(GetSafeHwnd(), OBJID_WINDOW, IID_IDispatch, (void**)ppdispParent);
  2412. }
  2413. return E_FAIL;
  2414. }
  2416. int CXTPTaskPanel::GetAccessibleIndex(CXTPTaskPanelItem* pItem)
  2417. {
  2418. int nCount = 0;
  2419. for (int i = 0; i < GetGroupCount(); i++)
  2420. {
  2421. CXTPTaskPanelGroup* pGroup = GetAt(i);
  2422. nCount++;
  2424. if (pItem)
  2425. {
  2426. if (pGroup == pItem)
  2427. return nCount;
  2429. if (pItem->GetItemGroup() == pGroup)
  2430. return nCount + pItem->GetIndex() + 1;
  2431. }
  2433. nCount += pGroup->GetItemCount();
  2434. }
  2436. return nCount;
  2437. }
  2439. CXTPTaskPanelItem* CXTPTaskPanel::GetAccessibleItem(int nIndex)
  2440. {
  2441. for (int i = 0; i < GetGroupCount(); i++)
  2442. {
  2443. CXTPTaskPanelGroup* pGroup = GetAt(i);
  2444. nIndex--;
  2446. if (nIndex == 0)
  2447. return pGroup;
  2449. if (nIndex <= pGroup->GetItemCount())
  2450. return pGroup->GetAt(nIndex - 1);
  2452. nIndex -= pGroup->GetItemCount();
  2453. }
  2455. return NULL;
  2456. }
  2458. HRESULT CXTPTaskPanel::GetAccessibleChildCount(long FAR* pChildCount)
  2459. {
  2460. if (pChildCount == 0)
  2461. {
  2462. return E_INVALIDARG;
  2463. }
  2465. *pChildCount = GetAccessibleIndex(NULL);
  2466. return S_OK;
  2467. }
  2469. HRESULT CXTPTaskPanel::GetAccessibleChild(VARIANT varChild, IDispatch* FAR* ppdispChild)
  2470. {
  2471. *ppdispChild = NULL;
  2472. int nChild = GetChildIndex(&varChild);
  2474. if (nChild <= 0)
  2475. {
  2476. return E_INVALIDARG;
  2477. }
  2479. CXTPTaskPanelItem* pItem = GetAccessibleItem(nChild);
  2480. if (!pItem)
  2481. {
  2482. return E_INVALIDARG;
  2483. }
  2485. *ppdispChild = pItem->GetIDispatch(TRUE);
  2486. return S_OK;
  2487. }
  2489. HRESULT CXTPTaskPanel::GetAccessibleName(VARIANT varChild, BSTR* pszName)
  2490. {
  2491. int nChild = GetChildIndex(&varChild);
  2493. if (nChild == CHILDID_SELF || nChild == -1)
  2494. {
  2495. CString strCaption;
  2496. GetWindowText(strCaption);
  2497. *pszName = strCaption.AllocSysString();
  2498. return S_OK;
  2499. }
  2501. return E_INVALIDARG;
  2502. }
  2504. HRESULT CXTPTaskPanel::GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole)
  2505. {
  2506. pvarRole->vt = VT_EMPTY;
  2507. int nChild = GetChildIndex(&varChild);
  2509. if (nChild == CHILDID_SELF)
  2510. {
  2511. pvarRole->vt = VT_I4;
  2512. pvarRole->lVal = ROLE_SYSTEM_OUTLINE;
  2513. return S_OK;
  2514. }
  2516. return E_INVALIDARG;
  2517. }
  2519. HRESULT CXTPTaskPanel::GetAccessibleState(VARIANT varChild, VARIANT* pvarState)
  2520. {
  2521. pvarState->vt = VT_I4;
  2522. pvarState->lVal = 0;
  2523. int nChild = GetChildIndex(&varChild);
  2525. if (nChild == CHILDID_SELF)
  2526. {
  2527. pvarState->lVal = STATE_SYSTEM_FOCUSABLE;
  2528. }
  2530. return S_OK;
  2531. }
  2534. HRESULT CXTPTaskPanel::AccessibleLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild)
  2535. {
  2536. *pxLeft = *pyTop = *pcxWidth = *pcyHeight = 0;
  2538. if (!GetSafeHwnd())
  2539. return S_OK;
  2541. CRect rc;
  2542. GetWindowRect(&rc);
  2544. int nChild = GetChildIndex(&varChild);
  2546. if (nChild > 0)
  2547. {
  2548. CXTPTaskPanelItem* pItem = GetAccessibleItem(nChild);
  2549. if (pItem)
  2550. {
  2551. CRect rcItem = pItem->GetHitTestRect();
  2552. rc = CRect(CPoint(rc.left + rcItem.left, rc.top + rcItem.top), rcItem.Size());
  2553. }
  2555. }
  2557. *pxLeft = rc.left;
  2558. *pyTop = rc.top;
  2559. *pcxWidth = rc.Width();
  2560. *pcyHeight = rc.Height();
  2562. return S_OK;
  2563. }
  2565. HRESULT CXTPTaskPanel::AccessibleHitTest(long xLeft, long yTop, VARIANT* pvarID)
  2566. {
  2567. if (pvarID == NULL)
  2568. return E_INVALIDARG;
  2570. pvarID->vt = VT_EMPTY;
  2572. if (!GetSafeHwnd())
  2573. return S_FALSE;
  2575. if (!CXTPWindowRect(this).PtInRect(CPoint(xLeft, yTop)))
  2576. return S_FALSE;
  2578. pvarID->vt = VT_I4;
  2579. pvarID->lVal = 0;
  2581. CPoint pt(xLeft, yTop);
  2582. ScreenToClient(&pt);
  2584. CXTPTaskPanelItem* pItem = HitTestItem(pt);
  2586. if (pItem)
  2587. {
  2588. pvarID->vt = VT_DISPATCH;
  2589. pvarID->pdispVal = pItem->GetIDispatch(TRUE);
  2590. }
  2592. return S_OK;
  2593. }