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

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

对话框与窗口

开发平台：

Visual C++

XTOutBarCtrl.cpp：源码内容
  1. // XTOutBarCtrl.cpp : implementation of the CXTOutBarCtrl class.
  2. //
  3. // This file is a part of the XTREME CONTROLS 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/XTPResourceManager.h"
  23. #include "Common/XTPColorManager.h"
  24. #include "Common/XTPDrawHelpers.h"
  26. #include "Resource.h"
  27. #include "XTDefines.h"
  28. #include "XTGlobal.h"
  29. #include "XTVC50Helpers.h"
  31. #include "XTFlatComboBox.h"
  32. #include "XTOutBarCtrl.h"
  33. #include "XTOutBarCtrlTheme.h"
  34. #include "XTFunctions.h"
  36. #ifdef _DEBUG
  37. #define new DEBUG_NEW
  38. #undef THIS_FILE
  39. static char THIS_FILE[] = __FILE__;
  40. #endif
  42. /////////////////////////////////////////////////////////////////////////////
  43. // CXTOutBarEditItem
  45. CXTOutBarEditItem::CXTOutBarEditItem()
  46. {
  47. m_iIndex = -1;
  48. m_pParentWnd = NULL;
  49. m_bSmallIcons = false;
  50. m_bEscapeKey = false;
  51. m_bIsFolder = false;
  52. }
  54. CXTOutBarEditItem::~CXTOutBarEditItem()
  55. {
  57. }
  59. IMPLEMENT_DYNAMIC(CXTOutBarEditItem, CXTEdit)
  61. BEGIN_MESSAGE_MAP(CXTOutBarEditItem, CXTEdit)
  62. //{{AFX_MSG_MAP(CXTOutBarEditItem)
  63. ON_WM_KILLFOCUS()
  64. ON_WM_CHAR()
  65. ON_WM_SETCURSOR()
  66. //}}AFX_MSG_MAP
  67. END_MESSAGE_MAP()
  69. void CXTOutBarEditItem::OnKillFocus(CWnd* /*pNewWnd*/)
  70. {
  71. PostMessage(WM_CLOSE);
  73. if (!m_bEscapeKey)
  74. {
  75. GetWindowText(m_strText);
  77. if (!m_strText.IsEmpty())
  78. {
  79. m_pParentWnd->EndLabelEdit(this, m_bIsFolder);
  80. }
  81. }
  82. }
  84. BOOL CXTOutBarEditItem::PreTranslateMessage(MSG* pMsg)
  85. {
  86. switch (pMsg->wParam)
  87. {
  88. case VK_ESCAPE:
  89. {
  90. m_bEscapeKey = TRUE; // fall thru
  91. }
  92. case VK_RETURN:
  93. {
  94. PostMessage(WM_CLOSE);
  95. return TRUE;
  96. }
  97. }
  99. return CXTEdit::PreTranslateMessage(pMsg);
  100. }
  102. void CXTOutBarEditItem::PostNcDestroy()
  103. {
  104. delete this;
  105. }
  107. BOOL CXTOutBarEditItem::Create(LPCTSTR lpszText, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, UINT nIndex, bool bIsFolder, bool bSmallIcons)
  108. {
  109. ASSERT_VALID(pParentWnd); // must be valid.
  111. m_pParentWnd = (CXTOutBarCtrl*)pParentWnd;
  112. ASSERT_KINDOF(CXTOutBarCtrl, m_pParentWnd); // must be an outlook bar control.
  114. // get the inside size of the outlook bar.
  115. CRect rcInside;
  116. m_pParentWnd->GetInsideRect(rcInside);
  117. rcInside.DeflateRect(5, 5);
  119. // adjust the size if necessary.
  120. m_rcOriginal = rect;
  121. m_bSmallIcons = bSmallIcons;
  122. m_bIsFolder = bIsFolder;
  123. m_iIndex = nIndex;
  124. m_strText = lpszText;
  126. if (m_rcOriginal.Width() > rcInside.Width())
  127. {
  128. if (m_bSmallIcons != TRUE)
  129. {
  130. m_rcOriginal.left = rcInside.left;
  131. }
  133. m_rcOriginal.right = rcInside.right;
  134. }
  136. if (!CXTEdit::Create(dwStyle, m_rcOriginal, pParentWnd, nID))
  137. return FALSE;
  139. if (!CXTEdit::Initialize(m_pParentWnd))
  140. return FALSE;
  142. SetFont(m_pParentWnd->GetFontX());
  143. SetWindowText(m_strText);
  145. return TRUE;
  146. }
  148. void CXTOutBarEditItem::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  149. {
  150. // if this is a folder, do default processing.
  151. if (m_bIsFolder)
  152. {
  153. CXTEdit::OnChar(nChar, nRepCnt, nFlags);
  154. return;
  155. }
  157. // if the escape or return key has been pressed, abort edit.
  158. else if (nChar == VK_ESCAPE || nChar == VK_RETURN)
  159. {
  160. if (nChar == VK_ESCAPE)
  161. {
  162. m_bEscapeKey = TRUE;
  163. }
  165. m_pParentWnd->SetFocus();
  166. return;
  167. }
  169. CXTEdit::OnChar(nChar, nRepCnt, nFlags);
  171. // get the inside size of the outlook bar.
  172. CRect rcInside;
  173. m_pParentWnd->GetInsideRect(rcInside);
  174. rcInside.DeflateRect(5, 5);
  176. // get the edit box text
  177. CString strText;
  178. GetWindowText(strText);
  180. // get the font used by the outlook bar.
  181. CFont* pFont = m_pParentWnd->GetFontX();
  182. ASSERT(pFont && pFont->GetSafeHandle());
  184. // select the font used by the outlook bar.
  185. CWindowDC dc(NULL);
  187. // get the size of the text string.
  188. CFont* f = dc.SelectObject(pFont);
  189. CSize sz = dc.GetTextExtent(strText);
  190. dc.SelectObject(f);
  192. // construct the edit box size.
  193. CRect rcItem = m_rcOriginal;
  195. // calculate the width of the edit box.
  196. if (m_bSmallIcons == TRUE)
  197. {
  198. rcItem.right = rcItem.left + sz.cx + 9;
  200. if (rcItem.right < m_rcOriginal.right)
  201. {
  202. rcItem.right = m_rcOriginal.right;
  203. }
  204. else if (rcItem.right > rcInside.right)
  205. {
  206. rcItem.right = rcInside.right;
  207. }
  208. }
  209. else
  210. {
  211. int x = (rcInside.Width()-sz.cx)/2;
  213. rcItem.left = rcInside.left + x;
  214. rcItem.right = rcItem.left + sz.cx;
  215. rcItem.InflateRect(6, 0);
  217. if (rcItem.Width() < m_rcOriginal.Width())
  218. {
  219. rcItem = m_rcOriginal;
  220. }
  222. else if (rcItem.Width() > rcInside.Width())
  223. {
  224. rcItem.left = rcInside.left;
  225. rcItem.right = rcInside.right;
  226. }
  227. }
  229. // resize the edit box.
  230. MoveWindow(&rcItem);
  231. }
  233. BOOL CXTOutBarEditItem::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  234. {
  235. HCURSOR hCursor = AfxGetApp()->LoadStandardCursor(IDC_IBEAM);
  236. if (hCursor != NULL)
  237. {
  238. ::SetCursor(hCursor);
  239. return TRUE;
  240. }
  242. return CXTEdit::OnSetCursor(pWnd, nHitTest, message);
  243. }
  245. /////////////////////////////////////////////////////////////////////////////
  246. // CXTOutBarCtrl
  248. IMPLEMENT_THEME_HOST(CXTOutBarCtrl)
  249. IMPLEMENT_THEME_REFRESH(CXTOutBarCtrl, CWnd)
  251. CXTOutBarCtrl::CXTOutBarCtrl()
  252. : CXTThemeManagerStyleHost(GetThemeFactoryClass())
  253. , m_penBlack(PS_SOLID, 1, RGB(0, 0, 0))
  254. {
  255. m_rcUpArrow.SetRectEmpty();
  256. m_rcDownArrow.SetRectEmpty();
  258. m_dwFlags = OBS_XT_DEFAULT;
  259. m_pLargeImageList = NULL;
  260. m_pSmallImageList = NULL;
  261. m_sizeOffset.cx = 4;
  262. m_sizeOffset.cy = 3;
  263. m_sizeMargin.cx = 5;
  264. m_sizeMargin.cy = 5;
  265. m_nFolderHeight = 22;
  266. m_nSelFolder = 0;
  267. m_nLastFolderSelected = -1;
  268. m_nFolderHilighted = -1;
  269. m_nLastItemSelected = -1;
  270. m_nItemHilighted = -1;
  271. m_nLastDragItemDraw = -1;
  272. m_nLastDragItemDrawType = -1;
  273. m_nFirstItem = 0;
  274. m_nIconSpacingSmall = 10;
  275. m_nIconSpacingLarge = 8;
  276. m_nAnimationTickCount = 10;
  277. m_nSelAnimCount = 0;
  278. m_nSelAnimTiming = 0;
  279. m_nHitInternal1 = 0;
  280. m_nHitInternal2 = 0;
  281. m_bUpArrow = FALSE;
  282. m_bDownArrow = FALSE;
  283. m_bUpPressed = FALSE;
  284. m_bDownPressed = FALSE;
  285. m_bLooping = FALSE;
  286. m_bPressedHighlight = FALSE;
  287. m_bIconPressed = FALSE;
  289. SetFontX(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  290. }
  292. CXTOutBarCtrl::~CXTOutBarCtrl()
  293. {
  294. int iFolder;
  295. for (iFolder = 0; iFolder < m_arFolder.GetSize(); iFolder++)
  296. {
  297. m_nSelFolder = iFolder;
  298. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  299. SAFE_DELETE(pBarFolder);
  300. }
  302. m_arFolder.RemoveAll();
  303. m_penBlack.DeleteObject();
  304. m_font.DeleteObject();
  306. }
  308. IMPLEMENT_DYNCREATE(CXTOutBarCtrl, CWnd)
  310. BEGIN_MESSAGE_MAP(CXTOutBarCtrl, CWnd)
  311. //{{AFX_MSG_MAP(CXTOutBarCtrl)
  312. ON_WM_TIMER()
  313. ON_WM_PAINT()
  314. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  315. ON_WM_ERASEBKGND()
  316. ON_WM_MOUSEMOVE()
  317. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  318. ON_WM_LBUTTONDOWN()
  319. ON_WM_SETCURSOR()
  320. ON_WM_SIZE()
  321. ON_COMMAND(XT_IDC_LARGEICON, OnLargeIcon)
  322. ON_UPDATE_COMMAND_UI(XT_IDC_LARGEICON, OnUpdateLargeIcon)
  323. ON_COMMAND(XT_IDC_SMALLICON, OnSmallIcon)
  324. ON_UPDATE_COMMAND_UI(XT_IDC_SMALLICON, OnUpdateSmallIcon)
  325. ON_COMMAND(XT_IDC_REMOVEITEM, OnRemoveItem)
  326. ON_UPDATE_COMMAND_UI(XT_IDC_REMOVEITEM, OnUpdateRemoveItem)
  327. ON_COMMAND(XT_IDC_RENAMEITEM, OnRenameItem)
  328. ON_UPDATE_COMMAND_UI(XT_IDC_RENAMEITEM, OnUpdateRenameItem)
  329. ON_WM_RBUTTONUP()
  330. ON_WM_DESTROY()
  331. //}}AFX_MSG_MAP
  332. END_MESSAGE_MAP()
  335. void CXTOutBarCtrl::DrawItemIcon(CDC* pDC, CPoint pt, CXTOutBarItem* pBarItem, CImageList* pImageList)
  336. {
  337. GetTheme()->DrawItemIcon(pDC, pt, pBarItem, pImageList);
  338. }
  340. void CXTOutBarCtrl::DrawItemText(CDC* pDC, CRect rc, CXTOutBarItem* pBarItem, UINT nFormat)
  341. {
  342. GetTheme()->DrawItemText(pDC, rc, pBarItem, nFormat);
  343. }
  345. LRESULT CXTOutBarCtrl::NotifyOwner(UINT nCode, XT_OUTBAR_INFO* pobi)
  346. {
  347. CWnd* pOwner = (CWnd*)GetOwner();
  348. ASSERT_VALID(pOwner);
  350. pobi->hWnd = m_hWnd;
  352. return pOwner->SendMessage(XTWM_OUTBAR_NOTIFY,
  353. (WPARAM)nCode, (LPARAM)pobi);
  354. }
  356. void CXTOutBarCtrl::EndLabelEdit(CXTOutBarEditItem* pEdit, bool bIsFolder)
  357. {
  358. ASSERT_VALID(pEdit); // must be valid.
  360. XT_OUTBAR_INFO obi;
  361. obi.bFolder = bIsFolder;
  362. obi.nIndex = pEdit->GetIndex();
  363. obi.lpszText = pEdit->GetText();
  364. obi.nDragFrom = -1;
  365. obi.nDragTo = -1;
  367. LRESULT lResult = 0;
  369. // give the owner a chance to process the message first.
  370. if (bIsFolder)
  371. {
  372. lResult = NotifyOwner(OBN_XT_ONGROUPENDEDIT, &obi);
  373. }
  374. else
  375. {
  376. lResult = NotifyOwner(OBN_XT_ONLABELENDEDIT, &obi);
  377. }
  379. // If the return value is "0" then the owner has processed
  380. // the message, so just return.
  381. if (lResult == 0)
  382. {
  383. return;
  384. }
  386. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  387. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  388. if (pBarFolder == NULL)
  389. {
  390. return;
  391. }
  393. CRect rc;
  394. bool  bUpdate = false;
  396. if (bIsFolder)
  397. {
  398. bUpdate = (pBarFolder->GetName() != obi.lpszText);
  400. if (bUpdate)
  401. {
  402. GetFolderRect(obi.nIndex, rc);
  403. SetFolderText(obi.nIndex, obi.lpszText);
  404. }
  405. }
  406. else
  407. {
  408. ASSERT(obi.nIndex >= 0 && obi.nIndex < pBarFolder->GetItemCount());
  409. CXTOutBarItem* pBarItem = pBarFolder->GetItemAt(obi.nIndex);
  410. if (pBarItem == NULL)
  411. {
  412. return;
  413. }
  415. bUpdate = (pBarItem->GetName() != obi.lpszText);
  417. if (bUpdate)
  418. {
  419. GetInsideRect(rc);
  420. SetItemText(obi.nIndex, obi.lpszText);
  421. }
  422. }
  424. if (bUpdate)
  425. {
  426. OnLabelChanged(&obi); // handle in derived class.
  427. InvalidateRect(rc);
  428. }
  429. }
  431. void CXTOutBarCtrl::OnLabelChanged(const XT_OUTBAR_INFO* /*pObi*/)
  432. {
  433. }
  435. void CXTOutBarCtrl::SetFolderText(const int iIndex, LPCTSTR lpszFolderName)
  436. {
  437. if (m_arFolder.GetSize() != 0)
  438. {
  439. ASSERT((iIndex >= 0) && (iIndex < GetFolderCount()));
  440. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iIndex);
  441. pBarFolder->SetName(lpszFolderName);
  442. }
  443. }
  445. void CXTOutBarCtrl::SetItemText(const int iIndex, LPCTSTR lpszItemName)
  446. {
  447. if (m_arFolder.GetSize() != 0)
  448. {
  449. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  451. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  453. CXTOutBarItem* pBarItem = pBarFolder->GetItemAt(iIndex);
  454. pBarItem->SetName(lpszItemName);
  455. }
  456. }
  458. BOOL CXTOutBarCtrl::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, const DWORD dwFlags)
  459. {
  460. if (!CreateEx(NULL, dwStyle, rect, pParentWnd, nID, dwFlags))
  461. {
  462. return FALSE;
  463. }
  465. return TRUE;
  466. }
  468. BOOL CXTOutBarCtrl::CreateEx(DWORD dwExStyle, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, const DWORD dwFlags)
  469. {
  470. ASSERT(dwStyle & WS_CHILD);
  471. ASSERT_VALID(pParentWnd);
  473. if (!CWnd::CreateEx(dwExStyle, NULL, NULL, dwStyle, rect, pParentWnd, nID))
  474. {
  475. return FALSE;
  476. }
  478. m_dwFlags = dwFlags;
  480. return TRUE;
  481. }
  483. BOOL CXTOutBarCtrl::IsSmallIconView(const int iFolder/*= -1*/) const
  484. {
  485. if (GetFolderCount() <= 0 || iFolder == -1)
  486. return ((m_dwFlags & OBS_XT_SMALLICON) == OBS_XT_SMALLICON);
  488. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  489. return pBarFolder->m_bSmallIcons;
  490. }
  492. void CXTOutBarCtrl::SetSmallIconView(const BOOL bSet, const int iFolder/*= -1*/)
  493. {
  494. m_nFirstItem = 0;
  496. if (iFolder != -1)
  497. {
  498. if (iFolder >= 0 && iFolder < GetFolderCount())
  499. {
  500. CXTOutBarFolder* pbf = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  501. pbf->m_bSmallIcons = bSet;
  502. }
  503. }
  504. else
  505. {
  506. // do all current folders, and set flag so new folders
  507. // have the chosen style
  508. int nFolders = GetFolderCount();
  509. int i;
  510. for (i = 0; i < nFolders; i++)
  511. {
  512. CXTOutBarFolder* pbf = (CXTOutBarFolder*)m_arFolder.GetAt(i);
  513. pbf->m_bSmallIcons = bSet;
  514. }
  516. if (bSet && !IsSmallIconView())
  517. m_dwFlags |= OBS_XT_SMALLICON;
  519. else if (!bSet && IsSmallIconView())
  520. m_dwFlags &= ~OBS_XT_SMALLICON;
  521. }
  523. CRect rc;
  524. GetInsideRect(rc);
  525. InvalidateRect(rc, false);
  526. }
  528. DWORD CXTOutBarCtrl::GetFlag() const
  529. {
  530. return m_dwFlags;
  531. }
  533. void CXTOutBarCtrl::ModifyFlag(const DWORD& dwRemove, const DWORD& dwAdd, const bool bRedraw)
  534. {
  535. if (dwRemove)
  536. {
  537. m_dwFlags &= ~dwRemove;
  538. }
  539. if (dwAdd)
  540. {
  541. m_dwFlags |= dwAdd;
  542. }
  543. if (GetSafeHwnd())
  544. {
  545. if (bRedraw == true)
  546. {
  547. Invalidate();
  548. UpdateWindow();
  549. }
  550. }
  551. }
  553. void CXTOutBarCtrl::OnTimer(UINT_PTR nIDEvent)
  554. {
  555. if (nIDEvent == 3 && m_nLastItemSelected >= 0)
  556. {
  557. m_nSelAnimCount++;
  558. if (m_nSelAnimCount > 10) m_nSelAnimCount = -1;
  559. if (m_nSelAnimCount == 0)
  560. DrawAnimItem(-1, 1, m_nLastItemSelected);
  561. if (m_nSelAnimCount == 1)
  562. DrawAnimItem(0, 0, m_nLastItemSelected);
  563. if (m_nSelAnimCount == 2)
  564. DrawAnimItem(1, 1, m_nLastItemSelected);
  565. if (m_nSelAnimCount == 3)
  566. DrawAnimItem(0, 0, m_nLastItemSelected);
  567. }
  568. CWnd::OnTimer(nIDEvent);
  569. }
  571. void CXTOutBarCtrl::DrawAnimItem(const int iOffsetX, const int iOffsetY, const int iIndex)
  572. {
  573. CImageList* pImageList = GetFolderImageList(m_nSelFolder, IsSmallIconView(m_nSelFolder));
  575. CRect rc, irc;
  576. GetInsideRect(irc);
  577. GetItemRect(m_nSelFolder, m_nLastItemSelected, rc);
  579. if (m_arFolder.GetSize() != 0)
  580. {
  581. if (m_nLastItemSelected >= m_nFirstItem && irc.bottom > rc.bottom && irc.top < rc.top)
  582. {
  583. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  584. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  586. ASSERT(iIndex >= 0 && iIndex < pBarFolder->GetItemCount());
  587. CXTOutBarItem* pBarItem = (CXTOutBarItem*)pBarFolder->GetItemAt(iIndex);
  589. ASSERT(pBarItem && pImageList);
  591. CClientDC dc(this);
  593. if (IsSmallIconView(m_nSelFolder))
  594. {
  595. if (pImageList)
  596. {
  597. IMAGEINFO ii;
  598. pImageList->GetImageInfo(pBarItem->GetIndex(), &ii);
  599. CSize szImage = CRect(ii.rcImage).Size();
  600. CPoint pt;
  601. pt.x = rc.left + 2;
  602. pt.y = rc.top + (rc.Height() - szImage.cy) / 2;
  604. CRect rcBck(pt.x-1, pt.y-1, pt.x + szImage.cx + 2, pt.y + szImage.cy + 2);
  605. dc.FillSolidRect(rcBck, GetXtremeColor(COLOR_3DSHADOW));
  607. pt.x += iOffsetX;
  608. pt.y += iOffsetY;
  610. DrawItemIcon(&dc, pt, pBarItem, pImageList);
  611. }
  612. }
  613. else
  614. {
  615. if (pImageList)
  616. {
  617. IMAGEINFO ii;
  618. pImageList->GetImageInfo(pBarItem->GetIndex(), &ii);
  619. CSize szImage = CRect(ii.rcImage).Size();
  620. CPoint pt;
  621. pt.x = rc.left + (rc.Width() - szImage.cx) / 2;
  622. pt.y = rc.top;
  624. CRect rcBck(pt.x-1, pt.y-1, pt.x + szImage.cx + 2, pt.y + szImage.cy + 2);
  625. dc.FillSolidRect(rcBck, GetXtremeColor(COLOR_3DSHADOW));
  627. pt.x += iOffsetX;
  628. pt.y += iOffsetY;
  630. DrawItemIcon(&dc, pt, pBarItem, pImageList);
  631. }
  632. }
  633. }
  634. }
  635. }
  637. void CXTOutBarCtrl::OnPaint()
  638. {
  639. // background is already filled in gray
  640. CPaintDC dc(this);
  642. // Paint to a memory device context to help
  643. // eliminate screen flicker.
  644. CXTPBufferDC memDC(dc);
  646. OnDraw(&memDC);
  647. }
  649. LRESULT CXTOutBarCtrl::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  650. {
  651. CDC* pDC = CDC::FromHandle((HDC)wParam);
  652. if (pDC)
  653. {
  654. OnDraw(pDC);
  655. }
  657. return TRUE;
  658. }
  660. void CXTOutBarCtrl::OnDraw(CDC* pDC)
  661. {
  662. // Get the client rect.
  663. CXTPClientRect rectClient(this);
  666. CRect rc;
  667. GetInsideRect(rc);
  668. if (!GetFolderChild())
  669. {
  670. //pDC->FillSolidRect(rc, m_clrBack);
  671. GetTheme()->FillInsideRect(pDC, rc);
  672. }
  674. int max = (int)m_arFolder.GetSize();
  675. CRect frc;
  676. int t;
  677. for (t = 0; t < max; t++)
  678. {
  679. GetFolderRect(t, frc);
  680. DrawFolder(pDC, t, frc, xtMouseNormal);
  681. }
  682. if (!GetFolderChild())
  683. {
  684. int f, l;
  685. GetVisibleRange(m_nSelFolder, f, l);
  686. m_rcUpArrow.SetRect(0, 0, GetSystemMetrics(SM_CXVSCROLL), GetSystemMetrics(SM_CXVSCROLL));
  687. m_rcDownArrow = m_rcUpArrow;
  688. m_rcUpArrow.OffsetRect(rc.right - 5 - GetSystemMetrics(SM_CXVSCROLL), rc.top +5);
  689. m_rcDownArrow.OffsetRect(rc.right - 5 - GetSystemMetrics(SM_CXVSCROLL), rc.bottom - 5 - GetSystemMetrics(SM_CXVSCROLL));
  691. if (f > 0 && m_rcUpArrow.IntersectRect(rc, m_rcUpArrow))
  692. {
  693. if (m_bUpPressed)
  694. {
  695. DrawScrollButton(pDC, m_rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP | DFCS_PUSHED);
  696. }
  697. else
  698. {
  699. DrawScrollButton(pDC, m_rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  700. }
  701. m_bUpArrow = TRUE;
  702. pDC->ExcludeClipRect(m_rcUpArrow);
  703. }
  704. else m_bUpArrow = FALSE;
  706. if (l < GetItemCount() - 1 && m_rcDownArrow.IntersectRect(rc, m_rcDownArrow))
  707. {
  708. if (m_bDownPressed)
  709. {
  710. DrawScrollButton(pDC, m_rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN | DFCS_PUSHED);
  711. }
  712. else
  713. {
  714. DrawScrollButton(pDC, m_rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  715. }
  716. m_bDownArrow = TRUE;
  717. pDC->ExcludeClipRect(m_rcDownArrow);
  718. }
  719. else m_bDownArrow = FALSE;
  721. PaintItems(pDC, m_nSelFolder, rc);
  722. }
  724. //dc.BitBlt(rectClient.left, rectClient.top, rectClient.Width(), rectClient.Height(), pDC, 0, 0, SRCCOPY);
  726. //pDC->RestoreDC(nSavedDC);
  728. if (m_nFolderHilighted >= 0)
  729. {
  730. int i = m_nFolderHilighted;
  731. m_nFolderHilighted = -1;
  732. HighlightFolder(pDC, i);
  733. }
  734. if (m_nItemHilighted >= 0)
  735. {
  736. int i = m_nItemHilighted;
  737. m_nItemHilighted = -1;
  738. HighlightItem(pDC, i, m_bPressedHighlight);
  739. }
  740. }
  742. BOOL CXTOutBarCtrl::OnEraseBkgnd(CDC* /*pDC*/)
  743. {
  744. return TRUE;
  745. }
  747. BOOL CXTOutBarCtrl::GetFolderRect(const int iIndex, CRect& rect) const
  748. {
  749. if (m_arFolder.GetSize() != 0)
  750. {
  751. int max = (int)m_arFolder.GetSize();
  752. ASSERT(iIndex >= 0 && iIndex < max);
  754. if (iIndex >= 0 && iIndex < max)
  755. {
  756. CRect rc;
  757. GetClientRect(rc);
  758. if (iIndex > m_nSelFolder)
  759. rect.SetRect(rc.left, rc.bottom - ((max - iIndex))* m_nFolderHeight, rc.right,
  760. rc.bottom - (max - iIndex - 1)* m_nFolderHeight);
  761. else
  762. rect.SetRect(rc.left, rc.top + iIndex* m_nFolderHeight, rc.right,
  763. rc.top + (1 + iIndex)* m_nFolderHeight);
  764. return TRUE;
  765. }
  766. }
  767. return FALSE;
  768. }
  770. void CXTOutBarCtrl::GetItemRect(const int iFolder, const int iIndex, CRect& rect, CRect* pInsideRect /*= NULL*/)
  771. {
  772. CRect rc;
  773. if (pInsideRect)
  774. rc = *pInsideRect;
  775. else
  776. GetInsideRect(rc);
  778. int top = rc.top;
  779. CSize sz(0, 0);
  780. int y = 0;
  781. int t;
  782. for (t = 0; t < iIndex; t++)
  783. {
  784. sz = GetItemSize(iFolder, t, rectItemBoth);
  785. top += sz.cy;
  787. if (IsSmallIconView(iFolder))
  788. {
  789. top += m_nIconSpacingSmall;
  790. }
  791. else
  792. {
  793. top += m_nIconSpacingLarge;
  794. }
  795. if (t == m_nFirstItem - 1) y = top - rc.top;
  796. }
  797. sz = GetItemSize(iFolder, iIndex, rectItemBoth);
  798. rect.SetRect(rc.left, top, rc.left + sz.cx, top + sz.cy);
  800. rect.top -= y;
  801. rect.bottom -= y;
  803. rect.left += m_sizeMargin.cx;
  804. rect.top += m_sizeMargin.cy;
  805. rect.bottom += m_sizeMargin.cy;
  807. if (!IsSmallIconView(iFolder))
  808. {
  809. rect.left = rc.left;
  810. rect.right = rc.right;
  811. }
  812. }
  814. void CXTOutBarCtrl::DrawFolder(CDC* pDC, const int iIndex, CRect rect, const XTMouseState eHilight)
  815. {
  816. if (iIndex < m_arFolder.GetSize() && (iIndex >= 0))
  817. {
  818. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iIndex);
  820. GetTheme()->DrawFolder(pDC, rect, pBarFolder, eHilight);
  821. }
  822. }
  824. int CXTOutBarCtrl::AddFolder(LPCTSTR lpszFolderName, const DWORD dwData)
  825. {
  826. CXTOutBarFolder* pBarFolder = new CXTOutBarFolder(lpszFolderName, dwData, this);
  827. ASSERT(pBarFolder);
  829. pBarFolder->m_bSmallIcons = (m_dwFlags & OBS_XT_SMALLICON);
  831. return (int)m_arFolder.Add((void*)pBarFolder);
  832. }
  834. void CXTOutBarCtrl::GetInsideRect(CRect& rect) const
  835. {
  836. GetClientRect(rect);
  837. if (m_arFolder.GetSize() > 0)
  838. {
  839. int max = (int)m_arFolder.GetSize();
  840. rect.top += m_nFolderHeight* (m_nSelFolder + 1);
  841. rect.bottom -= (max - m_nSelFolder - 1) * m_nFolderHeight;
  842. return;
  843. }
  844. }
  846. void CXTOutBarCtrl::OnMouseLeave()
  847. {
  848. OnMouseMove(0, CPoint(-1, -1));
  849. }
  851. void CXTOutBarCtrl::OnMouseMove(UINT nFlags, CPoint point)
  852. {
  853. int iIndex;
  854. int ht = HitTestEx(point, iIndex);
  856. int nFolderHilighted = -1, nItemHilighted = -1;
  858. if (ht == hitFolder) nFolderHilighted = iIndex;
  859. if (ht == hitItem) nItemHilighted = iIndex;
  861. if ((m_nFolderHilighted != nFolderHilighted) || (m_nItemHilighted != nItemHilighted))
  862. {
  863. m_nFolderHilighted = nFolderHilighted;
  864. m_nItemHilighted = nItemHilighted;
  865. Invalidate(FALSE);
  867. if (nFolderHilighted != -1 || nItemHilighted != -1)
  868. {
  869. TRACKMOUSEEVENT tme =
  870. {
  871. sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd
  872. };
  873. _TrackMouseEvent(&tme);
  874. }
  875. }
  877. CWnd::OnMouseMove(nFlags, point);
  878. }
  880. CXTOutBarCtrl::HitTestCode CXTOutBarCtrl::HitTestEx(const CPoint& point, int& iIndex)
  881. {
  882. if (m_arFolder.GetSize() != 0)
  883. {
  884. if (m_bUpArrow && m_rcUpArrow.PtInRect(point)) return hitUpScroll;
  885. if (m_bDownArrow && m_rcDownArrow.PtInRect(point)) return hitDnScroll;
  887. int max = (int)m_arFolder.GetSize(), t;
  889. CRect rc;
  890. for (t = 0; t < max; t++)
  891. {
  892. GetFolderRect(t, rc);
  893. if (rc.PtInRect(point))
  894. {
  895. iIndex = t;
  896. return hitFolder;
  897. }
  898. }
  899. GetInsideRect(rc);
  900. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  901. max = pBarFolder->GetItemCount();
  902. for (t = m_nFirstItem; t < max; t++)
  903. {
  904. CRect rcItem;
  905. if (!IsSmallIconView(m_nSelFolder))
  906. {
  907. GetIconRect(m_nSelFolder, t, rcItem);
  908. if (rcItem.PtInRect(point))
  909. {
  910. iIndex = t;
  911. return hitItem;
  912. }
  913. else if (rcItem.top > rc.bottom) break;
  914. GetLabelRect(m_nSelFolder, t, rcItem);
  915. rcItem.top -= m_sizeOffset.cy;
  917. if (rcItem.PtInRect(point))
  918. {
  919. iIndex = t;
  920. return hitItem;
  921. }
  922. else if (rcItem.top > rc.bottom) break;
  923. }
  924. else
  925. {
  926. GetItemRect(m_nSelFolder, t, rcItem);
  927. if (rcItem.PtInRect(point))
  928. {
  929. iIndex = t;
  930. return hitItem;
  931. }
  932. else if (rcItem.top > rc.bottom) break;
  933. }
  934. }
  935. }
  936. return hitNone;
  937. }
  939. void CXTOutBarCtrl::HighlightFolder(CDC* pDC, const int iIndex)
  940. {
  941. CWnd* pFocus = GetFocus();
  942. if (pFocus != NULL && pFocus != this && IsChild(pFocus))
  943. {
  944. return;
  945. }
  947. if (m_nFolderHilighted == iIndex)
  948. return;
  950. CDC dcClient;
  951. if (!pDC)
  952. {
  953. dcClient.Attach(::GetDC(m_hWnd));
  954. pDC = &dcClient;
  955. }
  957. if (m_nFolderHilighted >= 0)
  958. {
  959. CRect rc;
  960. if (GetFolderRect(m_nFolderHilighted, rc))
  961. {
  962. DrawFolder(pDC, m_nFolderHilighted, rc, xtMouseNormal);
  963. }
  964. }
  966. if (iIndex >= 0)
  967. {
  968. CRect rc;
  969. if (GetFolderRect(iIndex, rc))
  970. {
  971. DrawFolder(pDC, iIndex, rc, xtMouseHover);
  972. }
  973. }
  974. if (dcClient.GetSafeHdc())
  975. {
  976. ::ReleaseDC(m_hWnd, dcClient.Detach());
  977. }
  979. m_nFolderHilighted = iIndex;
  980. }
  982. void CXTOutBarCtrl::OnLButtonDown(UINT nFlags, CPoint point)
  983. {
  984. if (GetFocus() != this) SetFocus();
  986. int iIndex, ht = HitTestEx(point, iIndex);
  987. m_nLastDragItemDrawType = -1;
  989. CRect inRc;
  990. GetInsideRect(inRc);
  992. if (ht == hitFolder)
  993. {
  994. BOOL bHigh = TRUE;
  995. CRect rc;
  996. GetFolderRect(iIndex, rc);
  998. if (::GetCapture() == NULL)
  999. {
  1000. SetCapture();
  1001. ASSERT(this == GetCapture());
  1002. CClientDC dc(this);
  1003. DrawFolder(&dc, iIndex, rc, xtMouseSelect);
  1004. AfxLockTempMaps();
  1005. for (;;)
  1006. {
  1007. MSG msg;
  1008. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1010. if (CWnd::GetCapture() != this) break;
  1012. switch (msg.message)
  1013. {
  1014. case WM_MOUSEMOVE:
  1015. {
  1016. CPoint pt(msg.lParam);
  1017. int idx, ht1 = HitTestEx(pt, idx);
  1018. if (ht1 == hitFolder && idx == iIndex)
  1019. {
  1020. if (!bHigh)
  1021. {
  1022. DrawFolder(&dc, iIndex, rc, xtMouseSelect);
  1023. bHigh = TRUE;
  1024. }
  1025. }
  1026. else
  1027. {
  1028. if (bHigh)
  1029. {
  1030. DrawFolder(&dc, iIndex, rc, xtMouseNormal);
  1031. bHigh = FALSE;
  1032. }
  1033. }
  1034. }
  1035. break;
  1037. case WM_LBUTTONUP:
  1038. {
  1039. ReleaseCapture();
  1041. if (bHigh)
  1042. {
  1043. DrawFolder(&dc, iIndex, rc, xtMouseNormal);
  1044. bHigh = FALSE;
  1045. }
  1046. CPoint pt(msg.lParam);
  1047. int idx, ht1 = HitTestEx(pt, idx);
  1048. if (ht1 == hitFolder && idx != m_nSelFolder)
  1049. SetSelFolder(idx);
  1050. }
  1052. goto ExitLoop2;
  1054. case WM_KEYDOWN:
  1055. if (msg.wParam != VK_ESCAPE)
  1056. break;
  1058. default:
  1059. DispatchMessage(&msg);
  1060. break;
  1061. }
  1062. }
  1064. ExitLoop2:
  1065. ReleaseCapture();
  1066. AfxUnlockTempMaps(FALSE);
  1067. }
  1068. if (bHigh) InvalidateRect(rc, FALSE);
  1069. }
  1070. else m_nLastFolderSelected = -1;
  1072. if (ht == hitItem)
  1073. {
  1074. m_nLastDragItemDraw = -1;
  1075. BOOL bHigh = TRUE, bDragging = FALSE;
  1076. CRect rc;
  1077. GetItemRect(m_nSelFolder, iIndex, rc);
  1079. HCURSOR hCur = GetCursor();
  1081. if (::GetCapture() == NULL)
  1082. {
  1083. SetCapture();
  1084. ASSERT(this == GetCapture());
  1085. CClientDC dc(this);
  1086. HighlightItem(NULL, iIndex, TRUE);
  1087. AfxLockTempMaps();
  1088. for (;;)
  1089. {
  1090. MSG msg;
  1091. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1093. if (CWnd::GetCapture() != this) break;
  1095. switch (msg.message)
  1096. {
  1097. case WM_MOUSEMOVE:
  1098. {
  1099. CPoint pt(msg.lParam);
  1100. int idx, ht1 = HitTestEx(pt, idx);
  1101. if (bDragging)
  1102. {
  1103. if (ht1 == hitItem)
  1104. {
  1105. DrawDragArrow(&dc, iIndex, idx);
  1106. ::SetCursor(XTAuxData().hcurDragMove);
  1107. hCur = XTAuxData().hcurDragMove;
  1108. }
  1109. else
  1110. {
  1111. CRect rcItem;
  1112. GetItemRect(m_nSelFolder, GetItemCount() - 1, rcItem);
  1113. if (pt.y > rcItem.bottom && pt.y < inRc.bottom)
  1114. {
  1115. DrawDragArrow(&dc, iIndex, GetItemCount());
  1116. ::SetCursor(XTAuxData().hcurDragMove);
  1117. hCur = XTAuxData().hcurDragMove;
  1118. }
  1119. else
  1120. {
  1121. DrawDragArrow(&dc, iIndex, -1);
  1122. ::SetCursor(XTAuxData().hcurDragNone);
  1123. hCur = XTAuxData().hcurDragNone;
  1124. }
  1125. }
  1126. }
  1127. else
  1128. {
  1129. if (ht1 == hitItem && idx == iIndex)
  1130. {
  1131. if (!bHigh)
  1132. {
  1133. HighlightItem(NULL, iIndex, TRUE);
  1134. bHigh = TRUE;
  1135. m_bPressedHighlight = TRUE;
  1136. }
  1137. }
  1138. else
  1139. {
  1140. if (ht1 == hitItem)
  1141. {
  1142. if (bHigh)
  1143. {
  1144. HighlightItem(NULL, iIndex, FALSE);
  1145. bHigh = FALSE;
  1146. m_bPressedHighlight = FALSE;
  1147. }
  1148. }
  1149. else
  1150. {
  1151. if (m_dwFlags & OBS_XT_DRAGITEMS)
  1152. {
  1153. HighlightItem(NULL, iIndex, TRUE);
  1154. bHigh = TRUE;
  1155. bDragging = TRUE;
  1157. XT_OUTBAR_INFO obi;
  1158. obi.nIndex = iIndex;
  1159. obi.nDragFrom = -1;
  1160. obi.nDragTo = -1;
  1161. obi.lpszText = GetItemText(iIndex);
  1162. obi.bFolder = false;
  1164. NotifyOwner(OBN_XT_BEGINDRAG, &obi);
  1166. ::SetCursor(XTAuxData().hcurDragMove);
  1167. hCur = XTAuxData().hcurDragMove;
  1169. m_bPressedHighlight = TRUE;
  1170. }
  1171. }
  1172. }
  1173. }
  1174. }
  1175. break;
  1177. case WM_SETCURSOR:
  1178. ::SetCursor(hCur);
  1179. break;
  1181. case WM_LBUTTONUP:
  1182. {
  1183. ReleaseCapture();
  1185. if (bHigh)
  1186. {
  1187. HighlightItem(NULL, -1);
  1188. bHigh = FALSE;
  1189. }
  1190. CPoint pt(msg.lParam);
  1191. int idx, ht1 = HitTestEx(pt, idx);
  1192. if (!bDragging)
  1193. {
  1194. if (ht1 == hitItem && idx == iIndex)
  1195. {
  1196. CXTOutBarItem* pBarItem = GetBarFolderItem(m_nSelFolder, idx);
  1197. if (!pBarItem->IsEnabled())
  1198. {
  1199. return;
  1200. }
  1202. XT_OUTBAR_INFO obi;
  1203. obi.nIndex = idx;
  1204. obi.nDragFrom = -1;
  1205. obi.nDragTo = -1;
  1206. obi.lpszText = GetItemText(idx);
  1207. obi.bFolder = false;
  1209. int nSelFolder = m_nSelFolder;
  1211. LRESULT lResult = NotifyOwner(OBN_XT_ITEMCLICK, &obi);
  1213. if (lResult == TRUE && nSelFolder == GetSelFolder())
  1214. {
  1215. CXTOutBarFolder* pBarFolder = GetBarFolder(GetSelFolder());
  1216. pBarFolder->SetSelItem(idx);
  1218. if (m_nSelAnimTiming > 0 && iIndex != m_nLastItemSelected && m_nLastItemSelected >= 0)
  1219. {
  1220. DrawAnimItem(0, 0, m_nLastItemSelected);
  1221. }
  1223. BOOL bInvalidate = FALSE;
  1225. if ((m_dwFlags & OBS_XT_SELHIGHLIGHT) && (m_nLastItemSelected >= 0))
  1226. {
  1227. bInvalidate = TRUE;
  1228. }
  1230. m_nLastItemSelected = iIndex;
  1232. if ((m_dwFlags & OBS_XT_SELHIGHLIGHT) && (m_nLastItemSelected >= 0))
  1233. {
  1234. bInvalidate = TRUE;
  1235. }
  1237. if (bInvalidate)
  1238. {
  1239. Invalidate(FALSE);
  1240. }
  1241. }
  1242. }
  1243. }
  1244. else
  1245. {
  1246. if (ht1 == hitItem)
  1247. {
  1248. if (idx != iIndex)
  1249. {
  1250. int iItemSelected = m_nLastItemSelected;
  1252. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  1253. POSITION pos1 = pBarFolder->m_barItems.FindIndex(iIndex);
  1255. CXTOutBarItem* pItemFrom = (CXTOutBarItem*)pBarFolder->m_barItems.GetAt(pos1);
  1256. POSITION pos2 = pBarFolder->m_barItems.FindIndex(idx);
  1258. XT_OUTBAR_INFO obi;
  1259. obi.nIndex = iIndex;
  1260. obi.nDragFrom = iIndex;
  1261. obi.nDragTo = idx;
  1262. obi.lpszText = GetItemText(iIndex);
  1263. obi.bFolder = false;
  1265. LRESULT lResult = NotifyOwner(OBN_XT_DRAGITEM, &obi);
  1267. if (lResult == TRUE)
  1268. {
  1269. if (m_arFolder.GetSize() != 0)
  1270. {
  1271. pBarFolder->m_barItems.RemoveAt(pos1);
  1272. pBarFolder->m_barItems.InsertBefore(pos2, pItemFrom);
  1273. }
  1275. int i = -1;
  1276. if (iItemSelected == iIndex)
  1277. {
  1278. i = idx;
  1280. if (idx > iIndex)
  1281. {
  1282. i--;
  1283. }
  1284. }
  1286. else if (((iIndex <= m_nLastItemSelected) && (idx <= m_nLastItemSelected)) ||
  1287. ((iIndex > m_nLastItemSelected) && (idx > m_nLastItemSelected)))
  1288. {
  1289. // do nothing...
  1290. }
  1292. else if (m_nLastItemSelected != -1)
  1293. {
  1294. i = m_nLastItemSelected;
  1296. if (idx > m_nLastItemSelected)
  1297. {
  1298. i--;
  1299. }
  1300. else
  1301. {
  1302. i++;
  1303. }
  1304. }
  1306. if (i >= 0)
  1307. {
  1308. pBarFolder->SetSelItem(i);
  1309. m_nLastItemSelected = i;
  1310. }
  1311. }
  1312. }
  1313. }
  1314. else
  1315. {
  1316. CRect rcItem;
  1317. GetItemRect(m_nSelFolder, GetItemCount() - 1, rcItem);
  1318. if (pt.y > rcItem.bottom && pt.y < inRc.bottom)
  1319. {
  1320. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  1321. POSITION pos1 = pBarFolder->m_barItems.FindIndex(iIndex);
  1323. CXTOutBarItem* pItemFrom = (CXTOutBarItem*)pBarFolder->m_barItems.GetAt(pos1);
  1324. POSITION pos2 = pBarFolder->m_barItems.FindIndex(pBarFolder->m_barItems.GetCount());
  1326. XT_OUTBAR_INFO obi;
  1327. obi.nIndex = (int)pBarFolder->m_barItems.GetCount();
  1328. obi.nDragFrom = iIndex;
  1329. obi.nDragTo = obi.nIndex;
  1330. obi.lpszText = GetItemText(iIndex);
  1331. obi.bFolder = false;
  1333. LRESULT lResult = NotifyOwner(OBN_XT_DRAGITEM, &obi);
  1335. if (lResult == TRUE)
  1336. {
  1337. pBarFolder->m_barItems.RemoveAt(pos1);
  1338. pBarFolder->m_barItems.InsertAfter(pos2, pItemFrom);
  1339. }
  1340. }
  1341. }
  1342. }
  1343. }
  1345. goto ExitLoop4;
  1347. default:
  1348. DispatchMessage(&msg);
  1349. break;
  1350. }
  1351. }
  1353. ExitLoop4:
  1354. ReleaseCapture();
  1355. AfxUnlockTempMaps(FALSE);
  1356. if (bDragging)
  1357. {
  1358. Invalidate();
  1359. }
  1360. }
  1361. m_bPressedHighlight = FALSE;
  1362. if (bHigh) InvalidateRect(rc, FALSE);
  1363. }
  1364. else m_nItemHilighted = -1;
  1366. if (ht == hitDnScroll)
  1367. {
  1368. m_bLooping = TRUE;
  1369. BOOL bHigh = TRUE;
  1371. if (::GetCapture() == NULL)
  1372. {
  1373. SetCapture();
  1374. ASSERT(this == GetCapture());
  1375. CClientDC dc(this);
  1377. DrawScrollButton(&dc, m_rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN | DFCS_PUSHED);
  1379. SetTimer(2, 300, NULL);
  1380. AfxLockTempMaps();
  1381. for (;;)
  1382. {
  1383. MSG msg;
  1384. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1386. if (CWnd::GetCapture() != this) break;
  1388. switch (msg.message)
  1389. {
  1390. case WM_MOUSEMOVE:
  1391. {
  1392. CPoint pt(msg.lParam);
  1393. if (m_rcDownArrow.PtInRect(pt))
  1394. {
  1395. if (bHigh == FALSE)
  1396. {
  1397. DrawScrollButton(&dc, m_rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN | DFCS_PUSHED);
  1398. bHigh = TRUE;
  1399. m_bDownArrow = TRUE;
  1400. m_bDownPressed = TRUE;
  1401. }
  1402. }
  1403. else
  1404. {
  1405. if (bHigh == TRUE)
  1406. {
  1407. DrawScrollButton(&dc, m_rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  1408. bHigh = FALSE;
  1409. m_bDownArrow = FALSE;
  1410. m_bDownPressed = FALSE;
  1411. }
  1412. }
  1413. }
  1414. break;
  1416. case WM_LBUTTONUP:
  1417. {
  1418. ReleaseCapture();
  1420. if (bHigh)
  1421. {
  1422. DrawScrollButton(&dc, m_rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  1423. bHigh = FALSE;
  1424. }
  1425. m_bDownArrow = FALSE;
  1426. CPoint pt(msg.lParam);
  1427. if (m_rcDownArrow.PtInRect(pt))
  1428. {
  1429. CRect itrc;
  1430. GetItemRect(m_nSelFolder, GetItemCount() - 1, itrc);
  1431. CRect crc;
  1432. GetInsideRect(crc);
  1433. if (itrc.bottom > crc.bottom)
  1434. {
  1435. m_nFirstItem++;
  1436. InvalidateRect(crc, TRUE);
  1437. }
  1438. }
  1439. }
  1440. goto ExitLoop3;
  1443. case WM_TIMER:
  1444. {
  1445. if (msg.wParam == 2)
  1446. {
  1447. if (bHigh)
  1448. {
  1449. CPoint pt(msg.pt);
  1450. ScreenToClient(&pt);
  1451. if (m_rcDownArrow.PtInRect(pt))
  1452. {
  1453. m_bDownPressed = TRUE;
  1454. CRect itrc;
  1455. GetItemRect(m_nSelFolder, GetItemCount() - 1, itrc);
  1456. CRect crc;
  1457. GetInsideRect(crc);
  1458. if (itrc.bottom > crc.bottom)
  1459. {
  1460. m_nFirstItem++;
  1461. InvalidateRect(crc, TRUE);
  1462. }
  1463. else goto ExitLoop3;
  1464. }
  1465. else m_bDownPressed = FALSE;
  1466. }
  1467. }
  1468. break;
  1469. }
  1471. case WM_KEYDOWN:
  1472. if (msg.wParam != VK_ESCAPE)
  1473. break;
  1475. default:
  1476. DispatchMessage(&msg);
  1477. break;
  1478. }
  1479. }
  1481. ExitLoop3:
  1482. KillTimer(2);
  1483. ReleaseCapture();
  1484. AfxUnlockTempMaps(FALSE);
  1485. m_bLooping = FALSE;
  1486. m_bDownPressed = FALSE;
  1487. m_bDownArrow = FALSE;
  1488. CRect crc;
  1489. GetInsideRect(crc);
  1490. InvalidateRect(crc, TRUE);
  1491. }
  1492. }
  1494. if (ht == hitUpScroll)
  1495. {
  1496. m_bLooping = TRUE;
  1497. BOOL bHigh = TRUE;
  1499. if (::GetCapture() == NULL)
  1500. {
  1501. SetCapture();
  1502. ASSERT(this == GetCapture());
  1503. CClientDC dc(this);
  1504. DrawScrollButton(&dc, m_rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP | DFCS_PUSHED);
  1505. SetTimer(2, 300, NULL);
  1506. AfxLockTempMaps();
  1507. for (;;)
  1508. {
  1509. MSG msg;
  1510. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1512. if (CWnd::GetCapture() != this) break;
  1514. switch (msg.message)
  1515. {
  1516. case WM_MOUSEMOVE:
  1517. {
  1518. CPoint pt(msg.lParam);
  1519. if (m_rcUpArrow.PtInRect(pt))
  1520. {
  1521. if (bHigh == FALSE)
  1522. {
  1523. DrawScrollButton(&dc, m_rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP | DFCS_PUSHED);
  1524. bHigh = TRUE;
  1525. m_bUpArrow = TRUE;
  1526. m_bUpPressed = TRUE;
  1527. }
  1528. }
  1529. else
  1530. {
  1531. if (bHigh == TRUE)
  1532. {
  1533. DrawScrollButton(&dc, m_rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  1534. bHigh = FALSE;
  1535. m_bUpArrow = FALSE;
  1536. m_bUpPressed = FALSE;
  1537. }
  1538. }
  1539. }
  1540. break;
  1542. case WM_LBUTTONUP:
  1543. {
  1544. ReleaseCapture();
  1546. if (bHigh)
  1547. {
  1548. DrawScrollButton(&dc, m_rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  1549. bHigh = FALSE;
  1550. }
  1551. m_bUpArrow = FALSE;
  1552. CPoint pt(msg.lParam);
  1553. if (m_rcUpArrow.PtInRect(pt))
  1554. {
  1555. if (m_nFirstItem > 0)
  1556. {
  1557. m_nFirstItem--;
  1558. CRect crc;
  1559. GetInsideRect(crc);
  1560. InvalidateRect(crc, TRUE);
  1561. }
  1562. }
  1563. }
  1565. goto ExitLoop;
  1567. case WM_TIMER:
  1568. {
  1569. if (msg.wParam == 2)
  1570. {
  1571. if (bHigh)
  1572. {
  1573. CPoint pt(msg.pt);
  1574. ScreenToClient(&pt);
  1575. if (m_rcUpArrow.PtInRect(pt))
  1576. {
  1577. m_bUpPressed = TRUE;
  1578. if (m_nFirstItem > 0)
  1579. {
  1580. m_nFirstItem--;
  1581. CRect crc;
  1582. GetInsideRect(crc);
  1583. InvalidateRect(crc, TRUE);
  1584. }
  1585. else goto ExitLoop;
  1586. }
  1587. else m_bUpPressed = FALSE;
  1588. }
  1589. }
  1590. break;
  1591. }
  1592. case WM_KEYDOWN:
  1593. if (msg.wParam != VK_ESCAPE) break;
  1595. default:
  1596. DispatchMessage(&msg);
  1597. break;
  1598. }
  1599. }
  1601. ExitLoop:
  1602. KillTimer(2);
  1603. ReleaseCapture();
  1604. AfxUnlockTempMaps(FALSE);
  1605. m_bLooping = FALSE;
  1606. m_bUpPressed = FALSE;
  1607. m_bUpArrow = FALSE;
  1608. CRect crc;
  1609. GetInsideRect(crc);
  1610. InvalidateRect(crc, TRUE);
  1611. }
  1612. }
  1614. CWnd::OnLButtonDown(nFlags, point);
  1615. }
  1617. int CXTOutBarCtrl::InsertItem(const int iFolder, const int iIndex, LPCTSTR lpszItemName, const int iImage, const DWORD dwData)
  1618. {
  1619. if (m_arFolder.GetSize() != 0)
  1620. {
  1621. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1623. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  1625. return pBarFolder->InsertItem(iIndex, lpszItemName, iImage, dwData);
  1626. }
  1627. return -1;
  1628. }
  1630. int CXTOutBarCtrl::GetItemCount() const
  1631. {
  1632. if (m_arFolder.GetSize() != 0)
  1633. {
  1634. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  1635. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  1636. return  pBarFolder->GetItemCount();
  1637. }
  1638. return 0;
  1639. }
  1641. void CXTOutBarCtrl::SetSelFolder(const int iIndex)
  1642. {
  1643. if (m_arFolder.GetSize() != 0)
  1644. {
  1645. ASSERT(iIndex >= 0 && iIndex < GetFolderCount());
  1647. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iIndex);
  1649. XT_OUTBAR_INFO obi;
  1650. obi.nIndex = iIndex;
  1651. obi.nDragFrom = -1;
  1652. obi.nDragTo = -1;
  1653. obi.lpszText = (LPCTSTR)pBarFolder->GetName();
  1654. obi.bFolder = true;
  1656. LRESULT lResult = NotifyOwner(OBN_XT_FOLDERCHANGE, &obi);
  1658. if (lResult == TRUE)
  1659. {
  1660. CWnd* pWnd = GetFolderChild();
  1661. if (pWnd)
  1662. {
  1663. pWnd->ShowWindow(SW_HIDE);
  1664. }
  1666. m_nLastItemSelected = -1;
  1668. if (iIndex != m_nSelFolder && m_nSelFolder >= 0)
  1669. {
  1670. if ((m_dwFlags & OBS_XT_ANIMATION) && (m_nAnimationTickCount >= 0))
  1671. {
  1672. AnimateFolderScroll(m_nSelFolder, iIndex);
  1673. }
  1674. }
  1676. m_nSelFolder = iIndex;
  1677. m_nFirstItem = 0;
  1679. pWnd = GetFolderChild();
  1680. if (pWnd)
  1681. {
  1682. CRect rc;
  1683. GetInsideRect(rc);
  1684. pWnd->MoveWindow(rc);
  1685. pWnd->ShowWindow(SW_SHOW);
  1686. }
  1688. InvalidateRect(NULL);
  1689. }
  1690. }
  1691. }
  1693. int CXTOutBarCtrl::GetFolderCount() const
  1694. {
  1695. return (int)m_arFolder.GetSize();
  1696. }
  1698. int CXTOutBarCtrl::GetSelFolder() const
  1699. {
  1700. return m_nSelFolder;
  1701. }
  1703. void CXTOutBarCtrl::RemoveFolder(const int iIndex)
  1704. {
  1705. if (m_arFolder.GetSize() != 0)
  1706. {
  1707. ASSERT(iIndex >= 0 && iIndex < GetFolderCount());
  1708. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iIndex);
  1710. XT_OUTBAR_INFO obi;
  1711. obi.nIndex = iIndex;
  1712. obi.nDragFrom = -1;
  1713. obi.nDragTo = -1;
  1714. obi.lpszText = (LPCTSTR)pBarFolder->GetName();
  1715. obi.bFolder = true;
  1717. LRESULT lResult = NotifyOwner(OBN_XT_DELETEFOLDER, &obi);
  1719. if (lResult == TRUE)
  1720. {
  1721. if (m_nSelFolder >= iIndex)
  1722. {
  1723. m_nSelFolder = iIndex - 1;
  1724. }
  1725. if (m_nSelFolder < 0 && GetFolderCount() > 0)
  1726. {
  1727. m_nSelFolder = 0;
  1728. }
  1730. m_arFolder.RemoveAt(iIndex);
  1731. SAFE_DELETE(pBarFolder);
  1733. InvalidateRect(NULL);
  1734. }
  1735. }
  1736. }
  1738. CImageList* CXTOutBarCtrl::SetImageList(CImageList* pImageList, DWORD dwImageList)
  1739. {
  1740. CImageList* pOldImageList = NULL;
  1742. if (dwImageList & OBS_XT_SMALLICON)
  1743. {
  1744. pOldImageList = m_pSmallImageList;
  1745. m_pSmallImageList = pImageList;
  1746. }
  1747. else if (dwImageList & OBS_XT_LARGEICON)
  1748. {
  1749. pOldImageList = m_pLargeImageList;
  1750. m_pLargeImageList = pImageList;
  1751. }
  1753. return pOldImageList;
  1754. }
  1756. CImageList* CXTOutBarCtrl::GetImageList(DWORD dwImageList)
  1757. {
  1758. if (dwImageList & OBS_XT_SMALLICON)
  1759. {
  1760. return m_pSmallImageList;
  1761. }
  1762. else if (dwImageList & OBS_XT_LARGEICON)
  1763. {
  1764. return m_pLargeImageList;
  1765. }
  1767. return NULL;
  1768. }
  1770. CImageList* CXTOutBarCtrl::SetFolderImageList(const int iFolder, CImageList* pImageList, DWORD dwImageList)
  1771. {
  1772. if (m_arFolder.GetSize() != 0)
  1773. {
  1774. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1775. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  1776. CImageList* pOldImageList = NULL;
  1778. if (dwImageList & OBS_XT_SMALLICON)
  1779. {
  1780. pOldImageList = pBarFolder->GetSmallImageList();
  1781. pBarFolder->SetSmallImageList(pImageList);
  1782. }
  1784. else if (dwImageList & OBS_XT_LARGEICON)
  1785. {
  1786. pOldImageList = pBarFolder->GetLargeImageList();
  1787. pBarFolder->SetLargeImageList(pImageList);
  1788. }
  1790. return pOldImageList;
  1791. }
  1792. return NULL;
  1793. }
  1795. void CXTOutBarCtrl::PaintItems(CDC* pDC, const int iFolder, CRect rc)
  1796. {
  1797. if (m_arFolder.GetSize() != 0)
  1798. {
  1799. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1800. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  1802. int nItemCount = pBarFolder->GetItemCount();
  1804. CRgn rgn;
  1805. rgn.CreateRectRgnIndirect(&rc);
  1806. pDC->SelectClipRgn(&rgn);
  1808. for (int i = m_nFirstItem; i < nItemCount; i++)
  1809. {
  1810. CRect rcItem;
  1811. GetItemRect(iFolder, i, rcItem, &rc);
  1812. if (rcItem.top > rc.bottom)
  1813. break;
  1815. DrawItem(pDC, iFolder, rcItem, i);
  1816. }
  1818. pDC->SelectClipRgn(NULL);
  1820. //rgn.DeleteObject();
  1821. }
  1822. }
  1824. CSize CXTOutBarCtrl::GetItemSize(const int iFolder, const int iIndex, const RectItem iType)
  1825. {
  1826. if (m_arFolder.GetSize() != 0)
  1827. {
  1828. if (iFolder < 0 || iFolder >= GetFolderCount())
  1829. return CSize(0, 0);
  1831. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  1833. if (iIndex < 0 || iIndex >= pBarFolder->GetItemCount())
  1834. return CSize(0, 0);
  1836. CXTOutBarItem* pBarItem = pBarFolder->GetItemAt(iIndex);
  1838. CSize szImage(0, 0);
  1839. CSize szLabel(0, 0);
  1840. CSize szAll(0, 0);
  1842. if (pBarItem->GetIndex() >= 0)
  1843. {
  1844. if (iType != rectItemLabel)
  1845. {
  1846. CImageList* il = GetFolderImageList(iFolder, IsSmallIconView(iFolder));
  1847. ASSERT(il);
  1848. if (il)
  1849. {
  1850. IMAGEINFO ii;
  1851. il->GetImageInfo(pBarItem->GetIndex(), &ii);
  1852. szImage = CRect(ii.rcImage).Size();
  1853. }
  1854. }
  1855. }
  1856. if (pBarItem->GetName().GetLength())
  1857. {
  1858. if (iType != rectItemIcon)
  1859. {
  1860. CClientDC dc(this);
  1861. CFont* oft = (CFont*)dc.SelectObject(GetFontX());
  1862. if (IsSmallIconView(iFolder))
  1863. {
  1864. szLabel = dc.GetTextExtent(pBarItem->GetName(), pBarItem->GetName().GetLength());
  1865. }
  1866. else
  1867. {
  1868. CRect rc;
  1869. GetInsideRect(rc);
  1870. rc.bottom = rc.top;
  1871. dc.DrawText(pBarItem->GetName(), pBarItem->GetName().GetLength(), rc,
  1872. DT_CALCRECT | DT_CENTER | DT_VCENTER | DT_WORDBREAK | DT_END_ELLIPSIS);
  1873. szLabel = rc.Size();
  1874. }
  1875. dc.SelectObject(oft);
  1876. }
  1877. }
  1878. if (IsSmallIconView(iFolder))
  1879. {
  1880. if (iType == rectItemIcon) szAll = szImage;
  1881. else if (iType == rectItemLabel) szAll = szLabel;
  1882. else if (iType == rectItemBoth) szAll = CSize(szImage.cx + szLabel.cx + m_sizeOffset.cx, szImage.cy > szLabel.cy ? szImage.cy : szLabel.cy);
  1883. }
  1884. else
  1885. {
  1886. if (iType == rectItemIcon) szAll = szImage;
  1887. else if (iType == rectItemLabel) szAll = szLabel;
  1888. else if (iType == rectItemBoth)
  1889. {
  1890. szAll = CSize(szImage.cx > szLabel.cx ? szImage.cx : szLabel.cx, szLabel.cy + szImage.cy + m_sizeOffset.cy + m_nIconSpacingLarge);
  1891. }
  1892. }
  1893. return szAll;
  1894. }
  1896. return CSize(0, 0);
  1897. }
  1899. CImageList* CXTOutBarCtrl::GetFolderImageList(const int iIndex, const BOOL bSmall) const
  1900. {
  1901. if (m_arFolder.GetSize() != 0)
  1902. {
  1903. ASSERT(iIndex >= 0 && iIndex < GetFolderCount());
  1904. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iIndex);
  1905. if (bSmall)
  1906. {
  1907. if (pBarFolder->GetSmallImageList())
  1908. return pBarFolder->GetSmallImageList();
  1909. else
  1910. return m_pSmallImageList;
  1911. }
  1912. if (pBarFolder->GetLargeImageList())
  1913. return pBarFolder->GetLargeImageList();
  1914. else
  1915. return m_pLargeImageList;
  1916. }
  1917. return NULL;
  1918. }
  1920. void CXTOutBarCtrl::DrawScrollButton(CDC* pDC, CRect rect, UINT uType, UINT uState)
  1921. {
  1922. pDC->DrawFrameControl(&rect, uType, uState);
  1923. }
  1925. void CXTOutBarCtrl::DrawItem(CDC* pDC, const int iFolder, CRect rc, const int iIndex, const BOOL bOnlyImage)
  1926. {
  1927. if (m_arFolder.GetSize() != 0)
  1928. {
  1929. CImageList* pImageList = GetFolderImageList(iFolder, IsSmallIconView(iFolder));
  1931. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1932. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  1934. ASSERT(iIndex >= 0 && iIndex < pBarFolder->GetItemCount());
  1935. CXTOutBarItem* pBarItem = pBarFolder->GetItemAt(iIndex);
  1937. ASSERT(pBarItem && pImageList);
  1938. if (!pBarItem)
  1939. return;
  1941. CFont* oft = (CFont*)pDC->SelectObject(GetFontX());
  1942. pDC->SetBkMode(TRANSPARENT);
  1944. CRect rcFolder;
  1945. GetFolderRect(iFolder, rcFolder);
  1946. rc.left = rcFolder.left +4;
  1947. rc.right = rcFolder.right-4;
  1949. // Exclude the up and down arrows from painting.
  1950. if (m_bUpArrow)
  1951. pDC->ExcludeClipRect(&m_rcUpArrow);
  1952. if (m_bDownArrow)
  1953. pDC->ExcludeClipRect(&m_rcDownArrow);
  1955. // set the items text color.
  1956. pDC->SetTextColor(GetTheme()->m_clrText);
  1958. if ((m_dwFlags & OBS_XT_SELHIGHLIGHT) && (m_nLastItemSelected == iIndex) && (m_nLastItemSelected >= 0))
  1959. {
  1960. CRect rcIcon;
  1961. GetIconRect(m_nSelFolder, m_nLastItemSelected, rcIcon);
  1962. rcIcon.InflateRect(1, 1);
  1964. GetTheme()->DrawIconFrame(pDC, rcIcon, TRUE, FALSE);
  1965. }
  1968. if (pImageList && pBarItem)
  1969. {
  1970. IMAGEINFO ii;
  1971. pImageList->GetImageInfo(pBarItem->GetIndex(), &ii);
  1972. CSize szImage = CRect(ii.rcImage).Size();
  1973. CPoint pt;
  1975. if (IsSmallIconView(iFolder))
  1976. {
  1977. pt.x = rc.left + 2;
  1978. pt.y = rc.top + (rc.Height() - szImage.cy) / 2;
  1980. DrawItemIcon(pDC, pt, pBarItem, pImageList);
  1982. if (!bOnlyImage)
  1983. {
  1984. rc.left += (szImage.cx + m_sizeOffset.cx);
  1986. DrawItemText(pDC, rc, pBarItem, DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS);
  1987. }
  1988. }
  1989. else
  1990. {
  1991. pt.x = rc.left + (rc.Width() - szImage.cx) / 2;
  1992. pt.y = rc.top;
  1994. DrawItemIcon(pDC, pt, pBarItem, pImageList);
  1996. if (!bOnlyImage)
  1997. {
  1998. rc.top += szImage.cy + m_sizeOffset.cy;
  1999. rc.bottom += 4;
  2000. DrawItemText(pDC, rc, pBarItem, DT_CENTER | DT_VCENTER | DT_WORDBREAK | DT_END_ELLIPSIS);
  2001. }
  2002. }
  2003. }
  2005. pDC->SelectObject(oft);
  2006. }
  2007. }
  2009. BOOL CXTOutBarCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  2010. {
  2011. CPoint pt(GetMessagePos());
  2012. ScreenToClient(&pt);
  2013. int iIndex, ht = HitTestEx(pt, iIndex);
  2014. if (ht == hitFolder)
  2015. {
  2016. ::SetCursor(XTAuxData().hcurHand);
  2017. return TRUE;
  2018. }
  2020. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  2021. }
  2023. void CXTOutBarCtrl::GetVisibleRange(const int iFolder, int& iFirst, int& iLast)
  2024. {
  2025. iFirst = m_nFirstItem;
  2027. CRect rcInside;
  2028. GetInsideRect(rcInside);
  2030. if (m_arFolder.GetSize() != 0)
  2031. {
  2032. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  2033. if (pBarFolder == NULL)
  2034. return;
  2036. int iCount = pBarFolder->GetItemCount();
  2037. if (iCount <= 0)
  2038. {
  2039. iFirst = iLast = -1;
  2040. return;
  2041. }
  2043. int iItem;
  2044. for (iItem = m_nFirstItem; iItem < iCount; iItem++)
  2045. {
  2046. CRect rcItem;
  2047. GetItemRect(iFolder, iItem, rcItem);
  2049. if (rcItem.bottom > rcInside.bottom)
  2050. {
  2051. iLast = iItem - 1;
  2052. break;
  2053. }
  2054. else
  2055. {
  2056. iLast = iItem;
  2057. }
  2058. }
  2059. }
  2060. }
  2062. void CXTOutBarCtrl::OnSize(UINT nType, int cx, int cy)
  2063. {
  2064. m_bUpArrow = m_bDownArrow = FALSE;
  2066. CWnd::OnSize(nType, cx, cy);
  2068. int t, max = GetFolderCount();
  2069. CRect rc;
  2070. GetInsideRect(rc);
  2072. for (t = 0; t < max; t++)
  2073. {
  2074. CWnd* pWnd = GetFolderChild(t);
  2075. if (pWnd) pWnd->SetWindowPos(0, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER);
  2076. }
  2077. }
  2079. void CXTOutBarCtrl::DrawIcon(CDC* pDC, int iIcon, int iFolder, bool bHilight)
  2080. {
  2081. // Clear the icon background
  2082. CRect rcIcon;
  2083. GetIconRect(iFolder, iIcon, rcIcon);
  2085. if (!IsSmallIconView(iFolder))
  2086. {
  2087. rcIcon.InflateRect(1, 1);
  2088. }
  2089. else
  2090. {
  2091. rcIcon.left--;
  2092. rcIcon.top--;
  2093. }
  2095. GetTheme()->FillInsideRect(pDC, rcIcon);
  2097. // Should we highlight the icon ?
  2098. if (bHilight)
  2099. {
  2100. GetTheme()->DrawIconFrame(pDC, rcIcon, FALSE, m_bIconPressed);
  2101. }
  2103. // Draw the icon using the image list.
  2104. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  2105. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  2107. ASSERT(iIcon >= 0 && iIcon < pBarFolder->GetItemCount());
  2108. CXTOutBarItem* pBarItem = pBarFolder->GetItemAt(iIcon);
  2110. CImageList* pImageList = GetFolderImageList(iFolder, IsSmallIconView(iFolder));
  2111. ASSERT(pBarItem && pImageList);
  2113. CRect rc;
  2114. GetItemRect(iFolder, iIcon, rc);
  2116. CRect rcFolder;
  2117. GetFolderRect(iFolder, rcFolder);
  2118. rc.left = rcFolder.left +4;
  2119. rc.right = rcFolder.right-4;
  2121. if (IsSmallIconView(iFolder))
  2122. {
  2123. if (pImageList && pBarItem)
  2124. {
  2125. IMAGEINFO ii;
  2126. pImageList->GetImageInfo(pBarItem->GetIndex(), &ii);
  2127. CSize szImage = CRect(ii.rcImage).Size();
  2128. CPoint pt;
  2129. pt.x = rc.left + 2;
  2130. pt.y = rc.top + (rc.Height() - szImage.cy) / 2;
  2132. DrawItemIcon(pDC, pt, pBarItem, pImageList);
  2133. }
  2134. }
  2135. else
  2136. {
  2137. if (pImageList && pBarItem)
  2138. {
  2139. IMAGEINFO ii;
  2140. pImageList->GetImageInfo(pBarItem->GetIndex(), &ii);
  2141. CSize szImage = CRect(ii.rcImage).Size();
  2142. CPoint pt;
  2143. pt.x = rc.left + (rc.Width() - szImage.cx) / 2;
  2144. pt.y = rc.top;// + (rc.Height() - szImage.cy) / 2;
  2146. DrawItemIcon(pDC, pt, pBarItem, pImageList);
  2147. }
  2148. }
  2149. }
  2151. void CXTOutBarCtrl::HighlightItem(CDC* pDC, const int iIndex, const BOOL bPressed)
  2152. {
  2153. static BOOL bOldPressed = FALSE;
  2155. CWnd* pFocus = GetFocus();
  2156. if (pFocus != NULL && pFocus != this && IsChild(pFocus))
  2157. {
  2158. return;
  2159. }
  2161. if (m_nItemHilighted == iIndex && bOldPressed == bPressed)
  2162. {
  2163. return;
  2164. }
  2166. if (iIndex != -1)
  2167. {
  2168. CXTOutBarItem* pBarItem = GetBarFolderItem(m_nSelFolder, iIndex);
  2169. if (!pBarItem->IsEnabled())
  2170. {
  2171. return;
  2172. }
  2173. }
  2175. m_bIconPressed = FALSE;
  2176. bOldPressed = bPressed;
  2178. XT_OUTBAR_INFO obi;
  2179. obi.nIndex = iIndex;
  2180. obi.nDragFrom = -1;
  2181. obi.nDragTo = -1;
  2182. obi.lpszText = GetItemText(iIndex);
  2183. obi.bFolder = false;
  2185. LRESULT lResult = NotifyOwner(OBN_XT_ITEMHOVER, &obi);
  2187. if (!lResult)
  2188. return;
  2190. CDC dcClient;
  2191. if (!pDC)
  2192. {
  2193. dcClient.Attach(::GetDC(m_hWnd));
  2194. pDC = &dcClient;
  2195. }
  2197. CRect irc;
  2198. GetInsideRect(irc);
  2200. CRgn rgn;
  2201. rgn.CreateRectRgnIndirect(&irc);
  2202. pDC->SelectClipRgn(&rgn);
  2204. // Exclude the up and down arrows from painting.
  2205. if (m_bUpArrow)
  2206. pDC->ExcludeClipRect(&m_rcUpArrow);
  2207. if (m_bDownArrow)
  2208. pDC->ExcludeClipRect(&m_rcDownArrow);
  2210. if (m_nItemHilighted >= 0 && IsValidItem(m_nItemHilighted))
  2211. {
  2212. DrawIcon(pDC, m_nItemHilighted, m_nSelFolder, false);
  2213. }
  2214. if ((m_nSelAnimTiming > 0 && iIndex == m_nLastItemSelected) ||
  2215. ((m_dwFlags & OBS_XT_SELHIGHLIGHT) && (m_nLastItemSelected == iIndex)))
  2216. {
  2217. m_nItemHilighted = -1;
  2218. }
  2219. else
  2220. {
  2221. m_nItemHilighted = iIndex;
  2222. m_bIconPressed = bPressed;
  2224. if (m_nItemHilighted >= 0 && IsValidItem(m_nItemHilighted))
  2225. {
  2226. DrawIcon(pDC, m_nItemHilighted, m_nSelFolder, true);
  2227. }
  2228. }
  2230. pDC->SelectClipRgn(NULL);
  2231. rgn.DeleteObject();
  2233. if (dcClient.GetSafeHdc())
  2234. {
  2235. ::ReleaseDC(m_hWnd, dcClient.Detach());
  2236. }
  2237. }
  2239. void CXTOutBarCtrl::GetIconRect(const int iFolder, const int iIndex, CRect& rect, CRect* pInsideRect /*= NULL*/)
  2240. {
  2241. CRect rc;
  2242. if (pInsideRect)
  2243. rc = *pInsideRect;
  2244. else
  2245. GetInsideRect(rc);
  2247. int top = rc.top;
  2248. CSize sz(0, 0);
  2249. int y = 0;
  2250. int spacing = IsSmallIconView(iFolder) ? m_nIconSpacingSmall : m_nIconSpacingLarge;
  2252. int t;
  2253. for (t = 0; t < iIndex; t++)
  2254. {
  2255. sz = GetItemSize(iFolder, t, rectItemBoth);
  2256. top += sz.cy;
  2257. top += spacing;
  2258. if (t == m_nFirstItem - 1) y = top - rc.top;
  2259. }
  2260. top += spacing;
  2262. sz = GetItemSize(iFolder, iIndex, rectItemIcon);
  2263. if (IsSmallIconView(iFolder))
  2264. {
  2265. rect.SetRect(rc.left, top, rc.left + sz.cx, top + sz.cy);
  2266. rect.left += m_sizeMargin.cx + 2;
  2267. rect.right += m_sizeMargin.cx + 2;
  2268. rect.top -= m_sizeMargin.cy;
  2269. rect.bottom -= m_sizeMargin.cy;
  2271. rect.top -= y;
  2272. rect.bottom -= y;
  2273. }
  2274. else
  2275. {
  2276. rect.SetRect(rc.left + (rc.Width() - sz.cx)/2, top, rc.left + (rc.Width() - sz.cx)/2 + sz.cx, top + sz.cy);
  2277. rect.top -= y + 3;
  2278. rect.bottom -= y + 2;
  2279. }
  2280. }
  2282. void CXTOutBarCtrl::GetLabelRect(const int iFolder, const int iIndex, CRect& rect)
  2283. {
  2284. CRect rc;
  2285. GetInsideRect(rc);
  2286. int top = rc.top;
  2287. CSize sz(0, 0);
  2288. int y = 0;
  2289. int spacing = IsSmallIconView(iFolder) ? m_nIconSpacingSmall : m_nIconSpacingLarge;
  2291. int t;
  2292. for (t = 0; t < iIndex; t++)
  2293. {
  2294. sz = GetItemSize(iFolder, t, rectItemBoth);
  2295. top += sz.cy;
  2296. top += spacing;
  2297. if (t == m_nFirstItem - 1) y = top - rc.top;
  2298. }
  2299. top += spacing;
  2301. sz = GetItemSize(iFolder, iIndex, rectItemBoth);
  2303. CSize szLabel = GetItemSize(iFolder, iIndex, rectItemLabel);
  2305. if (IsSmallIconView(iFolder))
  2306. {
  2307. rect.SetRect(rc.left, top, rc.left + sz.cx, top + sz.cy);
  2308. rect.left += m_sizeMargin.cx + 2;
  2309. rect.right += m_sizeMargin.cx + 2;
  2310. rect.top += m_sizeMargin.cy - 5;
  2311. rect.bottom += m_sizeMargin.cy - 5;
  2312. }
  2313. else
  2314. {
  2315. rect.SetRect(rc.left + (rc.Width() - sz.cx)/2, top, rc.left + (rc.Width() - sz.cx)/2 + sz.cx, top + sz.cy);
  2316. rect.top -= y + 3;
  2317. rect.bottom -= y + 2;
  2319. rect.bottom -= m_nIconSpacingLarge;
  2320. rect.top = rect.bottom - szLabel.cy;
  2321. }
  2322. }
  2324. void CXTOutBarCtrl::StartGroupEdit(const int iIndex)
  2325. {
  2326. CRect rc;
  2327. GetFolderRect(iIndex, rc);
  2328. rc.InflateRect(-2, -2);
  2330. if (m_arFolder.GetSize() != 0)
  2331. {
  2332. ASSERT(iIndex >= 0 && iIndex < GetFolderCount());
  2333. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iIndex);
  2335. CXTOutBarEditItem* pEdit = new CXTOutBarEditItem;
  2336. if (pEdit->Create(pBarFolder->GetName(), WS_CHILD | WS_VISIBLE | ES_CENTER | ES_AUTOHSCROLL,
  2337. rc, this, 0xFF, iIndex, true, false))
  2338. {
  2339. pEdit->Initialize(this);
  2340. pEdit->ModifyStyleEx(0, WS_EX_CLIENTEDGE, SWP_FRAMECHANGED);
  2341. pEdit->SetFocus();
  2342. pEdit->SetSel(0, -1);
  2343. }
  2344. }
  2345. }
  2347. void CXTOutBarCtrl::StartItemEdit(const int iIndex)
  2348. {
  2349. if (m_arFolder.GetSize() != 0)
  2350. {
  2351. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  2352. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  2354. ASSERT(iIndex >= 0 && iIndex < pBarFolder->GetItemCount());
  2355. CXTOutBarItem* pBarItem = pBarFolder->GetItemAt(iIndex);
  2356. if (pBarItem == NULL)
  2357. {
  2358. return;
  2359. }
  2361. CRect rcLabel;
  2362. GetLabelRect(m_nSelFolder, iIndex, rcLabel);
  2364. DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL;
  2366. bool bNoDown = false;
  2367. if (IsSmallIconView(m_nSelFolder))
  2368. {
  2369. bNoDown = true;
  2371. CRect rcIcon;
  2372. GetIconRect(m_nSelFolder, iIndex, rcIcon);
  2373. rcLabel.OffsetRect(rcIcon.Width()+1, -6);
  2374. rcLabel.InflateRect(0, 1);
  2375. }
  2376. else
  2377. {
  2378. CRect rcInside;
  2379. GetInsideRect(rcInside);
  2381. CWindowDC dc(NULL);
  2382. CFont* f = dc.SelectObject(GetFontX());
  2383. CSize sz = dc.GetTextExtent(pBarItem->GetName());
  2384. dc.SelectObject(f);
  2386. int x = (rcInside.Width()-sz.cx)/2;
  2388. rcLabel.left = rcInside.left + x;
  2389. rcLabel.right = rcLabel.left + sz.cx;
  2390. rcLabel.InflateRect(6, 2);
  2391. rcLabel.OffsetRect(0, -1);
  2393. dwStyle |= ES_CENTER;
  2394. }
  2396. CXTOutBarEditItem* pEdit = new CXTOutBarEditItem;
  2397. if (pEdit->Create(pBarItem->GetName(), dwStyle, rcLabel, this,
  2398. 0xFF, iIndex, false, bNoDown))
  2399. {
  2400. pEdit->Initialize(this);
  2401. pEdit->SetFocus();
  2402. pEdit->SetSel(0, -1);
  2404. Invalidate();
  2405. }
  2406. }
  2407. }
  2409. void CXTOutBarCtrl::OnLargeIcon()
  2410. {
  2411. SetSmallIconView(FALSE, m_nSelFolder);
  2412. Invalidate();
  2413. }
  2415. void CXTOutBarCtrl::OnUpdateLargeIcon(CCmdUI* pCmdUI)
  2416. {
  2417. pCmdUI->Enable(IsSmallIconView(m_nSelFolder));
  2418. }
  2420. void CXTOutBarCtrl::OnSmallIcon()
  2421. {
  2422. SetSmallIconView(TRUE, m_nSelFolder);
  2423. Invalidate();
  2424. }
  2426. void CXTOutBarCtrl::OnUpdateSmallIcon(CCmdUI* pCmdUI)
  2427. {
  2428. pCmdUI->Enable(!IsSmallIconView(m_nSelFolder));
  2429. }
  2431. void CXTOutBarCtrl::OnRemoveItem()
  2432. {
  2433. if (m_nHitInternal1 == hitFolder)
  2434. {
  2435. RemoveFolder(m_nHitInternal2);
  2436. }
  2437. else if (m_nHitInternal1 == hitItem)
  2438. {
  2439. RemoveItem(m_nHitInternal2);
  2440. }
  2441. }
  2443. void CXTOutBarCtrl::OnUpdateRemoveItem(CCmdUI* /*pCmdUI*/)
  2444. {
  2446. }
  2448. void CXTOutBarCtrl::OnRenameItem()
  2449. {
  2450. if (m_nHitInternal1 == hitFolder)
  2451. {
  2452. StartGroupEdit(m_nHitInternal2);
  2453. }
  2454. else if (m_nHitInternal1 == hitItem)
  2455. {
  2456. StartItemEdit(m_nHitInternal2);
  2457. }
  2458. }
  2460. void CXTOutBarCtrl::OnUpdateRenameItem(CCmdUI* /*pCmdUI*/)
  2461. {
  2463. }
  2465. void CXTOutBarCtrl::RemoveAllItems(int iFolder, bool bNofify/*= false*/)
  2466. {
  2467. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  2468. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  2469. if (pBarFolder != NULL)
  2470. {
  2471. int iFolderCount = pBarFolder->GetItemCount();
  2473. int iIndex;
  2474. for (iIndex = iFolderCount-1; iIndex >= 0; --iIndex)
  2475. {
  2476. CXTOutBarItem* pBarItem = pBarFolder->RemoveItemAt(iIndex);
  2477. if (pBarItem == NULL)
  2478. {
  2479. continue;
  2480. }
  2482. if (bNofify)
  2483. {
  2484. XT_OUTBAR_INFO obi;
  2485. obi.nIndex = iIndex;
  2486. obi.nDragFrom = -1;
  2487. obi.nDragTo = -1;
  2488. obi.lpszText = pBarItem->GetName();
  2489. obi.bFolder = false;
  2491. NotifyOwner(OBN_XT_DELETEITEM, &obi);
  2492. }
  2494. SAFE_DELETE(pBarItem);
  2495. }
  2497. Invalidate();
  2498. UpdateWindow();
  2499. }
  2500. }
  2502. void CXTOutBarCtrl::RemoveItem(const int iIndex)
  2503. {
  2504. if (m_arFolder.GetSize() != 0)
  2505. {
  2506. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  2507. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  2508. ASSERT(iIndex >= 0 && iIndex < pBarFolder->GetItemCount());
  2510. if (IsValidItem(iIndex))
  2511. {
  2512. XT_OUTBAR_INFO obi;
  2513. obi.nIndex = iIndex;
  2514. obi.nDragFrom = -1;
  2515. obi.nDragTo = -1;
  2516. obi.lpszText = GetItemText(iIndex);
  2517. obi.bFolder = false;
  2519. LRESULT lResult = NotifyOwner(OBN_XT_DELETEITEM, &obi);
  2521. if (lResult == TRUE)
  2522. {
  2523. CXTOutBarItem* pBarItem = pBarFolder->RemoveItemAt(iIndex);
  2524. SAFE_DELETE(pBarItem);
  2526. if (m_nLastItemSelected == iIndex)
  2527. m_nLastItemSelected = -1;
  2529. InvalidateRect(NULL);
  2530. }
  2531. }
  2532. }
  2533. }
  2535. BOOL CXTOutBarCtrl::IsValidItem(const int iIndex) const
  2536. {
  2537. if (m_arFolder.GetSize() != 0)
  2538. {
  2539. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  2540. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  2541. return (iIndex >= 0 && iIndex < pBarFolder->GetItemCount());
  2542. }
  2543. return FALSE;
  2544. }
  2546. DWORD CXTOutBarCtrl::GetItemData(const int iIndex) const
  2547. {
  2548. if (m_arFolder.GetSize() != 0)
  2549. {
  2550. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  2551. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  2552. if (IsValidItem(iIndex))
  2553. {
  2554. CXTOutBarItem* i = pBarFolder->GetItemAt(iIndex);
  2555. return i->GetData();
  2556. }
  2557. }
  2558. return 0;
  2559. }
  2561. int CXTOutBarCtrl::GetItemImage(const int iIndex) const
  2562. {
  2563. if (m_arFolder.GetSize() != 0)
  2564. {
  2565. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  2566. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  2567. if (IsValidItem(iIndex))
  2568. {
  2569. CXTOutBarItem* i = pBarFolder->GetItemAt(iIndex);
  2570. return i->GetIndex();
  2571. }
  2572. }
  2573. return 0;
  2574. }
  2576. void CXTOutBarCtrl::SetItemData(const int iIndex, const DWORD dwData)
  2577. {
  2578. if (m_arFolder.GetSize() != 0)
  2579. {
  2580. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  2581. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  2582. if (IsValidItem(iIndex))
  2583. {
  2584. CXTOutBarItem* i = pBarFolder->GetItemAt(iIndex);
  2585. i->SetData(dwData);
  2586. }
  2587. }
  2588. }
  2590. void CXTOutBarCtrl::SetItemImage(const int iIndex, const int iImage)
  2591. {
  2592. if (m_arFolder.GetSize() != 0)
  2593. {
  2594. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  2595. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  2596. if (IsValidItem(iIndex))
  2597. {
  2598. CXTOutBarItem* i = pBarFolder->GetItemAt(iIndex);
  2599. i->SetIndex(iImage);
  2600. }
  2601. }
  2602. }
  2604. void CXTOutBarCtrl::DrawDragArrow(CDC* pDC, const int /*iFrom*/, const int iTo)
  2605. {
  2606. if (iTo == m_nLastDragItemDraw)
  2607. return;
  2609. CRect rc1;
  2610. if (m_nLastDragItemDraw >= 0)
  2611. {
  2612. GetDragItemRect(m_nLastDragItemDraw, rc1);
  2613. if (m_nLastDragItemDrawType == 0)
  2614. {
  2615. rc1.bottom = rc1.top + 5;
  2616. }
  2617. else if (m_nLastDragItemDrawType == 1)
  2618. {
  2619. rc1.top -= 4;
  2620. rc1.bottom = rc1.top + 9;
  2621. }
  2622. else if (m_nLastDragItemDrawType == 2)
  2623. {
  2624. rc1.top -= 4;
  2625. rc1.bottom = rc1.top + 5;
  2626. }
  2627. InvalidateRect(rc1, TRUE);
  2628. UpdateWindow();
  2629. }
  2630. m_nLastDragItemDraw = iTo;
  2632. if (m_nLastDragItemDraw >= 0)
  2633. {
  2634. m_nLastDragItemDrawType = GetDragItemRect(m_nLastDragItemDraw, rc1);
  2636. CPen* op = pDC->SelectObject(&m_penBlack);
  2638. pDC->MoveTo(rc1.left, rc1.top);
  2639. pDC->LineTo(rc1.right, rc1.top);
  2641. if (m_nLastDragItemDrawType != 2)
  2642. {
  2643. pDC->MoveTo(rc1.left, rc1.top + 1);
  2644. pDC->LineTo(rc1.left + 7, rc1.top + 1);
  2645. pDC->MoveTo(rc1.left, rc1.top + 2);
  2646. pDC->LineTo(rc1.left + 5, rc1.top + 2);
  2647. pDC->MoveTo(rc1.left, rc1.top + 3);
  2648. pDC->LineTo(rc1.left + 3, rc1.top + 3);
  2649. pDC->MoveTo(rc1.left, rc1.top + 4);
  2650. pDC->LineTo(rc1.left + 1, rc1.top + 4);
  2652. pDC->MoveTo(rc1.right-1, rc1.top + 1);
  2653. pDC->LineTo(rc1.right - 7, rc1.top + 1);
  2654. pDC->MoveTo(rc1.right-1, rc1.top + 2);
  2655. pDC->LineTo(rc1.right - 5, rc1.top + 2);
  2656. pDC->MoveTo(rc1.right-1, rc1.top + 3);
  2657. pDC->LineTo(rc1.right - 3, rc1.top + 3);
  2658. }
  2659. if (m_nLastDragItemDrawType != 0)
  2660. {
  2661. pDC->MoveTo(rc1.left, rc1.top-1);
  2662. pDC->LineTo(rc1.left + 7, rc1.top-1);
  2663. pDC->MoveTo(rc1.left, rc1.top-2);
  2664. pDC->LineTo(rc1.left + 5, rc1.top-2);
  2665. pDC->MoveTo(rc1.left, rc1.top-3);
  2666. pDC->LineTo(rc1.left + 3, rc1.top-3);
  2667. pDC->MoveTo(rc1.left, rc1.top-4);
  2668. pDC->LineTo(rc1.left + 1, rc1.top-4);
  2670. pDC->MoveTo(rc1.right-1, rc1.top-1);
  2671. pDC->LineTo(rc1.right - 7, rc1.top-1);
  2672. pDC->MoveTo(rc1.right-1, rc1.top-2);
  2673. pDC->LineTo(rc1.right - 5, rc1.top-2);
  2674. pDC->MoveTo(rc1.right-1, rc1.top-3);
  2675. pDC->LineTo(rc1.right - 3, rc1.top-3);
  2676. pDC->MoveTo(rc1.right-1, rc1.top-4);
  2677. pDC->LineTo(rc1.right - 1, rc1.top-4);
  2678. }
  2680. pDC->SelectObject(op);
  2681. }
  2682. }
  2684. int CXTOutBarCtrl::GetDragItemRect(const int iIndex, CRect& rect)
  2685. {
  2686. CRect rc, crc;
  2687. GetInsideRect(crc);
  2688. crc.InflateRect(-2, 0);
  2690. GetItemRect(m_nSelFolder, iIndex < GetItemCount() ? iIndex : iIndex - 1, rc);
  2691. int line = 0;
  2692. if (iIndex < GetItemCount())
  2693. {
  2694. line = rc.top - 4;
  2695. }
  2696. else
  2697. {
  2698. line = rc.bottom + 6;
  2699. }
  2700. int tpe;
  2701. if (iIndex == 0)
  2702. {
  2703. rect.SetRect(crc.left, line + 2, crc.right, line + 7);
  2704. tpe = 0;
  2705. }
  2706. else if (iIndex < GetItemCount())
  2707. {
  2708. rect.SetRect(crc.left, line - 9, crc.right, line);
  2709. tpe = 1;
  2710. if (IsSmallIconView(m_nSelFolder))
  2711. {
  2712. rect.top += 8;
  2713. rect.bottom += 8;
  2714. }
  2715. }
  2716. else
  2717. {
  2718. rect.SetRect(crc.left, line, crc.right, line + 5);
  2719. tpe = 2;
  2720. }
  2721. return tpe;
  2722. }
  2724. void CXTOutBarCtrl::DrawPreviewBitmap(CWnd* pWnd, CDC* pDC, int nOffset)
  2725. {
  2726. if (!pWnd || !::IsWindow(pWnd->m_hWnd))
  2727. return;
  2729. CPoint ovpt = pDC->SetViewportOrg(0, nOffset);
  2730. BOOL bPrev = pWnd->ShowWindow(SW_SHOW);
  2732. CXTPWindowRect rectWindow(pWnd);
  2733. CClientDC dc(pWnd);
  2734. CBitmap bitmapNonClient;
  2736. VERIFY(bitmapNonClient.CreateCompatibleBitmap(&dc, rectWindow.Width(), rectWindow.Height()));
  2738. CXTPCompatibleDC dcMemSourceNonClient(&dc, &bitmapNonClient);
  2740. dcMemSourceNonClient.FillSolidRect(0, 0, rectWindow.Width(), rectWindow.Height(), GetXtremeColor(COLOR_WINDOW));
  2741. pWnd->Print(&dcMemSourceNonClient, PRF_NONCLIENT);
  2743. pDC->BitBlt(0, 0, rectWindow.Width(), rectWindow.Height(), &dcMemSourceNonClient, 0, 0, SRCCOPY);
  2745. CPoint pLT(0, 0);
  2746. pWnd->ClientToScreen(&pLT);
  2748. CPoint pt = pDC->GetViewportOrg();
  2749. pDC->SetViewportOrg(pt.x + pLT.x - rectWindow.left, pt.y + pLT.y - rectWindow.top);
  2750. pWnd->Print(pDC, PRF_CHILDREN | PRF_CLIENT | PRF_ERASEBKGND);
  2752. if (!bPrev) pWnd->ShowWindow(SW_HIDE);
  2753. pDC->SetViewportOrg(ovpt);
  2755. }
  2757. void CXTOutBarCtrl::AnimateFolderScroll(const int iFrom, const int iTo)
  2758. {
  2759. if (m_arFolder.GetSize() == 0)
  2760. return;
  2762. ASSERT(iFrom >= 0 && iFrom < GetFolderCount());
  2763. ASSERT(iTo >= 0 && iTo < GetFolderCount());
  2765. CRect rc, frc;
  2766. GetInsideRect(rc);
  2767. GetFolderRect(iTo, frc);
  2768. int nFolderHeight = frc.Height();
  2770. CClientDC dc(this);
  2771. CDC memDC;
  2772. memDC.CreateCompatibleDC(&dc);
  2774. int nTopItem = iTo > iFrom ? iFrom : iTo;
  2775. int nBottomItem = iTo > iFrom ? iTo : iFrom;
  2777. CBitmap bmpFrom, bmpTo;
  2778. bmpFrom.CreateCompatibleBitmap(&dc, rc.Width(), rc.Height() + nFolderHeight * (nBottomItem - nTopItem));
  2779. bmpTo.CreateCompatibleBitmap(&dc, rc.Width(), rc.Height() + nFolderHeight * (nBottomItem - nTopItem));
  2782. CBitmap* pOldBitmap = (CBitmap*)memDC.SelectObject(&bmpFrom);
  2784. CRect rcFrom(0, 0, rc.Width(), rc.Height());
  2785. GetTheme()->FillInsideRect(&memDC, rcFrom);
  2787. CWnd* pWnd1 = GetFolderChild(nTopItem);
  2788. CWnd* pWnd2 = GetFolderChild(nBottomItem);
  2790. if (pWnd1)
  2791. {
  2792. DrawPreviewBitmap(pWnd1, &memDC, 0);
  2793. }
  2794. else PaintItems(&memDC, nTopItem, rcFrom);
  2796. memDC.SelectObject(&bmpTo);
  2798. CRect rcTo(rcFrom);
  2799. for (int i = nTopItem + 1; i <= nBottomItem; i++)
  2800. {
  2801. CRect rcFolder(frc.left, rcTo.top, frc.right, rcTo.top + nFolderHeight);
  2802. DrawFolder(&memDC, i, rcFolder, xtMouseNormal);
  2803. rcTo.OffsetRect(0, nFolderHeight);
  2804. }
  2806. GetTheme()->FillInsideRect(&memDC, rcTo);
  2809. if (pWnd2)
  2810. {
  2811. DrawPreviewBitmap(pWnd2, &memDC, rcTo.top);
  2812. }
  2813. else PaintItems(&memDC, nBottomItem, rcTo);
  2815. if (iTo > iFrom)
  2816. {
  2817. GetFolderRect(iFrom, rcFrom);
  2818. GetFolderRect(iTo, rcTo);
  2820. for (int y = rcTo.top - nFolderHeight; y > rcFrom.bottom; y -= nFolderHeight)
  2821. {
  2822. memDC.SelectObject(&bmpFrom);
  2823. dc.BitBlt(rc.left, rcFrom.bottom, rc.Width(), y - rcFrom.bottom, &memDC, 0, 0, SRCCOPY);
  2825. memDC.SelectObject(&bmpTo);
  2826. dc.BitBlt(rc.left, y, rc.Width(), rc.bottom - y + (iTo - iFrom) * nFolderHeight, &memDC, 0, 0, SRCCOPY);
  2827. Sleep(m_nAnimationTickCount);
  2828. }
  2829. }
  2830. else
  2831. {
  2832. nTopItem = iTo;
  2833. nBottomItem = iFrom;
  2835. GetFolderRect(nTopItem, rcFrom);
  2836. GetFolderRect(nBottomItem, rcTo);
  2837. rcTo.OffsetRect(0, rc.Height());
  2839. for (int y = rcFrom.bottom; y < rcTo.top - nFolderHeight ; y += nFolderHeight)
  2840. {
  2841. memDC.SelectObject(&bmpFrom);
  2842. dc.BitBlt(rc.left, rcFrom.bottom, rc.Width(), y - rcFrom.bottom, &memDC, 0, 0, SRCCOPY);
  2844. memDC.SelectObject(&bmpTo);
  2845. dc.BitBlt(rc.left, y, rc.Width(), rc.bottom - y , &memDC, 0, 0, SRCCOPY);
  2846. Sleep(m_nAnimationTickCount);
  2847. }
  2848. }
  2850. memDC.SelectObject(pOldBitmap);
  2851. }
  2853. CString CXTOutBarCtrl::GetItemText(const int iIndex)
  2854. {
  2855. CString item = _T("");
  2857. if (m_arFolder.GetSize() != 0)
  2858. {
  2859. ASSERT(m_nSelFolder >= 0 && m_nSelFolder < GetFolderCount());
  2860. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(m_nSelFolder);
  2861. if (IsValidItem(iIndex))
  2862. {
  2863. CXTOutBarItem* pBarItem = pBarFolder->GetItemAt(iIndex);
  2864. if (pBarItem->GetName().GetLength())
  2865. item = pBarItem->GetName();
  2866. }
  2867. }
  2868. return item;
  2869. }
  2871. int CXTOutBarCtrl::AddFolderBar(LPCTSTR lpszFolderName, CWnd* pWndChild, const DWORD dwData)
  2872. {
  2873. CXTOutBarFolder* pBarFolder = new CXTOutBarFolder(lpszFolderName, dwData, this);
  2874. ASSERT(pBarFolder);
  2876. pBarFolder->SetChild(pWndChild);
  2877. return  (int)m_arFolder.Add((void*)pBarFolder);
  2878. }
  2880. CWnd* CXTOutBarCtrl::GetFolderChild(int iFolder)
  2881. {
  2882. if (GetFolderCount())
  2883. {
  2884. if (iFolder < 0 && m_nSelFolder < 0)
  2885. return NULL;
  2887. if (iFolder < 0)
  2888. iFolder = m_nSelFolder;
  2890. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  2891. return pBarFolder->GetChild();
  2892. }
  2893. return NULL;
  2894. }
  2896. DWORD CXTOutBarCtrl::GetFolderData(int iFolder)
  2897. {
  2898. if (iFolder < 0) iFolder = m_nSelFolder;
  2899. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  2900. return pBarFolder->GetData();
  2901. }
  2903. void CXTOutBarCtrl::SetAnimSelHighlight(const int iTime)
  2904. {
  2905. if (iTime <= 0) KillTimer(3);
  2906. else SetTimer(3, iTime, NULL);
  2907. m_nSelAnimTiming = iTime;
  2908. }
  2910. void CXTOutBarCtrl::OnRButtonUp(UINT nFlags, CPoint point)
  2911. {
  2912. XT_OUTBAR_INFO obi = { 0 };
  2914. int ht = HitTestEx(point, obi.nIndex);
  2915. if (ht != hitItem)
  2916. {
  2917. obi.bFolder = true;
  2919. if (ht != hitFolder)
  2920. {
  2921. obi.nIndex = -1;
  2922. }
  2923. }
  2925. // allow users to add their own right click handlers.
  2926. LRESULT lResult = NotifyOwner(OBN_XT_ITEMRCLICK, &obi);
  2928. if (lResult == TRUE)
  2929. {
  2931. m_nHitInternal1 = HitTestEx(point, m_nHitInternal2);
  2933. CPoint pt = point;
  2934. ClientToScreen(&pt);
  2936. CMenu menu;
  2937. VERIFY(XTPResourceManager()->LoadMenu(&menu, XT_IDM_POPUP));
  2939. CMenu* pPopup = menu.GetSubMenu(0);
  2940. ASSERT(pPopup != NULL);
  2941. if (!pPopup)
  2942. return;
  2943. CWnd* pWndPopupOwner = this;
  2945. CString string;
  2946. if (m_nHitInternal1 == hitItem)
  2947. {
  2948. if ((m_dwFlags & OBS_XT_REMOVEITEMS) || (m_dwFlags & OBS_XT_EDITITEMS))
  2949. {
  2950. pPopup->AppendMenu(MF_SEPARATOR);
  2951. if (m_dwFlags & OBS_XT_REMOVEITEMS)
  2952. {
  2953. VERIFY(XTPResourceManager()->LoadString(&string, XT_IDC_REMOVEITEM));
  2954. pPopup->AppendMenu(MF_STRING, XT_IDC_REMOVEITEM, string);
  2955. }
  2956. if (m_dwFlags & OBS_XT_EDITITEMS)
  2957. {
  2958. VERIFY(XTPResourceManager()->LoadString(&string, XT_IDC_RENAMEITEM));
  2959. pPopup->AppendMenu(MF_STRING, XT_IDC_RENAMEITEM, string);
  2960. }
  2961. }
  2962. }
  2963. else if (m_nHitInternal1 == hitFolder)
  2964. {
  2965. if ((m_dwFlags & OBS_XT_REMOVEGROUPS) || (m_dwFlags & OBS_XT_EDITGROUPS))
  2966. {
  2967. pPopup->AppendMenu(MF_SEPARATOR);
  2969. if (m_dwFlags & OBS_XT_REMOVEGROUPS)
  2970. {
  2971. VERIFY(XTPResourceManager()->LoadString(&string, XT_IDC_REMOVEGROUP));
  2972. pPopup->AppendMenu(MF_STRING, XT_IDC_REMOVEITEM, string);
  2973. }
  2974. if (m_dwFlags & OBS_XT_EDITGROUPS)
  2975. {
  2976. VERIFY(XTPResourceManager()->LoadString(&string, XT_IDC_RENAMEGROUP));
  2977. pPopup->AppendMenu(MF_STRING, XT_IDC_RENAMEITEM, string);
  2978. }
  2979. }
  2980. }
  2982. pPopup->CheckMenuItem(IsSmallIconView(m_nSelFolder) ?
  2983. XT_IDC_SMALLICON : XT_IDC_LARGEICON, MF_CHECKED | MF_BYCOMMAND);
  2985. XTFuncContextMenu(pPopup, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, pWndPopupOwner, XT_IDR_TBAR_OUT);
  2986. }
  2988. CWnd::OnRButtonUp(nFlags, point);
  2989. }
  2991. void CXTOutBarCtrl::OnDestroy()
  2992. {
  2993. // send notification for each folder / item that is deleted.
  2994. int iFolder;
  2995. for (iFolder = 0; iFolder < m_arFolder.GetSize(); iFolder++)
  2996. {
  2997. m_nSelFolder = iFolder;
  2998. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  3000. XT_OUTBAR_INFO obif;
  3001. obif.nIndex = iFolder;
  3002. obif.nDragFrom = -1;
  3003. obif.nDragTo = -1;
  3004. obif.lpszText = pBarFolder->GetName();
  3005. obif.bFolder = true;
  3007. if (pBarFolder != NULL)
  3008. {
  3009. int iCount = (int)pBarFolder->m_barItems.GetCount();
  3011. int iItem;
  3012. for (iItem = 0; iItem < iCount; iItem++)
  3013. {
  3014. CXTOutBarItem* pBarItem = pBarFolder->GetItemAt(iItem);
  3016. XT_OUTBAR_INFO obi;
  3017. obi.nIndex = iItem;
  3018. obi.nDragFrom = -1;
  3019. obi.nDragTo = -1;
  3020. obi.lpszText = pBarItem->GetName();
  3021. obi.bFolder = false;
  3023. NotifyOwner(OBN_XT_DELETEITEM, &obi);
  3024. }
  3026. NotifyOwner(OBN_XT_DELETEFOLDER, &obif);
  3027. }
  3028. }
  3030. CWnd::OnDestroy();
  3031. }
  3033. void CXTOutBarCtrl::EnableItem(int iFolder, int iItem, bool bEnable)
  3034. {
  3035. ASSERT(iFolder < m_arFolder.GetSize());
  3037. CXTOutBarItem* pBarItem = GetBarFolderItem(iFolder, iItem);
  3038. if (pBarItem)
  3039. {
  3040. pBarItem->EnableItem(bEnable);
  3041. }
  3042. }
  3044. void CXTOutBarCtrl::SetSelItem(int iFolder, int iItem, BOOL bEnsureVisible/*= TRUE*/)
  3045. {
  3046. if (iFolder >= 0 && iFolder < GetFolderCount())
  3047. {
  3048. // select the specified folder.
  3049. SetSelFolder(iFolder);
  3051. // get a pointer to the folder object.
  3052. CXTOutBarFolder* pBarFolder = GetBarFolder(iFolder);
  3054. int iItemCount = pBarFolder->GetItemCount();
  3055. if (pBarFolder && iItem >= 0 && iItem < iItemCount)
  3056. {
  3057. // select the specified item.
  3058. pBarFolder->SetSelItem(iItem);
  3059. m_nLastItemSelected = iItem;
  3061. if (bEnsureVisible)
  3062. {
  3063. int iFirst, iLast;
  3064. GetVisibleRange(iFolder, iFirst, iLast);
  3065. if (iLast != -1 && (iItem < iFirst || iItem > iLast))
  3066. {
  3067. m_nFirstItem = iItem-(iLast-iFirst);
  3068. }
  3069. }
  3070. }
  3071. }
  3072. }
  3074. /////////////////////////////////////////////////////////////////////////////
  3075. // CXTOutBarItem
  3076. /////////////////////////////////////////////////////////////////////////////
  3078. CXTOutBarItem::CXTOutBarItem(LPCTSTR lpszName, const int nImageIndex, DWORD dwData)
  3079. : m_strName(lpszName)
  3080. , m_nIndex(nImageIndex)
  3081. , m_dwData(dwData)
  3082. , m_bSelected(false)
  3083. , m_bEnabled(true)
  3084. {
  3086. }
  3088. CXTOutBarItem::~CXTOutBarItem()
  3089. {
  3091. }
  3093. /////////////////////////////////////////////////////////////////////////////
  3094. // CXTOutBarFolder
  3095. /////////////////////////////////////////////////////////////////////////////
  3097. CXTOutBarFolder::CXTOutBarFolder(LPCTSTR lpszName, DWORD dwData, CXTOutBarCtrl* pControl)
  3098. : m_strName(lpszName)
  3099. , m_dwData(dwData)
  3100. , m_pLargeList(NULL)
  3101. , m_pSmallList(NULL)
  3102. , m_pChild(NULL)
  3103. , m_pControl(pControl)
  3104. {
  3105. m_bSmallIcons = TRUE;
  3106. }
  3108. CXTOutBarFolder::~CXTOutBarFolder()
  3109. {
  3110. while (!m_barItems.IsEmpty())
  3111. {
  3112. CXTOutBarItem* pBarItem = m_barItems.RemoveTail();
  3113. SAFE_DELETE(pBarItem);
  3114. }
  3115. }
  3117. int CXTOutBarFolder::InsertItem(int iIndex, LPCTSTR lpszName, const int nImage, const DWORD dwData)
  3118. {
  3119. // if the iIndex is out of range, insert the item at the end
  3120. // of the list.
  3121. if ((iIndex < 0) || (iIndex > GetItemCount()))
  3122. {
  3123. iIndex = GetItemCount();
  3124. }
  3126. // allocate a new bar item.
  3127. CXTOutBarItem* pBarItem = new CXTOutBarItem(lpszName, nImage, dwData);
  3128. ASSERT(pBarItem);
  3130. // insert the new item into the item array.
  3131. InsertItemAt(iIndex, pBarItem);
  3133. return iIndex;
  3134. }
  3136. CXTOutBarItem* CXTOutBarFolder::GetItemAt(int iIndex)
  3137. {
  3138. POSITION pos = m_barItems.FindIndex(iIndex);
  3139. return m_barItems.GetAt(pos);
  3140. }
  3142. void CXTOutBarFolder::InsertItemAt(int iIndex, CXTOutBarItem* pBarItem)
  3143. {
  3144. POSITION pos = m_barItems.FindIndex(iIndex);
  3145. m_barItems.InsertAfter(pos, pBarItem);
  3146. }
  3148. CXTOutBarItem* CXTOutBarFolder::RemoveItemAt(int iIndex)
  3149. {
  3150. POSITION pos = m_barItems.FindIndex(iIndex);
  3151. if (pos != NULL)
  3152. {
  3153. CXTOutBarItem* pBarItem = m_barItems.GetAt(pos);
  3154. if (pBarItem != NULL)
  3155. {
  3156. m_barItems.RemoveAt(pos);
  3157. return pBarItem;
  3158. }
  3159. }
  3160. return NULL;
  3161. }
  3163. void CXTOutBarFolder::SetSelItem(int iItem)
  3164. {
  3165. POSITION pos;
  3166. for (pos = m_barItems.GetHeadPosition(); pos; m_barItems.GetNext(pos))
  3167. {
  3168. CXTOutBarItem* pBarItem = m_barItems.GetAt(pos);
  3169. ASSERT(pBarItem != NULL);
  3171. if (pBarItem)
  3172. {
  3173. pBarItem->SelectItem(false);
  3174. }
  3175. }
  3177. CXTOutBarItem* pBarItem = GetItemAt(iItem);
  3178. if (pBarItem != NULL)
  3179. {
  3180. pBarItem->SelectItem(true);
  3181. }
  3182. }
  3185. CXTOutBarItem* CXTOutBarFolder::GetSelItem()
  3186. {
  3187. POSITION pos;
  3188. for (pos = m_barItems.GetHeadPosition(); pos; m_barItems.GetNext(pos))
  3189. {
  3190. CXTOutBarItem* pBarItem = m_barItems.GetAt(pos);
  3191. if (pBarItem == NULL)
  3192. {
  3193. return NULL;
  3194. }
  3196. if (pBarItem && pBarItem->IsSelected())
  3197. {
  3198. return pBarItem;
  3199. }
  3200. }
  3201. return NULL;
  3202. }
  3204. int CXTOutBarFolder::GetSelIndex()
  3205. {
  3206. int i;
  3207. for (i = 0; i < m_barItems.GetCount(); ++i)
  3208. {
  3209. CXTOutBarItem* pBarItem = GetItemAt(i);
  3210. if (pBarItem == NULL)
  3211. {
  3212. return -1;
  3213. }
  3215. if (pBarItem && pBarItem->IsSelected())
  3216. {
  3217. return i;
  3218. }
  3219. }
  3220. return -1;
  3221. }
  3223. void CXTOutBarCtrl::SetBackColor(COLORREF clrBack)
  3224. {
  3225. GetTheme()->m_clrBack.SetCustomValue(clrBack);
  3226. }
  3227. void CXTOutBarCtrl::SetTextColor(COLORREF clrText)
  3228. {
  3229. GetTheme()->m_clrText.SetCustomValue(clrText);
  3230. }
  3233. /////////////////////////////////////////////////////////////////////////////
  3234. // CXTToolBox
  3235. /////////////////////////////////////////////////////////////////////////////
  3237. CXTToolBox::CXTToolBox()
  3238. {
  3239. m_bAnimating = false;
  3240. m_iFirst = 0;
  3241. m_iLast = 0;
  3242. }
  3244. CXTToolBox::~CXTToolBox()
  3245. {
  3246. }
  3248. IMPLEMENT_DYNCREATE(CXTToolBox, CXTOutBarCtrl)
  3250. BEGIN_MESSAGE_MAP(CXTToolBox, CXTOutBarCtrl)
  3251. //{{AFX_MSG_MAP(CXTToolBox)
  3252. ON_WM_RBUTTONUP()
  3253. //}}AFX_MSG_MAP
  3254. END_MESSAGE_MAP()
  3256. /////////////////////////////////////////////////////////////////////////////
  3257. // CXTToolBox message handlers
  3259. void CXTToolBox::GetItemRect(const int iFolder, const int iIndex, CRect& rect, CRect* pInsideRect /*= NULL*/)
  3260. {
  3261. GetIconRect(iFolder, iIndex, rect, pInsideRect);
  3262. }
  3264. void CXTToolBox::GetIconRect(const int iFolder, const int iIndex, CRect& rcIcon, CRect* pInsideRect /*= NULL*/)
  3265. {
  3266. CXTOutBarCtrl::GetIconRect(iFolder, iIndex, rcIcon, pInsideRect);
  3268. CRect rcInside;
  3269. if (pInsideRect)
  3270. rcInside = *pInsideRect;
  3271. else
  3272. GetInsideRect(rcInside);
  3274. rcIcon.left = rcInside.left;
  3275. rcIcon.right = rcInside.right;
  3276. rcIcon.InflateRect(-2, 4);
  3278. if ((m_bUpArrow && iIndex == m_iFirst) ||
  3279. (m_bDownArrow && iIndex == m_iLast) ||
  3280. (m_bDownArrow && iIndex == m_iLast-1))
  3281. {
  3282. rcIcon.right -= XTAuxData().cxHThumb + 6;
  3283. }
  3284. }
  3286. void CXTToolBox::DrawIcon(CDC* pDC, int iIcon, int iFolder, bool bHilight)
  3287. {
  3288. CRect rcIcon;
  3289. GetIconRect(iFolder, iIcon, rcIcon);
  3291. pDC->Draw3dRect(rcIcon, GetTheme()->m_clrBack, GetTheme()->m_clrBack);
  3293. // Should we highlight the icon ?
  3294. if (bHilight)
  3295. {
  3296. if (m_bIconPressed)
  3297. {
  3298. pDC->Draw3dRect(rcIcon,
  3299. GetXtremeColor(COLOR_3DSHADOW), GetXtremeColor(COLOR_3DHILIGHT));
  3300. }
  3301. else
  3302. {
  3303. pDC->Draw3dRect(rcIcon,
  3304. GetXtremeColor(COLOR_3DHILIGHT), GetXtremeColor(COLOR_3DSHADOW));
  3305. }
  3306. }
  3308. // Draw the icon using the image list.
  3309. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  3310. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  3312. ASSERT(iIcon >= 0 && iIcon < pBarFolder->GetItemCount());
  3313. CXTOutBarItem* pBarItem = pBarFolder->GetItemAt(iIcon);
  3315. CImageList* pImageList = GetFolderImageList(iFolder, IsSmallIconView(iFolder));
  3316. ASSERT(pBarItem && pImageList);
  3318. CRect rc;
  3319. GetItemRect(iFolder, iIcon, rc);
  3321. CRect rcFolder;
  3322. GetFolderRect(iFolder, rcFolder);
  3323. rc.left = rcFolder.left +4;
  3324. rc.right = rcFolder.right-4;
  3326. if (pImageList && pBarItem)
  3327. {
  3328. IMAGEINFO ii;
  3329. pImageList->GetImageInfo(pBarItem->GetIndex(), &ii);
  3330. CSize szImage = CRect(ii.rcImage).Size();
  3331. CPoint pt;
  3332. pt.x = rc.left + 2;
  3333. pt.y = rc.top + (rc.Height() - szImage.cy) / 2;
  3335. DrawItemIcon(pDC, pt, pBarItem, pImageList);
  3336. }
  3337. }
  3339. void CXTToolBox::DrawItem(CDC* pDC, const int iFolder, CRect rc, const int iIndex, const BOOL bOnlyImage)
  3340. {
  3341. if (m_arFolder.GetSize() != 0)
  3342. {
  3343. CImageList* pImageList = GetFolderImageList(iFolder, IsSmallIconView(iFolder));
  3345. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  3346. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iFolder);
  3348. ASSERT(iIndex >= 0 && iIndex < pBarFolder->GetItemCount());
  3349. CXTOutBarItem* pBarItem = pBarFolder->GetItemAt(iIndex);
  3351. ASSERT(pBarItem && pImageList);
  3352. if (!pBarItem)
  3353. return;
  3355. CFont* oft = (CFont*)pDC->SelectObject(GetFontX());
  3356. COLORREF ocr = pDC->SetTextColor(GetXtremeColor(COLOR_WINDOW));
  3357. int obk = pDC->SetBkMode(TRANSPARENT);
  3359. CRect rcFolder;
  3360. GetFolderRect(iFolder, rcFolder);
  3361. rc.left = rcFolder.left +4;
  3362. rc.right = rcFolder.right-4;
  3364. // Exclude the up and down arrows from painting.
  3365. if (m_bUpArrow)
  3366. pDC->ExcludeClipRect(&m_rcUpArrow);
  3367. if (m_bDownArrow)
  3368. pDC->ExcludeClipRect(&m_rcDownArrow);
  3370. // set the items text color.
  3371. pDC->SetTextColor(GetTheme()->m_clrText);
  3373. if (pBarItem && pBarItem->IsSelected() && !m_bAnimating && m_nLastItemSelected >= 0)
  3374. {
  3375. CRect rcIcon;
  3376. GetIconRect(m_nSelFolder, m_nLastItemSelected, rcIcon);
  3377. pDC->FillSolidRect(rcIcon, GetXtremeColor(COLOR_3DLIGHT));
  3378. pDC->Draw3dRect(rcIcon, GetXtremeColor(COLOR_3DSHADOW), GetXtremeColor(COLOR_3DHILIGHT));
  3379. }
  3381. if (pImageList)
  3382. {
  3383. IMAGEINFO ii;
  3384. pImageList->GetImageInfo(pBarItem->GetIndex(), &ii);
  3385. CSize szImage = CRect(ii.rcImage).Size();
  3386. CPoint pt;
  3387. pt.x = rc.left + 2;
  3388. pt.y = rc.top + (rc.Height() - szImage.cy) / 2;
  3390. DrawItemIcon(pDC, pt, pBarItem, pImageList);
  3392. if (!bOnlyImage)
  3393. {
  3394. rc.left += (szImage.cx + m_sizeOffset.cx);
  3395. DrawItemText(pDC, rc, pBarItem, DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS);
  3396. }
  3397. }
  3399. pDC->SetTextColor(ocr);
  3400. pDC->SelectObject(oft);
  3401. pDC->SetBkMode(obk);
  3402. }
  3403. }
  3405. void CXTToolBox::DrawScrollButton(CDC* pDC, CRect rect, UINT uType, UINT uState)
  3406. {
  3407. rect.InflateRect(1, 2, 1, 2);
  3409. CRect rcInside;
  3410. GetInsideRect(rcInside);
  3411. rcInside.DeflateRect(2, 2);
  3413. rect.right = rcInside.right;
  3414. rect.left = rect.right - rect.Width();
  3416. rect.DeflateRect(1, 1, 1, 1);
  3417. CXTOutBarCtrl::DrawScrollButton(pDC, rect, uType, uState);
  3419. rect.DeflateRect(1, 1, 1, 1);
  3420. pDC->Draw3dRect(&rect, GetXtremeColor(COLOR_3DFACE), GetXtremeColor(COLOR_3DFACE));
  3422. rect.InflateRect(1, 1, 1, 1);
  3423. if ((uState & DFCS_PUSHED) == DFCS_PUSHED)
  3424. {
  3425. pDC->Draw3dRect(&rect, GetXtremeColor(COLOR_3DSHADOW), GetXtremeColor(COLOR_3DHILIGHT));
  3426. }
  3427. else
  3428. {
  3429. pDC->Draw3dRect(&rect, GetXtremeColor(COLOR_3DHILIGHT), GetXtremeColor(COLOR_3DSHADOW));
  3430. }
  3431. }
  3433. void CXTToolBox::OnDraw(CDC* pDC)
  3434. {
  3435. m_iLast = m_nFirstItem;
  3437. GetTheme()->m_clrBack.SetStandardValue(GetXtremeColor(COLOR_3DFACE));
  3438. GetTheme()->m_clrText.SetStandardValue(GetXtremeColor(COLOR_BTNTEXT));
  3440. // Get the client rect.
  3441. CXTPClientRect rectClient(this);
  3443. CRect rc;
  3444. GetInsideRect(rc);
  3445. if (!GetFolderChild())
  3446. {
  3447. pDC->FillSolidRect(rc, GetTheme()->m_clrBack);
  3448. }
  3450. int max = (int)m_arFolder.GetSize();
  3451. CRect frc;
  3452. int t;
  3453. for (t = 0; t < max; t++)
  3454. {
  3455. GetFolderRect(t, frc);
  3456. DrawFolder(pDC, t, frc, xtMouseNormal);
  3457. }
  3459. if (!GetFolderChild())
  3460. {
  3461. GetVisibleRange(m_nSelFolder, m_iFirst, m_iLast);
  3462. m_rcUpArrow.SetRect(0, 0, GetSystemMetrics(SM_CXVSCROLL), GetSystemMetrics(SM_CXVSCROLL));
  3463. m_rcDownArrow = m_rcUpArrow;
  3464. m_rcUpArrow.OffsetRect(rc.right - 5 - GetSystemMetrics(SM_CXVSCROLL), rc.top +5);
  3465. m_rcDownArrow.OffsetRect(rc.right - 5 - GetSystemMetrics(SM_CXVSCROLL), rc.bottom - 5 - GetSystemMetrics(SM_CXVSCROLL));
  3467. if (m_iFirst > 0 && m_rcUpArrow.IntersectRect(rc, m_rcUpArrow))
  3468. {
  3469. if (m_bUpPressed)
  3470. {
  3471. DrawScrollButton(pDC, m_rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP | DFCS_PUSHED);
  3472. }
  3473. else
  3474. {
  3475. DrawScrollButton(pDC, m_rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  3476. }
  3477. m_bUpArrow = TRUE;
  3478. pDC->ExcludeClipRect(m_rcUpArrow);
  3479. }
  3480. else
  3481. {
  3482. m_bUpArrow = FALSE;
  3483. }
  3485. if (m_bUpArrow && m_rcUpArrow.bottom >= m_rcDownArrow.top)
  3486. {
  3487. m_rcDownArrow.OffsetRect(0, m_rcUpArrow.bottom - m_rcDownArrow.top + 1);
  3488. }
  3490. if (GetItemCount() > 0 && m_iLast < GetItemCount() - 1 && m_rcDownArrow.IntersectRect(rc, m_rcDownArrow))
  3491. {
  3492. if (m_bDownPressed)
  3493. {
  3494. DrawScrollButton(pDC, m_rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN | DFCS_PUSHED);
  3495. }
  3496. else
  3497. {
  3498. DrawScrollButton(pDC, m_rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  3499. }
  3500. m_bDownArrow = TRUE;
  3501. pDC->ExcludeClipRect(m_rcDownArrow);
  3502. }
  3503. else m_bDownArrow = FALSE;
  3505. PaintItems(pDC, m_nSelFolder, rc);
  3506. }
  3508. //dc.BitBlt(rectClient.left, rectClient.top, rectClient.Width(), rectClient.Height(), pDC, 0, 0, SRCCOPY);
  3510. //pDC->RestoreDC(nSavedDC);
  3512. if (m_nFolderHilighted >= 0)
  3513. {
  3514. int i = m_nFolderHilighted;
  3515. m_nFolderHilighted = -1;
  3516. HighlightFolder(pDC, i);
  3517. }
  3518. if (m_nItemHilighted >= 0)
  3519. {
  3520. int i = m_nItemHilighted;
  3521. m_nItemHilighted = -1;
  3522. HighlightItem(pDC, i, m_bPressedHighlight);
  3523. }
  3524. }
  3526. void CXTToolBox::DrawFolder(CDC* pDC, const int iIndex, CRect rect, const XTMouseState eHilight)
  3527. {
  3528. if (m_arFolder.GetSize() != 0)
  3529. {
  3530. pDC->FillSolidRect(rect, GetTheme()->m_clrBack);
  3532. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iIndex);
  3534. int nSavedDC = pDC->SaveDC();
  3536. CPen pen(PS_SOLID, 1, GetXtremeColor(COLOR_3DSHADOW));
  3538. CRect rcInside;
  3539. GetInsideRect(rcInside);
  3541. CRect rcFolder(rect);
  3542. rcFolder.left = rcInside.left + 2;
  3543. rcFolder.right = rcInside.right - 2;
  3544. rcFolder.DeflateRect(0, 1);
  3546. switch (eHilight)
  3547. {
  3548. case xtMouseNormal:
  3549. case xtMouseHover:
  3550. {
  3551. pDC->FillSolidRect(rcFolder, GetXtremeColor(COLOR_3DFACE));
  3552. pDC->Draw3dRect(rcFolder, GetXtremeColor(COLOR_3DHILIGHT), GetXtremeColor(COLOR_3DSHADOW));
  3553. pDC->SetBkMode(TRANSPARENT);
  3554. pDC->SelectObject(GetFontX());
  3556. rcFolder.DeflateRect(4, 0);
  3557. pDC->DrawText(pBarFolder->GetName(), rcFolder,
  3558. DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS);
  3559. }
  3560. break;
  3562. case xtMouseSelect:
  3563. {
  3564. pDC->FillSolidRect(rcFolder, GetXtremeColor(COLOR_3DFACE));
  3565. pDC->Draw3dRect(rcFolder, GetXtremeColor(COLOR_3DSHADOW), GetXtremeColor(COLOR_3DHILIGHT));
  3566. pDC->SetBkMode(TRANSPARENT);
  3567. pDC->SelectObject(GetFontX());
  3569. rcFolder.DeflateRect(4, 0);
  3570. pDC->DrawText(pBarFolder->GetName(), rcFolder,
  3571. DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS);
  3572. }
  3573. break;
  3574. }
  3576. pDC->RestoreDC(nSavedDC);
  3577. pen.DeleteObject();
  3578. }
  3579. }
  3581. void CXTToolBox::SetSelFolder(const int iIndex)
  3582. {
  3583. if (m_arFolder.GetSize() != 0)
  3584. {
  3585. ASSERT(iIndex >= 0 && iIndex < GetFolderCount());
  3587. CXTOutBarFolder* pBarFolder = (CXTOutBarFolder*)m_arFolder.GetAt(iIndex);
  3589. XT_OUTBAR_INFO obi;
  3590. obi.nIndex = iIndex;
  3591. obi.nDragFrom = -1;
  3592. obi.nDragTo = -1;
  3593. obi.lpszText = (LPCTSTR)pBarFolder->GetName();
  3594. obi.bFolder = true;
  3596. LRESULT lResult = NotifyOwner(OBN_XT_FOLDERCHANGE, &obi);
  3598. if (lResult == TRUE)
  3599. {
  3600. CWnd* pWnd = GetFolderChild();
  3601. if (pWnd)
  3602. {
  3603. pWnd->ShowWindow(SW_HIDE);
  3604. }
  3606. if (iIndex != m_nSelFolder && m_nSelFolder >= 0)
  3607. {
  3608. if ((m_dwFlags & OBS_XT_ANIMATION) && (m_nAnimationTickCount >= 0))
  3609. {
  3610. m_bAnimating = true;
  3611. AnimateFolderScroll(m_nSelFolder, iIndex);
  3612. m_bAnimating = false;
  3613. }
  3614. }
  3616. m_nSelFolder = iIndex;
  3617. m_nFirstItem = 0;
  3618. m_nLastItemSelected = pBarFolder->GetSelIndex();
  3620. if (m_nLastItemSelected != -1)
  3621. {
  3622. pBarFolder->SetSelItem(m_nLastItemSelected);
  3623. }
  3625. pWnd = GetFolderChild();
  3626. if (pWnd)
  3627. {
  3628. CRect rc;
  3629. GetInsideRect(rc);
  3630. pWnd->MoveWindow(rc);
  3631. pWnd->ShowWindow(SW_SHOW);
  3632. }
  3634. InvalidateRect(NULL);
  3635. }
  3636. }
  3637. }
  3639. BOOL CXTToolBox::CreateEx(DWORD dwExStyle, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, const DWORD dwFlags)
  3640. {
  3641. if (!CXTOutBarCtrl::CreateEx(dwExStyle, dwStyle, rect, pParentWnd, nID,
  3642. dwFlags | OBS_XT_SELHIGHLIGHT | OBS_XT_ANIMATION))
  3643. {
  3644. return FALSE;
  3645. }
  3647. SetSmallIconView(TRUE);
  3649. return TRUE;
  3650. }
  3652. void CXTToolBox::OnRButtonUp(UINT nFlags, CPoint point)
  3653. {
  3654. // bypass base class.
  3655. CWnd::OnRButtonUp(nFlags, point);
  3656. }