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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > ICQ/即时通讯 > 查看源码
GfxOutBarCtrl.cpp
资源名称：QQ2004_Source_0.01.rar　[点击查看]
上传用户：hysujiao87
上传日期：2007-12-02
资源大小：156k
文件大小：54k
源码类别：

ICQ/即时通讯

开发平台：

C/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
  281. {
  282. if (nIDEvent == 3 && iLastSel >= 0)
  283. {
  284. iSelAnimCount ++;
  285. if (iSelAnimCount > 10) iSelAnimCount = -1;
  286. if (iSelAnimCount == 0)
  287. DrawAnimItem(-1, 1, iLastSel);
  288. if (iSelAnimCount == 1)
  289. DrawAnimItem(0, 0, iLastSel);
  290. if (iSelAnimCount == 2)
  291. DrawAnimItem(1, 1, iLastSel);
  292. if (iSelAnimCount == 3)
  293. DrawAnimItem(0, 0, iLastSel);
  294. }
  295. }
  296. CWnd::OnTimer(nIDEvent);
  297. }
  299. void CGfxOutBarCtrl::DrawAnimItem(const int xoffset, const int yoffset, const int index)
  300. {
  301. CImageList * ima = GetFolderImageList(iSelFolder, IsSmallIconView());
  303. CRect rc, irc;
  304. GetInsideRect(irc);
  305. GetItemRect(iSelFolder, iLastSel, rc);
  307. if (iLastSel >= iFirstItem && irc.bottom > rc.bottom && irc.top < rc.top)
  308. {
  309. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  310. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  312. ASSERT(index >= 0 && index < pbf->GetItemCount());
  313. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  315. ASSERT(pi && ima);
  317. CClientDC dc(this);
  319. if (IsSmallIconView())
  320. {
  321. if (ima)
  322. {
  323. IMAGEINFO ii;
  324. ima->GetImageInfo(pi->iImageIndex, &ii);
  325. CSize szImage = CRect(ii.rcImage).Size();
  326. CPoint pt;
  327. pt.x = rc.left + 2;
  328. pt.y = rc.top + (rc.Height() - szImage.cy) / 2;
  330. CRect rcBck(pt.x-1, pt.y-1, pt.x + szImage.cx+2, pt.y + szImage.cy+2);
  331. dc.FillSolidRect(rcBck, crBackGroundColor);
  333. pt.x += xoffset;
  334. pt.y += yoffset;
  336. ima->Draw(&dc, pi->iImageIndex, pt, ILD_NORMAL);
  338. }
  339. }
  340. else
  341. {
  342. if (ima)
  343. {
  344. IMAGEINFO ii;
  345. ima->GetImageInfo(pi->iImageIndex, &ii);
  346. CSize szImage = CRect(ii.rcImage).Size();
  347. CPoint pt;
  348. pt.x = rc.left + (rc.Width() - szImage.cx) / 2;
  349. pt.y = rc.top;
  351. CRect rcBck(pt.x-1, pt.y-1, pt.x + szImage.cx+2, pt.y + szImage.cy+2);
  352. dc.FillSolidRect(rcBck, crBackGroundColor);
  354. pt.x += xoffset;
  355. pt.y += yoffset;
  357. ima->Draw(&dc, pi->iImageIndex, pt, ILD_NORMAL);
  358. }
  359. }
  360. }
  361. }
  363. void CGfxOutBarCtrl::OnPaint() 
  364. {
  365. CRect clientRc;
  366. GetClientRect(&clientRc);
  367. CPaintDC dc(this);
  368. CDC memDC;
  369. memDC.CreateCompatibleDC(&dc);
  370. CBitmap bmp;
  371. bmp.CreateCompatibleBitmap(&dc, clientRc.Width(), clientRc.Height());
  372. CBitmap * obmp = memDC.SelectObject(&bmp);
  374. CDC * pDC = &memDC;
  376. CRect rc;
  377. GetInsideRect(rc);
  378. if (!GetFolderChild()) pDC->FillSolidRect(rc, crBackGroundColor);
  381. int max = arFolder.GetSize();
  382. CRect frc;
  383. for (int t = 0; t < max; t++)
  384. {
  385. GetFolderRect(t, frc);
  386. DrawFolder(pDC, t, frc, false);
  387. }
  388. if (!GetFolderChild())
  389. {
  390. int f,l;
  391. GetVisibleRange(iSelFolder, f,l);
  392. rcUpArrow.SetRect(0,0,GetSystemMetrics(SM_CXVSCROLL), GetSystemMetrics(SM_CXVSCROLL));
  393. rcDownArrow = rcUpArrow;
  394. rcUpArrow.OffsetRect(rc.right - 5 - GetSystemMetrics(SM_CXVSCROLL), rc.top +5);
  395. rcDownArrow.OffsetRect(rc.right - 5 - GetSystemMetrics(SM_CXVSCROLL), rc.bottom - 5 - GetSystemMetrics(SM_CXVSCROLL));
  397. if (f > 0)
  398. {
  399. if (bUpPressed) pDC->DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP|DFCS_PUSHED);
  400. else pDC->DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  401. bUpArrow = true;
  402. pDC->ExcludeClipRect(rcUpArrow);
  403. }
  404. else bUpArrow = false;
  406. if (l < GetItemCount() - 1)
  407. {
  408. if (bDownPressed) pDC->DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN|DFCS_PUSHED);
  409. else pDC->DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  410. bDownArrow = true;
  411. pDC->ExcludeClipRect(rcDownArrow);
  412. }
  413. else bDownArrow = false;
  415. PaintItems(pDC, iSelFolder, rc);
  416. }
  418. dc.BitBlt(clientRc.left, clientRc.top, clientRc.Width(), clientRc.Height(), &memDC, 0,0, SRCCOPY);
  420. memDC.SelectObject(obmp);
  422. if (iLastFolderHighlighted >= 0)
  423. {
  424. int i = iLastFolderHighlighted;
  425. iLastFolderHighlighted = -1;
  426. HighlightFolder(i);
  427. }
  428. if (iLastItemHighlighted >= 0)
  429. {
  430. int i = iLastItemHighlighted;
  431. iLastItemHighlighted = -1;
  432. HighlightItem(i, bPressedHighlight);
  433. }
  435. }
  437. BOOL CGfxOutBarCtrl::OnEraseBkgnd(CDC* pDC) 
  438. {
  439. return true;
  440. }
  442. bool CGfxOutBarCtrl::GetFolderRect(const int iIndex, CRect & rect) const
  443. {
  444. int max = arFolder.GetSize();
  445. ASSERT(iIndex >= 0 && iIndex < max);
  447. if (iIndex >= 0 && iIndex < max)
  448. {
  449. CRect rc;
  450. GetClientRect(rc);
  451. if (iIndex > iSelFolder)
  452. rect.SetRect(rc.left, rc.bottom - ((max - iIndex)) * iFolderHeight, rc.right, 
  453. rc.bottom - (max - iIndex - 1) * iFolderHeight);
  454. else 
  455. rect.SetRect(rc.left, rc.top + iIndex * iFolderHeight - 1, rc.right, 
  456. rc.top + (1 + iIndex) * iFolderHeight - 1);
  457. return true;
  458. }
  459. return false;
  460. }
  462. void CGfxOutBarCtrl::GetItemRect(const int iFolder, const int iIndex, CRect & rect)
  463. {
  464. CRect rc;
  465. GetInsideRect(rc);
  466. int top = rc.top;
  467. CSize sz(0,0);
  468. int y = 0;
  469. for (int t = 0; t < iIndex; t++)
  470. {
  471. sz = GetItemSize(iFolder, t, ircAll);
  472. top += sz.cy;
  474. if (IsSmallIconView()) 
  475. {
  476. top += ySmallIconSpacing; 
  477. }
  478. else 
  479. {
  480. top += yLargeIconSpacing;
  481. }
  482. if (t == iFirstItem - 1) y = top - rc.top;
  483. }
  484. sz = GetItemSize(iFolder, iIndex, ircAll);
  485. rect.SetRect(rc.left, top, rc.left + sz.cx, top + sz.cy);
  487. rect.top -= y;
  488. rect.bottom -= y;
  490. rect.left += xLeftMargin;
  491. rect.top  += yTopMargin;
  492. rect.bottom += yTopMargin;
  494. if (!IsSmallIconView()) 
  495. {
  496. rect.left = rc.left;
  497. rect.right = rc.right;
  498. }
  499. }
  501. void CGfxOutBarCtrl::DrawFolder(CDC * pDC, const int iIdx, CRect rect, const bool bSelected)
  502. {
  503. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iIdx);
  505. if (!bSelected)
  506. {
  507. CPen pn1(PS_SOLID, 1, crBackGroundColor1);
  508. CPen * op = pDC->SelectObject(&pn1);
  509. pDC->MoveTo(rect.left, rect.top);
  510. pDC->LineTo(rect.right, rect.top);
  511. pDC->SelectObject(op);
  513. rect.top ++;
  515. pDC->Draw3dRect(rect, crHilightBorder, crBackGroundColor1);
  516. rect.InflateRect(-1,-1);
  517. pDC->FillSolidRect(rect, cr3dFace);
  518. int obk = pDC->SetBkMode(TRANSPARENT);
  519. CFont * of = pDC->SelectObject(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  520. pDC->DrawText(CString(pbf->cName), rect, DT_CENTER|DT_VCENTER|DT_SINGLELINE);
  521. pDC->SetBkMode(obk);
  522. pDC->SelectObject(of);
  523. }
  524. else
  525. {
  526. CPen pn1(PS_SOLID, 1, crBackGroundColor1);
  527. CPen * op = pDC->SelectObject(&pn1);
  528. pDC->MoveTo(rect.left+1, rect.top);
  529. pDC->LineTo(rect.right, rect.top);
  530. pDC->SelectObject(op);
  532. rect.top ++;
  534. pDC->Draw3dRect(rect, crDkShadowBorder, crHilightBorder);
  535. rect.InflateRect(-1,-1);
  536. pDC->Draw3dRect(rect, crBackGroundColor1, cr3dFace);
  537. rect.InflateRect(-1,-1);
  539. pDC->FillSolidRect(rect, cr3dFace);
  541. int obk = pDC->SetBkMode(TRANSPARENT);
  542. CFont * of = pDC->SelectObject(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  543. pDC->DrawText(CString(pbf->cName), rect, DT_CENTER|DT_VCENTER|DT_SINGLELINE);
  544. pDC->SetBkMode(obk);
  545. pDC->SelectObject(of);
  546. }
  547. }
  549. int CGfxOutBarCtrl::AddFolder(const char * cFolderName, const DWORD exData)
  550. {
  551. CBarFolder * pbf = new CBarFolder(cFolderName, exData);
  552. ASSERT(pbf);
  553. arFolder.Add((void *)pbf);
  555. return arFolder.GetSize() - 1;
  556. }
  558. CGfxOutBarCtrl::CBarFolder::CBarFolder(const char * name, DWORD exData)
  559. {
  560. cName = NULL;
  561. dwData = exData;
  563. if (name)
  564. {
  565. cName = new char[lstrlen(name)+1];
  566. ASSERT(cName);
  567. lstrcpy(cName, name);
  568. }
  569. pLargeImageList = NULL;
  570. pSmallImageList = NULL;
  571. pChild = NULL;
  572. }
  574. CGfxOutBarCtrl::CBarFolder::~CBarFolder()
  575. {
  576. if (cName) delete [] cName;
  577. for (int t = 0; t < arItems.GetSize(); t++)
  578. if (arItems.GetAt(t)) delete (CBarFolder*) arItems.GetAt(t);
  580. arItems.RemoveAll();
  581. }
  583. void CGfxOutBarCtrl::GetInsideRect(CRect & rect) const
  584. {
  585. GetClientRect(rect);
  586. if (arFolder.GetSize() > 0)
  587. {
  588. int max = arFolder.GetSize();
  589. rect.top += iFolderHeight * (iSelFolder + 1) - 1;//+ 2;
  590. rect.bottom -= (max - iSelFolder - 1)*iFolderHeight;
  591. return;
  592. }
  593. }
  595. void CGfxOutBarCtrl::OnMouseMove(UINT nFlags, CPoint point) 
  596. {
  597. int index, ht = HitTestEx(point, index);
  599. if (ht != htFolder && iLastFolderHighlighted >= 0) HighlightFolder(-1);
  600. if (ht != htItem   && iLastItemHighlighted   >= 0) HighlightItem(-1);
  602. if (ht == htFolder)
  603. {
  604. HighlightFolder(index);
  605. SetTimer(1,100,NULL);
  606. }
  607. else if (ht == htItem)
  608. {
  609. HighlightItem(index);
  610. SetTimer(1,100,NULL);
  611. }
  613. CWnd::OnMouseMove(nFlags, point);
  614. }
  616. int CGfxOutBarCtrl::HitTestEx(const CPoint & point, int &index)
  617. {
  618. if (bUpArrow && rcUpArrow.PtInRect(point)) return htUpScroll;
  619. if (bDownArrow && rcDownArrow.PtInRect(point)) return htDownScroll;
  621. int max = arFolder.GetSize(), t;
  623. CRect rc;
  624. for (t = 0; t < max; t++)
  625. {
  626. GetFolderRect(t, rc);
  627. if (rc.PtInRect(point)) 
  628. {
  629. index = t;
  630. return htFolder;
  631. }
  632. }
  633. GetInsideRect(rc);
  634. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  635. max = pbf->GetItemCount();
  636. for (t = iFirstItem; t < max; t++)
  637. {
  638. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(t);
  639. CRect itemRc;
  640. if (!IsSmallIconView()) 
  641. {
  642. GetIconRect(iSelFolder, t, itemRc);
  643. if (itemRc.PtInRect(point))
  644. {
  645. index = t;
  646. return htItem;
  647. }
  648. else if (itemRc.top > rc.bottom) break;
  649. GetLabelRect(iSelFolder, t, itemRc);
  650. itemRc.top -= yLargeIconLabelOffset;
  652. if (itemRc.PtInRect(point))
  653. {
  654. index = t;
  655. return htItem;
  656. }
  657. else if (itemRc.top > rc.bottom) break;
  658. }
  659. else
  660. {
  661. GetItemRect(iSelFolder, t, itemRc);
  662. if (itemRc.PtInRect(point))
  663. {
  664. index = t;
  665. return htItem;
  666. }
  667. else if (itemRc.top > rc.bottom) break;
  668. }
  669. }
  670. return htNothing;
  671. }
  673. void CGfxOutBarCtrl::HighlightFolder(const int index)
  674. {
  675. CWnd * pf = GetFocus();
  676. if (pf != NULL && pf != this && IsChild(pf)) return;
  678. if (iLastFolderHighlighted == index) return;
  680. if (iLastFolderHighlighted >= 0)
  681. {
  682. CRect rc;
  683. if (GetFolderRect(iLastFolderHighlighted, rc))
  684. {
  685. CClientDC dc(this);
  686. CPen pn(PS_SOLID, 1, crBackGroundColor1);//crShadowBorder);
  687. CPen * op = dc.SelectObject(&pn);
  688. dc.MoveTo(rc.left, rc.bottom-1);
  689. dc.LineTo(rc.right-1, rc.bottom-1);
  690. dc.LineTo(rc.right-1, rc.top);
  691. CPen pn1(PS_SOLID, 1, cr3dFace);
  692. dc.SelectObject(&pn1);
  693. dc.MoveTo(rc.left+1, rc.bottom-2);
  694. dc.LineTo(rc.right-2, rc.bottom-2);
  695. dc.LineTo(rc.right-2, rc.top+1);
  696. dc.SelectObject(op);
  697. }
  698. }
  699. iLastFolderHighlighted = index;
  700. if (iLastFolderHighlighted >= 0)
  701. {
  702. CRect rc;
  703. if (GetFolderRect(iLastFolderHighlighted, rc))
  704. {
  705. CClientDC dc(this);
  706. CPen pn(PS_SOLID, 1, crDkShadowBorder);
  707. CPen * op = dc.SelectObject(&pn);
  708. dc.MoveTo(rc.left, rc.bottom-1);
  709. dc.LineTo(rc.right-1, rc.bottom-1);
  710. dc.LineTo(rc.right-1, rc.top);
  711. CPen pn1(PS_SOLID, 1, crBackGroundColor1);
  712. dc.SelectObject(&pn1);
  713. dc.MoveTo(rc.left+1, rc.bottom-2);
  714. dc.LineTo(rc.right-2, rc.bottom-2);
  715. dc.LineTo(rc.right-2, rc.top+1);
  716. dc.SelectObject(op);
  717. }
  718. }
  719. }
  721. void CGfxOutBarCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  722. {
  723. if (GetFocus() != this) SetFocus();
  725. int index, ht = HitTestEx(point, index);
  726. iLastDragItemDrawType = -1;
  728. CRect inRc;
  729. GetInsideRect(inRc);
  731. if (ht == htFolder)
  732. {
  733. bool bHigh = true;
  734. CRect rc;
  735. GetFolderRect(index, rc);
  737. if (::GetCapture() == NULL)
  738. {
  739. SetCapture();
  740. ASSERT(this == GetCapture());
  741. CClientDC dc(this);
  742. DrawFolder(&dc, index, rc, true);
  743. AfxLockTempMaps();
  744. for (;;)
  745. {
  746. MSG msg;
  747. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  749. if (CWnd::GetCapture() != this) break;
  751. switch (msg.message)
  752. {
  753. case WM_MOUSEMOVE:
  754. {
  755. CPoint pt(msg.lParam);
  756. int idx, ht1 = HitTestEx(pt, idx);
  757. if (ht1 == htFolder && idx == index)
  758. {
  759. if (!bHigh)
  760. {
  761. DrawFolder(&dc, index, rc, true);
  762. bHigh = true;
  763. }
  764. }
  765. else
  766. {
  767. if (bHigh)
  768. {
  769. DrawFolder(&dc, index, rc, false);
  770. bHigh = false;
  771. }
  772. }
  773. }
  774. break;
  776. case WM_LBUTTONUP:
  777. {
  778. if (bHigh)
  779. {
  780. DrawFolder(&dc, index, rc, false);
  781. bHigh = false;
  782. }
  783. CPoint pt(msg.lParam);
  784. int idx, ht1 = HitTestEx(pt, idx);
  785. if (ht1 == htFolder && idx != iSelFolder)
  786. SetSelFolder(idx);
  787. }
  789. goto ExitLoop2;
  791. case WM_KEYDOWN:
  792. if (msg.wParam != VK_ESCAPE) 
  793. break;
  795. default:
  796. DispatchMessage(&msg);
  797. break;
  798. }
  799. }
  801. ExitLoop2:
  802. ReleaseCapture();
  803. AfxUnlockTempMaps(FALSE);
  804. }
  805. if (bHigh) InvalidateRect(rc, false);
  806. }
  807. else iLastSelectedFolder = -1;
  809. if (ht == htItem)
  810. {
  811. iLastDragItemDraw = -1;
  812. bool bHigh = true, bDragging = false;
  813. CRect rc;
  814. GetItemRect(iSelFolder, index, rc);
  816. HCURSOR hCur = GetCursor();
  818. if (::GetCapture() == NULL)
  819. {
  820. SetCapture();
  821. ASSERT(this == GetCapture());
  822. CClientDC dc(this);
  823. HighlightItem(index, true);
  825. AfxLockTempMaps();
  826. for (;;)
  827. {
  828. MSG msg;
  829. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  831. if (CWnd::GetCapture() != this) break;
  833. switch (msg.message)
  834. {
  835. case WM_MOUSEMOVE:
  836. {
  837. CPoint pt(msg.lParam);
  838. int idx;
  839. int ht1 = HitTestEx(pt, idx);
  840. if (bDragging)
  841. {
  842. if (ht1 == htItem) 
  843. {
  844. DrawDragArrow(&dc, index, idx);
  845. SetCursor(hDragCursor);
  846. hCur = hDragCursor;
  847. }
  848. else 
  849. {
  850. CRect rcItem;
  851. GetItemRect(iSelFolder, GetItemCount() - 1, rcItem);
  852. if (pt.y > rcItem.bottom && pt.y < inRc.bottom)
  853. {
  854. DrawDragArrow(&dc, index, GetItemCount());
  855. SetCursor(hDragCursor);
  856. hCur = hDragCursor;
  857. }
  858. else
  859. {
  860. DrawDragArrow(&dc, index, -1);
  861. SetCursor(hNoDragCursor);
  862. hCur = hNoDragCursor;
  863. }
  864. }
  865. }
  866. else
  867. {
  868. if (ht1 == htItem && idx == index)
  869. {
  870. if (!bHigh)
  871. {
  872. HighlightItem(index, true);
  873. bHigh = true;
  874. bPressedHighlight = true;
  875. }
  876. }
  877. else 
  878. {
  879. if (ht1 == htItem)
  880. {
  881. if (bHigh)
  882. {
  883. HighlightItem(index, false);
  884. bHigh = false;
  885. bPressedHighlight = false;
  886. }
  887. }
  888. else
  889. {
  890. if (dwFlags&fDragItems)
  891. {
  892. HighlightItem(index, true);
  893. bHigh = true;
  894. bDragging = true;
  896. SetCursor(hDragCursor);
  897. hCur = hDragCursor;
  899. bPressedHighlight = true;
  900. }
  901. }
  902. }
  903. }
  904. }
  905. break;
  907. case WM_SETCURSOR:
  908. SetCursor(hCur);
  909. break;
  911. case WM_LBUTTONUP:
  912. {
  913. if (bHigh)
  914. {
  915. HighlightItem(-1);
  916. bHigh = false;
  917. }
  918. CPoint pt(msg.lParam);
  919. int idx, ht1 = HitTestEx(pt, idx);
  920. if (!bDragging)
  921. {
  922. if (ht1 == htItem && idx == index) 
  923. {
  924. if (iSelAnimTiming > 0 && index != iLastSel && iLastSel >= 0)
  925. {
  926. DrawAnimItem(0, 0, iLastSel);
  927. }
  929. if (dwFlags&fSelHighlight && iLastSel >= 0)
  930. {
  931. CRect rc;
  932. GetIconRect(iSelFolder, iLastSel, rc);
  933. rc.InflateRect(1,1);
  934. InvalidateRect(rc);
  935. }
  937. iLastSel = index;
  939. if (dwFlags&fSelHighlight && iLastSel >= 0)
  940. {
  941. CRect rc;
  942. GetIconRect(iSelFolder, iLastSel, rc);
  943. rc.InflateRect(1,1);
  944. InvalidateRect(rc);
  945. }
  947. GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_ITEMCLICK, idx);
  948. }
  949. }
  950. else
  951. {
  952. if (ht1 == htItem)
  953. {
  954. if (idx != index)
  955. {
  956. OUTBAR_INFO ob;
  957. ob.iDragFrom = iSelFolder;
  958. ob.iDragTo = index;
  959. if (GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_DRAGITEM, (LPARAM) &ob))
  960. {
  961. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  962. CBarItem * piFrom = (CBarItem *) pbf->arItems.GetAt(index);
  963. pbf->arItems.RemoveAt(index);
  964. if (idx > index) idx --;
  965. pbf->arItems.InsertAt(idx, piFrom);
  966. }
  967. }
  968. }
  969. else
  970. {
  971. CRect rcItem;
  972. GetItemRect(iSelFolder, GetItemCount() - 1, rcItem);
  973. if (pt.y > rcItem.bottom && pt.y < inRc.bottom)
  974. {
  975. OUTBAR_INFO ob;
  976. ob.iDragFrom = iSelFolder;
  977. ob.iDragTo = index;
  978. if (GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_DRAGITEM, (LPARAM) &ob))
  979. {
  980. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  981. CBarItem * piFrom = (CBarItem *) pbf->arItems.GetAt(index);
  982. pbf->arItems.RemoveAt(index);
  983. pbf->arItems.Add((void *) piFrom);
  984. }
  985. }
  986. }
  987. }
  988. }
  990. goto ExitLoop4;
  992. default:
  993. DispatchMessage(&msg);
  994. break;
  995. }
  996. }
  998. ExitLoop4:
  999. ReleaseCapture();
  1000. AfxUnlockTempMaps(FALSE);
  1001. if (bDragging) 
  1002. {
  1003. Invalidate();
  1004. }
  1005. }
  1006. bPressedHighlight = false;
  1007. if (bHigh) InvalidateRect(rc, false);
  1008. }
  1009. else iLastItemHighlighted = -1;
  1011. if (ht == htDownScroll)
  1012. {
  1013. bLooping = true;
  1014. bool bHigh = true;
  1016. if (::GetCapture() == NULL)
  1017. {
  1018. SetCapture();
  1019. ASSERT(this == GetCapture());
  1020. CClientDC dc(this);
  1021. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN|DFCS_PUSHED);
  1022. SetTimer(2,300,NULL);
  1023. AfxLockTempMaps();
  1024. for (;;)
  1025. {
  1026. MSG msg;
  1027. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1029. if (CWnd::GetCapture() != this) break;
  1031. switch (msg.message)
  1032. {
  1033. case WM_MOUSEMOVE:
  1034. {
  1035. CPoint pt(msg.lParam);
  1036. if (rcDownArrow.PtInRect(pt))
  1037. {
  1038. if (bHigh == false)
  1039. {
  1040. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN|DFCS_PUSHED);
  1041. bHigh = true;
  1042. bDownArrow = true;
  1043. bDownPressed = true;
  1044. }
  1045. }
  1046. else
  1047. {
  1048. if (bHigh == true)
  1049. {
  1050. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  1051. bHigh = false;
  1052. bDownArrow = false;
  1053. bDownPressed = false;
  1054. }
  1055. }
  1056. }
  1057. break;
  1059. case WM_LBUTTONUP:
  1060. {
  1061. if (bHigh)
  1062. {
  1063. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  1064. bHigh = false;
  1065. }
  1066. bDownArrow = false;
  1067. CPoint pt(msg.lParam);
  1068. if (rcDownArrow.PtInRect(pt))
  1069. {
  1070. CRect itrc;
  1071. int itemCount = GetItemCount();
  1072.                             if (itemCount > 0)
  1073. {
  1074. GetItemRect(iSelFolder, GetItemCount() - 1, itrc);
  1076. CRect crc;
  1077. GetInsideRect(crc);
  1078. if (itrc.bottom > crc.bottom)
  1079. {
  1080. iFirstItem ++;
  1081. InvalidateRect(crc, true);
  1082. }
  1083. }
  1084. }
  1085. }
  1086. goto ExitLoop3;
  1089. case WM_TIMER:
  1090. {
  1091. if (msg.wParam == 2)
  1092. {
  1093. if (bHigh)
  1094. {
  1095. CPoint pt(msg.pt);
  1096. ScreenToClient(&pt);
  1097. if (rcDownArrow.PtInRect(pt))
  1098. {
  1099. bDownPressed = true;
  1100. CRect itrc;
  1101. GetItemRect(iSelFolder, GetItemCount() - 1, itrc);
  1102. CRect crc;
  1103. GetInsideRect(crc);
  1104. if (itrc.bottom > crc.bottom)
  1105. {
  1106. iFirstItem ++;
  1107. InvalidateRect(crc, true);
  1108. }
  1109. else goto ExitLoop3;
  1110. }
  1111. else bDownPressed = false;
  1112. }
  1113. }
  1114. break;
  1115. }
  1117. case WM_KEYDOWN:
  1118. if (msg.wParam != VK_ESCAPE) 
  1119. break;
  1121. default:
  1122. DispatchMessage(&msg);
  1123. break;
  1124. }
  1125. }
  1127. ExitLoop3:
  1128. KillTimer(2);
  1129. ReleaseCapture();
  1130. AfxUnlockTempMaps(FALSE);
  1131. bLooping = false;
  1132. bDownPressed = false;
  1133. bDownArrow = false;
  1134. CRect crc;
  1135. GetInsideRect(crc);
  1136. InvalidateRect(crc, true);
  1137. }
  1138. }
  1140. if (ht == htUpScroll)
  1141. {
  1142. bLooping = true;
  1143. bool bHigh = true;
  1145. if (::GetCapture() == NULL)
  1146. {
  1147. SetCapture();
  1148. ASSERT(this == GetCapture());
  1149. CClientDC dc(this);
  1150. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP|DFCS_PUSHED);
  1151. SetTimer(2,300,NULL);
  1152. AfxLockTempMaps();
  1153. for (;;)
  1154. {
  1155. MSG msg;
  1156. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1158. if (CWnd::GetCapture() != this) break;
  1160. switch (msg.message)
  1161. {
  1162. case WM_MOUSEMOVE:
  1163. {
  1164. CPoint pt(msg.lParam);
  1165. if (rcUpArrow.PtInRect(pt))
  1166. {
  1167. if (bHigh == false)
  1168. {
  1169. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP|DFCS_PUSHED);
  1170. bHigh = true;
  1171. bUpArrow = true;
  1172. bUpPressed = true;
  1173. }
  1174. }
  1175. else
  1176. {
  1177. if (bHigh == true)
  1178. {
  1179. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  1180. bHigh = false;
  1181. bUpArrow = false;
  1182. bUpPressed = false;
  1183. }
  1184. }
  1185. }
  1186. break;
  1188. case WM_LBUTTONUP:
  1189. {
  1190. if (bHigh)
  1191. {
  1192. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  1193. bHigh = false;
  1194. }
  1195. bUpArrow = false;
  1196. CPoint pt(msg.lParam);
  1197. if (rcUpArrow.PtInRect(pt))
  1198. {
  1199. if (iFirstItem > 0 ) 
  1200. {
  1201. iFirstItem --;
  1202. CRect crc;
  1203. GetInsideRect(crc);
  1204. InvalidateRect(crc, true);
  1205. }
  1206. }
  1207. }
  1209. goto ExitLoop;
  1211. case WM_TIMER:
  1212. {
  1213. if (msg.wParam == 2)
  1214. {
  1215. if (bHigh)
  1216. {
  1217. CPoint pt(msg.pt);
  1218. ScreenToClient(&pt);
  1219. if (rcUpArrow.PtInRect(pt))
  1220. {
  1221. bUpPressed = true;
  1222. if (iFirstItem > 0) 
  1223. {
  1224. iFirstItem --;
  1225. CRect crc;
  1226. GetInsideRect(crc);
  1227. InvalidateRect(crc, true);
  1228. }
  1229. else goto ExitLoop;
  1230. }
  1231. else bUpPressed = false;
  1232. }
  1233. }
  1234. break;
  1235. }
  1236. case WM_KEYDOWN:
  1237. if (msg.wParam != VK_ESCAPE) break;
  1239. default:
  1240. DispatchMessage(&msg);
  1241. break;
  1242. }
  1243. }
  1245. ExitLoop:
  1246. KillTimer(2);
  1247. ReleaseCapture();
  1248. AfxUnlockTempMaps(FALSE);
  1249. bLooping = false;
  1250. bUpPressed = false;
  1251. bUpArrow = false;
  1252. CRect crc;
  1253. GetInsideRect(crc);
  1254. InvalidateRect(crc, true);
  1255. }
  1256. }
  1258. CWnd::OnLButtonDown(nFlags, point);
  1259. }
  1262. int CGfxOutBarCtrl::InsertItem(const int folder, const int index, const char * text, const int image, const DWORD exData)
  1263. {
  1264. ASSERT(folder >= 0 && folder < GetFolderCount());
  1265. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(folder);
  1266. return pbf->InsertItem(index, text, image, exData);
  1267. }
  1269. int CGfxOutBarCtrl::GetItemCount() const
  1270. {
  1271. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1272. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1273. return  pbf->GetItemCount();
  1274. }
  1276. void CGfxOutBarCtrl::SetSelFolder(const int index)
  1277. {
  1278. ASSERT(index >= 0 && index < GetFolderCount());
  1279. // if (index == iSelFolder) return;
  1281. CWnd * pc = GetFolderChild();
  1282. if (pc) pc->ShowWindow(SW_HIDE);
  1284. if (index != iSelFolder)
  1285. {
  1286. if (dwFlags&fAnimation && lAnimationTickCount >= 0) AnimateFolderScroll(iSelFolder, index);
  1287. }
  1289. iSelFolder = index;
  1290. iFirstItem = 0;
  1291. iLastSel = -1;
  1293. pc = GetFolderChild();
  1294. if (pc)
  1295. {
  1296. CRect rc;
  1297. GetInsideRect(rc);
  1298. pc->MoveWindow(rc);
  1299. pc->ShowWindow(SW_SHOW);
  1300. }
  1302. GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_FOLDERCHANGE, (LPARAM) iSelFolder);
  1304. Invalidate();
  1305. }
  1307. int CGfxOutBarCtrl::GetFolderCount() const
  1308. {
  1309. return arFolder.GetSize();
  1310. }
  1312. int CGfxOutBarCtrl::GetSelFolder() const
  1313. {
  1314. return iSelFolder;
  1315. }
  1317. void CGfxOutBarCtrl::RemoveFolder(const int index)
  1318. {
  1319. ASSERT(index >= 0 && index < GetFolderCount());
  1320. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(index);
  1321. delete pbf;
  1322. arFolder.RemoveAt(index);
  1323. if (iSelFolder >= index) iSelFolder = index - 1;
  1324. if (iSelFolder < 0 && GetFolderCount() > 0) iSelFolder = 0;
  1325. Invalidate();
  1326. }
  1328. int CGfxOutBarCtrl::CBarFolder::InsertItem(int index, const char * text, const int image, const DWORD exData)
  1329. {
  1330. if (index < 0 || index > GetItemCount()) index = GetItemCount();
  1332. int c = GetItemCount();
  1334. CBarItem * pbf = new CBarItem(text, image, exData);
  1335. ASSERT(pbf);
  1336. if (index < GetItemCount()) 
  1337. arItems.InsertAt(index, (void *) pbf);
  1338. else 
  1339. arItems.Add((void *) pbf);
  1341. c = GetItemCount();
  1343. return index;
  1344. }
  1346. int CGfxOutBarCtrl::GetCountPerPage() const
  1347. {
  1348. return 0;
  1349. }
  1351. CImageList * CGfxOutBarCtrl::SetImageList(CImageList * pImageList, int nImageList)
  1352. {
  1353. CImageList * o = NULL;
  1354. if (nImageList == fSmallIcon)
  1355. {
  1356. o = pSmallImageList;
  1357. pSmallImageList = pImageList;
  1358. }
  1359. else if (nImageList == fLargeIcon)
  1360. {
  1361. o = pLargeImageList;
  1362. pLargeImageList = pImageList;
  1363. }
  1364. return o;
  1365. }
  1367. CImageList * CGfxOutBarCtrl::GetImageList(CImageList * pImageList, int nImageList)
  1368. {
  1369. if (nImageList == fSmallIcon) return pSmallImageList;
  1370. else if (nImageList == fLargeIcon) return pLargeImageList;
  1371. return NULL;
  1372. }
  1374. CImageList * CGfxOutBarCtrl::SetFolderImageList(const int folder, CImageList * pImageList, int nImageList)
  1375. {
  1376. ASSERT(folder >= 0 && folder < GetFolderCount());
  1377. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(folder);
  1378. CImageList * o = NULL;
  1379. if (nImageList == fSmallIcon)
  1380. {
  1381. o = pbf->pSmallImageList;
  1382. pbf->pSmallImageList = pImageList;
  1383. }
  1384. else if (nImageList == fLargeIcon)
  1385. {
  1386. o = pbf->pLargeImageList;
  1387. pbf->pLargeImageList = pImageList;
  1388. }
  1389. return o;
  1390. }
  1393. CGfxOutBarCtrl::CBarItem::CBarItem(const char * name, const int image, DWORD exData)
  1394. {
  1395. cItem = NULL;
  1396. iImageIndex = image;
  1397. dwData = exData;
  1398. if (name)
  1399. {
  1400. cItem = new char[lstrlen(name)+1];
  1401. ASSERT(cItem);
  1402. lstrcpy(cItem, name);
  1403. }
  1404. }
  1406. CGfxOutBarCtrl::CBarItem::~CBarItem()
  1407. {
  1408. if (cItem) delete [] cItem;
  1409. }
  1411. int CGfxOutBarCtrl::CBarFolder::GetItemCount()
  1412. {
  1413. return arItems.GetSize();
  1414. }
  1416. void CGfxOutBarCtrl::PaintItems(CDC * pDC, const int iFolder, CRect rc)
  1417. {
  1418. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1419. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  1420. int max = pbf->GetItemCount(), t;
  1421. CRect irc;
  1422. GetInsideRect(irc);
  1423. int isdc = pDC->SaveDC();
  1424. CRgn itemRegion;
  1425. itemRegion.CreateRectRgnIndirect(&irc);
  1426. pDC->SelectClipRgn(&itemRegion);
  1427. itemRegion.DeleteObject();
  1428. for (t = iFirstItem; t < max; t++)
  1429. {
  1430. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(t);
  1431. CRect itemRc;
  1432. GetItemRect(iFolder, t, itemRc);
  1433. if (itemRc.top > rc.bottom) break;
  1434. else DrawItem(pDC, iFolder, itemRc, t);
  1435. }
  1436. pDC->RestoreDC(isdc);
  1437. }
  1440. CSize CGfxOutBarCtrl::GetItemSize(const int iFolder, const int index, const int type)
  1441. {
  1442. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1443. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  1445. ASSERT(index >= 0 && index < pbf->GetItemCount());
  1446. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  1448. CSize szImage(0,0);
  1449. CSize szLabel(0,0);
  1450. CSize szAll(0,0);
  1452. if (pi->iImageIndex >= 0)
  1453. {
  1454. if (type != ircLabel)
  1455. {
  1456. CImageList * il = GetFolderImageList(iFolder, IsSmallIconView());
  1457. ASSERT(il);
  1458. if (il)
  1459. {
  1460. IMAGEINFO ii;
  1461. il->GetImageInfo(pi->iImageIndex, &ii);
  1462. szImage = CRect(ii.rcImage).Size();
  1463. }
  1464. }
  1465. }
  1466. if (pi->cItem)
  1467. {
  1468. if (type != ircIcon)
  1469. {
  1470. CClientDC dc(this);
  1471. CFont * oft = (CFont *) dc.SelectObject(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  1472. if (IsSmallIconView())
  1473. {
  1474. szLabel = dc.GetTextExtent(pi->cItem, lstrlen(pi->cItem));
  1475. }
  1476. else
  1477. {
  1478. CRect rc;
  1479. GetInsideRect(rc);
  1480. rc.bottom = rc.top;
  1481. dc.DrawText(pi->cItem, lstrlen(pi->cItem), rc, DT_CALCRECT|DT_CENTER|DT_WORDBREAK);
  1482. szLabel = rc.Size();
  1483. }
  1484. dc.SelectObject(oft);
  1485. }
  1486. }
  1487. if (IsSmallIconView())
  1488. {
  1489. if (type == ircIcon) szAll = szImage;
  1490. else if (type == ircLabel) szAll = szLabel;
  1491. else if (type == ircAll) szAll = CSize(szImage.cx + szLabel.cx + xSmallIconLabelOffset, szImage.cy > szLabel.cy ? szImage.cy : szLabel.cy);
  1492. }
  1493. else
  1494. {
  1495. if (type == ircIcon) szAll = szImage;
  1496. else if (type == ircLabel) szAll = szLabel;
  1497. else if (type == ircAll) 
  1498. {
  1499. szAll = CSize(szImage.cx > szLabel.cx ? szImage.cx : szLabel.cx, szLabel.cy + szImage.cy + yLargeIconLabelOffset + yLargeIconSpacing);
  1500. }
  1501. }
  1502. return szAll;
  1503. }
  1505. CImageList * CGfxOutBarCtrl::GetFolderImageList(const int index, const bool bSmall) const
  1506. {
  1507. ASSERT(index >= 0 && index < GetFolderCount());
  1508. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(index);
  1509. if (bSmall)
  1510. {
  1511. if (pbf->pSmallImageList) return pbf->pSmallImageList; else return pSmallImageList;
  1512. }
  1514. if (pbf->pLargeImageList) 
  1515. return pbf->pLargeImageList; 
  1516. else 
  1517. return pLargeImageList;
  1518. }
  1520. void CGfxOutBarCtrl::DrawItem(CDC * pDC, const int iFolder, CRect rc, const int index, const bool bOnlyImage)
  1521. {
  1522. CImageList * ima = GetFolderImageList(iFolder, IsSmallIconView());
  1524. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1525. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  1527. ASSERT(index >= 0 && index < pbf->GetItemCount());
  1528. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  1530. ASSERT(pi && ima);
  1532. CFont * oft = (CFont *) pDC->SelectObject(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  1533. COLORREF ocr = pDC->SetTextColor(crTextColor);
  1534. int obk = pDC->SetBkMode(TRANSPARENT);
  1536. if (IsSmallIconView())
  1537. {
  1538. if (ima)
  1539. {
  1540. IMAGEINFO ii;
  1541. ima->GetImageInfo(pi->iImageIndex, &ii);
  1542. CSize szImage = CRect(ii.rcImage).Size();
  1543. CPoint pt;
  1544. pt.x = rc.left + 2;
  1545. pt.y = rc.top + (rc.Height() - szImage.cy) / 2;
  1546. ima->Draw(pDC, pi->iImageIndex, pt, ILD_NORMAL);
  1548. if (!bOnlyImage)
  1549. {
  1550. rc.left += szImage.cx + xSmallIconLabelOffset;
  1551. pDC->TextOut(rc.left, rc.top, CString(pi->cItem));
  1552. }
  1554. }
  1555. }
  1556. else
  1557. {
  1558. if (ima)
  1559. {
  1560. IMAGEINFO ii;
  1561. ima->GetImageInfo(pi->iImageIndex, &ii);
  1562. CSize szImage = CRect(ii.rcImage).Size();
  1563. CPoint pt;
  1564. pt.x = rc.left + (rc.Width() - szImage.cx) / 2;
  1565. pt.y = rc.top;// + (rc.Height() - szImage.cy) / 2;
  1566. ima->Draw(pDC, pi->iImageIndex, pt, ILD_NORMAL);
  1567. if (!bOnlyImage)
  1568. {
  1569. rc.top += szImage.cy + yLargeIconLabelOffset;
  1570. pDC->DrawText(pi->cItem, lstrlen(pi->cItem), rc, DT_CENTER|DT_WORDBREAK);
  1571. }
  1572. }
  1573. }
  1575. if (dwFlags&fSelHighlight && iLastSel == index && iLastSel >= 0)
  1576. {
  1577. CRect rc;
  1578. GetIconRect(iSelFolder, iLastSel, rc);
  1579. rc.InflateRect(1,1);
  1580. pDC->Draw3dRect(rc, crDkShadowBorder, cr3dFace);
  1581. }
  1583. pDC->SetTextColor(ocr);
  1584. pDC->SelectObject(oft);
  1585. pDC->SetBkMode(obk);
  1587. }
  1590. BOOL CGfxOutBarCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  1591. {
  1592. CPoint pt(GetMessagePos());
  1593. ScreenToClient(&pt);
  1594. int index, ht = HitTestEx(pt, index);
  1595. if (ht == htFolder)
  1596. {
  1597. SetCursor(hHandCursor);
  1598. return true;
  1599. }
  1601. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  1602. }
  1604. void CGfxOutBarCtrl::GetVisibleRange(const int iFolder, int & first, int & last)
  1605. {
  1606. first = iFirstItem;
  1607. CRect rc;
  1608. GetInsideRect(rc);
  1610. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  1611. int max = pbf->GetItemCount(), t;
  1612. for (t = iFirstItem; t < max; t++)
  1613. {
  1614. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(t);
  1615. CRect itemRc;
  1616. GetItemRect(iFolder, t, itemRc);
  1617. if (itemRc.bottom > rc.bottom) 
  1618. {
  1619. last = t - 1;
  1620. break;
  1621. }
  1622. else last = t;
  1623. }
  1624. }
  1626. void CGfxOutBarCtrl::OnSize(UINT nType, int cx, int cy) 
  1627. {
  1628. bUpArrow = bDownArrow = false;
  1630. CWnd::OnSize(nType, cx, cy);
  1632. int t, max = GetFolderCount();
  1633. CRect rc;
  1634. GetInsideRect(rc);
  1636. for (t = 0; t < max; t++)
  1637. {
  1638. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(t);
  1639. CWnd * pc = GetFolderChild(t);
  1640. if (pc) pc->SetWindowPos(0, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER);
  1641. }
  1642. }
  1644. void CGfxOutBarCtrl::HighlightItem(const int index, const bool bPressed)
  1645. {
  1646. CWnd * pf = GetFocus();
  1647. if (pf != NULL && pf != this && IsChild(pf)) return;
  1649. static bool bOldPressed = false;
  1650. if (iLastItemHighlighted == index && bOldPressed == bPressed) return;
  1652. bOldPressed = bPressed;
  1654. CClientDC dc(this);
  1656. CRect irc;
  1657. GetInsideRect(irc);
  1658. int isdc = dc.SaveDC();
  1659. CRgn itemRegion;
  1660. itemRegion.CreateRectRgnIndirect(&irc);
  1661. dc.SelectClipRgn(&itemRegion);
  1662. itemRegion.DeleteObject();
  1665. if (iLastItemHighlighted >= 0 && IsValidItem(iLastItemHighlighted))
  1666. {
  1667. CRect rc;
  1668. GetIconRect(iSelFolder, iLastItemHighlighted, rc);
  1669. rc.InflateRect(1,1);
  1670. dc.Draw3dRect(rc, crBackGroundColor, crBackGroundColor);
  1671. }
  1672. if (iSelAnimTiming > 0 && index == iLastSel)
  1673. {
  1674. iLastItemHighlighted = -1;
  1675. return;
  1676. }
  1677. if (dwFlags&fSelHighlight && iLastSel == index)
  1678. {
  1679. iLastItemHighlighted = -1;
  1680. return;
  1681. }
  1683. iLastItemHighlighted = index;
  1684. if (iLastItemHighlighted >= 0 && IsValidItem(iLastItemHighlighted))
  1685. {
  1686. CRect rc;
  1687. GetIconRect(iSelFolder, iLastItemHighlighted, rc);
  1688. rc.InflateRect(1,1);
  1689. if (bPressed)
  1690. dc.Draw3dRect(rc, crDkShadowBorder, cr3dFace);
  1691. else
  1692. dc.Draw3dRect(rc, cr3dFace, crDkShadowBorder);
  1693. }
  1694. dc.RestoreDC(isdc);
  1695. }
  1697. void CGfxOutBarCtrl::GetIconRect(const int iFolder, const int iIndex, CRect & rect)
  1698. {
  1699. CRect rc;
  1700. GetInsideRect(rc);
  1701. int top = rc.top;
  1702. CSize sz(0,0);
  1703. int y = 0;
  1704. int spacing = IsSmallIconView() ? ySmallIconSpacing : yLargeIconSpacing;
  1706. for (int t = 0; t < iIndex; t++)
  1707. {
  1708. sz = GetItemSize(iFolder, t, ircAll);
  1709. top += sz.cy;
  1710. top += spacing;
  1711. if (t == iFirstItem - 1) y = top - rc.top;
  1712. }
  1713. top += spacing;
  1715. sz = GetItemSize(iFolder, iIndex, ircIcon);
  1716. if (IsSmallIconView())
  1717. {
  1718. rect.SetRect(rc.left, top, rc.left + sz.cx, top + sz.cy);
  1719. rect.left += xLeftMargin + 2;
  1720. rect.right += xLeftMargin + 2;
  1721. rect.top -= yTopMargin;
  1722. rect.bottom -= yTopMargin;
  1724. rect.top -= y;
  1725. rect.bottom -= y;
  1726. }
  1727. else
  1728. {
  1729. rect.SetRect(rc.left + (rc.Width() - sz.cx)/2, top, rc.left + (rc.Width() - sz.cx)/2 + sz.cx, top + sz.cy);
  1730. rect.top -= y + 3;
  1731. rect.bottom -= y + 2;
  1732. }
  1733. }
  1735. void CGfxOutBarCtrl::GetLabelRect(const int iFolder, const int iIndex, CRect & rect)
  1736. {
  1737. CRect rc;
  1738. GetInsideRect(rc);
  1739. int top = rc.top;
  1740. CSize sz(0,0);
  1741. int y = 0;
  1742. int spacing = IsSmallIconView() ? ySmallIconSpacing : yLargeIconSpacing;
  1744. for (int t = 0; t < iIndex; t++)
  1745. {
  1746. sz = GetItemSize(iFolder, t, ircAll);
  1747. top += sz.cy;
  1748. top += spacing;
  1749. if (t == iFirstItem - 1) y = top - rc.top;
  1750. }
  1751. top += spacing;
  1753. sz = GetItemSize(iFolder, iIndex, ircAll);
  1755. CSize szLabel = GetItemSize(iFolder, iIndex, ircLabel);
  1757. if (IsSmallIconView())
  1758. {
  1759. rect.SetRect(rc.left, top, rc.left + sz.cx, top + sz.cy);
  1760. rect.left += xLeftMargin + 2;
  1761. rect.right += xLeftMargin + 2;
  1762. rect.top  += yTopMargin - 5;
  1763. rect.bottom += yTopMargin - 5;
  1764. }
  1765. else
  1766. {
  1767. rect.SetRect(rc.left + (rc.Width() - sz.cx)/2, top, rc.left + (rc.Width() - sz.cx)/2 + sz.cx, top + sz.cy);
  1768. rect.top -= y + 3;
  1769. rect.bottom -= y + 2;
  1771. rect.bottom -=  yLargeIconSpacing;
  1772. rect.top    = rect.bottom - szLabel.cy;
  1773. }
  1774. }
  1777. void CGfxOutBarCtrl::StartGroupEdit(const int index)
  1778. {
  1779. CGfxGroupEdit * pEdit = new CGfxGroupEdit;
  1780. pEdit->iIndex = index;
  1781. CRect rc;
  1782. GetFolderRect(index, rc);
  1783. rc.InflateRect(-2,-2);
  1784. pEdit->Create(WS_CHILD|WS_VISIBLE|ES_CENTER|ES_MULTILINE,rc,this,1);
  1785. pEdit->msgSend = NM_OB_ONGROUPENDEDIT;
  1786. pEdit->ModifyStyleEx(0, WS_EX_CLIENTEDGE, SWP_FRAMECHANGED);
  1787. ASSERT(index >= 0 && index < GetFolderCount());
  1788. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(index);
  1789. pEdit->SetWindowText(pbf->cName);
  1790. pEdit->SetFocus();
  1791. }
  1793. void CGfxOutBarCtrl::StartItemEdit(const int index)
  1794. {
  1795. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1796. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1797. ASSERT(index >= 0 && index < pbf->GetItemCount());
  1798. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  1800. CGfxGroupEdit * pEdit = new CGfxGroupEdit;
  1801. pEdit->iIndex = index;
  1802. CRect rc, crc;
  1803. GetLabelRect(iSelFolder, index, rc);
  1804. GetInsideRect(crc);
  1806. DWORD dwFlag = WS_CHILD|WS_VISIBLE|WS_BORDER;
  1808. if (!IsSmallIconView())
  1809. {
  1810. rc.left = crc.left + 5;
  1811. rc.right = crc.right - 5;
  1812. rc.bottom += 5;
  1813. dwFlag |= ES_CENTER|ES_MULTILINE;
  1814. }
  1815. else 
  1816. {
  1817. CRect irc;
  1818. GetIconRect(iSelFolder, index, irc);
  1819. dwFlag |= ES_AUTOHSCROLL;
  1820. rc.OffsetRect(irc.Width()+1, -6);
  1821. pEdit->bNoDown = true;
  1822. }
  1824. pEdit->Create(dwFlag, rc, this, 1);
  1825. pEdit->msgSend = NM_OB_ONLABELENDEDIT;
  1827. pEdit->SetWindowText(pi->cItem);
  1828. pEdit->SetFocus();
  1830. }
  1832. void CGfxOutBarCtrl::OnRButtonDown(UINT nFlags, CPoint point) 
  1833. {
  1834. iHitInternal1 = HitTestEx(point, iHitInternal2);
  1836. CGfxPopupMenu cMenu;
  1837. cMenu.CreatePopupMenu();
  1839. /* cMenu.AppendMenu(MF_STRING, ID_GFX_SMALLICON, _ID_GFX_SMALLICON);
  1840. cMenu.AppendMenu(MF_STRING, ID_GFX_LARGEICON, _ID_GFX_LARGEICON);
  1841. cMenu.AppendMenu(MF_STRING, ID_GFX_GROUPICON, _ID_GFX_ADDAGROUP);
  1842. cMenu.AppendMenu(MF_STRING, ID_GFX_FONTCICON, _ID_GFX_FONTCOLOR);
  1843. cMenu.AppendMenu(MF_STRING, ID_GFX_BACKCICON, _ID_GFX_BACKCOLOR);
  1845. if (iHitInternal1 == htItem)
  1846. {
  1847. if (dwFlags&fRemoveItems || dwFlags&fEditItems)
  1848. {
  1849. cMenu.AppendMenu(MF_SEPARATOR);
  1850. if (dwFlags&fRemoveItems)
  1851. cMenu.AppendMenu(MF_STRING, ID_GFX_REMOVEITEM, _ID_GFX_REMOVEITEM);
  1853. if (dwFlags&fEditItems)
  1854. cMenu.AppendMenu(MF_STRING, ID_GFX_RENAMEITEM, _ID_GFX_RENAMEITEM);
  1855. }
  1856. }
  1857. else if (iHitInternal1 == htFolder)
  1858. {
  1859. if (dwFlags&fRemoveGroups || dwFlags&fEditGroups)
  1860. {
  1861. cMenu.AppendMenu(MF_SEPARATOR);
  1863. if (dwFlags&fRemoveGroups)
  1864. cMenu.AppendMenu(MF_STRING, ID_GFX_REMOVEITEM, _ID_GFX_REMOVEITEM);
  1866. if (dwFlags&fEditGroups)
  1867. cMenu.AppendMenu(MF_STRING, ID_GFX_RENAMEITEM, _ID_GFX_RENAMEITEM);
  1868. }
  1869. }*/
  1871. cMenu.LoadToolBarResource(IDR_MAINFRAME);
  1872. cMenu.RemapMenu(&cMenu);
  1873. cMenu.EnableMenuItems(&cMenu, this);
  1875. CPoint pt(point);
  1876. ClientToScreen(&pt);
  1877. cMenu.TrackPopupMenu(TPM_LEFTALIGN|TPM_RIGHTBUTTON, pt.x, pt.y, this);
  1879. cMenu.DestroyMenu();
  1881. CWnd::OnRButtonDown(nFlags, point);
  1882. }
  1884. void CGfxOutBarCtrl::OnGfxLargeicon() 
  1885. {
  1886. SetSmallIconView(false);
  1887. Invalidate();
  1888. }
  1890. void CGfxOutBarCtrl::OnUpdateGfxLargeicon(CCmdUI* pCmdUI) 
  1891. {
  1892. pCmdUI->Enable(IsSmallIconView());
  1893. }
  1895. void CGfxOutBarCtrl::OnGfxSmallicon() 
  1896. {
  1897. SetSmallIconView(true);
  1898. Invalidate();
  1899. }
  1901. void CGfxOutBarCtrl::OnUpdateGfxSmallicon(CCmdUI* pCmdUI) 
  1902. {
  1903. pCmdUI->Enable(!IsSmallIconView());
  1904. }
  1906. void CGfxOutBarCtrl::OnGfxRemoveitem() 
  1907. {
  1908. if (iHitInternal1 == htFolder)
  1909. {
  1910. RemoveFolder(iHitInternal2);
  1911. }
  1912. else if (iHitInternal1 == htItem)
  1913. {
  1914. RemoveItem(iHitInternal2);
  1915. }
  1916. }
  1918. void CGfxOutBarCtrl::OnUpdateGfxRemoveitem(CCmdUI* pCmdUI) 
  1919. {
  1921. }
  1923. void CGfxOutBarCtrl::OnGfxRenameitem() 
  1924. {
  1925. if (iHitInternal1 == htFolder)
  1926. {
  1927. StartGroupEdit(iHitInternal2);
  1928. }
  1929. else if (iHitInternal1 == htItem)
  1930. {
  1931. StartItemEdit(iHitInternal2);
  1932. }
  1933. }
  1935. void CGfxOutBarCtrl::OnUpdateGfxRenameitem(CCmdUI* pCmdUI) 
  1936. {
  1937. }
  1939. void CGfxOutBarCtrl::RemoveItem(const int index)
  1940. {
  1941. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1942. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1943. ASSERT(index >= 0 && index < pbf->GetItemCount());
  1944. if (IsValidItem(index))
  1945. {
  1946. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1947. delete i;
  1949. pbf->arItems.RemoveAt(index);
  1950. CRect rc;
  1951. GetInsideRect(rc);
  1952. InvalidateRect(rc);
  1953. }
  1954. }
  1956. bool CGfxOutBarCtrl::IsValidItem(const int index) const
  1957. {
  1958. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1959. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1960. return (index >= 0 && index < pbf->GetItemCount());
  1961. }
  1963. DWORD CGfxOutBarCtrl::GetItemData(const int index) const
  1964. {
  1965. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1966. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1967. if (IsValidItem(index))
  1968. {
  1969. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1970. return i->dwData;
  1971. }
  1972. return 0;
  1973. }
  1975. int CGfxOutBarCtrl::GetItemImage(const int index) const
  1976. {
  1977. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1978. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1979. if (IsValidItem(index))
  1980. {
  1981. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1982. return i->iImageIndex;
  1983. }
  1984. return 0;
  1985. }
  1987. void CGfxOutBarCtrl::SetItemData(const int index, const DWORD dwData)
  1988. {
  1989. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1990. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1991. if (IsValidItem(index))
  1992. {
  1993. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1994. i->dwData = dwData;
  1995. }
  1996. }
  1998. void CGfxOutBarCtrl::SetItemImage(const int index, const int iImage)
  1999. {
  2000. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  2001. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  2002. if (IsValidItem(index))
  2003. {
  2004. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  2005. i->iImageIndex = iImage;
  2006. }
  2007. }
  2009. void CGfxOutBarCtrl::DrawDragArrow(CDC * pDC, const int iFrom, const int iTo)
  2010. {
  2011. if (iTo == iLastDragItemDraw) return;
  2012. CRect rc1;
  2013. if (iLastDragItemDraw >= 0)
  2014. {
  2015. GetDragItemRect(iLastDragItemDraw, rc1);
  2016. if (iLastDragItemDrawType == 0) rc1.bottom = rc1.top + 5;
  2017. else if (iLastDragItemDrawType == 1) { rc1.top -= 4; rc1.bottom = rc1.top + 9; }
  2018. else if (iLastDragItemDrawType == 2) { rc1.top -= 4; rc1.bottom = rc1.top + 5; }
  2019. InvalidateRect(rc1, true);
  2020. UpdateWindow();
  2021. }
  2022. iLastDragItemDraw = iTo;
  2024. if (iLastDragItemDraw >= 0)
  2025. {
  2026. iLastDragItemDrawType = GetDragItemRect(iLastDragItemDraw, rc1);
  2028. CPen * op = pDC->SelectObject(pBlackPen);
  2030. pDC->MoveTo(rc1.left, rc1.top);
  2031. pDC->LineTo(rc1.right, rc1.top);
  2033. if (iLastDragItemDrawType != 2)
  2034. {
  2035. pDC->MoveTo(rc1.left, rc1.top+1);
  2036. pDC->LineTo(rc1.left + 7, rc1.top+1);
  2037. pDC->MoveTo(rc1.left, rc1.top+2);
  2038. pDC->LineTo(rc1.left + 5, rc1.top+2);
  2039. pDC->MoveTo(rc1.left, rc1.top+3);
  2040. pDC->LineTo(rc1.left + 3, rc1.top+3);
  2041. pDC->MoveTo(rc1.left, rc1.top+4);
  2042. pDC->LineTo(rc1.left + 1, rc1.top+4);
  2044. pDC->MoveTo(rc1.right-1, rc1.top+1);
  2045. pDC->LineTo(rc1.right - 7, rc1.top+1);
  2046. pDC->MoveTo(rc1.right-1, rc1.top+2);
  2047. pDC->LineTo(rc1.right - 5, rc1.top+2);
  2048. pDC->MoveTo(rc1.right-1, rc1.top+3);
  2049. pDC->LineTo(rc1.right - 3, rc1.top+3);
  2050. }
  2051. if (iLastDragItemDrawType != 0)
  2052. {
  2053. pDC->MoveTo(rc1.left, rc1.top-1);
  2054. pDC->LineTo(rc1.left + 7, rc1.top-1);
  2055. pDC->MoveTo(rc1.left, rc1.top-2);
  2056. pDC->LineTo(rc1.left + 5, rc1.top-2);
  2057. pDC->MoveTo(rc1.left, rc1.top-3);
  2058. pDC->LineTo(rc1.left + 3, rc1.top-3);
  2059. pDC->MoveTo(rc1.left, rc1.top-4);
  2060. pDC->LineTo(rc1.left + 1, rc1.top-4);
  2062. pDC->MoveTo(rc1.right-1, rc1.top-1);
  2063. pDC->LineTo(rc1.right - 7, rc1.top-1);
  2064. pDC->MoveTo(rc1.right-1, rc1.top-2);
  2065. pDC->LineTo(rc1.right - 5, rc1.top-2);
  2066. pDC->MoveTo(rc1.right-1, rc1.top-3);
  2067. pDC->LineTo(rc1.right - 3, rc1.top-3);
  2068. pDC->MoveTo(rc1.right-1, rc1.top-4);
  2069. pDC->LineTo(rc1.right - 1, rc1.top-4);
  2070. }
  2072. pDC->SelectObject(op);
  2073. }
  2074. }
  2076. int CGfxOutBarCtrl::GetDragItemRect(const int index, CRect & rect)
  2077. {
  2078. CRect rc, crc;
  2079. GetInsideRect(crc);
  2080. crc.InflateRect(-2, 0);
  2082. GetItemRect(iSelFolder, index < GetItemCount() ? index : index - 1, rc);
  2083. int line = 0;
  2084. if (index < GetItemCount())
  2085. {
  2086. line = rc.top - 4;
  2087. }
  2088. else
  2089. {
  2090. line = rc.bottom + 6;
  2091. }
  2092. int tpe;
  2093. if (index == 0)
  2094. {
  2095. rect.SetRect(crc.left, line+2, crc.right, line + 7);
  2096. tpe = 0;
  2097. }
  2098. else if (index < GetItemCount())
  2099. {
  2100. rect.SetRect(crc.left, line - 9, crc.right, line);
  2101. tpe = 1;
  2102. if (IsSmallIconView()) 
  2103. {
  2104. rect.top += 8;
  2105. rect.bottom += 8;
  2106. }
  2107. }
  2108. else
  2109. {
  2110. rect.SetRect(crc.left, line, crc.right, line + 5);
  2111. tpe = 2;
  2112. }
  2113. return tpe;
  2114. }
  2117. void CGfxOutBarCtrl::AnimateFolderScroll(const int iFrom, const int iTo)
  2118. {
  2119. ASSERT(iFrom >= 0 && iFrom < GetFolderCount());
  2120. ASSERT(iTo >= 0 && iTo < GetFolderCount());
  2122. CRect rc, rc1, frc, frc1;
  2123. GetInsideRect(rc);
  2124. rc1.SetRect(0,0,rc.Width(),rc.Height());
  2125. GetFolderRect(iTo, frc);
  2126. frc1 = frc;
  2128. CClientDC dc(this);
  2129. CDC memDC;
  2130. memDC.CreateCompatibleDC(&dc);
  2131. CBitmap bmpFrom, bmpTo;
  2132. bmpFrom.CreateCompatibleBitmap(&dc, rc1.Width(), rc1.Height() + frc.Height() * 2);
  2133. bmpTo.CreateCompatibleBitmap(&dc, rc1.Width(), rc1.Height() + frc.Height() * 2);
  2134. CDC * pDC = &memDC;
  2136. CWnd * pWnd1 = GetFolderChild(iFrom);
  2137. CWnd * pWnd2 = GetFolderChild(iTo);
  2140. CBitmap * obmp = pDC->SelectObject(&bmpFrom);
  2141. if (iTo > iFrom)
  2142. {
  2143. rc1.bottom += frc.Height() * 2;
  2144. pDC->FillSolidRect(rc1, crBackGroundColor);
  2145. if (pWnd1) 
  2146. {
  2147. BOOL bPrev = pWnd1->ShowWindow(SW_SHOW);
  2148. pWnd1->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2149. pWnd1->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2150. if (!bPrev) pWnd1->ShowWindow(SW_HIDE);
  2151. }
  2152. else PaintItems(pDC, iFrom, rc1);
  2154. pDC->SelectObject(&bmpTo);
  2155. frc.SetRect(0,0,frc.Width(),frc.Height());
  2156. rc1.SetRect(0,frc.Height(),rc.Width(), rc.Height()+frc.Height() * 2);
  2157. pDC->FillSolidRect(rc1, crBackGroundColor);
  2159. if (pWnd2) 
  2160. {
  2161. CPoint ovpt = pDC->SetViewportOrg(0, frc.Height());
  2162. BOOL bPrev = pWnd2->ShowWindow(SW_SHOW);
  2163. pWnd2->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2164. pWnd2->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2165. if (!bPrev) pWnd2->ShowWindow(SW_HIDE);
  2166. pDC->SetViewportOrg(ovpt);
  2167. }
  2168. else PaintItems(pDC, iTo, rc1);
  2169. DrawFolder(pDC, iTo, frc, false);
  2170. }
  2171. else
  2172. {
  2173. frc.SetRect(0,0,frc.Width(),frc.Height());
  2174. rc1.top += frc.Height();
  2175. rc1.bottom += frc.Height() * 2;
  2176. pDC->FillSolidRect(rc1, crBackGroundColor);
  2177. if (pWnd1) 
  2178. {
  2179. CPoint ovpt = pDC->SetViewportOrg(0, frc.Height());
  2180. BOOL bPrev = pWnd1->ShowWindow(SW_SHOW);
  2181. pWnd1->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2182. pWnd1->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2183. if (!bPrev) pWnd1->ShowWindow(SW_HIDE);
  2184. pDC->SetViewportOrg(ovpt);
  2185. }
  2186. else PaintItems(pDC, iFrom, rc1);
  2188. DrawFolder(pDC, iFrom, frc, false);
  2190. pDC->SelectObject(&bmpTo);
  2191. rc1.SetRect(0,0,rc.Width(), rc.Height() + frc.Height() * 2);
  2192. pDC->FillSolidRect(rc1, crBackGroundColor);
  2194. if (pWnd2) 
  2195. {
  2196. BOOL bPrev = pWnd2->ShowWindow(SW_SHOW);
  2197. pWnd2->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2198. pWnd2->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2199. if (!bPrev) pWnd2->ShowWindow(SW_HIDE);
  2200. }
  2201. else PaintItems(pDC, iTo, rc1);
  2202. }
  2204. if (iTo > iFrom)
  2205. {
  2206. CRect rcFrom, rcTo;
  2207. GetFolderRect(iFrom, rcFrom);
  2208. GetFolderRect(iTo, rcTo);
  2209. int fh = rcFrom.Height();
  2210. for (int y = rcTo.top - fh; y > rcFrom.bottom; y -= fh)
  2211. {
  2212. pDC->SelectObject(&bmpFrom);
  2213. dc.BitBlt(rc.left, rcFrom.bottom + 1, rc.Width(), y - rcFrom.bottom - 1, pDC, 0,fh, SRCCOPY);
  2214. pDC->SelectObject(&bmpTo);
  2215. dc.BitBlt(rc.left, y, rc.Width(), rc.bottom - y + fh, pDC, 0,0, SRCCOPY);
  2216. Sleep(lAnimationTickCount);
  2217. }
  2218. }
  2219. else
  2220. {
  2221. CRect rcFrom, rcTo;
  2222. GetFolderRect(iFrom, rcFrom);
  2223. int fh = rcFrom.Height();
  2224. rcTo.SetRect(rc.left, rc.bottom, rc.right, rc.bottom - fh);
  2225. for (int y = rcFrom.top + 1; y < rcTo.top - fh; y += fh)
  2226. {
  2227. pDC->SelectObject(&bmpTo);
  2228. dc.BitBlt(rc.left, rcFrom.top, rc.Width(), y - rcFrom.top - 1, pDC, 0, fh*2, SRCCOPY);
  2229. pDC->SelectObject(&bmpFrom);
  2230. dc.BitBlt(rc.left, y, rc.Width(), rc.bottom - y, pDC, 0,0, SRCCOPY);
  2231. Sleep(lAnimationTickCount);
  2232. }
  2233. }
  2235. pDC->SelectObject(obmp);
  2236. }
  2241. CString CGfxOutBarCtrl::GetItemText(const int index)
  2242. {
  2243. CString item;
  2245. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  2246. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  2247. if (IsValidItem(index))
  2248. {
  2249. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  2250. if (pi->cItem) item = pi->cItem;
  2251. }
  2252. return item;
  2253. }
  2255. int CGfxOutBarCtrl::AddFolderBar(const char * pFolder, CWnd * pSon, const DWORD exData)
  2256. {
  2257. CBarFolder * pbf = new CBarFolder(pFolder, exData);
  2258. ASSERT(pbf);
  2259. pbf->pChild = pSon;
  2261. arFolder.Add((void *)pbf);
  2263. return arFolder.GetSize() - 1;
  2264. }
  2266. CWnd * CGfxOutBarCtrl::GetFolderChild(int iFolder)
  2267. {
  2268. if (GetFolderCount())
  2269. {
  2270. if (iFolder < 0) iFolder = iSelFolder;
  2272. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  2273. return pbf->pChild;
  2274. }
  2275. return NULL;
  2276. }
  2278. DWORD CGfxOutBarCtrl::GetFolderData(int iFolder)
  2279. {
  2280. if (iFolder < 0) iFolder = iSelFolder;
  2281. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  2282. return pbf->dwData;
  2283. }
  2285. void CGfxOutBarCtrl::SetAnimSelHighlight(const int iTime)
  2286. {
  2287. if (iTime <= 0) KillTimer(3);
  2288. else SetTimer(3, iTime, NULL);
  2289. iSelAnimTiming = iTime;
  2290. }