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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > ActiveX/DCOM/ATL > 查看源码
TreeCtrlMultiColumn.cpp
资源名称：XFloorWndDemo.zip　[点击查看]
上传用户：louyoung
上传日期：2007-01-02
资源大小：123k
文件大小：17k
源码类别：

ActiveX/DCOM/ATL

开发平台：

Visual C++

TreeCtrlMultiColumn.cpp：源码内容
  1. /************************************
  2.   REVISION LOG ENTRY
  3.   Revision By: Mihai Filimon
  4.   Revised on 6/13/98 11:58:20 AM
  5.   Comments: TreeCtrlMultiColumn.cpp: implementation of the CTreeMultiColumnCtrl class.
  6.  ************************************/
  8. #include "stdafx.h"
  9. #include "TreeCtrlMultiColumn.h"
  10. #include "tfilltree.h"
  12. #define IDLIST 0x1111
  13. #define dxNode 20
  14. #define dxSquareNode 9
  15. #define rgbLine RGB(128,128,128)
  16. #define rgbExpand RGB(0,0,0)
  17. #define PS_DOT 2
  19. //////////////////////////////////////////////////////////////////////
  20. // Construction/Destruction
  21. //////////////////////////////////////////////////////////////////////
  22. BEGIN_MESSAGE_MAP(CTreeMultiColumnCtrl, CTsyslistviewex)
  23. //{{AFX_MSG_MAP(CTreeMultiColumnCtrl)
  24. ON_WM_LBUTTONDOWN()
  25. ON_WM_KEYDOWN()
  26. //}}AFX_MSG_MAP
  27. END_MESSAGE_MAP()
  29. _STTreeMCCloneMessage CTreeMultiColumnCtrl::m_mapCloneMessage;
  31. // Function name : CTreeMultiColumnCtrl::CTreeMultiColumnCtrl
  32. // Description     : Constructor
  33. // Return type : 
  34. CTreeMultiColumnCtrl::CTreeMultiColumnCtrl(int nHeightRel):CTsyslistviewex(nHeightRel)
  35. {
  36. m_bInsideCode = 0;
  37. m_nTreeColumn = 0;
  38. m_nLastItemFind = -1;
  39. m_nLastItemFound = -1;
  40. }
  42. // Function name : CTreeMultiColumnCtrl::~CTreeMultiColumnCtrl
  43. // Description     : virtual Destructor
  44. // Return type : 
  45. CTreeMultiColumnCtrl::~CTreeMultiColumnCtrl()
  46. {
  47. }
  49. // Function name : CTreeMultiColumnCtrl::SetRootColumn
  50. // Description     : Set the new tree column.
  51. // Return type : int 
  52. // Argument         : int nNewTreeColumn
  53. int CTreeMultiColumnCtrl::SetRootColumn(int nNewTreeColumn)
  54. {
  55. ASSERT (nNewTreeColumn < GetCountColumn());
  56. ASSERT (nNewTreeColumn >= 0);
  57. int nOldTreeColumn = m_nTreeColumn;
  58. m_nTreeColumn = nNewTreeColumn;
  59. Invalidate();
  60. return nOldTreeColumn;
  61. }
  63. // Function name : CTreeMultiColumnCtrl::GetRootColumn
  64. // Description     : Return the current tree column
  65. // Return type : int 
  66. int CTreeMultiColumnCtrl::GetRootColumn() const
  67. {
  68. return m_nTreeColumn;
  69. }
  71. // Function name : CTreeMultiColumnCtrl::DrawCell
  72. // Description     : Draw a cell of tree control
  73. // Return type : void 
  74. // Argument         : CDC* pDC
  75. // Argument         : CRect& drawRect
  76. // Argument         : DWORD format
  77. // Argument         : int nItem
  78. // Argument         : int nColumn
  79. void CTreeMultiColumnCtrl::DrawCell(CDC* pDC, CRect& drawRect, DWORD format, int nItem, int nColumn)
  80. {
  81. m_bInsideCode++;
  82. if (nColumn == m_nTreeColumn)
  83. {
  84. CRect clipRect(drawRect);
  85. clipRect.top -= 2;
  86. clipRect.bottom += 2;
  87. CRgn clipRgn; clipRgn.CreateRectRgnIndirect(clipRect);
  88. pDC->SelectClipRgn(&clipRgn);
  90. int i = GetItemData(nItem);
  91. CArray<int,int> arPathParents;
  92. int level = GetItemPath(i, arPathParents);
  93. int x = drawRect.left;
  94. int yTop = drawRect.top;
  95. int yBottom = drawRect.bottom;
  96. CPoint middle(dxNode / 2, drawRect.Height() / 2);
  97. int psStyle = PS_SOLID;
  98. CPen penGray( psStyle, 1, rgbLine);
  99. CPen penBlack(PS_SOLID, 1, rgbExpand);
  100. CPen* pOldPen = (CPen*)pDC->SelectObject(penGray);
  101. int j = 0;
  102. for (j = 0; j < level; j++, x += dxNode)
  103. if (!IsLastChildren(arPathParents[j]))
  104. {
  105. pDC->MoveTo(x + middle.x, yTop - 1);
  106. pDC->LineTo(x + middle.x, yBottom + 1);
  107. }
  109. int yM1 = (yBottom + yTop) / 2;
  110. int yM2 = yM1;
  111. int xM1 = x + middle.x;
  112. int xM2 = xM1;
  113. if (ItemHasChildren(i))
  114. {
  115. SIZE size = {dxSquareNode, dxSquareNode};
  116. POINT point = {xM1 -  size.cx / 2, yM1 - size.cy / 2};
  117. pDC->FrameRect(CRect(point,size), &CBrush(rgbLine));
  118. xM1 -= size.cx / 2;
  119. xM2 += size.cx / 2;
  121. pDC->SelectObject(penBlack);
  122. pDC->MoveTo(xM1 + 2, yM1);
  123. pDC->LineTo(xM2 - 1, yM1);
  125. yM1 -= size.cy / 2;
  126. yM2 += size.cy / 2;
  128. if (!ItemIsExpanded(i))
  129. {
  130. pDC->MoveTo(x + middle.x, yM1 + 2);
  131. pDC->LineTo(x + middle.x, yM2 - 1);
  132. }
  133. pDC->SelectObject(penGray);
  134. }
  135. if (i != 0)
  136. {
  137. pDC->MoveTo(x + middle.x, yTop - 1);
  138. pDC->LineTo(x + middle.x, yM1);
  139. }
  140. if (!IsLastChildren(i))
  141. {
  142. pDC->MoveTo(x + middle.x, yM2);
  143. pDC->LineTo(x + middle.x, yBottom + 1);
  144. }
  145. pDC->MoveTo(xM2, (yBottom + yTop) / 2);
  146. pDC->LineTo(x + dxNode, (yBottom + yTop) / 2);
  148. x += dxNode;
  149. drawRect.left = x + 2;
  151. pDC->SelectClipRgn(NULL);
  152. }
  153. CTsyslistviewex::DrawCell(pDC, drawRect, format, nItem, nColumn);
  154. m_bInsideCode--;
  155. }
  157. // Function name : CTreeMultiColumnCtrl::PreSubclassWindow
  158. // Description     : When control is subclassed, object try to construct a clone of this list object
  159. // Return type : void 
  160. void CTreeMultiColumnCtrl::PreSubclassWindow( )
  161. {
  162. CTsyslistviewex::PreSubclassWindow();
  163. ModifyStyle(LVS_SORTASCENDING,0);
  164. ModifyStyle(LVS_SORTDESCENDING,0);
  165. m_listItems.Create(WS_CHILD, CRect(0,0,0,0), this, IDLIST);
  166. }
  168. // Function name : CTreeMultiColumnCtrl::WindowProc
  169. // Description     : Treat messages separatly if variable m_bInsideCode is zero
  170. // Return type : LRESULT 
  171. // Argument         :  UINT message
  172. // Argument         : WPARAM wParam
  173. // Argument         : LPARAM lParam
  174. LRESULT CTreeMultiColumnCtrl::WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  175. {
  176. LRESULT result = NULL;
  177. if (m_bInsideCode == 0)
  178. if (m_mapCloneMessage.IsCloneMessage(message))
  179. {
  180. result = m_listItems.SendMessage(message, wParam, lParam);
  181. UpdateTree(message, wParam, lParam, result);
  182. return result;
  183. }
  185. if (m_bInsideCode == 0)
  186. if (m_mapCloneMessage.IsHeaderMessage(message))
  187. if (m_listItems.GetSafeHwnd())
  188. m_listItems.SendMessage(message, wParam, lParam);
  190. result = CTsyslistviewex::WindowProc(message, wParam, lParam );
  192. return result;
  193. }
  196. // Function name : CTreeMultiColumnCtrl::SetItemParent
  197. // Description     : Set the new parent of iItem to iItemParent
  198. // Return type : BOOL 
  199. // Argument         : int iItem
  200. // Argument         : int iItemParent
  201. BOOL CTreeMultiColumnCtrl::SetItemParent(int iItem, int iItemParent)
  202. {
  203. UpdateTree(LVM_SETPARENT, iItem, iItemParent, 0);
  204. return TRUE;
  205. }
  207. // Function name : CTreeMultiColumnCtrl::GetItemParent
  208. // Description     : Return -1 if iItem do not have parent
  209. // Return type : int 
  210. int CTreeMultiColumnCtrl::GetItemParent(int iItem)
  211. {
  212. int value = -1;
  213. if (m_mapParents.Lookup(iItem, value))
  214. return value;
  215. return -1;
  216. }
  218. // Function name : CTreeMultiColumnCtrl::ItemHasChildren
  219. // Description     : Return TRUE if item iItem has at least one children
  220. // Return type : BOOL 
  221. // Argument         : int iItem
  222. BOOL CTreeMultiColumnCtrl::ItemHasChildren(int iItem)
  223. {
  224. int key = -1;
  225. int value = -1;
  226. POSITION position = m_mapParents.GetStartPosition();
  227. while (position)
  228. {
  229. m_mapParents.GetNextAssoc(position, key, value);
  230. if (value == iItem)
  231. return TRUE;
  232. }
  233. return FALSE;
  234. }
  236. // Function name : CTreeMultiColumnCtrl::GetPath
  237. // Description     : Insert parents of iItem in arParents.
  238. // Return type : int 
  239. // Argument         : int iItem
  240. // Argument         : CArray<int,int>&
  241. // Argument         :  arParents
  242. int CTreeMultiColumnCtrl::GetItemPath(int iItem, CArray<int, int>& arParents)
  243. {
  244. arParents.RemoveAll();
  245. int i = iItem;
  246. while ((i = GetItemParent(i))>=0)
  247. arParents.InsertAt(0, i);
  248. return arParents.GetSize();
  249. }
  251. // Function name : CTreeMultiColumnCtrl::IsLastChildren
  252. // Description     : Check if iItem is last children
  253. // Return type : BOOL 
  254. // Argument         : int iItem
  255. BOOL CTreeMultiColumnCtrl::IsLastChildren(int iItem)
  256. {
  257. int iParent = GetItemParent(iItem);
  258. int cItem = m_listItems.GetItemCount();
  259. int i = iItem + 1;
  260. while (i < cItem)
  261. {
  262. if (GetItemParent(i) == iParent)
  263. return FALSE;
  264. i++;
  265. }
  266. return TRUE;
  267. }
  269. // Function name : CTreeMultiColumnCtrl::ItemIsExpanded
  270. // Description     : Return TRUE if Item is Expanded, FALSE if iItem is collapsed
  271. // Return type : BOOL 
  272. // Argument         : int iItem
  273. BOOL CTreeMultiColumnCtrl::ItemIsExpanded(int iItem)
  274. {
  275. BOOL value = FALSE;
  276. if (m_mapItemExpanded.Lookup(iItem, value))
  277. return value;
  278. return FALSE;
  279. }
  281. // Function name : CTreeMultiColumnCtrl::UpdateTree
  282. // Description     : Update the tree control function by message receive by object
  283. // Return type : void 
  284. // Argument         : UINT message
  285. // Argument         : WPARAM wParam
  286. // Argument         : LPARAM lParam
  287. // Argument         : LRESULT result
  288. void CTreeMultiColumnCtrl::UpdateTree(UINT message, WPARAM wParam, LPARAM lParam, LRESULT result)
  289. {
  290. m_bInsideCode++; // Do not process WindowProc...
  291. switch (message)
  292. {
  293. // Set new parent
  294. case LVM_DELETEALLITEMS:
  295. {
  296. m_listItems.DeleteAllItems();
  297. DeleteAllItems();
  298. m_mapItemExpanded.RemoveAll();
  299. m_mapParents.RemoveAll();
  300. break;
  301. }
  302. case LVM_SETPARENT:
  303. {
  304. int iItem = (int)wParam;
  305. int iItemParent = (int)lParam;
  306. int iItemOldParent = GetItemParent(iItem);
  307. LV_FINDINFO fInfo; fInfo.flags = LVFI_PARAM; fInfo.lParam = iItem;
  308. int i = FindItem(&fInfo);
  309. while ( (i < GetItemCount())  && ((int)GetItemParent(GetItemData(i)) == iItemOldParent) )
  310. {
  311. DeleteItem(i);
  312. if (iItemOldParent < 0)
  313. break;
  314. }
  315. m_mapItemExpanded.RemoveKey(iItem);
  316. if (ItemIsExpanded(iItemParent))
  317. {
  318. fInfo.flags = LVFI_PARAM;
  319. fInfo.lParam = iItemParent;
  320. i = FindItem(&fInfo);
  321. int newI = InsertItem(i < 0 ? GetItemCount() : i + 1, m_listItems.GetItemText(iItem,0));
  322. SetItemData(newI, iItem);
  323. for (int t = 1; t < GetCountColumn(); t++)
  324. SetItemText(newI, t, m_listItems.GetItemText(iItem,t));
  325. }
  326. m_mapParents[iItem] = iItemParent;
  327. if (CWnd* pParent = GetParent())
  328. pParent->SendMessage(LVM_SETPARENT, iItem, iItemParent);
  329. Invalidate();
  330. break;
  331. }
  332. // Insert item
  333. case LVM_INSERTITEMA:
  334. case LVM_INSERTITEMW:
  335. {
  336. int niItem = InsertItem(GetItemCount(),((const LV_ITEM FAR *)lParam)->pszText);
  337. SetItemData(niItem,result);
  338. break;
  339. }
  340. // Set the item text
  341. case LVM_SETITEMA:
  342. case LVM_SETITEMW:
  343. case LVM_SETITEMTEXTA:
  344. case LVM_SETITEMTEXTW:
  345. {
  346. const LV_ITEM FAR * pItem = (const LV_ITEM FAR *)lParam;
  347. LV_FINDINFO fInfo; fInfo.flags = LVFI_PARAM; fInfo.lParam = pItem->iItem;
  348. int sItem = FindItem(&fInfo);
  349. if (sItem >= 0)
  350. SetItemText(sItem, pItem->iSubItem, pItem->pszText);
  351. break;
  352. }
  353. }
  354. m_bInsideCode--;
  355. }
  357. // Function name : CTreeMultiColumnCtrl::ExpandItem
  358. // Description     : Expand nItem if this has childrens
  359. // Return type : void 
  360. // Argument         : int nItem
  361. void CTreeMultiColumnCtrl::ExpandItem(int nItem)
  362. {
  363. m_bInsideCode++;
  364. ASSERT (nItem >= 0);
  365. ASSERT (nItem < m_listItems.GetItemCount());
  366. if (ItemHasChildren(nItem))
  367. if (!ItemIsExpanded(nItem))
  368. {
  369. LV_FINDINFO fInfo; fInfo.flags = LVFI_PARAM; fInfo.lParam = nItem;
  370. int iEnd = FindItem(&fInfo);
  371. if (iEnd >= 0)
  372. {
  373. m_mapItemExpanded[nItem] = TRUE;
  374. int iStart = iEnd;
  375. int iChild = GetFirstItemChild(nItem);
  376. while (iChild >= 0)
  377. {
  378. int newI = InsertItem(++iEnd,m_listItems.GetItemText(iChild,0));
  379. for (int t = 1; t < GetCountColumn(); t++)
  380. SetItemText(newI, t, m_listItems.GetItemText(iChild,t));
  381. SetItemData(newI, iChild);
  382. iChild = GetNextItemChild();
  383. }
  384. RedrawItems(iStart,iStart);
  385. if (CWnd* pParent = GetParent())
  386. pParent->SendMessage(LVM_EXPAND, nItem, 0);
  388. }
  389. }
  390. m_bInsideCode--;
  391. }
  393. // Function name : CTreeMultiColumnCtrl::RecExpandItems
  394. // Description     : Expand all childs of nItem recursively
  395. // Return type : void 
  396. // Argument         : int nItem
  397. void CTreeMultiColumnCtrl::RecExpandItems(int nItem)
  398. {
  399. ExpandItem(nItem);
  400. int iChild = GetFirstItemChild(nItem);
  401. CArray<int,int> arChilds;
  402. while (iChild >= 0)
  403. {
  404. arChilds.Add(iChild);
  405. iChild = GetNextItemChild();
  406. };
  407. for (int k = 0; k < arChilds.GetSize(); k++)
  408. RecExpandItems(arChilds[k]);
  409. }
  411. // Function name : CTreeMultiColumnCtrl::CollapseItem
  412. // Description     : Close item nItem if that has childrens
  413. // Return type : void 
  414. // Argument         : int nItem
  415. void CTreeMultiColumnCtrl::CollapseItem(int nItem)
  416. {
  417. m_bInsideCode++;
  418. ASSERT (nItem >= 0);
  419. ASSERT (nItem < m_listItems.GetItemCount());
  420. if (ItemHasChildren(nItem))
  421. if (ItemIsExpanded(nItem))
  422. {
  423. m_mapItemExpanded.RemoveKey(nItem);
  424. LV_FINDINFO fInfo; fInfo.flags = LVFI_PARAM; fInfo.lParam = nItem;
  425. int iEnd = FindItem(&fInfo);
  426. if (iEnd >=0)
  427. {
  428. int iStart = iEnd;
  429. iEnd++;
  430. while (iEnd < GetItemCount())
  431. {
  432. CArray<int,int> arPathParents;
  433. int nTrueItem = GetItemData(iEnd);
  434. int level = GetItemPath(nTrueItem, arPathParents);
  435. if (level)
  436. {
  437. level--;
  438. while ((level>=0) && (arPathParents[level] != nItem)) level--;
  439. if ( level>=0 )
  440. {
  441. m_mapItemExpanded.RemoveKey(nTrueItem);
  442. DeleteItem(iEnd);
  443. }
  444. else
  445. break;
  446. }
  447. else break;
  448. }
  449. RedrawItems(iStart,iStart);
  450. if (CWnd* pParent = GetParent())
  451. pParent->SendMessage(LVM_COLLAPSE, nItem, 0);
  452. }
  453. }
  454. m_bInsideCode--;
  455. }
  457. // Function name : CTreeMultiColumnCtrl::GetFirstItemChild
  458. // Description     : Return the index of first item child of nItem
  459. // Return type : int 
  460. // Argument         : int nItem
  461. int CTreeMultiColumnCtrl::GetFirstItemChild(int nItem)
  462. {
  463. m_nLastItemFind = -1;
  464. m_nLastItemFound = nItem;
  465. return GetNextItemChild();
  466. }
  468. // Function name : CTreeMultiColumnCtrl::GetNextItemChild
  469. // Description     : Return the index of next item child of nItem
  470. // Return type : int 
  471. int CTreeMultiColumnCtrl::GetNextItemChild()
  472. {
  473. m_nLastItemFind++;
  474. while ((m_nLastItemFind < m_listItems.GetItemCount()) && (GetItemParent(m_nLastItemFind) != m_nLastItemFound))
  475. m_nLastItemFind++;
  476. if (m_nLastItemFind < m_listItems.GetItemCount())
  477. return m_nLastItemFind;
  478. return -1;
  479. }
  481. // Function name : CTreeMultiColumnCtrl::GetItemLevel
  482. // Description     : Return the level of item nItem
  483. // Return type : int 
  484. // Argument         : int nItem
  485. int CTreeMultiColumnCtrl::GetItemLevel(int nItem)
  486. {
  487. int i = nItem;
  488. int result = 0;
  489. while ((i = GetItemParent(i))>=0) result++;
  490. return result;
  491. }
  493. // Function name : CTreeMultiColumnCtrl::IsPtnInSquareRect
  494. // Description     : Return true if item from point has childrens, and point is in 
  495. // square node.
  496. // Return type : BOOL 
  497. // Argument         : CPoint point
  498. BOOL CTreeMultiColumnCtrl::IsPtnInSquareRect(CPoint point)
  499. {
  500. int subItem = -1;
  501. int nItem = HitTestEx(point, subItem);
  502. CRect rect;
  503. if (subItem == m_nTreeColumn)
  504. {
  505. int nTrueItem = GetItemData(nItem);
  506. if (ItemHasChildren(nTrueItem))
  507. if (GetSubItemRect(nItem, subItem, rect))
  508. {
  509. CRect rectSquare(CPoint(rect.left + GetItemLevel(nTrueItem) * dxNode + (dxNode - dxSquareNode) / 2, (rect.top + rect.bottom)/2 - dxSquareNode/2), CSize(dxSquareNode,dxSquareNode));
  510. return rectSquare.PtInRect(point + CPoint(-2,0));
  511. }
  512. }
  513. return FALSE;
  514. }
  516. // Function name : CTreeMultiColumnCtrl::OnLButtonDown
  517. // Description     : If user press the left button of mouse...
  518. // Return type : void 
  519. // Argument         : UINT nFlags
  520. // Argument         : CPoint point
  521. void CTreeMultiColumnCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  522. {
  523. int subItem = -1;
  524. int nItem = HitTestEx(point, subItem);
  525. if ((nItem >= 0) && (IsPtnInSquareRect(point)))
  526. {
  527. int nTrueItem = GetItemData(nItem);
  528. if (ItemHasChildren(nTrueItem))
  529. if (!ItemIsExpanded(nTrueItem))
  530. ExpandItem(nTrueItem);
  531. else
  532. CollapseItem(nTrueItem);
  533. }
  535. CTsyslistviewex::OnLButtonDown(nFlags, point);
  536. }
  538. // Function name : CTreeMultiColumnCtrl::OnKeyDown
  539. // Description     : If user press the one of following keys...
  540. // Return type : void 
  541. // Argument         : UINT nChar
  542. // Argument         : UINT nRepCnt
  543. // Argument         : UINT nFlags
  544. void CTreeMultiColumnCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  545. {
  546. m_bInsideCode++;
  547. int iSelected = -1;
  548. while ((iSelected = GetNextItem(iSelected, LVNI_SELECTED))>=0)
  549. {
  550. int nTrueItem = GetItemData(iSelected);
  551. switch (nChar)
  552. {
  553. case VK_ADD:
  554. case VK_RIGHT:
  555. {
  556. ExpandItem(nTrueItem);
  557. break;
  558. }
  559. case VK_SUBTRACT:
  560. case VK_LEFT:
  561. {
  562. CollapseItem(nTrueItem);
  563. break;
  564. }
  565. case VK_MULTIPLY:
  566. {
  567. RecExpandItems(nTrueItem);
  568. break;
  569. }
  570. }
  571. iSelected++;
  572. }
  573. m_bInsideCode--;
  574. if ((nChar != VK_RIGHT) && (nChar != VK_LEFT))
  575. CTsyslistviewex::OnKeyDown(nChar, nRepCnt, nFlags);
  576. }
  578. // Function name : CTreeMultiColumnCtrl::Fill
  579. // Description     : Fill the tree control with items from lpszItems. See tfilltree.h, tfilltree.cpp
  580. // Return type : void 
  581. // Argument         : LPCTSTR lpszItems
  582. void CTreeMultiColumnCtrl::Fill(LPCTSTR lpszItems)
  583. {
  584. STFillTreeMultiColumn s(this, lpszItems);
  585. s.Fill();
  586. }