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

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

ICQ/即时通讯

开发平台：

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. ON_COMMAND(ID_GFX_GROUPICON, OnGfxGroupicon)
  129. ON_COMMAND(ID_GFX_BACKCICON, OnGfxBackcicon)
  130. ON_COMMAND(ID_GFX_FONTCICON, OnGfxFontcicon)
  131. //}}AFX_MSG_MAP
  132. ON_MESSAGE(WM_OUTBAR_NOTIFY, OnEndLabelEdit)
  133. END_MESSAGE_MAP()
  136. /////////////////////////////////////////////////////////////////////////////
  137. // CGfxOutBarCtrl message handlers
  139. long CGfxOutBarCtrl::OnEndLabelEdit(WPARAM wParam, LPARAM lParam)
  140. {
  141. if (wParam == NM_OB_ONGROUPENDEDIT)
  142. {
  143. CGfxGroupEdit * pEdit = (CGfxGroupEdit *) lParam;
  144. OUTBAR_INFO ob;
  145. ob.index = pEdit->iIndex;
  146. ob.cText = pEdit->text;
  148. if (GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_ONGROUPENDEDIT, (LPARAM) &ob))
  149. {
  150. SetFolderText(pEdit->iIndex, pEdit->text);
  151. CRect rc;
  152. GetFolderRect(pEdit->iIndex, rc);
  153. InvalidateRect(rc, false);
  154. }
  155. }
  156. if (wParam == NM_OB_ONLABELENDEDIT)
  157. {
  158. CGfxGroupEdit * pEdit = (CGfxGroupEdit *) lParam;
  159. OUTBAR_INFO ob;
  160. ob.index = pEdit->iIndex;
  161. ob.cText = pEdit->text;
  163. if (GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_ONLABELENDEDIT, (LPARAM) &ob))
  164. {
  165. SetItemText(pEdit->iIndex, pEdit->text);
  166. CRect rc;
  167. GetInsideRect(rc);
  168. InvalidateRect(rc, true);
  169. }
  170. }
  171. return 0;
  172. }
  174. void CGfxOutBarCtrl::SetFolderText(const int index, const char * text)
  175. {
  176. ASSERT(index >= 0 && index < GetFolderCount());
  177. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(index);
  178. if (pbf->cName) 
  179. {
  180. delete [] pbf->cName;
  181. pbf->cName = NULL;
  182. }
  183. pbf->cName = new char [lstrlen(text)+1];
  184. lstrcpy(pbf->cName, text);
  185. }
  187. void CGfxOutBarCtrl::SetItemText(const int index, const char * text)
  188. {
  189. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  190. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  191. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  192. if (pi->cItem) 
  193. {
  194. delete [] pi->cItem;
  195. pi->cItem = NULL;
  196. }
  197. pi->cItem = new char [lstrlen(text)+1];
  198. lstrcpy(pi->cItem, text);
  199. }
  201. BOOL CGfxOutBarCtrl::Create(DWORD dwStyle, const RECT & rect, CWnd * pParentWnd, UINT nID, const DWORD dwFlag)
  202. {
  203. dwFlags = dwFlag;
  204. return CWnd::CreateEx(WS_EX_STATICEDGE, NULL, NULL, dwStyle|WS_CHILD, rect, pParentWnd, nID);
  205. //GFXOUTBARCTRL_CLASSNAME
  206. }
  208. bool CGfxOutBarCtrl::IsSmallIconView() const
  209. {
  210. return dwFlags&fSmallIcon;
  211. }
  213. void CGfxOutBarCtrl::SetSmallIconView(const bool bSet)
  214. {
  215. iFirstItem = 0;
  217. if (bSet)
  218. {
  219. if (!IsSmallIconView()) 
  220. {
  221. dwFlags |= fSmallIcon;
  222. CRect rc;
  223. GetInsideRect(rc);
  224. InvalidateRect(rc, false);
  225. }
  226. }
  227. else
  228. {
  229. if (IsSmallIconView()) 
  230. {
  231. dwFlags &= ~fSmallIcon;
  232. CRect rc;
  233. GetInsideRect(rc);
  234. InvalidateRect(rc, false);
  235. }
  236. }
  237. }
  239. DWORD CGfxOutBarCtrl::GetFlag() const
  240. {
  241. return dwFlags;
  242. }
  244. void CGfxOutBarCtrl::ModifyFlag(const DWORD & dwRemove, const DWORD & dwAdd, const UINT redraw)
  245. {
  246. if (dwRemove) dwFlags &= ~(dwRemove);
  247. if (dwAdd) dwFlags |= dwAdd;
  249. if (GetSafeHwnd())
  250. {
  251. if (redraw != 0) SetWindowPos(0,0,0,0,0,SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE|redraw);
  252. else Invalidate();
  253. }
  254. }
  256. int CGfxOutBarCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  257. {
  258. if (CWnd::OnCreate(lpCreateStruct) == -1)
  259. return -1;
  261. // TODO: Add your specialized creation code here
  263. return 0;
  264. }
  266. void CGfxOutBarCtrl::OnTimer(UINT nIDEvent) 
  267. {
  268. if (nIDEvent == 1)
  269. {
  270. CPoint pt(GetMessagePos());
  272. ScreenToClient(&pt);
  274. CRect rc;
  275. GetClientRect(&rc);
  276. if (!(rc.PtInRect(pt)))
  277. {
  278. HighlightFolder(-1);
  279. HighlightItem(-1);
  280. KillTimer(1);
  281. }
  282. }
  283. else if (nIDEvent == 3 && iLastSel >= 0)
  284. {
  285. iSelAnimCount ++;
  286. if (iSelAnimCount > 10) iSelAnimCount = -1;
  287. if (iSelAnimCount == 0)
  288. DrawAnimItem(-1, 1, iLastSel);
  289. if (iSelAnimCount == 1)
  290. DrawAnimItem(0, 0, iLastSel);
  291. if (iSelAnimCount == 2)
  292. DrawAnimItem(1, 1, iLastSel);
  293. if (iSelAnimCount == 3)
  294. DrawAnimItem(0, 0, iLastSel);
  295. }
  296. else if(nIDEvent==4)
  297. {
  298. GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_ITEMCLICK, iLastSel);
  299. KillTimer(4);
  300. }
  301. CWnd::OnTimer(nIDEvent);
  302. }
  304. void CGfxOutBarCtrl::DrawAnimItem(const int xoffset, const int yoffset, const int index)
  305. {
  306. CImageList * ima = GetFolderImageList(iSelFolder, IsSmallIconView());
  308. CRect rc, irc;
  309. GetInsideRect(irc);
  310. GetItemRect(iSelFolder, iLastSel, rc);
  312. if (iLastSel >= iFirstItem && irc.bottom > rc.bottom && irc.top < rc.top)
  313. {
  314. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  315. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  317. ASSERT(index >= 0 && index < pbf->GetItemCount());
  318. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  320. ASSERT(pi && ima);
  322. CClientDC dc(this);
  324. if (IsSmallIconView())
  325. {
  326. if (ima)
  327. {
  328. IMAGEINFO ii;
  329. ima->GetImageInfo(pi->iImageIndex, &ii);
  330. CSize szImage = CRect(ii.rcImage).Size();
  331. CPoint pt;
  332. pt.x = rc.left + 2;
  333. pt.y = rc.top + (rc.Height() - szImage.cy) / 2;
  335. CRect rcBck(pt.x-1, pt.y-1, pt.x + szImage.cx+2, pt.y + szImage.cy+2);
  336. dc.FillSolidRect(rcBck, crBackGroundColor);
  338. pt.x += xoffset;
  339. pt.y += yoffset;
  341. ima->Draw(&dc, pi->iImageIndex, pt, ILD_NORMAL);
  343. }
  344. }
  345. else
  346. {
  347. if (ima)
  348. {
  349. IMAGEINFO ii;
  350. ima->GetImageInfo(pi->iImageIndex, &ii);
  351. CSize szImage = CRect(ii.rcImage).Size();
  352. CPoint pt;
  353. pt.x = rc.left + (rc.Width() - szImage.cx) / 2;
  354. pt.y = rc.top;
  356. CRect rcBck(pt.x-1, pt.y-1, pt.x + szImage.cx+2, pt.y + szImage.cy+2);
  357. dc.FillSolidRect(rcBck, crBackGroundColor);
  359. pt.x += xoffset;
  360. pt.y += yoffset;
  362. ima->Draw(&dc, pi->iImageIndex, pt, ILD_NORMAL);
  363. }
  364. }
  365. }
  366. }
  368. void CGfxOutBarCtrl::OnPaint() 
  369. {
  370. CRect clientRc;
  371. GetClientRect(&clientRc);
  372. CPaintDC dc(this);
  373. CDC memDC;
  374. memDC.CreateCompatibleDC(&dc);
  375. CBitmap bmp;
  376. bmp.CreateCompatibleBitmap(&dc, clientRc.Width(), clientRc.Height());
  377. CBitmap * obmp = memDC.SelectObject(&bmp);
  379. CDC * pDC = &memDC;
  381. CRect rc;
  382. GetInsideRect(rc);
  383. if (!GetFolderChild()) pDC->FillSolidRect(rc, crBackGroundColor);
  386. int max = arFolder.GetSize();
  387. CRect frc;
  388. for (int t = 0; t < max; t++)
  389. {
  390. GetFolderRect(t, frc);
  391. DrawFolder(pDC, t, frc, false);
  392. }
  393. if (!GetFolderChild())
  394. {
  395. int f,l;
  396. GetVisibleRange(iSelFolder, f,l);
  397. rcUpArrow.SetRect(0,0,GetSystemMetrics(SM_CXVSCROLL), GetSystemMetrics(SM_CXVSCROLL));
  398. rcDownArrow = rcUpArrow;
  399. rcUpArrow.OffsetRect(rc.right - 5 - GetSystemMetrics(SM_CXVSCROLL), rc.top +5);
  400. rcDownArrow.OffsetRect(rc.right - 5 - GetSystemMetrics(SM_CXVSCROLL), rc.bottom - 5 - GetSystemMetrics(SM_CXVSCROLL));
  402. if (f > 0)
  403. {
  404. if (bUpPressed) pDC->DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP|DFCS_PUSHED);
  405. else pDC->DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  406. bUpArrow = true;
  407. pDC->ExcludeClipRect(rcUpArrow);
  408. }
  409. else bUpArrow = false;
  411. if (l < GetItemCount() - 1)
  412. {
  413. if (bDownPressed) pDC->DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN|DFCS_PUSHED);
  414. else pDC->DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  415. bDownArrow = true;
  416. pDC->ExcludeClipRect(rcDownArrow);
  417. }
  418. else bDownArrow = false;
  420. PaintItems(pDC, iSelFolder, rc);
  421. }
  423. dc.BitBlt(clientRc.left, clientRc.top, clientRc.Width(), clientRc.Height(), &memDC, 0,0, SRCCOPY);
  425. memDC.SelectObject(obmp);
  427. if (iLastFolderHighlighted >= 0)
  428. {
  429. int i = iLastFolderHighlighted;
  430. iLastFolderHighlighted = -1;
  431. HighlightFolder(i);
  432. }
  433. if (iLastItemHighlighted >= 0)
  434. {
  435. int i = iLastItemHighlighted;
  436. iLastItemHighlighted = -1;
  437. HighlightItem(i, bPressedHighlight);
  438. }
  440. }
  442. BOOL CGfxOutBarCtrl::OnEraseBkgnd(CDC* pDC) 
  443. {
  444. return true;
  445. }
  447. bool CGfxOutBarCtrl::GetFolderRect(const int iIndex, CRect & rect) const
  448. {
  449. int max = arFolder.GetSize();
  450. ASSERT(iIndex >= 0 && iIndex < max);
  452. if (iIndex >= 0 && iIndex < max)
  453. {
  454. CRect rc;
  455. GetClientRect(rc);
  456. if (iIndex > iSelFolder)
  457. rect.SetRect(rc.left, rc.bottom - ((max - iIndex)) * iFolderHeight, rc.right, 
  458. rc.bottom - (max - iIndex - 1) * iFolderHeight);
  459. else 
  460. rect.SetRect(rc.left, rc.top + iIndex * iFolderHeight - 1, rc.right, 
  461. rc.top + (1 + iIndex) * iFolderHeight - 1);
  462. return true;
  463. }
  464. return false;
  465. }
  467. void CGfxOutBarCtrl::GetItemRect(const int iFolder, const int iIndex, CRect & rect)
  468. {
  469. CRect rc;
  470. GetInsideRect(rc);
  471. int top = rc.top;
  472. CSize sz(0,0);
  473. int y = 0;
  474. for (int t = 0; t < iIndex; t++)
  475. {
  476. sz = GetItemSize(iFolder, t, ircAll);
  477. top += sz.cy;
  479. if (IsSmallIconView()) 
  480. {
  481. top += ySmallIconSpacing; 
  482. }
  483. else 
  484. {
  485. top += yLargeIconSpacing;
  486. }
  487. if (t == iFirstItem - 1) y = top - rc.top;
  488. }
  489. sz = GetItemSize(iFolder, iIndex, ircAll);
  490. rect.SetRect(rc.left, top, rc.left + sz.cx, top + sz.cy);
  492. rect.top -= y;
  493. rect.bottom -= y;
  495. rect.left += xLeftMargin;
  496. rect.top  += yTopMargin;
  497. rect.bottom += yTopMargin;
  499. if (!IsSmallIconView()) 
  500. {
  501. rect.left = rc.left;
  502. rect.right = rc.right;
  503. }
  504. }
  506. void CGfxOutBarCtrl::DrawFolder(CDC * pDC, const int iIdx, CRect rect, const bool bSelected)
  507. {
  508. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iIdx);
  510. if (!bSelected)
  511. {
  512. CPen pn1(PS_SOLID, 1, crBackGroundColor1);
  513. CPen * op = pDC->SelectObject(&pn1);
  514. pDC->MoveTo(rect.left, rect.top);
  515. pDC->LineTo(rect.right, rect.top);
  516. pDC->SelectObject(op);
  518. rect.top ++;
  520. pDC->Draw3dRect(rect, crHilightBorder, crBackGroundColor1);
  521. rect.InflateRect(-1,-1);
  522. pDC->FillSolidRect(rect, cr3dFace);
  523. int obk = pDC->SetBkMode(TRANSPARENT);
  524. CFont * of = pDC->SelectObject(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  525. pDC->DrawText(CString(pbf->cName), rect, DT_CENTER|DT_VCENTER|DT_SINGLELINE);
  526. pDC->SetBkMode(obk);
  527. pDC->SelectObject(of);
  528. }
  529. else
  530. {
  531. CPen pn1(PS_SOLID, 1, crBackGroundColor1);
  532. CPen * op = pDC->SelectObject(&pn1);
  533. pDC->MoveTo(rect.left+1, rect.top);
  534. pDC->LineTo(rect.right, rect.top);
  535. pDC->SelectObject(op);
  537. rect.top ++;
  539. pDC->Draw3dRect(rect, crDkShadowBorder, crHilightBorder);
  540. rect.InflateRect(-1,-1);
  541. pDC->Draw3dRect(rect, crBackGroundColor1, cr3dFace);
  542. rect.InflateRect(-1,-1);
  544. pDC->FillSolidRect(rect, cr3dFace);
  546. int obk = pDC->SetBkMode(TRANSPARENT);
  547. CFont * of = pDC->SelectObject(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  548. pDC->DrawText(CString(pbf->cName), rect, DT_CENTER|DT_VCENTER|DT_SINGLELINE);
  549. pDC->SetBkMode(obk);
  550. pDC->SelectObject(of);
  551. }
  552. }
  554. int CGfxOutBarCtrl::AddFolder(const char * cFolderName, const DWORD exData)
  555. {
  556. CBarFolder * pbf = new CBarFolder(cFolderName, exData);
  557. ASSERT(pbf);
  558. arFolder.Add((void *)pbf);
  560. return arFolder.GetSize() - 1;
  561. }
  563. CGfxOutBarCtrl::CBarFolder::CBarFolder(const char * name, DWORD exData)
  564. {
  565. cName = NULL;
  566. dwData = exData;
  568. if (name)
  569. {
  570. cName = new char[lstrlen(name)+1];
  571. ASSERT(cName);
  572. lstrcpy(cName, name);
  573. }
  574. pLargeImageList = NULL;
  575. pSmallImageList = NULL;
  576. pChild = NULL;
  577. }
  579. CGfxOutBarCtrl::CBarFolder::~CBarFolder()
  580. {
  581. if (cName) delete [] cName;
  582. for (int t = 0; t < arItems.GetSize(); t++)
  583. if (arItems.GetAt(t)) delete (CBarFolder*) arItems.GetAt(t);
  585. arItems.RemoveAll();
  586. }
  588. void CGfxOutBarCtrl::GetInsideRect(CRect & rect) const
  589. {
  590. GetClientRect(rect);
  591. if (arFolder.GetSize() > 0)
  592. {
  593. int max = arFolder.GetSize();
  594. rect.top += iFolderHeight * (iSelFolder + 1) - 1;//+ 2;
  595. rect.bottom -= (max - iSelFolder - 1)*iFolderHeight;
  596. return;
  597. }
  598. }
  600. void CGfxOutBarCtrl::OnMouseMove(UINT nFlags, CPoint point) 
  601. {
  602. int index, ht = HitTestEx(point, index);
  604. if (ht != htFolder && iLastFolderHighlighted >= 0) HighlightFolder(-1);
  605. if (ht != htItem   && iLastItemHighlighted   >= 0) HighlightItem(-1);
  607. if (ht == htFolder)
  608. {
  609. HighlightFolder(index);
  610. SetTimer(1,100,NULL);
  611. }
  612. else if (ht == htItem)
  613. {
  614. HighlightItem(index);
  615. SetTimer(1,100,NULL);
  616. }
  618. CWnd::OnMouseMove(nFlags, point);
  619. }
  621. int CGfxOutBarCtrl::HitTestEx(const CPoint & point, int &index)
  622. {
  623. if (bUpArrow && rcUpArrow.PtInRect(point)) return htUpScroll;
  624. if (bDownArrow && rcDownArrow.PtInRect(point)) return htDownScroll;
  626. int max = arFolder.GetSize(), t;
  628. CRect rc;
  629. for (t = 0; t < max; t++)
  630. {
  631. GetFolderRect(t, rc);
  632. if (rc.PtInRect(point)) 
  633. {
  634. index = t;
  635. return htFolder;
  636. }
  637. }
  638. GetInsideRect(rc);
  639. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  640. max = pbf->GetItemCount();
  641. for (t = iFirstItem; t < max; t++)
  642. {
  643. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(t);
  644. CRect itemRc;
  645. if (!IsSmallIconView()) 
  646. {
  647. GetIconRect(iSelFolder, t, itemRc);
  648. if (itemRc.PtInRect(point))
  649. {
  650. index = t;
  651. return htItem;
  652. }
  653. else if (itemRc.top > rc.bottom) break;
  654. GetLabelRect(iSelFolder, t, itemRc);
  655. itemRc.top -= yLargeIconLabelOffset;
  657. if (itemRc.PtInRect(point))
  658. {
  659. index = t;
  660. return htItem;
  661. }
  662. else if (itemRc.top > rc.bottom) break;
  663. }
  664. else
  665. {
  666. GetItemRect(iSelFolder, t, itemRc);
  667. if (itemRc.PtInRect(point))
  668. {
  669. index = t;
  670. return htItem;
  671. }
  672. else if (itemRc.top > rc.bottom) break;
  673. }
  674. }
  675. return htNothing;
  676. }
  678. void CGfxOutBarCtrl::HighlightFolder(const int index)
  679. {
  680. CWnd * pf = GetFocus();
  681. if (pf != NULL && pf != this && IsChild(pf)) return;
  683. if (iLastFolderHighlighted == index) return;
  685. if (iLastFolderHighlighted >= 0)
  686. {
  687. CRect rc;
  688. if (GetFolderRect(iLastFolderHighlighted, rc))
  689. {
  690. CClientDC dc(this);
  691. CPen pn(PS_SOLID, 1, crBackGroundColor1);//crShadowBorder);
  692. CPen * op = dc.SelectObject(&pn);
  693. dc.MoveTo(rc.left, rc.bottom-1);
  694. dc.LineTo(rc.right-1, rc.bottom-1);
  695. dc.LineTo(rc.right-1, rc.top);
  696. CPen pn1(PS_SOLID, 1, cr3dFace);
  697. dc.SelectObject(&pn1);
  698. dc.MoveTo(rc.left+1, rc.bottom-2);
  699. dc.LineTo(rc.right-2, rc.bottom-2);
  700. dc.LineTo(rc.right-2, rc.top+1);
  701. dc.SelectObject(op);
  702. }
  703. }
  704. iLastFolderHighlighted = index;
  705. if (iLastFolderHighlighted >= 0)
  706. {
  707. CRect rc;
  708. if (GetFolderRect(iLastFolderHighlighted, rc))
  709. {
  710. CClientDC dc(this);
  711. CPen pn(PS_SOLID, 1, crDkShadowBorder);
  712. CPen * op = dc.SelectObject(&pn);
  713. dc.MoveTo(rc.left, rc.bottom-1);
  714. dc.LineTo(rc.right-1, rc.bottom-1);
  715. dc.LineTo(rc.right-1, rc.top);
  716. CPen pn1(PS_SOLID, 1, crBackGroundColor1);
  717. dc.SelectObject(&pn1);
  718. dc.MoveTo(rc.left+1, rc.bottom-2);
  719. dc.LineTo(rc.right-2, rc.bottom-2);
  720. dc.LineTo(rc.right-2, rc.top+1);
  721. dc.SelectObject(op);
  722. }
  723. }
  724. }
  726. void CGfxOutBarCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  727. {
  728. if (GetFocus() != this) SetFocus();
  730. int index, ht = HitTestEx(point, index);
  731. iLastDragItemDrawType = -1;
  733. CRect inRc;
  734. GetInsideRect(inRc);
  736. if (ht == htFolder)
  737. {
  738. bool bHigh = true;
  739. CRect rc;
  740. GetFolderRect(index, rc);
  742. if (::GetCapture() == NULL)
  743. {
  744. SetCapture();
  745. ASSERT(this == GetCapture());
  746. CClientDC dc(this);
  747. DrawFolder(&dc, index, rc, true);
  748. AfxLockTempMaps();
  749. for (;;)
  750. {
  751. MSG msg;
  752. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  754. if (CWnd::GetCapture() != this) break;
  756. switch (msg.message)
  757. {
  758. case WM_MOUSEMOVE:
  759. {
  760. CPoint pt(msg.lParam);
  761. int idx, ht1 = HitTestEx(pt, idx);
  762. if (ht1 == htFolder && idx == index)
  763. {
  764. if (!bHigh)
  765. {
  766. DrawFolder(&dc, index, rc, true);
  767. bHigh = true;
  768. }
  769. }
  770. else
  771. {
  772. if (bHigh)
  773. {
  774. DrawFolder(&dc, index, rc, false);
  775. bHigh = false;
  776. }
  777. }
  778. }
  779. break;
  781. case WM_LBUTTONUP:
  782. {
  783. if (bHigh)
  784. {
  785. DrawFolder(&dc, index, rc, false);
  786. bHigh = false;
  787. }
  788. CPoint pt(msg.lParam);
  789. int idx, ht1 = HitTestEx(pt, idx);
  790. if (ht1 == htFolder && idx != iSelFolder)
  791. SetSelFolder(idx);
  792. }
  794. goto ExitLoop2;
  796. case WM_KEYDOWN:
  797. if (msg.wParam != VK_ESCAPE) 
  798. break;
  800. default:
  801. DispatchMessage(&msg);
  802. break;
  803. }
  804. }
  806. ExitLoop2:
  807. ReleaseCapture();
  808. AfxUnlockTempMaps(FALSE);
  809. }
  810. if (bHigh) InvalidateRect(rc, false);
  811. }
  812. else iLastSelectedFolder = -1;
  814. if (ht == htItem)
  815. {
  816. iLastDragItemDraw = -1;
  817. bool bHigh = true, bDragging = false;
  818. CRect rc;
  819. GetItemRect(iSelFolder, index, rc);
  821. HCURSOR hCur = GetCursor();
  823. if (::GetCapture() == NULL)
  824. {
  825. SetCapture();
  826. ASSERT(this == GetCapture());
  827. CClientDC dc(this);
  828. HighlightItem(index, true);
  829. AfxLockTempMaps();
  830. for (;;)
  831. {
  832. MSG msg;
  833. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  835. if (CWnd::GetCapture() != this) break;
  837. switch (msg.message)
  838. {
  839. case WM_MOUSEMOVE:
  840. {
  841. CPoint pt(msg.lParam);
  842. int idx, ht1 = HitTestEx(pt, idx);
  843. if (bDragging)
  844. {
  845. if (ht1 == htItem) 
  846. {
  847. DrawDragArrow(&dc, index, idx);
  848. SetCursor(hDragCursor);
  849. hCur = hDragCursor;
  850. }
  851. else 
  852. {
  853. CRect rcItem;
  854. GetItemRect(iSelFolder, GetItemCount() - 1, rcItem);
  855. if (pt.y > rcItem.bottom && pt.y < inRc.bottom)
  856. {
  857. DrawDragArrow(&dc, index, GetItemCount());
  858. SetCursor(hDragCursor);
  859. hCur = hDragCursor;
  860. }
  861. else
  862. {
  863. DrawDragArrow(&dc, index, -1);
  864. SetCursor(hNoDragCursor);
  865. hCur = hNoDragCursor;
  866. }
  867. }
  868. }
  869. else
  870. {
  871. if (ht1 == htItem && idx == index)
  872. {
  873. if (!bHigh)
  874. {
  875. HighlightItem(index, true);
  876. bHigh = true;
  877. bPressedHighlight = true;
  878. }
  879. }
  880. else 
  881. {
  882. if (ht1 == htItem)
  883. {
  884. if (bHigh)
  885. {
  886. HighlightItem(index, false);
  887. bHigh = false;
  888. bPressedHighlight = false;
  889. }
  890. }
  891. else
  892. {
  893. if (dwFlags&fDragItems)
  894. {
  895. HighlightItem(index, true);
  896. bHigh = true;
  897. bDragging = true;
  899. SetCursor(hDragCursor);
  900. hCur = hDragCursor;
  902. bPressedHighlight = true;
  903. }
  904. }
  905. }
  906. }
  907. }
  908. break;
  910. case WM_SETCURSOR:
  911. SetCursor(hCur);
  912. break;
  914. case WM_LBUTTONUP:
  915. {
  916. MSG msg1;
  917. VERIFY(::GetMessage(&msg1,NULL,0,0));
  918. if(GetCapture()==this&&(msg1.message==WM_LBUTTONDBLCLK||msg1.message==WM_LBUTTONDOWN))
  919. {
  920. KillTimer(4);
  921. GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_ITEMDCLICK, 0);
  922. }
  923. else
  924. {
  925. if (bHigh)
  926. {
  927. HighlightItem(-1);
  928. bHigh = false;
  929. }
  930. CPoint pt(msg.lParam);
  931. int idx, ht1 = HitTestEx(pt, idx);
  932. if (!bDragging)
  933. {
  934. if (ht1 == htItem && idx == index) 
  935. {
  936. if (iSelAnimTiming > 0 && index != iLastSel && iLastSel >= 0)
  937. {
  938. DrawAnimItem(0, 0, iLastSel);
  939. }
  941. if (dwFlags&fSelHighlight && iLastSel >= 0)
  942. {
  943. CRect rc;
  944. GetIconRect(iSelFolder, iLastSel, rc);
  945. rc.InflateRect(1,1);
  946. InvalidateRect(rc);
  947. }
  949. iLastSel = index;
  951. if (dwFlags&fSelHighlight && iLastSel >= 0)
  952. {
  953. CRect rc;
  954. GetIconRect(iSelFolder, iLastSel, rc);
  955. rc.InflateRect(1,1);
  956. InvalidateRect(rc);
  957. }
  958. SetTimer(4,200,NULL);
  959. }
  960. }
  961. else
  962. {
  963. if (ht1 == htItem)
  964. {
  965. if (idx != index)
  966. {
  967. OUTBAR_INFO ob;
  968. ob.iDragFrom = iSelFolder;
  969. ob.iDragTo = index;
  970. if (GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_DRAGITEM, (LPARAM) &ob))
  971. {
  972. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  973. CBarItem * piFrom = (CBarItem *) pbf->arItems.GetAt(index);
  974. pbf->arItems.RemoveAt(index);
  975. if (idx > index) idx --;
  976. pbf->arItems.InsertAt(idx, piFrom);
  977. }
  978. }
  979. }
  980. else
  981. {
  982. CRect rcItem;
  983. GetItemRect(iSelFolder, GetItemCount() - 1, rcItem);
  984. if (pt.y > rcItem.bottom && pt.y < inRc.bottom)
  985. {
  986. OUTBAR_INFO ob;
  987. ob.iDragFrom = iSelFolder;
  988. ob.iDragTo = index;
  989. if (GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_OB_DRAGITEM, (LPARAM) &ob))
  990. {
  991. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  992. CBarItem * piFrom = (CBarItem *) pbf->arItems.GetAt(index);
  993. pbf->arItems.RemoveAt(index);
  994. pbf->arItems.Add((void *) piFrom);
  995. }
  996. }
  997. }
  998. }
  999. ::DispatchMessage(&msg1);
  1000. }
  1001. }
  1003. goto ExitLoop4;
  1005. default:
  1006. DispatchMessage(&msg);
  1007. break;
  1008. }
  1009. }
  1011. ExitLoop4:
  1012. ReleaseCapture();
  1013. AfxUnlockTempMaps(FALSE);
  1014. if (bDragging) 
  1015. {
  1016. Invalidate();
  1017. }
  1018. }
  1019. bPressedHighlight = false;
  1020. if (bHigh) InvalidateRect(rc, false);
  1021. }
  1022. else iLastItemHighlighted = -1;
  1024. if (ht == htDownScroll)
  1025. {
  1026. bLooping = true;
  1027. bool bHigh = true;
  1029. if (::GetCapture() == NULL)
  1030. {
  1031. SetCapture();
  1032. ASSERT(this == GetCapture());
  1033. CClientDC dc(this);
  1034. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN|DFCS_PUSHED);
  1035. SetTimer(2,300,NULL);
  1036. AfxLockTempMaps();
  1037. for (;;)
  1038. {
  1039. MSG msg;
  1040. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1042. if (CWnd::GetCapture() != this) break;
  1044. switch (msg.message)
  1045. {
  1046. case WM_MOUSEMOVE:
  1047. {
  1048. CPoint pt(msg.lParam);
  1049. if (rcDownArrow.PtInRect(pt))
  1050. {
  1051. if (bHigh == false)
  1052. {
  1053. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN|DFCS_PUSHED);
  1054. bHigh = true;
  1055. bDownArrow = true;
  1056. bDownPressed = true;
  1057. }
  1058. }
  1059. else
  1060. {
  1061. if (bHigh == true)
  1062. {
  1063. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  1064. bHigh = false;
  1065. bDownArrow = false;
  1066. bDownPressed = false;
  1067. }
  1068. }
  1069. }
  1070. break;
  1072. case WM_LBUTTONUP:
  1073. {
  1074. if (bHigh)
  1075. {
  1076. dc.DrawFrameControl(rcDownArrow, DFC_SCROLL, DFCS_SCROLLDOWN);
  1077. bHigh = false;
  1078. }
  1079. bDownArrow = false;
  1080. CPoint pt(msg.lParam);
  1081. if (rcDownArrow.PtInRect(pt))
  1082. {
  1083. CRect itrc;
  1084. GetItemRect(iSelFolder, GetItemCount() - 1, itrc);
  1085. CRect crc;
  1086. GetInsideRect(crc);
  1087. if (itrc.bottom > crc.bottom)
  1088. {
  1089. iFirstItem ++;
  1090. InvalidateRect(crc, true);
  1091. }
  1092. }
  1093. }
  1094. goto ExitLoop3;
  1097. case WM_TIMER:
  1098. {
  1099. if (msg.wParam == 2)
  1100. {
  1101. if (bHigh)
  1102. {
  1103. CPoint pt(msg.pt);
  1104. ScreenToClient(&pt);
  1105. if (rcDownArrow.PtInRect(pt))
  1106. {
  1107. bDownPressed = true;
  1108. CRect itrc;
  1109. GetItemRect(iSelFolder, GetItemCount() - 1, itrc);
  1110. CRect crc;
  1111. GetInsideRect(crc);
  1112. if (itrc.bottom > crc.bottom)
  1113. {
  1114. iFirstItem ++;
  1115. InvalidateRect(crc, true);
  1116. }
  1117. else goto ExitLoop3;
  1118. }
  1119. else bDownPressed = false;
  1120. }
  1121. }
  1122. break;
  1123. }
  1125. case WM_KEYDOWN:
  1126. if (msg.wParam != VK_ESCAPE) 
  1127. break;
  1129. default:
  1130. DispatchMessage(&msg);
  1131. break;
  1132. }
  1133. }
  1135. ExitLoop3:
  1136. KillTimer(2);
  1137. ReleaseCapture();
  1138. AfxUnlockTempMaps(FALSE);
  1139. bLooping = false;
  1140. bDownPressed = false;
  1141. bDownArrow = false;
  1142. CRect crc;
  1143. GetInsideRect(crc);
  1144. InvalidateRect(crc, true);
  1145. }
  1146. }
  1148. if (ht == htUpScroll)
  1149. {
  1150. bLooping = true;
  1151. bool bHigh = true;
  1153. if (::GetCapture() == NULL)
  1154. {
  1155. SetCapture();
  1156. ASSERT(this == GetCapture());
  1157. CClientDC dc(this);
  1158. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP|DFCS_PUSHED);
  1159. SetTimer(2,300,NULL);
  1160. AfxLockTempMaps();
  1161. for (;;)
  1162. {
  1163. MSG msg;
  1164. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1166. if (CWnd::GetCapture() != this) break;
  1168. switch (msg.message)
  1169. {
  1170. case WM_MOUSEMOVE:
  1171. {
  1172. CPoint pt(msg.lParam);
  1173. if (rcUpArrow.PtInRect(pt))
  1174. {
  1175. if (bHigh == false)
  1176. {
  1177. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP|DFCS_PUSHED);
  1178. bHigh = true;
  1179. bUpArrow = true;
  1180. bUpPressed = true;
  1181. }
  1182. }
  1183. else
  1184. {
  1185. if (bHigh == true)
  1186. {
  1187. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  1188. bHigh = false;
  1189. bUpArrow = false;
  1190. bUpPressed = false;
  1191. }
  1192. }
  1193. }
  1194. break;
  1196. case WM_LBUTTONUP:
  1197. {
  1198. if (bHigh)
  1199. {
  1200. dc.DrawFrameControl(rcUpArrow, DFC_SCROLL, DFCS_SCROLLUP);
  1201. bHigh = false;
  1202. }
  1203. bUpArrow = false;
  1204. CPoint pt(msg.lParam);
  1205. if (rcUpArrow.PtInRect(pt))
  1206. {
  1207. if (iFirstItem > 0 ) 
  1208. {
  1209. iFirstItem --;
  1210. CRect crc;
  1211. GetInsideRect(crc);
  1212. InvalidateRect(crc, true);
  1213. }
  1214. }
  1215. }
  1217. goto ExitLoop;
  1219. case WM_TIMER:
  1220. {
  1221. if (msg.wParam == 2)
  1222. {
  1223. if (bHigh)
  1224. {
  1225. CPoint pt(msg.pt);
  1226. ScreenToClient(&pt);
  1227. if (rcUpArrow.PtInRect(pt))
  1228. {
  1229. bUpPressed = true;
  1230. if (iFirstItem > 0) 
  1231. {
  1232. iFirstItem --;
  1233. CRect crc;
  1234. GetInsideRect(crc);
  1235. InvalidateRect(crc, true);
  1236. }
  1237. else goto ExitLoop;
  1238. }
  1239. else bUpPressed = false;
  1240. }
  1241. }
  1242. break;
  1243. }
  1244. case WM_KEYDOWN:
  1245. if (msg.wParam != VK_ESCAPE) break;
  1247. default:
  1248. DispatchMessage(&msg);
  1249. break;
  1250. }
  1251. }
  1253. ExitLoop:
  1254. KillTimer(2);
  1255. ReleaseCapture();
  1256. AfxUnlockTempMaps(FALSE);
  1257. bLooping = false;
  1258. bUpPressed = false;
  1259. bUpArrow = false;
  1260. CRect crc;
  1261. GetInsideRect(crc);
  1262. InvalidateRect(crc, true);
  1263. }
  1264. }
  1266. CWnd::OnLButtonDown(nFlags, point);
  1267. }
  1270. int CGfxOutBarCtrl::InsertItem(const int folder, const int index, const char * text, const int image, const DWORD exData)
  1271. {
  1272. ASSERT(folder >= 0 && folder < GetFolderCount());
  1273. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(folder);
  1274. return pbf->InsertItem(index, text, image, exData);
  1275. }
  1277. int CGfxOutBarCtrl::GetItemCount() const
  1278. {
  1279. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1280. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1281. return  pbf->GetItemCount();
  1282. }
  1284. void CGfxOutBarCtrl::SetSelFolder(const int index)
  1285. {
  1286. ASSERT(index >= 0 && index < GetFolderCount());
  1287. // if (index == iSelFolder) return;
  1289. CWnd * pc = GetFolderChild();
  1290. if (pc) pc->ShowWindow(SW_HIDE);
  1292. if (index != iSelFolder)
  1293. {
  1294. if (dwFlags&fAnimation && lAnimationTickCount >= 0) AnimateFolderScroll(iSelFolder, index);
  1295. }
  1297. iSelFolder = index;
  1298. iFirstItem = 0;
  1299. iLastSel = -1;
  1301. pc = GetFolderChild();
  1302. if (pc)
  1303. {
  1304. CRect rc;
  1305. GetInsideRect(rc);
  1306. pc->MoveWindow(rc);
  1307. pc->ShowWindow(SW_SHOW);
  1308. }
  1310. GetOwner()->SendMessage(WM_OUTBAR_NOTIFY, NM_FOLDERCHANGE, (LPARAM) iSelFolder);
  1312. Invalidate();
  1313. }
  1315. int CGfxOutBarCtrl::GetFolderCount() const
  1316. {
  1317. return arFolder.GetSize();
  1318. }
  1320. int CGfxOutBarCtrl::GetSelFolder() const
  1321. {
  1322. return iSelFolder;
  1323. }
  1325. void CGfxOutBarCtrl::RemoveFolder(const int index)
  1326. {
  1327. ASSERT(index >= 0 && index < GetFolderCount());
  1328. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(index);
  1329. delete pbf;
  1330. arFolder.RemoveAt(index);
  1331. if (iSelFolder >= index) iSelFolder = index - 1;
  1332. if (iSelFolder < 0 && GetFolderCount() > 0) iSelFolder = 0;
  1333. Invalidate();
  1334. }
  1336. int CGfxOutBarCtrl::CBarFolder::InsertItem(int index, const char * text, const int image, const DWORD exData)
  1337. {
  1338. if (index < 0 || index > GetItemCount()) index = GetItemCount();
  1340. CBarItem * pbf = new CBarItem(text, image*2+1, exData);
  1341. ASSERT(pbf);
  1342. if (index < GetItemCount()) 
  1343. arItems.InsertAt(index, (void *) pbf);
  1344. else 
  1345. arItems.Add((void *) pbf);
  1347. return index;
  1348. }
  1350. int CGfxOutBarCtrl::GetCountPerPage() const
  1351. {
  1352. return 0;
  1353. }
  1355. CImageList * CGfxOutBarCtrl::SetImageList(CImageList * pImageList, int nImageList)
  1356. {
  1357. CImageList * o = NULL;
  1358. if (nImageList == fSmallIcon)
  1359. {
  1360. o = pSmallImageList;
  1361. pSmallImageList = pImageList;
  1362. }
  1363. else if (nImageList == fLargeIcon)
  1364. {
  1365. o = pLargeImageList;
  1366. pLargeImageList = pImageList;
  1367. }
  1368. return o;
  1369. }
  1371. CImageList * CGfxOutBarCtrl::GetImageList(CImageList * pImageList, int nImageList)
  1372. {
  1373. if (nImageList == fSmallIcon) return pSmallImageList;
  1374. else if (nImageList == fLargeIcon) return pLargeImageList;
  1375. return NULL;
  1376. }
  1378. CImageList * CGfxOutBarCtrl::SetFolderImageList(const int folder, CImageList * pImageList, int nImageList)
  1379. {
  1380. ASSERT(folder >= 0 && folder < GetFolderCount());
  1381. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(folder);
  1382. CImageList * o = NULL;
  1383. if (nImageList == fSmallIcon)
  1384. {
  1385. o = pbf->pSmallImageList;
  1386. pbf->pSmallImageList = pImageList;
  1387. }
  1388. else if (nImageList == fLargeIcon)
  1389. {
  1390. o = pbf->pLargeImageList;
  1391. pbf->pLargeImageList = pImageList;
  1392. }
  1393. return o;
  1394. }
  1397. CGfxOutBarCtrl::CBarItem::CBarItem(const char * name, const int image, DWORD exData)
  1398. {
  1399. cItem = NULL;
  1400. iImageIndex = image;
  1401. dwData = exData;
  1402. if (name)
  1403. {
  1404. cItem = new char[lstrlen(name)+1];
  1405. ASSERT(cItem);
  1406. lstrcpy(cItem, name);
  1407. }
  1408. }
  1410. CGfxOutBarCtrl::CBarItem::~CBarItem()
  1411. {
  1412. if (cItem) delete [] cItem;
  1413. }
  1415. int CGfxOutBarCtrl::CBarFolder::GetItemCount()
  1416. {
  1417. return arItems.GetSize();
  1418. }
  1420. void CGfxOutBarCtrl::PaintItems(CDC * pDC, const int iFolder, CRect rc)
  1421. {
  1422. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1423. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  1424. int max = pbf->GetItemCount(), t;
  1425. CRect irc;
  1426. GetInsideRect(irc);
  1427. int isdc = pDC->SaveDC();
  1428. CRgn itemRegion;
  1429. itemRegion.CreateRectRgnIndirect(&irc);
  1430. pDC->SelectClipRgn(&itemRegion);
  1431. itemRegion.DeleteObject();
  1432. for (t = iFirstItem; t < max; t++)
  1433. {
  1434. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(t);
  1435. CRect itemRc;
  1436. GetItemRect(iFolder, t, itemRc);
  1437. if (itemRc.top > rc.bottom) break;
  1438. else DrawItem(pDC, iFolder, itemRc, t);
  1439. }
  1440. pDC->RestoreDC(isdc);
  1441. }
  1444. CSize CGfxOutBarCtrl::GetItemSize(const int iFolder, const int index, const int type)
  1445. {
  1446. ASSERT(iFolder >= 0 && iFolder < GetFolderCount());
  1447. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  1449. ASSERT(index >= 0 && index < pbf->GetItemCount());
  1450. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  1452. CSize szImage(0,0);
  1453. CSize szLabel(0,0);
  1454. CSize szAll(0,0);
  1456. if (pi->iImageIndex >= 0)
  1457. {
  1458. if (type != ircLabel)
  1459. {
  1460. CImageList * il = GetFolderImageList(iFolder, IsSmallIconView());
  1461. ASSERT(il);
  1462. if (il)
  1463. {
  1464. IMAGEINFO ii;
  1465. il->GetImageInfo(pi->iImageIndex, &ii);
  1466. szImage = CRect(ii.rcImage).Size();
  1467. }
  1468. }
  1469. }
  1470. if (pi->cItem)
  1471. {
  1472. if (type != ircIcon)
  1473. {
  1474. CClientDC dc(this);
  1475. CFont * oft = (CFont *) dc.SelectObject(CFont::FromHandle((HFONT)GetStockObject(DEFAULT_GUI_FONT)));
  1476. if (IsSmallIconView())
  1477. {
  1478. szLabel = dc.GetTextExtent(pi->cItem, lstrlen(pi->cItem));
  1479. }
  1480. else
  1481. {
  1482. CRect rc;
  1483. GetInsideRect(rc);
  1484. rc.bottom = rc.top;
  1485. dc.DrawText(pi->cItem, lstrlen(pi->cItem), rc, DT_CALCRECT|DT_CENTER|DT_WORDBREAK);
  1486. szLabel = rc.Size();
  1487. }
  1488. dc.SelectObject(oft);
  1489. }
  1490. }
  1491. if (IsSmallIconView())
  1492. {
  1493. if (type == ircIcon) szAll = szImage;
  1494. else if (type == ircLabel) szAll = szLabel;
  1495. else if (type == ircAll) szAll = CSize(szImage.cx + szLabel.cx + xSmallIconLabelOffset, szImage.cy > szLabel.cy ? szImage.cy : szLabel.cy);
  1496. }
  1497. else
  1498. {
  1499. if (type == ircIcon) szAll = szImage;
  1500. else if (type == ircLabel) szAll = szLabel;
  1501. else if (type == ircAll) 
  1502. {
  1503. szAll = CSize(szImage.cx > szLabel.cx ? szImage.cx : szLabel.cx, szLabel.cy + szImage.cy + yLargeIconLabelOffset + yLargeIconSpacing);
  1504. }
  1505. }
  1506. return szAll;
  1507. }
  1509. CImageList * CGfxOutBarCtrl::GetFolderImageList(const int index, const bool bSmall) const
  1510. {
  1511. ASSERT(index >= 0 && index < GetFolderCount());
  1512. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(index);
  1513. if (bSmall)
  1514. {
  1515. if (pbf->pSmallImageList) return pbf->pSmallImageList; else return pSmallImageList;
  1516. }
  1517. if (pbf->pLargeImageList) return pbf->pLargeImageList; else 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. {
  1920. BOOL enable=TRUE;
  1921. if(iHitInternal1==htFolder&&iHitInternal2<3)
  1922. enable=FALSE;
  1923. pCmdUI->Enable(enable);
  1924. }
  1926. void CGfxOutBarCtrl::OnGfxRenameitem() 
  1927. {
  1928. if (iHitInternal1 == htFolder)
  1929. {
  1930. StartGroupEdit(iHitInternal2);
  1931. }
  1932. else if (iHitInternal1 == htItem)
  1933. {
  1934. StartItemEdit(iHitInternal2);
  1935. }
  1936. }
  1938. void CGfxOutBarCtrl::OnUpdateGfxRenameitem(CCmdUI* pCmdUI) 
  1939. {
  1940. BOOL enable=TRUE;
  1941. if(iHitInternal1==htFolder&&iHitInternal2<3)
  1942. enable=FALSE;
  1943. pCmdUI->Enable(enable);
  1944. }
  1946. void CGfxOutBarCtrl::RemoveItem(const int index)
  1947. {
  1948. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1949. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1950. ASSERT(index >= 0 && index < pbf->GetItemCount());
  1951. if (IsValidItem(index))
  1952. {
  1953. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1954. delete i;
  1956. pbf->arItems.RemoveAt(index);
  1957. CRect rc;
  1958. GetInsideRect(rc);
  1959. InvalidateRect(rc);
  1960. }
  1961. }
  1963. bool CGfxOutBarCtrl::IsValidItem(const int index) const
  1964. {
  1965. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1966. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1967. return (index >= 0 && index < pbf->GetItemCount());
  1968. }
  1970. DWORD CGfxOutBarCtrl::GetItemData(const int index) const
  1971. {
  1972. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1973. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1974. if (IsValidItem(index))
  1975. {
  1976. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1977. return i->dwData;
  1978. }
  1979. return 0;
  1980. }
  1982. int CGfxOutBarCtrl::GetItemImage(const int index) const
  1983. {
  1984. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1985. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1986. if (IsValidItem(index))
  1987. {
  1988. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  1989. return i->iImageIndex;
  1990. }
  1991. return 0;
  1992. }
  1994. void CGfxOutBarCtrl::SetItemData(const int index, const DWORD dwData)
  1995. {
  1996. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  1997. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  1998. if (IsValidItem(index))
  1999. {
  2000. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  2001. i->dwData = dwData;
  2002. }
  2003. }
  2005. void CGfxOutBarCtrl::SetItemImage(const int index, const int iImage)
  2006. {
  2007. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  2008. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  2009. if (IsValidItem(index))
  2010. {
  2011. CBarItem * i = (CBarItem *) pbf->arItems.GetAt(index);
  2012. i->iImageIndex = iImage;
  2013. }
  2014. }
  2016. void CGfxOutBarCtrl::DrawDragArrow(CDC * pDC, const int iFrom, const int iTo)
  2017. {
  2018. if (iTo == iLastDragItemDraw) return;
  2019. CRect rc1;
  2020. if (iLastDragItemDraw >= 0)
  2021. {
  2022. GetDragItemRect(iLastDragItemDraw, rc1);
  2023. if (iLastDragItemDrawType == 0) rc1.bottom = rc1.top + 5;
  2024. else if (iLastDragItemDrawType == 1) { rc1.top -= 4; rc1.bottom = rc1.top + 9; }
  2025. else if (iLastDragItemDrawType == 2) { rc1.top -= 4; rc1.bottom = rc1.top + 5; }
  2026. InvalidateRect(rc1, true);
  2027. UpdateWindow();
  2028. }
  2029. iLastDragItemDraw = iTo;
  2031. if (iLastDragItemDraw >= 0)
  2032. {
  2033. iLastDragItemDrawType = GetDragItemRect(iLastDragItemDraw, rc1);
  2035. CPen * op = pDC->SelectObject(pBlackPen);
  2037. pDC->MoveTo(rc1.left, rc1.top);
  2038. pDC->LineTo(rc1.right, rc1.top);
  2040. if (iLastDragItemDrawType != 2)
  2041. {
  2042. pDC->MoveTo(rc1.left, rc1.top+1);
  2043. pDC->LineTo(rc1.left + 7, rc1.top+1);
  2044. pDC->MoveTo(rc1.left, rc1.top+2);
  2045. pDC->LineTo(rc1.left + 5, rc1.top+2);
  2046. pDC->MoveTo(rc1.left, rc1.top+3);
  2047. pDC->LineTo(rc1.left + 3, rc1.top+3);
  2048. pDC->MoveTo(rc1.left, rc1.top+4);
  2049. pDC->LineTo(rc1.left + 1, rc1.top+4);
  2051. pDC->MoveTo(rc1.right-1, rc1.top+1);
  2052. pDC->LineTo(rc1.right - 7, rc1.top+1);
  2053. pDC->MoveTo(rc1.right-1, rc1.top+2);
  2054. pDC->LineTo(rc1.right - 5, rc1.top+2);
  2055. pDC->MoveTo(rc1.right-1, rc1.top+3);
  2056. pDC->LineTo(rc1.right - 3, rc1.top+3);
  2057. }
  2058. if (iLastDragItemDrawType != 0)
  2059. {
  2060. pDC->MoveTo(rc1.left, rc1.top-1);
  2061. pDC->LineTo(rc1.left + 7, rc1.top-1);
  2062. pDC->MoveTo(rc1.left, rc1.top-2);
  2063. pDC->LineTo(rc1.left + 5, rc1.top-2);
  2064. pDC->MoveTo(rc1.left, rc1.top-3);
  2065. pDC->LineTo(rc1.left + 3, rc1.top-3);
  2066. pDC->MoveTo(rc1.left, rc1.top-4);
  2067. pDC->LineTo(rc1.left + 1, rc1.top-4);
  2069. pDC->MoveTo(rc1.right-1, rc1.top-1);
  2070. pDC->LineTo(rc1.right - 7, rc1.top-1);
  2071. pDC->MoveTo(rc1.right-1, rc1.top-2);
  2072. pDC->LineTo(rc1.right - 5, rc1.top-2);
  2073. pDC->MoveTo(rc1.right-1, rc1.top-3);
  2074. pDC->LineTo(rc1.right - 3, rc1.top-3);
  2075. pDC->MoveTo(rc1.right-1, rc1.top-4);
  2076. pDC->LineTo(rc1.right - 1, rc1.top-4);
  2077. }
  2079. pDC->SelectObject(op);
  2080. }
  2081. }
  2083. int CGfxOutBarCtrl::GetDragItemRect(const int index, CRect & rect)
  2084. {
  2085. CRect rc, crc;
  2086. GetInsideRect(crc);
  2087. crc.InflateRect(-2, 0);
  2089. GetItemRect(iSelFolder, index < GetItemCount() ? index : index - 1, rc);
  2090. int line = 0;
  2091. if (index < GetItemCount())
  2092. {
  2093. line = rc.top - 4;
  2094. }
  2095. else
  2096. {
  2097. line = rc.bottom + 6;
  2098. }
  2099. int tpe;
  2100. if (index == 0)
  2101. {
  2102. rect.SetRect(crc.left, line+2, crc.right, line + 7);
  2103. tpe = 0;
  2104. }
  2105. else if (index < GetItemCount())
  2106. {
  2107. rect.SetRect(crc.left, line - 9, crc.right, line);
  2108. tpe = 1;
  2109. if (IsSmallIconView()) 
  2110. {
  2111. rect.top += 8;
  2112. rect.bottom += 8;
  2113. }
  2114. }
  2115. else
  2116. {
  2117. rect.SetRect(crc.left, line, crc.right, line + 5);
  2118. tpe = 2;
  2119. }
  2120. return tpe;
  2121. }
  2124. void CGfxOutBarCtrl::AnimateFolderScroll(const int iFrom, const int iTo)
  2125. {
  2126. ASSERT(iFrom >= 0 && iFrom < GetFolderCount());
  2127. ASSERT(iTo >= 0 && iTo < GetFolderCount());
  2129. CRect rc, rc1, frc, frc1;
  2130. GetInsideRect(rc);
  2131. rc1.SetRect(0,0,rc.Width(),rc.Height());
  2132. GetFolderRect(iTo, frc);
  2133. frc1 = frc;
  2135. CClientDC dc(this);
  2136. CDC memDC;
  2137. memDC.CreateCompatibleDC(&dc);
  2138. CBitmap bmpFrom, bmpTo;
  2139. bmpFrom.CreateCompatibleBitmap(&dc, rc1.Width(), rc1.Height() + frc.Height() * 2);
  2140. bmpTo.CreateCompatibleBitmap(&dc, rc1.Width(), rc1.Height() + frc.Height() * 2);
  2141. CDC * pDC = &memDC;
  2143. CWnd * pWnd1 = GetFolderChild(iFrom);
  2144. CWnd * pWnd2 = GetFolderChild(iTo);
  2147. CBitmap * obmp = pDC->SelectObject(&bmpFrom);
  2148. if (iTo > iFrom)
  2149. {
  2150. rc1.bottom += frc.Height() * 2;
  2151. pDC->FillSolidRect(rc1, crBackGroundColor);
  2152. if (pWnd1) 
  2153. {
  2154. BOOL bPrev = pWnd1->ShowWindow(SW_SHOW);
  2155. pWnd1->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2156. pWnd1->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2157. if (!bPrev) pWnd1->ShowWindow(SW_HIDE);
  2158. }
  2159. else PaintItems(pDC, iFrom, rc1);
  2161. pDC->SelectObject(&bmpTo);
  2162. frc.SetRect(0,0,frc.Width(),frc.Height());
  2163. rc1.SetRect(0,frc.Height(),rc.Width(), rc.Height()+frc.Height() * 2);
  2164. pDC->FillSolidRect(rc1, crBackGroundColor);
  2166. if (pWnd2) 
  2167. {
  2168. CPoint ovpt = pDC->SetViewportOrg(0, frc.Height());
  2169. BOOL bPrev = pWnd2->ShowWindow(SW_SHOW);
  2170. pWnd2->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2171. pWnd2->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2172. if (!bPrev) pWnd2->ShowWindow(SW_HIDE);
  2173. pDC->SetViewportOrg(ovpt);
  2174. }
  2175. else PaintItems(pDC, iTo, rc1);
  2176. DrawFolder(pDC, iTo, frc, false);
  2177. }
  2178. else
  2179. {
  2180. frc.SetRect(0,0,frc.Width(),frc.Height());
  2181. rc1.top += frc.Height();
  2182. rc1.bottom += frc.Height() * 2;
  2183. pDC->FillSolidRect(rc1, crBackGroundColor);
  2184. if (pWnd1) 
  2185. {
  2186. CPoint ovpt = pDC->SetViewportOrg(0, frc.Height());
  2187. BOOL bPrev = pWnd1->ShowWindow(SW_SHOW);
  2188. pWnd1->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2189. pWnd1->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2190. if (!bPrev) pWnd1->ShowWindow(SW_HIDE);
  2191. pDC->SetViewportOrg(ovpt);
  2192. }
  2193. else PaintItems(pDC, iFrom, rc1);
  2195. DrawFolder(pDC, iFrom, frc, false);
  2197. pDC->SelectObject(&bmpTo);
  2198. rc1.SetRect(0,0,rc.Width(), rc.Height() + frc.Height() * 2);
  2199. pDC->FillSolidRect(rc1, crBackGroundColor);
  2201. if (pWnd2) 
  2202. {
  2203. BOOL bPrev = pWnd2->ShowWindow(SW_SHOW);
  2204. pWnd2->SendMessage(WM_ERASEBKGND, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2205. pWnd2->SendMessage(WM_PAINT, (WPARAM) pDC->GetSafeHdc(), (LPARAM) 0);
  2206. if (!bPrev) pWnd2->ShowWindow(SW_HIDE);
  2207. }
  2208. else PaintItems(pDC, iTo, rc1);
  2209. }
  2211. if (iTo > iFrom)
  2212. {
  2213. CRect rcFrom, rcTo;
  2214. GetFolderRect(iFrom, rcFrom);
  2215. GetFolderRect(iTo, rcTo);
  2216. int fh = rcFrom.Height();
  2217. for (int y = rcTo.top - fh; y > rcFrom.bottom; y -= fh)
  2218. {
  2219. pDC->SelectObject(&bmpFrom);
  2220. dc.BitBlt(rc.left, rcFrom.bottom + 1, rc.Width(), y - rcFrom.bottom - 1, pDC, 0,fh, SRCCOPY);
  2221. pDC->SelectObject(&bmpTo);
  2222. dc.BitBlt(rc.left, y, rc.Width(), rc.bottom - y + fh, pDC, 0,0, SRCCOPY);
  2223. Sleep(lAnimationTickCount);
  2224. }
  2225. }
  2226. else
  2227. {
  2228. CRect rcFrom, rcTo;
  2229. GetFolderRect(iFrom, rcFrom);
  2230. int fh = rcFrom.Height();
  2231. rcTo.SetRect(rc.left, rc.bottom, rc.right, rc.bottom - fh);
  2232. for (int y = rcFrom.top + 1; y < rcTo.top - fh; y += fh)
  2233. {
  2234. pDC->SelectObject(&bmpTo);
  2235. dc.BitBlt(rc.left, rcFrom.top, rc.Width(), y - rcFrom.top - 1, pDC, 0, fh*2, SRCCOPY);
  2236. pDC->SelectObject(&bmpFrom);
  2237. dc.BitBlt(rc.left, y, rc.Width(), rc.bottom - y, pDC, 0,0, SRCCOPY);
  2238. Sleep(lAnimationTickCount);
  2239. }
  2240. }
  2242. pDC->SelectObject(obmp);
  2243. }
  2248. CString CGfxOutBarCtrl::GetItemText(const int index)
  2249. {
  2250. CString item;
  2252. ASSERT(iSelFolder >= 0 && iSelFolder < GetFolderCount());
  2253. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iSelFolder);
  2254. if (IsValidItem(index))
  2255. {
  2256. CBarItem * pi = (CBarItem *) pbf->arItems.GetAt(index);
  2257. if (pi->cItem) item = pi->cItem;
  2258. }
  2259. return item;
  2260. }
  2262. int CGfxOutBarCtrl::AddFolderBar(const char * pFolder, CWnd * pSon, const DWORD exData)
  2263. {
  2264. CBarFolder * pbf = new CBarFolder(pFolder, exData);
  2265. ASSERT(pbf);
  2266. pbf->pChild = pSon;
  2268. arFolder.Add((void *)pbf);
  2270. return arFolder.GetSize() - 1;
  2271. }
  2273. CWnd * CGfxOutBarCtrl::GetFolderChild(int iFolder)
  2274. {
  2275. if (GetFolderCount())
  2276. {
  2277. if (iFolder < 0) iFolder = iSelFolder;
  2279. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  2280. return pbf->pChild;
  2281. }
  2282. return NULL;
  2283. }
  2285. DWORD CGfxOutBarCtrl::GetFolderData(int iFolder)
  2286. {
  2287. if (iFolder < 0) iFolder = iSelFolder;
  2288. CBarFolder * pbf = (CBarFolder *) arFolder.GetAt(iFolder);
  2289. return pbf->dwData;
  2290. }
  2292. void CGfxOutBarCtrl::SetAnimSelHighlight(const int iTime)
  2293. {
  2294. if (iTime <= 0) KillTimer(3);
  2295. else SetTimer(3, iTime, NULL);
  2296. iSelAnimTiming = iTime;
  2297. }
  2299. void CGfxOutBarCtrl::OnGfxGroupicon() 
  2300. {
  2301. int index=GetFolderCount();
  2302. AddFolder("",index);
  2303. Invalidate();
  2304. StartGroupEdit(index);
  2305. }
  2307. void CGfxOutBarCtrl::OnGfxBackcicon() 
  2308. {
  2309. CColorDialog dlg;
  2310. if(dlg.DoModal()==IDCANCEL)return;
  2311. crBackGroundColor=dlg.GetColor();
  2312. Invalidate();
  2313. }
  2315. void CGfxOutBarCtrl::OnGfxFontcicon() 
  2316. {
  2317. CColorDialog dlg;
  2318. if(dlg.DoModal()==IDCANCEL)return;
  2319. crTextColor=dlg.GetColor();
  2320. Invalidate();
  2321. }
  2323. BOOL CGfxOutBarCtrl::CBarFolder::MoveToHead(int index)
  2324. {
  2325. if(index==0)return TRUE;
  2326. if(index>=GetItemCount())return FALSE;
  2327. void * pbf=arItems.GetAt(index);
  2328. arItems.RemoveAt(index);
  2329. arItems.InsertAt(0,pbf);
  2330. return TRUE;
  2331. }
  2333. BOOL CGfxOutBarCtrl::CBarFolder::MoveToTail(int index)
  2334. {
  2335. if(index==GetItemCount()-1)return TRUE;
  2336. if(index>=GetItemCount()||index<0)return FALSE;
  2337. void * pbf=arItems.GetAt(index);
  2338. arItems.RemoveAt(index);
  2339. arItems.Add(pbf);
  2340. return TRUE;
  2341. }
  2343. BOOL CGfxOutBarCtrl::MoveToHead(int folder,int index)
  2344. {
  2345. if(folder<0||folder>=GetFolderCount())return FALSE;
  2346. CBarFolder * pbf=(CBarFolder*)arFolder.GetAt(folder);
  2347. return pbf->MoveToHead(index);
  2348. }
  2350. BOOL CGfxOutBarCtrl::MoveToTail(int folder,int index)
  2351. {
  2352. if(folder<0||folder>=GetFolderCount())return FALSE;
  2353. CBarFolder* pbf=(CBarFolder*)arFolder.GetAt(folder);
  2354. return pbf->MoveToTail(index);
  2355. }
  2357. BOOL CGfxOutBarCtrl::ModifyItem(DWORD dwID, int image,LPCTSTR lpszText)
  2358. {
  2359. if(image<0&&lpszText==NULL)return FALSE;
  2360. for(int i=0;i<arFolder.GetSize();i++)
  2361. {
  2362. CBarFolder* pbf=(CBarFolder*)arFolder.GetAt(i);
  2363. if(pbf->ModifyItem(dwID,image,lpszText)) return TRUE;
  2364. }
  2365. return FALSE;
  2366. }
  2368. BOOL CGfxOutBarCtrl::CBarFolder::ModifyItem(DWORD dwID, int image, LPCTSTR lpszText)
  2369. {
  2370. for(int i=0;i<arItems.GetSize();i++)
  2371. {
  2372. CBarItem* pItem=(CBarItem*)arItems.GetAt(i);
  2373. if(pItem->dwData==dwID)
  2374. {
  2375. if(image>=0)
  2376. {
  2377. if(pItem->iImageIndex%2)
  2378. pItem->iImageIndex=image*2+1;
  2379. else
  2380. pItem->iImageIndex=image*2;
  2381. }
  2382. if(lpszText!=NULL)
  2383. {
  2384. if(pItem->cItem!=NULL)
  2385. {
  2386. delete [] pItem->cItem;
  2387. }
  2388. pItem->cItem=new char[lstrlen(lpszText)+1];
  2389. lstrcpy(pItem->cItem,lpszText);
  2390. }
  2391. return TRUE;
  2392. }
  2393. }
  2394. return FALSE;
  2395. }
  2397. BOOL CGfxOutBarCtrl::SetOnlineImage(DWORD dwID, BOOL bTrue)
  2398. {
  2399. for(int i=0;i<arFolder.GetSize();i++)
  2400. {
  2401. CBarFolder* pbf=(CBarFolder*)arFolder.GetAt(i);
  2402. if(pbf->SetOnlineImage(dwID,bTrue)) return TRUE;
  2403. }
  2404. return FALSE;
  2405. }
  2407. BOOL CGfxOutBarCtrl::CBarFolder::SetOnlineImage(DWORD dwID, BOOL bTrue)
  2408. {
  2409. for(int i=0;i<arItems.GetSize();i++)
  2410. {
  2411. CBarItem* pItem=(CBarItem*)arItems.GetAt(i);
  2412. if(pItem->dwData==dwID)
  2413. {
  2414. if(pItem->iImageIndex%2&&bTrue)
  2415. {
  2416. pItem->iImageIndex--;
  2417. MoveToHead(i);
  2418. return TRUE;
  2419. }
  2420. if(pItem->iImageIndex%2==0&&!bTrue)
  2421. {
  2422. pItem->iImageIndex++;
  2423. MoveToTail(i);
  2424. return TRUE;
  2425. }
  2426. }
  2427. }
  2428. return FALSE;
  2429. }
  2431. int CGfxOutBarCtrl::AddItem(int folder, LPCTSTR lpszText, int image, DWORD exData)
  2432. {
  2433. ASSERT(folder>=0&&folder<arFolder.GetSize());
  2435. CBarFolder* pbf=(CBarFolder*)arFolder.GetAt(folder);
  2436. ASSERT(pbf!=NULL);
  2437. return pbf->AddItem(lpszText,image,exData);
  2438. }
  2440. int CGfxOutBarCtrl::CBarFolder::AddItem(LPCTSTR lpszText, int image, DWORD exData)
  2441. {
  2442. CBarItem * pbf = new CBarItem(lpszText, image*2+1, exData);
  2443. ASSERT(pbf);
  2444. return arItems.Add((void *) pbf);
  2445. }
  2447. void CGfxOutBarCtrl::Serialize(CArchive& ar) 
  2448. {
  2449. if (ar.IsStoring())
  2450. {
  2452. }
  2453. else
  2454. { // loading code
  2455. }
  2456. }
  2458. void CGfxOutBarCtrl::SetOfflineState()
  2459. {
  2460. for(int i=0;i<arFolder.GetSize();i++)
  2461. {
  2462. CBarFolder * pbf=(CBarFolder*)arFolder.GetAt(i);
  2463. pbf->SetOfflineState();
  2464. }
  2465. Invalidate();
  2466. }
  2468. void CGfxOutBarCtrl::CBarFolder::SetOfflineState()
  2469. {
  2470. for(int i=0;i<arItems.GetSize();i++)
  2471. {
  2472. CBarItem* pItem=(CBarItem*)arItems.GetAt(i);
  2473. if(pItem->iImageIndex%2==0)pItem->iImageIndex++;
  2474. else break;
  2475. }
  2476. }
  2478. BOOL CGfxOutBarCtrl::RemoveAItem(int folder, DWORD dwID,BOOL bRefresh)
  2479. {
  2480. CBarFolder * pbf =(CBarFolder*)arFolder.GetAt(folder);
  2481. ASSERT(pbf);
  2482. if(pbf==NULL)return FALSE;
  2484. BOOL bSuccess=FALSE;
  2485. for(int i=0;i<pbf->arItems.GetSize();i++)
  2486. {
  2487. CBarItem* pItem=(CBarItem*)pbf->arItems.GetAt(i);
  2488. if(pItem->dwData==dwID)
  2489. {
  2490. pbf->arItems.RemoveAt(i);
  2491. bSuccess=TRUE;
  2492. break;
  2493. }
  2494. }
  2495. if(bRefresh)Invalidate();
  2496. return bSuccess;
  2497. }