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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 书籍源码 > 查看源码
GfxOutBarCtrl.cpp
资源名称：c++时尚编程百例__1-20.rar　[点击查看]
上传用户：aokegd
上传日期：2009-12-14
资源大小：1276k
文件大小：54k
源码类别：

书籍源码

开发平台：

Visual C++

GfxOutBarCtrl.cpp：源码内容
  1. // Copyright (c) Iuri Apollonio 1998
  2. // Use & modify as you want & need, and leave those 3 lines.
  3. // http://www.codeguru.com
  6. // GfxOutBarCtrl.cpp : implementation file
  7. //
  9. #include "stdafx.h"
  10. #include "resource.h"//"OutWAts1.h"
  11. #include "GfxOutBarCtrl.h"
  12. #include "GfxGroupEdit.h"
  14. #include "GfxPopupMenu.h"
  16. #define _ID_GFX_SMALLICON "小图标方式"
  17. #define _ID_GFX_LARGEICON "大图标方式"
  18. #define _ID_GFX_ADDAGROUP   "添加组"
  19. #define _ID_GFX_FONTCOLOR   "改变字体颜色"
  20. #define _ID_GFX_BACKCOLOR   "改变背景颜色"
  21. #define _ID_GFX_REMOVEITEM "从该组中删除"
  22. #define _ID_GFX_RENAMEITEM "改名"
  24. #ifdef _DEBUG
  25. #define new DEBUG_NEW
  26. #undef THIS_FILE
  27. static char THIS_FILE[] = __FILE__;
  28. #endif
  30. /////////////////////////////////////////////////////////////////////////////
  31. // CGfxOutBarCtrl
  33. IMPLEMENT_DYNCREATE(CGfxOutBarCtrl, CWnd)
  35. CGfxOutBarCtrl::CGfxOutBarCtrl()
  36. {
  37. crBackGroundColor = GetSysColor(COLOR_BACKGROUND);//RGB(0,128,128);//
  38. crBackGroundColor1 = GetSysColor(COLOR_BACKGROUND);
  39. crTextColor = GetSysColor(COLOR_WINDOW);
  40. cr3dFace = GetSysColor(COLOR_3DFACE);
  41. crLightBorder = GetSysColor(COLOR_3DLIGHT);
  42. crHilightBorder = GetSysColor(COLOR_3DHILIGHT);
  43. crShadowBorder = GetSysColor(COLOR_3DSHADOW);
  44. crDkShadowBorder = GetSysColor(COLOR_3DDKSHADOW);
  46. pBlackPen = new CPen(PS_SOLID, 1, RGB(0,0,0));
  48. iFolderHeight = 22;
  50. dwFlags = fDragItems|fEditGroups|fEditItems|fRemoveGroups|fRemoveItems|fAddGroups|fAnimation|fSelHighlight;
  52. iSelFolder = 1;
  54. iLastFolderHighlighted = -1;
  55. iLastSelectedFolder = -1;
  57. pLargeImageList = NULL;
  58. pSmallImageList = NULL;
  60. iFirstItem = 0;
  62. xSmallIconLabelOffset = 4;
  63. yLargeIconLabelOffset = 3;
  65. ySmallIconSpacing = 10;
  66. yLargeIconSpacing = 8;
  68. xLeftMargin = 5;
  69. yTopMargin = 5;
  71. bUpArrow = bDownArrow = false;
  73. hHandCursor = AfxGetApp()->LoadCursor(IDC_HANDCUR);
  74. rcUpArrow = rcDownArrow = CRect(0,0,0,0);
  76. bUpPressed = bDownPressed = false;
  78. bLooping = false;
  80. iLastItemHighlighted = -1;
  81. bPressedHighlight = false;
  83. iLastDragItemDraw = -1;
  85. lAnimationTickCount = 10;
  87. hDragCursor = AfxGetApp()->LoadCursor(IDC_DRAGGING);
  88. hNoDragCursor = AfxGetApp()->LoadCursor(IDC_NODRAGGING);
  90. iLastSel = -1;
  91. iSelAnimCount = 0;
  93. iSelAnimTiming = 0;
  94. }
  96. CGfxOutBarCtrl::~CGfxOutBarCtrl()
  97. {
  98. for (int t = 0; t < arFolder.GetSize(); t++)
  99. {
  100. if (arFolder.GetAt(t)) delete (CBarFolder*) arFolder.GetAt(t);
  101. }
  103. arFolder.RemoveAll();
  105. delete pBlackPen;
  106. }
  109. BEGIN_MESSAGE_MAP(CGfxOutBarCtrl, CWnd)
  110. //{{AFX_MSG_MAP(CGfxOutBarCtrl)
  111. ON_WM_CREATE()
  112. ON_WM_TIMER()
  113. ON_WM_PAINT()
  114. ON_WM_ERASEBKGND()
  115. ON_WM_MOUSEMOVE()
  116. ON_WM_LBUTTONDOWN()
  117. ON_WM_SETCURSOR()
  118. ON_WM_SIZE()
  119. ON_WM_RBUTTONDOWN()
  120. ON_COMMAND(ID_GFX_LARGEICON, OnGfxLargeicon)
  121. ON_UPDATE_COMMAND_UI(ID_GFX_LARGEICON, OnUpdateGfxLargeicon)
  122. ON_COMMAND(ID_GFX_SMALLICON, OnGfxSmallicon)
  123. ON_UPDATE_COMMAND_UI(ID_GFX_SMALLICON, OnUpdateGfxSmallicon)
  124. ON_COMMAND(ID_GFX_REMOVEITEM, OnGfxRemoveitem)
  125. ON_UPDATE_COMMAND_UI(ID_GFX_REMOVEITEM, OnUpdateGfxRemoveitem)
  126. ON_COMMAND(ID_GFX_RENAMEITEM, OnGfxRenameitem)
  127. ON_UPDATE_COMMAND_UI(ID_GFX_RENAMEITEM, OnUpdateGfxRenameitem)
  128. //}}AFX_MSG_MAP
  129. ON_MESSAGE(WM_OUTBAR_NOTIFY, OnEndLabelEdit)
  130. END_MESSAGE_MAP()
  133. /////////////////////////////////////////////////////////////////////////////
  134. // CGfxOutBarCtrl message handlers
  136. long CGfxOutBarCtrl::OnEndLabelEdit(WPARAM wParam, LPARAM lParam)
  137. {
  138. if (wParam == NM_OB_ONGROUPENDEDIT)
  139. {
  140. CGfxGroupEdit * pEdit = (CGfxGroupEdit *) lParam;
  141. OUTBAR_INFO ob;
  142. ob.index = pEdit->iIndex;
  143. ob.cText = pEdit->text;
  145. if (GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_ONGROUPENDEDIT, (LPARAM) &ob))
  146. {
  147. SetFolderText(pEdit->iIndex, pEdit->text);
  148. CRect rc;
  149. GetFolderRect(pEdit->iIndex, rc);
  150. InvalidateRect(rc, false);
  151. }
  152. }
  153. if (wParam == NM_OB_ONLABELENDEDIT)
  154. {
  155. CGfxGroupEdit * pEdit = (CGfxGroupEdit *) lParam;
  156. OUTBAR_INFO ob;
  157. ob.index = pEdit->iIndex;
  158. ob.cText = pEdit->text;
  160. if (GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_ONLABELENDEDIT, (LPARAM) &ob))
  161. {
  162. SetItemText(pEdit->iIndex, pEdit->text);
  163. CRect rc;
  164. GetInsideRect(rc);
  165. InvalidateRect(rc, true);
  166. }
  167. }
  168. return 0;
  169. }
  171. void CGfxOutBarCtrl::SetFolderText(const int index, const char * text)
  172. {
  173. ASSERT(index >= 0 && index < GetFolderCount());
  174. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(index);
  175. if (pbf->cName) 
  176. {
  177. delete [] pbf->cName;
  178. pbf->cName = NULL;
  179. }
  180. pbf->cName = new char [lstrlen(text)+1];
  181. lstrcpy(pbf->cName, text);
  182. }
  184. void CGfxOutBarCtrl::SetItemText(const int index, const char * text)
  185. {
  186. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  187. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  188. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  189. if (pi->cItem) 
  190. {
  191. delete [] pi->cItem;
  192. pi->cItem = NULL;
  193. }
  194. pi->cItem = new char [lstrlen(text)+1];
  195. lstrcpy(pi->cItem, text);
  196. }
  198. BOOL CGfxOutBarCtrl::Create(DWORD dwStyle, const RECT & rect, CWnd * pParentWnd, UINT nID, const DWORD dwFlag)
  199. {
  200. dwFlags = dwFlag;
  201. return CWnd::CreateEx(WS_EX_STATICEDGE, NULL, NULL, dwStyle|WS_CHILD, rect, pParentWnd, nID);
  202. //GFXOUTBARCTRL_CLASSNAME
  203. }
  205. bool CGfxOutBarCtrl::IsSmallIconView() const
  206. {
  207. return dwFlags&fSmallIcon;
  208. }
  210. void CGfxOutBarCtrl::SetSmallIconView(const bool bSet)
  211. {
  212. iFirstItem = 0;
  214. if (bSet)
  215. {
  216. if (!IsSmallIconView()) 
  217. {
  218. dwFlags |= fSmallIcon;
  219. CRect rc;
  220. GetInsideRect(rc);
  221. InvalidateRect(rc, false);
  222. }
  223. }
  224. else
  225. {
  226. if (IsSmallIconView()) 
  227. {
  228. dwFlags &= ~fSmallIcon;
  229. CRect rc;
  230. GetInsideRect(rc);
  231. InvalidateRect(rc, false);
  232. }
  233. }
  234. }
  236. DWORD CGfxOutBarCtrl::GetFlag() const
  237. {
  238. return dwFlags;
  239. }
  241. void CGfxOutBarCtrl::ModifyFlag(const DWORD & dwRemove, const DWORD & dwAdd, const UINT redraw)
  242. {
  243. if (dwRemove) dwFlags &= ~(dwRemove);
  244. if (dwAdd) dwFlags |= dwAdd;
  246. if (GetSafeHwnd())
  247. {
  248. if (redraw != 0) SetWindowPos(0,0,0,0,0,SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE|redraw);
  249. else Invalidate();
  250. }
  251. }
  253. int CGfxOutBarCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  254. {
  255. if (CWnd::OnCreate(lpCreateStruct) == -1)
  256. return -1;
  258. // TODO: Add your specialized creation code here
  260. return 0;
  261. }
  263. void CGfxOutBarCtrl::OnTimer(UINT nIDEvent) 
  264. {
  265. if (nIDEvent == 1)
  266. {
  267. CPoint pt(GetMessagePos());
  269. ScreenToClient(&pt);
  271. CRect rc;
  272. GetClientRect(&rc);
  273. if (!(rc.PtInRect(pt)))
  274. {
  275. HighlightFolder(-1);
  276. HighlightItem(-1);
  277. KillTimer(1);
  278. }
  279. }
  280. else if (nIDEvent == 3 && iLastSel >= 0)
  281. {
  282. iSelAnimCount ++;
  283. if (iSelAnimCount > 10) iSelAnimCount = -1;
  284. if (iSelAnimCount == 0)
  285. DrawAnimItem(-1, 1, iLastSel);
  286. if (iSelAnimCount == 1)
  287. DrawAnimItem(0, 0, iLastSel);
  288. if (iSelAnimCount == 2)
  289. DrawAnimItem(1, 1, iLastSel);
  290. if (iSelAnimCount == 3)
  291. DrawAnimItem(0, 0, iLastSel);
  292. }
  293. CWnd::OnTimer(nIDEvent);
  294. }
  296. void CGfxOutBarCtrl::DrawAnimItem(const int xoffset, const int yoffset, const int index)
  297. {
  298. CImageList * ima = GetFolderImageList(iSelFolder, IsSmallIconView());
  300. CRect rc, irc;
  301. GetInsideRect(irc);
  302. GetItemRect(iSelFolder, iLastSel, rc);
  304. if (iLastSel >= iFirstItem && irc.bottom > rc.bottom && irc.top < rc.top)
  305. {
  306. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  307. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  309. ASSERT(index >= 0 && index < pbf->GetItemCount());
  310. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  312. ASSERT(pi && ima);
  314. CClientDC dc(this);
  316. if (IsSmallIconView())
  317. {
  318. if (ima)
  319. {
  320. IMAGEINFO ii;
  321. ima->GetImageInfo(pi->iImageIndex, &ii);
  322. CSize szImage = CRect(ii.rcImage).Size();
  323. CPoint pt;
  324. pt.x = rc.left + 2;
  325. pt.y = rc.top + (rc.Height() - szImage.cy) / 2;
  327. CRect rcBck(pt.x-1, pt.y-1, pt.x + szImage.cx+2, pt.y + szImage.cy+2);
  328. dc.FillSolidRect(rcBck, crBackGroundColor);
  330. pt.x += xoffset;
  331. pt.y += yoffset;
  333. ima->Draw(&dc, pi->iImageIndex, pt, ILD_NORMAL);
  335. }
  336. }
  337. else
  338. {
  339. if (ima)
  340. {
  341. IMAGEINFO ii;
  342. ima->GetImageInfo(pi->iImageIndex, &ii);
  343. CSize szImage = CRect(ii.rcImage).Size();
  344. CPoint pt;
  345. pt.x = rc.left + (rc.Width() - szImage.cx) / 2;
  346. pt.y = rc.top;
  348. CRect rcBck(pt.x-1, pt.y-1, pt.x + szImage.cx+2, pt.y + szImage.cy+2);
  349. dc.FillSolidRect(rcBck, crBackGroundColor);
  351. pt.x += xoffset;
  352. pt.y += yoffset;
  354. ima->Draw(&dc, pi->iImageIndex, pt, ILD_NORMAL);
  355. }
  356. }
  357. }
  358. }
  360. void CGfxOutBarCtrl::OnPaint() 
  361. {
  362. CRect clientRc;
  363. GetClientRect(&clientRc);
  364. CPaintDC dc(this);
  365. CDC memDC;
  366. memDC.CreateCompatibleDC(&dc);
  367. CBitmap bmp;
  368. bmp.CreateCompatibleBitmap(&dc, clientRc.Width(), clientRc.Height());
  369. CBitmap * obmp = memDC.SelectObject(&bmp);
  371. CDC * pDC = &memDC;
  373. CRect rc;
  374. GetInsideRect(rc);
  375. if (!GetFolderChild()) pDC->FillSolidRect(rc, crBackGroundColor);
  378. int max = arFolder.GetSize();
  379. CRect frc;
  380. for (int t = 0; t < max; t++)
  381. {
  382. GetFolderRect(t, frc);
  383. DrawFolder(pDC, t, frc, false);
  384. }
  385. if (!GetFolderChild())
  386. {
  387. int f,l;
  388. GetVisibleRange(iSelFolder, f,l);
  389. rcUpArrow.SetRect(0,0,GetSystemMetrics(SM_CXVSCROLL), GetSystemMetrics(SM_CXVSCROLL));
  390. rcDownArrow = rcUpArrow;
  391. rcUpArrow.OffsetRect(rc.right - 5 - GetSystemMetrics(SM_CXVSCROLL), rc.top +5);
  392. rcDownArrow.OffsetRect(rc.right - 5 - GetSystemMetrics(SM_CXVSCROLL), rc.bottom - 5 - GetSystemMetrics(SM_CXVSCROLL));
  394. if (f > 0)
  395. {
  396. if (bUpPressed) pDC->DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP|DFCS_PUSHED);
  397. else pDC->DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  398. bUpArrow = true;
  399. pDC->ExcludeClipRect(rcUpArrow);
  400. }
  401. else bUpArrow = false;
  403. if (l < GetItemCount() - 1)
  404. {
  405. if (bDownPressed) pDC->DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN|DFCS_PUSHED);
  406. else pDC->DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  407. bDownArrow = true;
  408. pDC->ExcludeClipRect(rcDownArrow);
  409. }
  410. else bDownArrow = false;
  412. PaintItems(pDC, iSelFolder, rc);
  413. }
  415. dc.BitBlt(clientRc.left, clientRc.top, clientRc.Width(), clientRc.Height(), &memDC, 0,0, SRCCOPY);
  417. memDC.SelectObject(obmp);
  419. if (iLastFolderHighlighted >= 0)
  420. {
  421. int i = iLastFolderHighlighted;
  422. iLastFolderHighlighted = -1;
  423. HighlightFolder(i);
  424. }
  425. if (iLastItemHighlighted >= 0)
  426. {
  427. int i = iLastItemHighlighted;
  428. iLastItemHighlighted = -1;
  429. HighlightItem(i, bPressedHighlight);
  430. }
  432. }
  434. BOOL CGfxOutBarCtrl::OnEraseBkgnd(CDC* pDC) 
  435. {
  436. return true;
  437. }
  439. bool CGfxOutBarCtrl::GetFolderRect(const int iIndex, CRect & rect) const
  440. {
  441. int max = arFolder.GetSize();
  442. ASSERT(iIndex >= 0 && iIndex < max);
  444. if (iIndex >= 0 && iIndex < max)
  445. {
  446. CRect rc;
  447. GetClientRect(rc);
  448. if (iIndex > iSelFolder)
  449. rect.SetRect(rc.left, rc.bottom - ((max - iIndex)) * iFolderHeight, rc.right, 
  450. rc.bottom - (max - iIndex - 1) * iFolderHeight);
  451. else 
  452. rect.SetRect(rc.left, rc.top + iIndex * iFolderHeight - 1, rc.right, 
  453. rc.top + (1 + iIndex) * iFolderHeight - 1);
  454. return true;
  455. }
  456. return false;
  457. }
  459. void CGfxOutBarCtrl::GetItemRect(const int iFolder, const int iIndex, CRect & rect)
  460. {
  461. CRect rc;
  462. GetInsideRect(rc);
  463. int top = rc.top;
  464. CSize sz(0,0);
  465. int y = 0;
  466. for (int t = 0; t < iIndex; t++)
  467. {
  468. sz = GetItemSize(iFolder, t, ircAll);
  469. top += sz.cy;
  471. if (IsSmallIconView()) 
  472. {
  473. top += ySmallIconSpacing; 
  474. }
  475. else 
  476. {
  477. top += yLargeIconSpacing;
  478. }
  479. if (t == iFirstItem - 1) y = top - rc.top;
  480. }
  481. sz = GetItemSize(iFolder, iIndex, ircAll);
  482. rect.SetRect(rc.left, top, rc.left + sz.cx, top + sz.cy);
  484. rect.top -= y;
  485. rect.bottom -= y;
  487. rect.left += xLeftMargin;
  488. rect.top  += yTopMargin;
  489. rect.bottom += yTopMargin;
  491. if (!IsSmallIconView()) 
  492. {
  493. rect.left = rc.left;
  494. rect.right = rc.right;
  495. }
  496. }
  498. void CGfxOutBarCtrl::DrawFolder(CDC * pDC, const int iIdx, CRect rect, const bool bSelected)
  499. {
  500. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iIdx);
  502. if (!bSelected)
  503. {
  504. CPen pn1(PS_SOLID, 1, crBackGroundColor1);
  505. CPen * op = pDC->SelectObject(&pn1);
  506. pDC->MoveTo(rect.left, rect.top);
  507. pDC->LineTo(rect.right, rect.top);
  508. pDC->SelectObject(op);
  510. rect.top ++;
  512. pDC->Draw3dRect(rect, crHilightBorder, crBackGroundColor1);
  513. rect.InflateRect(-1,-1);
  514. pDC->FillSolidRect(rect, cr3dFace);
  515. int obk = pDC->SetBkMode(TRANSPARENT);
  516. CFont * of = pDC->SelectObject(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  517. pDC->DrawText(CString(pbf->cName), rect, DT_CENTER|DT_VCENTER|DT_SINGLELINE);
  518. pDC->SetBkMode(obk);
  519. pDC->SelectObject(of);
  520. }
  521. else
  522. {
  523. CPen pn1(PS_SOLID, 1, crBackGroundColor1);
  524. CPen * op = pDC->SelectObject(&pn1);
  525. pDC->MoveTo(rect.left+1, rect.top);
  526. pDC->LineTo(rect.right, rect.top);
  527. pDC->SelectObject(op);
  529. rect.top ++;
  531. pDC->Draw3dRect(rect, crDkShadowBorder, crHilightBorder);
  532. rect.InflateRect(-1,-1);
  533. pDC->Draw3dRect(rect, crBackGroundColor1, cr3dFace);
  534. rect.InflateRect(-1,-1);
  536. pDC->FillSolidRect(rect, cr3dFace);
  538. int obk = pDC->SetBkMode(TRANSPARENT);
  539. CFont * of = pDC->SelectObject(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  540. pDC->DrawText(CString(pbf->cName), rect, DT_CENTER|DT_VCENTER|DT_SINGLELINE);
  541. pDC->SetBkMode(obk);
  542. pDC->SelectObject(of);
  543. }
  544. }
  546. int CGfxOutBarCtrl::AddFolder(const char * cFolderName, const DWORD exData)
  547. {
  548. CBarFolder * pbf = new CBarFolder(cFolderName, exData);
  549. ASSERT(pbf);
  550. arFolder.Add((void *)pbf);
  552. return arFolder.GetSize() - 1;
  553. }
  555. CGfxOutBarCtrl::CBarFolder::CBarFolder(const char * name, DWORD exData)
  556. {
  557. cName = NULL;
  558. dwData = exData;
  560. if (name)
  561. {
  562. cName = new char[lstrlen(name)+1];
  563. ASSERT(cName);
  564. lstrcpy(cName, name);
  565. }
  566. pLargeImageList = NULL;
  567. pSmallImageList = NULL;
  568. pChild = NULL;
  569. }
  571. CGfxOutBarCtrl::CBarFolder::~CBarFolder()
  572. {
  573. if (cName) delete [] cName;
  574. for (int t = 0; t < arItems.GetSize(); t++)
  575. if (arItems.GetAt(t)) delete (CBarFolder*) arItems.GetAt(t);
  577. arItems.RemoveAll();
  578. }
  580. void CGfxOutBarCtrl::GetInsideRect(CRect & rect) const
  581. {
  582. GetClientRect(rect);
  583. if (arFolder.GetSize() > 0)
  584. {
  585. int max = arFolder.GetSize();
  586. rect.top += iFolderHeight * (iSelFolder + 1) - 1;//+ 2;
  587. rect.bottom -= (max - iSelFolder - 1)*iFolderHeight;
  588. return;
  589. }
  590. }
  592. void CGfxOutBarCtrl::OnMouseMove(UINT nFlags, CPoint point) 
  593. {
  594. int index, ht = HitTestEx(point, index);
  596. if (ht != htFolder && iLastFolderHighlighted >= 0) HighlightFolder(-1);
  597. if (ht != htItem   && iLastItemHighlighted   >= 0) HighlightItem(-1);
  599. if (ht == htFolder)
  600. {
  601. HighlightFolder(index);
  602. SetTimer(1,100,NULL);
  603. }
  604. else if (ht == htItem)
  605. {
  606. HighlightItem(index);
  607. SetTimer(1,100,NULL);
  608. }
  610. CWnd::OnMouseMove(nFlags, point);
  611. }
  613. int CGfxOutBarCtrl::HitTestEx(const CPoint & point, int &index)
  614. {
  615. if (bUpArrow && rcUpArrow.PtInRect(point)) return htUpScroll;
  616. if (bDownArrow && rcDownArrow.PtInRect(point)) return htDownScroll;
  618. int max = arFolder.GetSize(), t;
  620. CRect rc;
  621. for (t = 0; t < max; t++)
  622. {
  623. GetFolderRect(t, rc);
  624. if (rc.PtInRect(point)) 
  625. {
  626. index = t;
  627. return htFolder;
  628. }
  629. }
  630. GetInsideRect(rc);
  631. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  632. max = pbf->GetItemCount();
  633. for (t = iFirstItem; t < max; t++)
  634. {
  635. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(t);
  636. CRect itemRc;
  637. if (!IsSmallIconView()) 
  638. {
  639. GetIconRect(iSelFolder, t, itemRc);
  640. if (itemRc.PtInRect(point))
  641. {
  642. index = t;
  643. return htItem;
  644. }
  645. else if (itemRc.top > rc.bottom) break;
  646. GetLabelRect(iSelFolder, t, itemRc);
  647. itemRc.top -= yLargeIconLabelOffset;
  649. if (itemRc.PtInRect(point))
  650. {
  651. index = t;
  652. return htItem;
  653. }
  654. else if (itemRc.top > rc.bottom) break;
  655. }
  656. else
  657. {
  658. GetItemRect(iSelFolder, t, itemRc);
  659. if (itemRc.PtInRect(point))
  660. {
  661. index = t;
  662. return htItem;
  663. }
  664. else if (itemRc.top > rc.bottom) break;
  665. }
  666. }
  667. return htNothing;
  668. }
  670. void CGfxOutBarCtrl::HighlightFolder(const int index)
  671. {
  672. CWnd * pf = GetFocus();
  673. if (pf != NULL && pf != this && IsChild(pf)) return;
  675. if (iLastFolderHighlighted == index) return;
  677. if (iLastFolderHighlighted >= 0)
  678. {
  679. CRect rc;
  680. if (GetFolderRect(iLastFolderHighlighted, rc))
  681. {
  682. CClientDC dc(this);
  683. CPen pn(PS_SOLID, 1, crBackGroundColor1);//crShadowBorder);
  684. CPen * op = dc.SelectObject(&pn);
  685. dc.MoveTo(rc.left, rc.bottom-1);
  686. dc.LineTo(rc.right-1, rc.bottom-1);
  687. dc.LineTo(rc.right-1, rc.top);
  688. CPen pn1(PS_SOLID, 1, cr3dFace);
  689. dc.SelectObject(&pn1);
  690. dc.MoveTo(rc.left+1, rc.bottom-2);
  691. dc.LineTo(rc.right-2, rc.bottom-2);
  692. dc.LineTo(rc.right-2, rc.top+1);
  693. dc.SelectObject(op);
  694. }
  695. }
  696. iLastFolderHighlighted = index;
  697. if (iLastFolderHighlighted >= 0)
  698. {
  699. CRect rc;
  700. if (GetFolderRect(iLastFolderHighlighted, rc))
  701. {
  702. CClientDC dc(this);
  703. CPen pn(PS_SOLID, 1, crDkShadowBorder);
  704. CPen * op = dc.SelectObject(&pn);
  705. dc.MoveTo(rc.left, rc.bottom-1);
  706. dc.LineTo(rc.right-1, rc.bottom-1);
  707. dc.LineTo(rc.right-1, rc.top);
  708. CPen pn1(PS_SOLID, 1, crBackGroundColor1);
  709. dc.SelectObject(&pn1);
  710. dc.MoveTo(rc.left+1, rc.bottom-2);
  711. dc.LineTo(rc.right-2, rc.bottom-2);
  712. dc.LineTo(rc.right-2, rc.top+1);
  713. dc.SelectObject(op);
  714. }
  715. }
  716. }
  718. void CGfxOutBarCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  719. {
  720. if (GetFocus() != this) SetFocus();
  722. int index, ht = HitTestEx(point, index);
  723. iLastDragItemDrawType = -1;
  725. CRect inRc;
  726. GetInsideRect(inRc);
  728. if (ht == htFolder)
  729. {
  730. bool bHigh = true;
  731. CRect rc;
  732. GetFolderRect(index, rc);
  734. if (::GetCapture() == NULL)
  735. {
  736. SetCapture();
  737. ASSERT(this == GetCapture());
  738. CClientDC dc(this);
  739. DrawFolder(&dc, index, rc, true);
  740. AfxLockTempMaps();
  741. for (;;)
  742. {
  743. MSG msg;
  744. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  746. if (CWnd::GetCapture() != this) break;
  748. switch (msg.message)
  749. {
  750. case WM_MOUSEMOVE:
  751. {
  752. CPoint pt(msg.lParam);
  753. int idx, ht1 = HitTestEx(pt, idx);
  754. if (ht1 == htFolder && idx == index)
  755. {
  756. if (!bHigh)
  757. {
  758. DrawFolder(&dc, index, rc, true);
  759. bHigh = true;
  760. }
  761. }
  762. else
  763. {
  764. if (bHigh)
  765. {
  766. DrawFolder(&dc, index, rc, false);
  767. bHigh = false;
  768. }
  769. }
  770. }
  771. break;
  773. case WM_LBUTTONUP:
  774. {
  775. if (bHigh)
  776. {
  777. DrawFolder(&dc, index, rc, false);
  778. bHigh = false;
  779. }
  780. CPoint pt(msg.lParam);
  781. int idx, ht1 = HitTestEx(pt, idx);
  782. if (ht1 == htFolder && idx != iSelFolder)
  783. SetSelFolder(idx);
  784. }
  786. goto ExitLoop2;
  788. case WM_KEYDOWN:
  789. if (msg.wParam != VK_ESCAPE) 
  790. break;
  792. default:
  793. DispatchMessage(&msg);
  794. break;
  795. }
  796. }
  798. ExitLoop2:
  799. ReleaseCapture();
  800. AfxUnlockTempMaps(FALSE);
  801. }
  802. if (bHigh) InvalidateRect(rc, false);
  803. }
  804. else iLastSelectedFolder = -1;
  806. if (ht == htItem)
  807. {
  808. iLastDragItemDraw = -1;
  809. bool bHigh = true, bDragging = false;
  810. CRect rc;
  811. GetItemRect(iSelFolder, index, rc);
  813. HCURSOR hCur = GetCursor();
  815. if (::GetCapture() == NULL)
  816. {
  817. SetCapture();
  818. ASSERT(this == GetCapture());
  819. CClientDC dc(this);
  820. HighlightItem(index, true);
  821. AfxLockTempMaps();
  822. for (;;)
  823. {
  824. MSG msg;
  825. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  827. if (CWnd::GetCapture() != this) break;
  829. switch (msg.message)
  830. {
  831. case WM_MOUSEMOVE:
  832. {
  833. CPoint pt(msg.lParam);
  834. int idx, ht1 = HitTestEx(pt, idx);
  835. if (bDragging)
  836. {
  837. if (ht1 == htItem) 
  838. {
  839. DrawDragArrow(&dc, index, idx);
  840. SetCursor(hDragCursor);
  841. hCur = hDragCursor;
  842. }
  843. else 
  844. {
  845. CRect rcItem;
  846. GetItemRect(iSelFolder, GetItemCount() - 1, rcItem);
  847. if (pt.y > rcItem.bottom && pt.y < inRc.bottom)
  848. {
  849. DrawDragArrow(&dc, index, GetItemCount());
  850. SetCursor(hDragCursor);
  851. hCur = hDragCursor;
  852. }
  853. else
  854. {
  855. DrawDragArrow(&dc, index, -1);
  856. SetCursor(hNoDragCursor);
  857. hCur = hNoDragCursor;
  858. }
  859. }
  860. }
  861. else
  862. {
  863. if (ht1 == htItem && idx == index)
  864. {
  865. if (!bHigh)
  866. {
  867. HighlightItem(index, true);
  868. bHigh = true;
  869. bPressedHighlight = true;
  870. }
  871. }
  872. else 
  873. {
  874. if (ht1 == htItem)
  875. {
  876. if (bHigh)
  877. {
  878. HighlightItem(index, false);
  879. bHigh = false;
  880. bPressedHighlight = false;
  881. }
  882. }
  883. else
  884. {
  885. if (dwFlags&fDragItems)
  886. {
  887. HighlightItem(index, true);
  888. bHigh = true;
  889. bDragging = true;
  891. SetCursor(hDragCursor);
  892. hCur = hDragCursor;
  894. bPressedHighlight = true;
  895. }
  896. }
  897. }
  898. }
  899. }
  900. break;
  902. case WM_SETCURSOR:
  903. SetCursor(hCur);
  904. break;
  906. case WM_LBUTTONUP:
  907. {
  908. if (bHigh)
  909. {
  910. HighlightItem(-1);
  911. bHigh = false;
  912. }
  913. CPoint pt(msg.lParam);
  914. int idx, ht1 = HitTestEx(pt, idx);
  915. if (!bDragging)
  916. {
  917. if (ht1 == htItem && idx == index) 
  918. {
  919. if (iSelAnimTiming > 0 && index != iLastSel && iLastSel >= 0)
  920. {
  921. DrawAnimItem(0, 0, iLastSel);
  922. }
  924. if (dwFlags&fSelHighlight && iLastSel >= 0)
  925. {
  926. CRect rc;
  927. GetIconRect(iSelFolder, iLastSel, rc);
  928. rc.InflateRect(1,1);
  929. InvalidateRect(rc);
  930. }
  932. iLastSel = index;
  934. if (dwFlags&fSelHighlight && iLastSel >= 0)
  935. {
  936. CRect rc;
  937. GetIconRect(iSelFolder, iLastSel, rc);
  938. rc.InflateRect(1,1);
  939. InvalidateRect(rc);
  940. }
  942. GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_ITEMCLICK, idx);
  943. }
  944. }
  945. else
  946. {
  947. if (ht1 == htItem)
  948. {
  949. if (idx != index)
  950. {
  951. OUTBAR_INFO ob;
  952. ob.iDragFrom = iSelFolder;
  953. ob.iDragTo = index;
  954. if (GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_DRAGITEM, (LPARAM) &ob))
  955. {
  956. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  957. CBarItem * piFrom = (CBarItem *) pbf->arItems.GetAt(index);
  958. pbf->arItems.RemoveAt(index);
  959. if (idx > index) idx --;
  960. pbf->arItems.InsertAt(idx, piFrom);
  961. }
  962. }
  963. }
  964. else
  965. {
  966. CRect rcItem;
  967. GetItemRect(iSelFolder, GetItemCount() - 1, rcItem);
  968. if (pt.y > rcItem.bottom && pt.y < inRc.bottom)
  969. {
  970. OUTBAR_INFO ob;
  971. ob.iDragFrom = iSelFolder;
  972. ob.iDragTo = index;
  973. if (GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_DRAGITEM, (LPARAM) &ob))
  974. {
  975. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  976. CBarItem * piFrom = (CBarItem *) pbf->arItems.GetAt(index);
  977. pbf->arItems.RemoveAt(index);
  978. pbf->arItems.Add((void *) piFrom);
  979. }
  980. }
  981. }
  982. }
  983. }
  985. goto ExitLoop4;
  987. default:
  988. DispatchMessage(&msg);
  989. break;
  990. }
  991. }
  993. ExitLoop4:
  994. ReleaseCapture();
  995. AfxUnlockTempMaps(FALSE);
  996. if (bDragging) 
  997. {
  998. Invalidate();
  999. }
  1000. }
  1001. bPressedHighlight = false;
  1002. if (bHigh) InvalidateRect(rc, false);
  1003. }
  1004. else iLastItemHighlighted = -1;
  1006. if (ht == htDownScroll)
  1007. {
  1008. bLooping = true;
  1009. bool bHigh = true;
  1011. if (::GetCapture() == NULL)
  1012. {
  1013. SetCapture();
  1014. ASSERT(this == GetCapture());
  1015. CClientDC dc(this);
  1016. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN|DFCS_PUSHED);
  1017. SetTimer(2,300,NULL);
  1018. AfxLockTempMaps();
  1019. for (;;)
  1020. {
  1021. MSG msg;
  1022. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1024. if (CWnd::GetCapture() != this) break;
  1026. switch (msg.message)
  1027. {
  1028. case WM_MOUSEMOVE:
  1029. {
  1030. CPoint pt(msg.lParam);
  1031. if (rcDownArrow.PtInRect(pt))
  1032. {
  1033. if (bHigh == false)
  1034. {
  1035. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN|DFCS_PUSHED);
  1036. bHigh = true;
  1037. bDownArrow = true;
  1038. bDownPressed = true;
  1039. }
  1040. }
  1041. else
  1042. {
  1043. if (bHigh == true)
  1044. {
  1045. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  1046. bHigh = false;
  1047. bDownArrow = false;
  1048. bDownPressed = false;
  1049. }
  1050. }
  1051. }
  1052. break;
  1054. case WM_LBUTTONUP:
  1055. {
  1056. if (bHigh)
  1057. {
  1058. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  1059. bHigh = false;
  1060. }
  1061. bDownArrow = false;
  1062. CPoint pt(msg.lParam);
  1063. if (rcDownArrow.PtInRect(pt))
  1064. {
  1065. CRect itrc;
  1066. GetItemRect(iSelFolder, GetItemCount() - 1, itrc);
  1067. CRect crc;
  1068. GetInsideRect(crc);
  1069. if (itrc.bottom > crc.bottom)
  1070. {
  1071. iFirstItem ++;
  1072. InvalidateRect(crc, true);
  1073. }
  1074. }
  1075. }
  1076. goto ExitLoop3;
  1079. case WM_TIMER:
  1080. {
  1081. if (msg.wParam == 2)
  1082. {
  1083. if (bHigh)
  1084. {
  1085. CPoint pt(msg.pt);
  1086. ScreenToClient(&pt);
  1087. if (rcDownArrow.PtInRect(pt))
  1088. {
  1089. bDownPressed = true;
  1090. CRect itrc;
  1091. GetItemRect(iSelFolder, GetItemCount() - 1, itrc);
  1092. CRect crc;
  1093. GetInsideRect(crc);
  1094. if (itrc.bottom > crc.bottom)
  1095. {
  1096. iFirstItem ++;
  1097. InvalidateRect(crc, true);
  1098. }
  1099. else goto ExitLoop3;
  1100. }
  1101. else bDownPressed = false;
  1102. }
  1103. }
  1104. break;
  1105. }
  1107. case WM_KEYDOWN:
  1108. if (msg.wParam != VK_ESCAPE) 
  1109. break;
  1111. default:
  1112. DispatchMessage(&msg);
  1113. break;
  1114. }
  1115. }
  1117. ExitLoop3:
  1118. KillTimer(2);
  1119. ReleaseCapture();
  1120. AfxUnlockTempMaps(FALSE);
  1121. bLooping = false;
  1122. bDownPressed = false;
  1123. bDownArrow = false;
  1124. CRect crc;
  1125. GetInsideRect(crc);
  1126. InvalidateRect(crc, true);
  1127. }
  1128. }
  1130. if (ht == htUpScroll)
  1131. {
  1132. bLooping = true;
  1133. bool bHigh = true;
  1135. if (::GetCapture() == NULL)
  1136. {
  1137. SetCapture();
  1138. ASSERT(this == GetCapture());
  1139. CClientDC dc(this);
  1140. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP|DFCS_PUSHED);
  1141. SetTimer(2,300,NULL);
  1142. AfxLockTempMaps();
  1143. for (;;)
  1144. {
  1145. MSG msg;
  1146. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1148. if (CWnd::GetCapture() != this) break;
  1150. switch (msg.message)
  1151. {
  1152. case WM_MOUSEMOVE:
  1153. {
  1154. CPoint pt(msg.lParam);
  1155. if (rcUpArrow.PtInRect(pt))
  1156. {
  1157. if (bHigh == false)
  1158. {
  1159. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP|DFCS_PUSHED);
  1160. bHigh = true;
  1161. bUpArrow = true;
  1162. bUpPressed = true;
  1163. }
  1164. }
  1165. else
  1166. {
  1167. if (bHigh == true)
  1168. {
  1169. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  1170. bHigh = false;
  1171. bUpArrow = false;
  1172. bUpPressed = false;
  1173. }
  1174. }
  1175. }
  1176. break;
  1178. case WM_LBUTTONUP:
  1179. {
  1180. if (bHigh)
  1181. {
  1182. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  1183. bHigh = false;
  1184. }
  1185. bUpArrow = false;
  1186. CPoint pt(msg.lParam);
  1187. if (rcUpArrow.PtInRect(pt))
  1188. {
  1189. if (iFirstItem > 0 ) 
  1190. {
  1191. iFirstItem --;
  1192. CRect crc;
  1193. GetInsideRect(crc);
  1194. InvalidateRect(crc, true);
  1195. }
  1196. }
  1197. }
  1199. goto ExitLoop;
  1201. case WM_TIMER:
  1202. {
  1203. if (msg.wParam == 2)
  1204. {
  1205. if (bHigh)
  1206. {
  1207. CPoint pt(msg.pt);
  1208. ScreenToClient(&pt);
  1209. if (rcUpArrow.PtInRect(pt))
  1210. {
  1211. bUpPressed = true;
  1212. if (iFirstItem > 0) 
  1213. {
  1214. iFirstItem --;
  1215. CRect crc;
  1216. GetInsideRect(crc);
  1217. InvalidateRect(crc, true);
  1218. }
  1219. else goto ExitLoop;
  1220. }
  1221. else bUpPressed = false;
  1222. }
  1223. }
  1224. break;
  1225. }
  1226. case WM_KEYDOWN:
  1227. if (msg.wParam != VK_ESCAPE) break;
  1229. default:
  1230. DispatchMessage(&msg);
  1231. break;
  1232. }
  1233. }
  1235. ExitLoop:
  1236. KillTimer(2);
  1237. ReleaseCapture();
  1238. AfxUnlockTempMaps(FALSE);
  1239. bLooping = false;
  1240. bUpPressed = false;
  1241. bUpArrow = false;
  1242. CRect crc;
  1243. GetInsideRect(crc);
  1244. InvalidateRect(crc, true);
  1245. }
  1246. }
  1248. CWnd::OnLButtonDown(nFlags, point);
  1249. }
  1252. int CGfxOutBarCtrl::InsertItem(const int folder, const int index, const char * text, const int image, const DWORD exData)
  1253. {
  1254. ASSERT(folder >= 0 && folder < GetFolderCount());
  1255. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(folder);
  1256. return pbf->InsertItem(index, text, image, exData);
  1257. }
  1259. int CGfxOutBarCtrl::GetItemCount() const
  1260. {
  1261. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1262. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1263. return  pbf->GetItemCount();
  1264. }
  1266. void CGfxOutBarCtrl::SetSelFolder(const int index)
  1267. {
  1268. ASSERT(index >= 0 && index < GetFolderCount());
  1269. // if (index == iSelFolder) return;
  1271. CWnd * pc = GetFolderChild();
  1272. if (pc) pc->ShowWindow(SW_HIDE);
  1274. if (index != iSelFolder)
  1275. {
  1276. if (dwFlags&fAnimation && lAnimationTickCount >= 0) AnimateFolderScroll(iSelFolder, index);
  1277. }
  1279. iSelFolder = index;
  1280. iFirstItem = 0;
  1281. iLastSel = -1;
  1283. pc = GetFolderChild();
  1284. if (pc)
  1285. {
  1286. CRect rc;
  1287. GetInsideRect(rc);
  1288. pc->MoveWindow(rc);
  1289. pc->ShowWindow(SW_SHOW);
  1290. }
  1292. GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_FOLDERCHANGE, (LPARAM) iSelFolder);
  1294. Invalidate();
  1295. }
  1297. int CGfxOutBarCtrl::GetFolderCount() const
  1298. {
  1299. return arFolder.GetSize();
  1300. }
  1302. int CGfxOutBarCtrl::GetSelFolder() const
  1303. {
  1304. return iSelFolder;
  1305. }
  1307. void CGfxOutBarCtrl::RemoveFolder(const int index)
  1308. {
  1309. ASSERT(index >= 0 && index < GetFolderCount());
  1310. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(index);
  1311. delete pbf;
  1312. arFolder.RemoveAt(index);
  1313. if (iSelFolder >= index) iSelFolder = index - 1;
  1314. if (iSelFolder < 0 && GetFolderCount() > 0) iSelFolder = 0;
  1315. Invalidate();
  1316. }
  1318. int CGfxOutBarCtrl::CBarFolder::InsertItem(int index, const char * text, const int image, const DWORD exData)
  1319. {
  1320. if (index < 0 || index > GetItemCount()) index = GetItemCount();
  1322. int c = GetItemCount();
  1324. CBarItem * pbf = new CBarItem(text, image, exData);
  1325. ASSERT(pbf);
  1326. if (index < GetItemCount()) 
  1327. arItems.InsertAt(index, (void *) pbf);
  1328. else 
  1329. arItems.Add((void *) pbf);
  1331. c = GetItemCount();
  1333. return index;
  1334. }
  1336. int CGfxOutBarCtrl::GetCountPerPage() const
  1337. {
  1338. return 0;
  1339. }
  1341. CImageList * CGfxOutBarCtrl::SetImageList(CImageList * pImageList, int nImageList)
  1342. {
  1343. CImageList * o = NULL;
  1344. if (nImageList == fSmallIcon)
  1345. {
  1346. o = pSmallImageList;
  1347. pSmallImageList = pImageList;
  1348. }
  1349. else if (nImageList == fLargeIcon)
  1350. {
  1351. o = pLargeImageList;
  1352. pLargeImageList = pImageList;
  1353. }
  1354. return o;
  1355. }
  1357. CImageList * CGfxOutBarCtrl::GetImageList(CImageList * pImageList, int nImageList)
  1358. {
  1359. if (nImageList == fSmallIcon) return pSmallImageList;
  1360. else if (nImageList == fLargeIcon) return pLargeImageList;
  1361. return NULL;
  1362. }
  1364. CImageList * CGfxOutBarCtrl::SetFolderImageList(const int folder, CImageList * pImageList, int nImageList)
  1365. {
  1366. ASSERT(folder >= 0 && folder < GetFolderCount());
  1367. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(folder);
  1368. CImageList * o = NULL;
  1369. if (nImageList == fSmallIcon)
  1370. {
  1371. o = pbf->pSmallImageList;
  1372. pbf->pSmallImageList = pImageList;
  1373. }
  1374. else if (nImageList == fLargeIcon)
  1375. {
  1376. o = pbf->pLargeImageList;
  1377. pbf->pLargeImageList = pImageList;
  1378. }
  1379. return o;
  1380. }
  1383. CGfxOutBarCtrl::CBarItem::CBarItem(const char * name, const int image, DWORD exData)
  1384. {
  1385. cItem = NULL;
  1386. iImageIndex = image;
  1387. dwData = exData;
  1388. if (name)
  1389. {
  1390. cItem = new char[lstrlen(name)+1];
  1391. ASSERT(cItem);
  1392. lstrcpy(cItem, name);
  1393. }
  1394. }
  1396. CGfxOutBarCtrl::CBarItem::~CBarItem()
  1397. {
  1398. if (cItem) delete [] cItem;
  1399. }
  1401. int CGfxOutBarCtrl::CBarFolder::GetItemCount()
  1402. {
  1403. return arItems.GetSize();
  1404. }
  1406. void CGfxOutBarCtrl::PaintItems(CDC * pDC, const int iFolder, CRect rc)
  1407. {
  1408. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1409. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  1410. int max = pbf->GetItemCount(), t;
  1411. CRect irc;
  1412. GetInsideRect(irc);
  1413. int isdc = pDC->SaveDC();
  1414. CRgn itemRegion;
  1415. itemRegion.CreateRectRgnIndirect(&irc);
  1416. pDC->SelectClipRgn(&itemRegion);
  1417. itemRegion.DeleteObject();
  1418. for (t = iFirstItem; t < max; t++)
  1419. {
  1420. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(t);
  1421. CRect itemRc;
  1422. GetItemRect(iFolder, t, itemRc);
  1423. if (itemRc.top > rc.bottom) break;
  1424. else DrawItem(pDC, iFolder, itemRc, t);
  1425. }
  1426. pDC->RestoreDC(isdc);
  1427. }
  1430. CSize CGfxOutBarCtrl::GetItemSize(const int iFolder, const int index, const int type)
  1431. {
  1432. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1433. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  1435. ASSERT(index >= 0 && index < pbf->GetItemCount());
  1436. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  1438. CSize szImage(0,0);
  1439. CSize szLabel(0,0);
  1440. CSize szAll(0,0);
  1442. if (pi->iImageIndex >= 0)
  1443. {
  1444. if (type != ircLabel)
  1445. {
  1446. CImageList * il = GetFolderImageList(iFolder, IsSmallIconView());
  1447. ASSERT(il);
  1448. if (il)
  1449. {
  1450. IMAGEINFO ii;
  1451. il->GetImageInfo(pi->iImageIndex, &ii);
  1452. szImage = CRect(ii.rcImage).Size();
  1453. }
  1454. }
  1455. }
  1456. if (pi->cItem)
  1457. {
  1458. if (type != ircIcon)
  1459. {
  1460. CClientDC dc(this);
  1461. CFont * oft = (CFont *) dc.SelectObject(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  1462. if (IsSmallIconView())
  1463. {
  1464. szLabel = dc.GetTextExtent(pi->cItem, lstrlen(pi->cItem));
  1465. }
  1466. else
  1467. {
  1468. CRect rc;
  1469. GetInsideRect(rc);
  1470. rc.bottom = rc.top;
  1471. dc.DrawText(pi->cItem, lstrlen(pi->cItem), rc, DT_CALCRECT|DT_CENTER|DT_WORDBREAK);
  1472. szLabel = rc.Size();
  1473. }
  1474. dc.SelectObject(oft);
  1475. }
  1476. }
  1477. if (IsSmallIconView())
  1478. {
  1479. if (type == ircIcon) szAll = szImage;
  1480. else if (type == ircLabel) szAll = szLabel;
  1481. else if (type == ircAll) szAll = CSize(szImage.cx + szLabel.cx + xSmallIconLabelOffset, szImage.cy > szLabel.cy ? szImage.cy : szLabel.cy);
  1482. }
  1483. else
  1484. {
  1485. if (type == ircIcon) szAll = szImage;
  1486. else if (type == ircLabel) szAll = szLabel;
  1487. else if (type == ircAll) 
  1488. {
  1489. szAll = CSize(szImage.cx > szLabel.cx ? szImage.cx : szLabel.cx, szLabel.cy + szImage.cy + yLargeIconLabelOffset + yLargeIconSpacing);
  1490. }
  1491. }
  1492. return szAll;
  1493. }
  1495. CImageList * CGfxOutBarCtrl::GetFolderImageList(const int index, const bool bSmall) const
  1496. {
  1497. ASSERT(index >= 0 && index < GetFolderCount());
  1498. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(index);
  1499. if (bSmall)
  1500. {
  1501. if (pbf->pSmallImageList) return pbf->pSmallImageList; else return pSmallImageList;
  1502. }
  1503. if (pbf->pLargeImageList) return pbf->pLargeImageList; else return pLargeImageList;
  1504. }
  1506. void CGfxOutBarCtrl::DrawItem(CDC * pDC, const int iFolder, CRect rc, const int index, const bool bOnlyImage)
  1507. {
  1508. CImageList * ima = GetFolderImageList(iFolder, IsSmallIconView());
  1510. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1511. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  1513. ASSERT(index >= 0 && index < pbf->GetItemCount());
  1514. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  1516. ASSERT(pi && ima);
  1518. CFont * oft = (CFont *) pDC->SelectObject(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  1519. COLORREF ocr = pDC->SetTextColor(crTextColor);
  1520. int obk = pDC->SetBkMode(TRANSPARENT);
  1522. if (IsSmallIconView())
  1523. {
  1524. if (ima)
  1525. {
  1526. IMAGEINFO ii;
  1527. ima->GetImageInfo(pi->iImageIndex, &ii);
  1528. CSize szImage = CRect(ii.rcImage).Size();
  1529. CPoint pt;
  1530. pt.x = rc.left + 2;
  1531. pt.y = rc.top + (rc.Height() - szImage.cy) / 2;
  1532. ima->Draw(pDC, pi->iImageIndex, pt, ILD_NORMAL);
  1534. if (!bOnlyImage)
  1535. {
  1536. rc.left += szImage.cx + xSmallIconLabelOffset;
  1537. pDC->TextOut(rc.left, rc.top, CString(pi->cItem));
  1538. }
  1540. }
  1541. }
  1542. else
  1543. {
  1544. if (ima)
  1545. {
  1546. IMAGEINFO ii;
  1547. ima->GetImageInfo(pi->iImageIndex, &ii);
  1548. CSize szImage = CRect(ii.rcImage).Size();
  1549. CPoint pt;
  1550. pt.x = rc.left + (rc.Width() - szImage.cx) / 2;
  1551. pt.y = rc.top;// + (rc.Height() - szImage.cy) / 2;
  1552. ima->Draw(pDC, pi->iImageIndex, pt, ILD_NORMAL);
  1553. if (!bOnlyImage)
  1554. {
  1555. rc.top += szImage.cy + yLargeIconLabelOffset;
  1556. pDC->DrawText(pi->cItem, lstrlen(pi->cItem), rc, DT_CENTER|DT_WORDBREAK);
  1557. }
  1558. }
  1559. }
  1561. if (dwFlags&fSelHighlight && iLastSel == index && iLastSel >= 0)
  1562. {
  1563. CRect rc;
  1564. GetIconRect(iSelFolder, iLastSel, rc);
  1565. rc.InflateRect(1,1);
  1566. pDC->Draw3dRect(rc, crDkShadowBorder, cr3dFace);
  1567. }
  1569. pDC->SetTextColor(ocr);
  1570. pDC->SelectObject(oft);
  1571. pDC->SetBkMode(obk);
  1573. }
  1576. BOOL CGfxOutBarCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  1577. {
  1578. CPoint pt(GetMessagePos());
  1579. ScreenToClient(&pt);
  1580. int index, ht = HitTestEx(pt, index);
  1581. if (ht == htFolder)
  1582. {
  1583. SetCursor(hHandCursor);
  1584. return true;
  1585. }
  1587. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  1588. }
  1590. void CGfxOutBarCtrl::GetVisibleRange(const int iFolder, int & first, int & last)
  1591. {
  1592. first = iFirstItem;
  1593. CRect rc;
  1594. GetInsideRect(rc);
  1596. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  1597. int max = pbf->GetItemCount(), t;
  1598. for (t = iFirstItem; t < max; t++)
  1599. {
  1600. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(t);
  1601. CRect itemRc;
  1602. GetItemRect(iFolder, t, itemRc);
  1603. if (itemRc.bottom > rc.bottom) 
  1604. {
  1605. last = t - 1;
  1606. break;
  1607. }
  1608. else last = t;
  1609. }
  1610. }
  1612. void CGfxOutBarCtrl::OnSize(UINT nType, int cx, int cy) 
  1613. {
  1614. bUpArrow = bDownArrow = false;
  1616. CWnd::OnSize(nType, cx, cy);
  1618. int t, max = GetFolderCount();
  1619. CRect rc;
  1620. GetInsideRect(rc);
  1622. for (t = 0; t < max; t++)
  1623. {
  1624. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(t);
  1625. CWnd * pc = GetFolderChild(t);
  1626. if (pc) pc->SetWindowPos(0, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER);
  1627. }
  1628. }
  1630. void CGfxOutBarCtrl::HighlightItem(const int index, const bool bPressed)
  1631. {
  1632. CWnd * pf = GetFocus();
  1633. if (pf != NULL && pf != this && IsChild(pf)) return;
  1635. static bool bOldPressed = false;
  1636. if (iLastItemHighlighted == index && bOldPressed == bPressed) return;
  1638. bOldPressed = bPressed;
  1640. CClientDC dc(this);
  1642. CRect irc;
  1643. GetInsideRect(irc);
  1644. int isdc = dc.SaveDC();
  1645. CRgn itemRegion;
  1646. itemRegion.CreateRectRgnIndirect(&irc);
  1647. dc.SelectClipRgn(&itemRegion);
  1648. itemRegion.DeleteObject();
  1651. if (iLastItemHighlighted >= 0 && IsValidItem(iLastItemHighlighted))
  1652. {
  1653. CRect rc;
  1654. GetIconRect(iSelFolder, iLastItemHighlighted, rc);
  1655. rc.InflateRect(1,1);
  1656. dc.Draw3dRect(rc, crBackGroundColor, crBackGroundColor);
  1657. }
  1658. if (iSelAnimTiming > 0 && index == iLastSel)
  1659. {
  1660. iLastItemHighlighted = -1;
  1661. return;
  1662. }
  1663. if (dwFlags&fSelHighlight && iLastSel == index)
  1664. {
  1665. iLastItemHighlighted = -1;
  1666. return;
  1667. }
  1669. iLastItemHighlighted = index;
  1670. if (iLastItemHighlighted >= 0 && IsValidItem(iLastItemHighlighted))
  1671. {
  1672. CRect rc;
  1673. GetIconRect(iSelFolder, iLastItemHighlighted, rc);
  1674. rc.InflateRect(1,1);
  1675. if (bPressed)
  1676. dc.Draw3dRect(rc, crDkShadowBorder, cr3dFace);
  1677. else
  1678. dc.Draw3dRect(rc, cr3dFace, crDkShadowBorder);
  1679. }
  1680. dc.RestoreDC(isdc);
  1681. }
  1683. void CGfxOutBarCtrl::GetIconRect(const int iFolder, const int iIndex, CRect & rect)
  1684. {
  1685. CRect rc;
  1686. GetInsideRect(rc);
  1687. int top = rc.top;
  1688. CSize sz(0,0);
  1689. int y = 0;
  1690. int spacing = IsSmallIconView() ? ySmallIconSpacing : yLargeIconSpacing;
  1692. for (int t = 0; t < iIndex; t++)
  1693. {
  1694. sz = GetItemSize(iFolder, t, ircAll);
  1695. top += sz.cy;
  1696. top += spacing;
  1697. if (t == iFirstItem - 1) y = top - rc.top;
  1698. }
  1699. top += spacing;
  1701. sz = GetItemSize(iFolder, iIndex, ircIcon);
  1702. if (IsSmallIconView())
  1703. {
  1704. rect.SetRect(rc.left, top, rc.left + sz.cx, top + sz.cy);
  1705. rect.left += xLeftMargin + 2;
  1706. rect.right += xLeftMargin + 2;
  1707. rect.top -= yTopMargin;
  1708. rect.bottom -= yTopMargin;
  1710. rect.top -= y;
  1711. rect.bottom -= y;
  1712. }
  1713. else
  1714. {
  1715. rect.SetRect(rc.left + (rc.Width() - sz.cx)/2, top, rc.left + (rc.Width() - sz.cx)/2 + sz.cx, top + sz.cy);
  1716. rect.top -= y + 3;
  1717. rect.bottom -= y + 2;
  1718. }
  1719. }
  1721. void CGfxOutBarCtrl::GetLabelRect(const int iFolder, const int iIndex, CRect & rect)
  1722. {
  1723. CRect rc;
  1724. GetInsideRect(rc);
  1725. int top = rc.top;
  1726. CSize sz(0,0);
  1727. int y = 0;
  1728. int spacing = IsSmallIconView() ? ySmallIconSpacing : yLargeIconSpacing;
  1730. for (int t = 0; t < iIndex; t++)
  1731. {
  1732. sz = GetItemSize(iFolder, t, ircAll);
  1733. top += sz.cy;
  1734. top += spacing;
  1735. if (t == iFirstItem - 1) y = top - rc.top;
  1736. }
  1737. top += spacing;
  1739. sz = GetItemSize(iFolder, iIndex, ircAll);
  1741. CSize szLabel = GetItemSize(iFolder, iIndex, ircLabel);
  1743. if (IsSmallIconView())
  1744. {
  1745. rect.SetRect(rc.left, top, rc.left + sz.cx, top + sz.cy);
  1746. rect.left += xLeftMargin + 2;
  1747. rect.right += xLeftMargin + 2;
  1748. rect.top  += yTopMargin - 5;
  1749. rect.bottom += yTopMargin - 5;
  1750. }
  1751. else
  1752. {
  1753. rect.SetRect(rc.left + (rc.Width() - sz.cx)/2, top, rc.left + (rc.Width() - sz.cx)/2 + sz.cx, top + sz.cy);
  1754. rect.top -= y + 3;
  1755. rect.bottom -= y + 2;
  1757. rect.bottom -=  yLargeIconSpacing;
  1758. rect.top    = rect.bottom - szLabel.cy;
  1759. }
  1760. }
  1763. void CGfxOutBarCtrl::StartGroupEdit(const int index)
  1764. {
  1765. CGfxGroupEdit * pEdit = new CGfxGroupEdit;
  1766. pEdit->iIndex = index;
  1767. CRect rc;
  1768. GetFolderRect(index, rc);
  1769. rc.InflateRect(-2,-2);
  1770. pEdit->Create(WS_CHILD|WS_VISIBLE|ES_CENTER|ES_MULTILINE,rc,this,1);
  1771. pEdit->msgSend = NM_OB_ONGROUPENDEDIT;
  1772. pEdit->ModifyStyleEx(0, WS_EX_CLIENTEDGE, SWP_FRAMECHANGED);
  1773. ASSERT(index >= 0 && index < GetFolderCount());
  1774. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(index);
  1775. pEdit->SetWindowText(pbf->cName);
  1776. pEdit->SetFocus();
  1777. }
  1779. void CGfxOutBarCtrl::StartItemEdit(const int index)
  1780. {
  1781. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1782. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1783. ASSERT(index >= 0 && index < pbf->GetItemCount());
  1784. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  1786. CGfxGroupEdit * pEdit = new CGfxGroupEdit;
  1787. pEdit->iIndex = index;
  1788. CRect rc, crc;
  1789. GetLabelRect(iSelFolder, index, rc);
  1790. GetInsideRect(crc);
  1792. DWORD dwFlag = WS_CHILD|WS_VISIBLE|WS_BORDER;
  1794. if (!IsSmallIconView())
  1795. {
  1796. rc.left = crc.left + 5;
  1797. rc.right = crc.right - 5;
  1798. rc.bottom += 5;
  1799. dwFlag |= ES_CENTER|ES_MULTILINE;
  1800. }
  1801. else 
  1802. {
  1803. CRect irc;
  1804. GetIconRect(iSelFolder, index, irc);
  1805. dwFlag |= ES_AUTOHSCROLL;
  1806. rc.OffsetRect(irc.Width()+1, -6);
  1807. pEdit->bNoDown = true;
  1808. }
  1810. pEdit->Create(dwFlag, rc, this, 1);
  1811. pEdit->msgSend = NM_OB_ONLABELENDEDIT;
  1813. pEdit->SetWindowText(pi->cItem);
  1814. pEdit->SetFocus();
  1816. }
  1818. void CGfxOutBarCtrl::OnRButtonDown(UINT nFlags, CPoint point) 
  1819. {
  1820. iHitInternal1 = HitTestEx(point, iHitInternal2);
  1822. CGfxPopupMenu cMenu;
  1823. cMenu.CreatePopupMenu();
  1825. cMenu.AppendMenu(MF_STRING, ID_GFX_SMALLICON, _ID_GFX_SMALLICON);
  1826. cMenu.AppendMenu(MF_STRING, ID_GFX_LARGEICON, _ID_GFX_LARGEICON);
  1827. cMenu.AppendMenu(MF_STRING, ID_GFX_GROUPICON, _ID_GFX_ADDAGROUP);
  1828. cMenu.AppendMenu(MF_STRING, ID_GFX_FONTCICON, _ID_GFX_FONTCOLOR);
  1829. cMenu.AppendMenu(MF_STRING, ID_GFX_BACKCICON, _ID_GFX_BACKCOLOR);
  1831. if (iHitInternal1 == htItem)
  1832. {
  1833. if (dwFlags&fRemoveItems || dwFlags&fEditItems)
  1834. {
  1835. cMenu.AppendMenu(MF_SEPARATOR);
  1836. if (dwFlags&fRemoveItems)
  1837. cMenu.AppendMenu(MF_STRING, ID_GFX_REMOVEITEM, _ID_GFX_REMOVEITEM);
  1839. if (dwFlags&fEditItems)
  1840. cMenu.AppendMenu(MF_STRING, ID_GFX_RENAMEITEM, _ID_GFX_RENAMEITEM);
  1841. }
  1842. }
  1843. else if (iHitInternal1 == htFolder)
  1844. {
  1845. if (dwFlags&fRemoveGroups || dwFlags&fEditGroups)
  1846. {
  1847. cMenu.AppendMenu(MF_SEPARATOR);
  1849. if (dwFlags&fRemoveGroups)
  1850. cMenu.AppendMenu(MF_STRING, ID_GFX_REMOVEITEM, _ID_GFX_REMOVEITEM);
  1852. if (dwFlags&fEditGroups)
  1853. cMenu.AppendMenu(MF_STRING, ID_GFX_RENAMEITEM, _ID_GFX_RENAMEITEM);
  1854. }
  1855. }
  1857. cMenu.LoadToolBarResource(IDR_MAINFRAME);
  1858. cMenu.RemapMenu(&cMenu);
  1859. cMenu.EnableMenuItems(&cMenu, this);
  1861. CPoint pt(point);
  1862. ClientToScreen(&pt);
  1863. cMenu.TrackPopupMenu(TPM_LEFTALIGN|TPM_RIGHTBUTTON, pt.x, pt.y, this);
  1865. cMenu.DestroyMenu();
  1867. CWnd::OnRButtonDown(nFlags, point);
  1868. }
  1870. void CGfxOutBarCtrl::OnGfxLargeicon() 
  1871. {
  1872. SetSmallIconView(false);
  1873. Invalidate();
  1874. }
  1876. void CGfxOutBarCtrl::OnUpdateGfxLargeicon(CCmdUI* pCmdUI) 
  1877. {
  1878. pCmdUI->Enable(IsSmallIconView());
  1879. }
  1881. void CGfxOutBarCtrl::OnGfxSmallicon() 
  1882. {
  1883. SetSmallIconView(true);
  1884. Invalidate();
  1885. }
  1887. void CGfxOutBarCtrl::OnUpdateGfxSmallicon(CCmdUI* pCmdUI) 
  1888. {
  1889. pCmdUI->Enable(!IsSmallIconView());
  1890. }
  1892. void CGfxOutBarCtrl::OnGfxRemoveitem() 
  1893. {
  1894. if (iHitInternal1 == htFolder)
  1895. {
  1896. RemoveFolder(iHitInternal2);
  1897. }
  1898. else if (iHitInternal1 == htItem)
  1899. {
  1900. RemoveItem(iHitInternal2);
  1901. }
  1902. }
  1904. void CGfxOutBarCtrl::OnUpdateGfxRemoveitem(CCmdUI* pCmdUI) 
  1905. {
  1907. }
  1909. void CGfxOutBarCtrl::OnGfxRenameitem() 
  1910. {
  1911. if (iHitInternal1 == htFolder)
  1912. {
  1913. StartGroupEdit(iHitInternal2);
  1914. }
  1915. else if (iHitInternal1 == htItem)
  1916. {
  1917. StartItemEdit(iHitInternal2);
  1918. }
  1919. }
  1921. void CGfxOutBarCtrl::OnUpdateGfxRenameitem(CCmdUI* pCmdUI) 
  1922. {
  1923. }
  1925. void CGfxOutBarCtrl::RemoveItem(const int index)
  1926. {
  1927. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1928. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1929. ASSERT(index >= 0 && index < pbf->GetItemCount());
  1930. if (IsValidItem(index))
  1931. {
  1932. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1933. delete i;
  1935. pbf->arItems.RemoveAt(index);
  1936. CRect rc;
  1937. GetInsideRect(rc);
  1938. InvalidateRect(rc);
  1939. }
  1940. }
  1942. bool CGfxOutBarCtrl::IsValidItem(const int index) const
  1943. {
  1944. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1945. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1946. return (index >= 0 && index < pbf->GetItemCount());
  1947. }
  1949. DWORD CGfxOutBarCtrl::GetItemData(const int index) const
  1950. {
  1951. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1952. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1953. if (IsValidItem(index))
  1954. {
  1955. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1956. return i->dwData;
  1957. }
  1958. return 0;
  1959. }
  1961. int CGfxOutBarCtrl::GetItemImage(const int index) const
  1962. {
  1963. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1964. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1965. if (IsValidItem(index))
  1966. {
  1967. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1968. return i->iImageIndex;
  1969. }
  1970. return 0;
  1971. }
  1973. void CGfxOutBarCtrl::SetItemData(const int index, const DWORD dwData)
  1974. {
  1975. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1976. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1977. if (IsValidItem(index))
  1978. {
  1979. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1980. i->dwData = dwData;
  1981. }
  1982. }
  1984. void CGfxOutBarCtrl::SetItemImage(const int index, const int iImage)
  1985. {
  1986. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1987. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1988. if (IsValidItem(index))
  1989. {
  1990. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1991. i->iImageIndex = iImage;
  1992. }
  1993. }
  1995. void CGfxOutBarCtrl::DrawDragArrow(CDC * pDC, const int iFrom, const int iTo)
  1996. {
  1997. if (iTo == iLastDragItemDraw) return;
  1998. CRect rc1;
  1999. if (iLastDragItemDraw >= 0)
  2000. {
  2001. GetDragItemRect(iLastDragItemDraw, rc1);
  2002. if (iLastDragItemDrawType == 0) rc1.bottom = rc1.top + 5;
  2003. else if (iLastDragItemDrawType == 1) { rc1.top -= 4; rc1.bottom = rc1.top + 9; }
  2004. else if (iLastDragItemDrawType == 2) { rc1.top -= 4; rc1.bottom = rc1.top + 5; }
  2005. InvalidateRect(rc1, true);
  2006. UpdateWindow();
  2007. }
  2008. iLastDragItemDraw = iTo;
  2010. if (iLastDragItemDraw >= 0)
  2011. {
  2012. iLastDragItemDrawType = GetDragItemRect(iLastDragItemDraw, rc1);
  2014. CPen * op = pDC->SelectObject(pBlackPen);
  2016. pDC->MoveTo(rc1.left, rc1.top);
  2017. pDC->LineTo(rc1.right, rc1.top);
  2019. if (iLastDragItemDrawType != 2)
  2020. {
  2021. pDC->MoveTo(rc1.left, rc1.top+1);
  2022. pDC->LineTo(rc1.left + 7, rc1.top+1);
  2023. pDC->MoveTo(rc1.left, rc1.top+2);
  2024. pDC->LineTo(rc1.left + 5, rc1.top+2);
  2025. pDC->MoveTo(rc1.left, rc1.top+3);
  2026. pDC->LineTo(rc1.left + 3, rc1.top+3);
  2027. pDC->MoveTo(rc1.left, rc1.top+4);
  2028. pDC->LineTo(rc1.left + 1, rc1.top+4);
  2030. pDC->MoveTo(rc1.right-1, rc1.top+1);
  2031. pDC->LineTo(rc1.right - 7, rc1.top+1);
  2032. pDC->MoveTo(rc1.right-1, rc1.top+2);
  2033. pDC->LineTo(rc1.right - 5, rc1.top+2);
  2034. pDC->MoveTo(rc1.right-1, rc1.top+3);
  2035. pDC->LineTo(rc1.right - 3, rc1.top+3);
  2036. }
  2037. if (iLastDragItemDrawType != 0)
  2038. {
  2039. pDC->MoveTo(rc1.left, rc1.top-1);
  2040. pDC->LineTo(rc1.left + 7, rc1.top-1);
  2041. pDC->MoveTo(rc1.left, rc1.top-2);
  2042. pDC->LineTo(rc1.left + 5, rc1.top-2);
  2043. pDC->MoveTo(rc1.left, rc1.top-3);
  2044. pDC->LineTo(rc1.left + 3, rc1.top-3);
  2045. pDC->MoveTo(rc1.left, rc1.top-4);
  2046. pDC->LineTo(rc1.left + 1, rc1.top-4);
  2048. pDC->MoveTo(rc1.right-1, rc1.top-1);
  2049. pDC->LineTo(rc1.right - 7, rc1.top-1);
  2050. pDC->MoveTo(rc1.right-1, rc1.top-2);
  2051. pDC->LineTo(rc1.right - 5, rc1.top-2);
  2052. pDC->MoveTo(rc1.right-1, rc1.top-3);
  2053. pDC->LineTo(rc1.right - 3, rc1.top-3);
  2054. pDC->MoveTo(rc1.right-1, rc1.top-4);
  2055. pDC->LineTo(rc1.right - 1, rc1.top-4);
  2056. }
  2058. pDC->SelectObject(op);
  2059. }
  2060. }
  2062. int CGfxOutBarCtrl::GetDragItemRect(const int index, CRect & rect)
  2063. {
  2064. CRect rc, crc;
  2065. GetInsideRect(crc);
  2066. crc.InflateRect(-2, 0);
  2068. GetItemRect(iSelFolder, index < GetItemCount() ? index : index - 1, rc);
  2069. int line = 0;
  2070. if (index < GetItemCount())
  2071. {
  2072. line = rc.top - 4;
  2073. }
  2074. else
  2075. {
  2076. line = rc.bottom + 6;
  2077. }
  2078. int tpe;
  2079. if (index == 0)
  2080. {
  2081. rect.SetRect(crc.left, line+2, crc.right, line + 7);
  2082. tpe = 0;
  2083. }
  2084. else if (index < GetItemCount())
  2085. {
  2086. rect.SetRect(crc.left, line - 9, crc.right, line);
  2087. tpe = 1;
  2088. if (IsSmallIconView()) 
  2089. {
  2090. rect.top += 8;
  2091. rect.bottom += 8;
  2092. }
  2093. }
  2094. else
  2095. {
  2096. rect.SetRect(crc.left, line, crc.right, line + 5);
  2097. tpe = 2;
  2098. }
  2099. return tpe;
  2100. }
  2103. void CGfxOutBarCtrl::AnimateFolderScroll(const int iFrom, const int iTo)
  2104. {
  2105. ASSERT(iFrom >= 0 && iFrom < GetFolderCount());
  2106. ASSERT(iTo >= 0 && iTo < GetFolderCount());
  2108. CRect rc, rc1, frc, frc1;
  2109. GetInsideRect(rc);
  2110. rc1.SetRect(0,0,rc.Width(),rc.Height());
  2111. GetFolderRect(iTo, frc);
  2112. frc1 = frc;
  2114. CClientDC dc(this);
  2115. CDC memDC;
  2116. memDC.CreateCompatibleDC(&dc);
  2117. CBitmap bmpFrom, bmpTo;
  2118. bmpFrom.CreateCompatibleBitmap(&dc, rc1.Width(), rc1.Height() + frc.Height() * 2);
  2119. bmpTo.CreateCompatibleBitmap(&dc, rc1.Width(), rc1.Height() + frc.Height() * 2);
  2120. CDC * pDC = &memDC;
  2122. CWnd * pWnd1 = GetFolderChild(iFrom);
  2123. CWnd * pWnd2 = GetFolderChild(iTo);
  2126. CBitmap * obmp = pDC->SelectObject(&bmpFrom);
  2127. if (iTo > iFrom)
  2128. {
  2129. rc1.bottom += frc.Height() * 2;
  2130. pDC->FillSolidRect(rc1, crBackGroundColor);
  2131. if (pWnd1) 
  2132. {
  2133. BOOL bPrev = pWnd1->ShowWindow(SW_SHOW);
  2134. pWnd1->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2135. pWnd1->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2136. if (!bPrev) pWnd1->ShowWindow(SW_HIDE);
  2137. }
  2138. else PaintItems(pDC, iFrom, rc1);
  2140. pDC->SelectObject(&bmpTo);
  2141. frc.SetRect(0,0,frc.Width(),frc.Height());
  2142. rc1.SetRect(0,frc.Height(),rc.Width(), rc.Height()+frc.Height() * 2);
  2143. pDC->FillSolidRect(rc1, crBackGroundColor);
  2145. if (pWnd2) 
  2146. {
  2147. CPoint ovpt = pDC->SetViewportOrg(0, frc.Height());
  2148. BOOL bPrev = pWnd2->ShowWindow(SW_SHOW);
  2149. pWnd2->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2150. pWnd2->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2151. if (!bPrev) pWnd2->ShowWindow(SW_HIDE);
  2152. pDC->SetViewportOrg(ovpt);
  2153. }
  2154. else PaintItems(pDC, iTo, rc1);
  2155. DrawFolder(pDC, iTo, frc, false);
  2156. }
  2157. else
  2158. {
  2159. frc.SetRect(0,0,frc.Width(),frc.Height());
  2160. rc1.top += frc.Height();
  2161. rc1.bottom += frc.Height() * 2;
  2162. pDC->FillSolidRect(rc1, crBackGroundColor);
  2163. if (pWnd1) 
  2164. {
  2165. CPoint ovpt = pDC->SetViewportOrg(0, frc.Height());
  2166. BOOL bPrev = pWnd1->ShowWindow(SW_SHOW);
  2167. pWnd1->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2168. pWnd1->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2169. if (!bPrev) pWnd1->ShowWindow(SW_HIDE);
  2170. pDC->SetViewportOrg(ovpt);
  2171. }
  2172. else PaintItems(pDC, iFrom, rc1);
  2174. DrawFolder(pDC, iFrom, frc, false);
  2176. pDC->SelectObject(&bmpTo);
  2177. rc1.SetRect(0,0,rc.Width(), rc.Height() + frc.Height() * 2);
  2178. pDC->FillSolidRect(rc1, crBackGroundColor);
  2180. if (pWnd2) 
  2181. {
  2182. BOOL bPrev = pWnd2->ShowWindow(SW_SHOW);
  2183. pWnd2->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2184. pWnd2->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2185. if (!bPrev) pWnd2->ShowWindow(SW_HIDE);
  2186. }
  2187. else PaintItems(pDC, iTo, rc1);
  2188. }
  2190. if (iTo > iFrom)
  2191. {
  2192. CRect rcFrom, rcTo;
  2193. GetFolderRect(iFrom, rcFrom);
  2194. GetFolderRect(iTo, rcTo);
  2195. int fh = rcFrom.Height();
  2196. for (int y = rcTo.top - fh; y > rcFrom.bottom; y -= fh)
  2197. {
  2198. pDC->SelectObject(&bmpFrom);
  2199. dc.BitBlt(rc.left, rcFrom.bottom + 1, rc.Width(), y - rcFrom.bottom - 1, pDC, 0,fh, SRCCOPY);
  2200. pDC->SelectObject(&bmpTo);
  2201. dc.BitBlt(rc.left, y, rc.Width(), rc.bottom - y + fh, pDC, 0,0, SRCCOPY);
  2202. Sleep(lAnimationTickCount);
  2203. }
  2204. }
  2205. else
  2206. {
  2207. CRect rcFrom, rcTo;
  2208. GetFolderRect(iFrom, rcFrom);
  2209. int fh = rcFrom.Height();
  2210. rcTo.SetRect(rc.left, rc.bottom, rc.right, rc.bottom - fh);
  2211. for (int y = rcFrom.top + 1; y < rcTo.top - fh; y += fh)
  2212. {
  2213. pDC->SelectObject(&bmpTo);
  2214. dc.BitBlt(rc.left, rcFrom.top, rc.Width(), y - rcFrom.top - 1, pDC, 0, fh*2, SRCCOPY);
  2215. pDC->SelectObject(&bmpFrom);
  2216. dc.BitBlt(rc.left, y, rc.Width(), rc.bottom - y, pDC, 0,0, SRCCOPY);
  2217. Sleep(lAnimationTickCount);
  2218. }
  2219. }
  2221. pDC->SelectObject(obmp);
  2222. }
  2227. CString CGfxOutBarCtrl::GetItemText(const int index)
  2228. {
  2229. CString item;
  2231. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  2232. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  2233. if (IsValidItem(index))
  2234. {
  2235. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  2236. if (pi->cItem) item = pi->cItem;
  2237. }
  2238. return item;
  2239. }
  2241. int CGfxOutBarCtrl::AddFolderBar(const char * pFolder, CWnd * pSon, const DWORD exData)
  2242. {
  2243. CBarFolder * pbf = new CBarFolder(pFolder, exData);
  2244. ASSERT(pbf);
  2245. pbf->pChild = pSon;
  2247. arFolder.Add((void *)pbf);
  2249. return arFolder.GetSize() - 1;
  2250. }
  2252. CWnd * CGfxOutBarCtrl::GetFolderChild(int iFolder)
  2253. {
  2254. if (GetFolderCount())
  2255. {
  2256. if (iFolder < 0) iFolder = iSelFolder;
  2258. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  2259. return pbf->pChild;
  2260. }
  2261. return NULL;
  2262. }
  2264. DWORD CGfxOutBarCtrl::GetFolderData(int iFolder)
  2265. {
  2266. if (iFolder < 0) iFolder = iSelFolder;
  2267. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  2268. return pbf->dwData;
  2269. }
  2271. void CGfxOutBarCtrl::SetAnimSelHighlight(const int iTime)
  2272. {
  2273. if (iTime <= 0) KillTimer(3);
  2274. else SetTimer(3, iTime, NULL);
  2275. iSelAnimTiming = iTime;
  2276. }