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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > TreeView控件 > 查看源码
TreeCtrlMultiColumn.cpp
资源名称：MultColumnTreeListControl.zip　[点击查看]
上传用户：maicowu
上传日期：2007-01-02
资源大小：87k
文件大小：18k
源码类别：

TreeView控件

开发平台：

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::GetPath
  219. // Description     : Insert parents of iItem in arParents.
  220. // Return type : int 
  221. // Argument         : int iItem
  222. // Argument         : CArray<int,int>&
  223. // Argument         :  arParents
  224. int CTreeMultiColumnCtrl::GetItemPath(int iItem, CArray<int, int>& arParents)
  225. {
  226. arParents.RemoveAll();
  227. int i = iItem;
  228. while ((i = GetItemParent(i))>=0)
  229. arParents.InsertAt(0, i);
  230. return arParents.GetSize();
  231. }
  233. // Function name : CTreeMultiColumnCtrl::ItemIsExpanded
  234. // Description     : Return TRUE if Item is Expanded, FALSE if iItem is collapsed
  235. // Return type : BOOL 
  236. // Argument         : int iItem
  237. BOOL CTreeMultiColumnCtrl::ItemIsExpanded(int iItem)
  238. {
  239. BOOL value = FALSE;
  240. if (m_mapItemExpanded.Lookup(iItem, value))
  241. return value;
  242. return FALSE;
  243. }
  245. // Function name : CTreeMultiColumnCtrl::UpdateTree
  246. // Description     : Update the tree control function by message receive by object
  247. // Return type : void 
  248. // Argument         : UINT message
  249. // Argument         : WPARAM wParam
  250. // Argument         : LPARAM lParam
  251. // Argument         : LRESULT result
  252. void CTreeMultiColumnCtrl::UpdateTree(UINT message, WPARAM wParam, LPARAM lParam, LRESULT result)
  253. {
  254. m_bInsideCode++; // Do not process WindowProc...
  255. switch (message)
  256. {
  257. // Set new parent
  258. case LVM_DELETEALLITEMS:
  259. {
  260. m_listItems.DeleteAllItems();
  261. DeleteAllItems();
  262. m_mapItemExpanded.RemoveAll();
  263. m_mapParents.RemoveAll();
  264. break;
  265. }
  266. case LVM_SETPARENT:
  267. {
  268. int iItem = (int)wParam;
  269. int iItemParent = (int)lParam;
  270. int iItemOldParent = GetItemParent(iItem);
  271. LV_FINDINFO fInfo; fInfo.flags = LVFI_PARAM; fInfo.lParam = iItem;
  272. int i = FindItem(&fInfo);
  273. while ( (i < GetItemCount())  && ((int)GetItemParent(GetItemData(i)) == iItemOldParent) )
  274. {
  275. DeleteItem(i);
  276. if (iItemOldParent < 0)
  277. break;
  278. }
  279. m_mapItemExpanded.RemoveKey(iItem);
  280. if (ItemIsExpanded(iItemParent))
  281. {
  282. fInfo.flags = LVFI_PARAM;
  283. fInfo.lParam = iItemParent;
  284. i = FindItem(&fInfo);
  285. int newI = InsertItem(i < 0 ? GetItemCount() : i + 1, m_listItems.GetItemText(iItem,0));
  286. SetItemData(newI, iItem);
  287. for (int t = 1; t < GetCountColumn(); t++)
  288. SetItemText(newI, t, m_listItems.GetItemText(iItem,t));
  289. }
  290. m_mapParents[iItem] = iItemParent;
  291. if (CWnd* pParent = GetParent())
  292. pParent->SendMessage(LVM_SETPARENT, iItem, iItemParent);
  293. Invalidate();
  294. break;
  295. }
  296. // Insert item
  297. case LVM_INSERTITEMA:
  298. case LVM_INSERTITEMW:
  299. {
  300. int niItem = InsertItem(GetItemCount(),((const LV_ITEM FAR *)lParam)->pszText);
  301. SetItemData(niItem,result);
  302. break;
  303. }
  304. // Set the item text
  305. case LVM_SETITEMA:
  306. case LVM_SETITEMW:
  307. case LVM_SETITEMTEXTA:
  308. case LVM_SETITEMTEXTW:
  309. {
  310. const LV_ITEM FAR * pItem = (const LV_ITEM FAR *)lParam;
  311. LV_FINDINFO fInfo; fInfo.flags = LVFI_PARAM; fInfo.lParam = pItem->iItem;
  312. int sItem = FindItem(&fInfo);
  313. if (sItem >= 0)
  314. SetItemText(sItem, pItem->iSubItem, pItem->pszText);
  315. break;
  316. }
  317. }
  318. m_bInsideCode--;
  319. }
  321. // Function name : CTreeMultiColumnCtrl::ExpandItem
  322. // Description     : Expand nItem if this has childrens
  323. // Return type : void 
  324. // Argument         : int nItem
  325. void CTreeMultiColumnCtrl::ExpandItem(int nItem)
  326. {
  327. m_bInsideCode++;
  328. ASSERT (nItem >= 0);
  329. ASSERT (nItem < m_listItems.GetItemCount());
  330. if (ItemHasChildren(nItem))
  331. if (!ItemIsExpanded(nItem))
  332. {
  333. LV_FINDINFO fInfo; fInfo.flags = LVFI_PARAM; fInfo.lParam = nItem;
  334. int iEnd = FindItem(&fInfo);
  335. if (iEnd >= 0)
  336. {
  337. m_mapItemExpanded[nItem] = TRUE;
  338. int iStart = iEnd;
  339. int iChild = GetFirstItemChild(nItem);
  340. while (iChild >= 0)
  341. {
  342. int newI = InsertItem(++iEnd,m_listItems.GetItemText(iChild,0));
  343. for (int t = 1; t < GetCountColumn(); t++)
  344. SetItemText(newI, t, m_listItems.GetItemText(iChild,t));
  345. SetItemData(newI, iChild);
  346. iChild = GetNextItemChild();
  347. }
  348. RedrawItems(iStart,iStart);
  349. if (CWnd* pParent = GetParent())
  350. pParent->SendMessage(LVM_EXPAND, nItem, 0);
  352. }
  353. }
  354. m_bInsideCode--;
  355. }
  357. // Function name : CTreeMultiColumnCtrl::RecExpandItems
  358. // Description     : Expand all childs of nItem recursively
  359. // Return type : void 
  360. // Argument         : int nItem
  361. void CTreeMultiColumnCtrl::RecExpandItems(int nItem)
  362. {
  363. ExpandItem(nItem);
  364. int iChild = GetFirstItemChild(nItem);
  365. CArray<int,int> arChilds;
  366. while (iChild >= 0)
  367. {
  368. arChilds.Add(iChild);
  369. iChild = GetNextItemChild();
  370. };
  371. for (int k = 0; k < arChilds.GetSize(); k++)
  372. RecExpandItems(arChilds[k]);
  373. }
  375. // Function name : CTreeMultiColumnCtrl::CollapseItem
  376. // Description     : Close item nItem if that has childrens
  377. // Return type : void 
  378. // Argument         : int nItem
  379. void CTreeMultiColumnCtrl::CollapseItem(int nItem)
  380. {
  381. m_bInsideCode++;
  382. ASSERT (nItem >= 0);
  383. ASSERT (nItem < m_listItems.GetItemCount());
  384. if (ItemHasChildren(nItem))
  385. if (ItemIsExpanded(nItem))
  386. {
  387. m_mapItemExpanded.RemoveKey(nItem);
  388. LV_FINDINFO fInfo; fInfo.flags = LVFI_PARAM; fInfo.lParam = nItem;
  389. int iEnd = FindItem(&fInfo);
  390. if (iEnd >=0)
  391. {
  392. int iStart = iEnd;
  393. iEnd++;
  394. while (iEnd < GetItemCount())
  395. {
  396. CArray<int,int> arPathParents;
  397. int nTrueItem = GetItemData(iEnd);
  398. int level = GetItemPath(nTrueItem, arPathParents);
  399. if (level)
  400. {
  401. level--;
  402. while ((level>=0) && (arPathParents[level] != nItem)) level--;
  403. if ( level>=0 )
  404. {
  405. m_mapItemExpanded.RemoveKey(nTrueItem);
  406. DeleteItem(iEnd);
  407. }
  408. else
  409. break;
  410. }
  411. else break;
  412. }
  413. RedrawItems(iStart,iStart);
  414. if (CWnd* pParent = GetParent())
  415. pParent->SendMessage(LVM_COLLAPSE, nItem, 0);
  416. }
  417. }
  418. m_bInsideCode--;
  419. }
  421. // Function name : CTreeMultiColumnCtrl::GetItemLevel
  422. // Description     : Return the level of item nItem
  423. // Return type : int 
  424. // Argument         : int nItem
  425. int CTreeMultiColumnCtrl::GetItemLevel(int nItem)
  426. {
  427. int i = nItem;
  428. int result = 0;
  429. while ((i = GetItemParent(i))>=0) result++;
  430. return result;
  431. }
  433. // Function name : CTreeMultiColumnCtrl::IsPtnInSquareRect
  434. // Description     : Return true if item from point has childrens, and point is in 
  435. // square node.
  436. // Return type : BOOL 
  437. // Argument         : CPoint point
  438. BOOL CTreeMultiColumnCtrl::IsPtnInSquareRect(CPoint point)
  439. {
  440. int subItem = -1;
  441. int nItem = HitTestEx(point, subItem);
  442. CRect rect;
  443. if (subItem == m_nTreeColumn)
  444. {
  445. int nTrueItem = GetItemData(nItem);
  446. if (ItemHasChildren(nTrueItem))
  447. if (GetSubItemRect(nItem, subItem, rect))
  448. {
  449. CRect rectSquare(CPoint(rect.left + GetItemLevel(nTrueItem) * dxNode + (dxNode - dxSquareNode) / 2, (rect.top + rect.bottom)/2 - dxSquareNode/2), CSize(dxSquareNode,dxSquareNode));
  450. return rectSquare.PtInRect(point + CPoint(-2,0));
  451. }
  452. }
  453. return FALSE;
  454. }
  456. // Function name : CTreeMultiColumnCtrl::OnLButtonDown
  457. // Description     : If user press the left button of mouse...
  458. // Return type : void 
  459. // Argument         : UINT nFlags
  460. // Argument         : CPoint point
  461. void CTreeMultiColumnCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  462. {
  463. int subItem = -1;
  464. int nItem = HitTestEx(point, subItem);
  465. if ((nItem >= 0) && (IsPtnInSquareRect(point)))
  466. {
  467. int nTrueItem = GetItemData(nItem);
  468. if (ItemHasChildren(nTrueItem))
  469. if (!ItemIsExpanded(nTrueItem))
  470. ExpandItem(nTrueItem);
  471. else
  472. CollapseItem(nTrueItem);
  473. }
  475. CTsyslistviewex::OnLButtonDown(nFlags, point);
  476. }
  478. // Function name : CTreeMultiColumnCtrl::OnKeyDown
  479. // Description     : If user press the one of following keys...
  480. // Return type : void 
  481. // Argument         : UINT nChar
  482. // Argument         : UINT nRepCnt
  483. // Argument         : UINT nFlags
  484. void CTreeMultiColumnCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  485. {
  486. m_bInsideCode++;
  487. int iSelected = -1;
  488. while ((iSelected = GetNextItem(iSelected, LVNI_SELECTED))>=0)
  489. {
  490. int nTrueItem = GetItemData(iSelected);
  491. switch (nChar)
  492. {
  493. case VK_ADD:
  494. case VK_RIGHT:
  495. {
  496. ExpandItem(nTrueItem);
  497. break;
  498. }
  499. case VK_SUBTRACT:
  500. case VK_LEFT:
  501. {
  502. CollapseItem(nTrueItem);
  503. break;
  504. }
  505. case VK_MULTIPLY:
  506. {
  507. RecExpandItems(nTrueItem);
  508. break;
  509. }
  510. }
  511. iSelected++;
  512. }
  513. m_bInsideCode--;
  514. if ((nChar != VK_RIGHT) && (nChar != VK_LEFT))
  515. CTsyslistviewex::OnKeyDown(nChar, nRepCnt, nFlags);
  516. }
  518. // Function name : CTreeMultiColumnCtrl::Fill
  519. // Description     : Fill the tree control with items from lpszItems. See tfilltree.h, tfilltree.cpp
  520. // Return type : void 
  521. // Argument         : LPCTSTR lpszItems
  522. void CTreeMultiColumnCtrl::Fill(LPCTSTR lpszItems)
  523. {
  524. STFillTreeMultiColumn s(this, lpszItems);
  525. s.Fill();
  526. }
  528. // Function name : CTreeMultiColumnCtrl::Delete
  529. // Description     : 
  530. // Return type : BOOL 
  531. // Argument         : int nItem
  532. // Argument         : BOOL bRecurse
  533. BOOL CTreeMultiColumnCtrl::Delete(int nItem)
  534. {
  535. int nTrueItem = GetItemData(nItem);
  536. if (!ItemHasChildren(nTrueItem))
  537. {
  538. m_bInsideCode++;
  539. DeleteItem(nItem);
  540. m_mapItemDeleted[nTrueItem] = TRUE;
  541. int lItem = max(0, nItem - 1);
  542. RedrawItems(lItem, lItem);
  543. m_bInsideCode--;
  544. return TRUE;
  545. }
  546. return FALSE;
  547. }
  549. // Function name : CTreeMultiColumnCtrl::IsDeleted
  550. // Description     : 
  551. // Return type : BOOL 
  552. // Argument         : int nItem
  553. BOOL CTreeMultiColumnCtrl::IsDeleted(int nItem)
  554. {
  555. BOOL bValue = FALSE;
  556. m_mapItemDeleted.Lookup(nItem, bValue);
  557. return bValue;
  558. }
  560. // Function name : CTreeMultiColumnCtrl::ItemHasChildren
  561. // Description     : Return TRUE if item iItem has at least one children
  562. // Return type : BOOL 
  563. // Argument         : int iItem
  564. BOOL CTreeMultiColumnCtrl::ItemHasChildren(int iItem)
  565. {
  566. int key = -1;
  567. int value = -1;
  568. POSITION position = m_mapParents.GetStartPosition();
  569. while (position)
  570. {
  571. m_mapParents.GetNextAssoc(position, key, value);
  572. if (!IsDeleted(value))
  573. if (!IsDeleted(key))
  574. if (value == iItem)
  575. return TRUE;
  576. }
  577. return FALSE;
  578. }
  580. // Function name : CTreeMultiColumnCtrl::GetFirstItemChild
  581. // Description     : Return the index of first item child of nItem
  582. // Return type : int 
  583. // Argument         : int nItem
  584. int CTreeMultiColumnCtrl::GetFirstItemChild(int nItem)
  585. {
  586. m_nLastItemFind = -1;
  587. m_nLastItemFound = nItem;
  588. return GetNextItemChild();
  589. }
  591. // Function name : CTreeMultiColumnCtrl::GetNextItemChild
  592. // Description     : Return the index of next item child of nItem
  593. // Return type : int 
  594. int CTreeMultiColumnCtrl::GetNextItemChild()
  595. {
  596. m_nLastItemFind++;
  597. while (IsDeleted(m_nLastItemFind) || ((m_nLastItemFind < m_listItems.GetItemCount()) && (GetItemParent(m_nLastItemFind) != m_nLastItemFound)))
  598. m_nLastItemFind++;
  599. if (m_nLastItemFind < m_listItems.GetItemCount())
  600. return m_nLastItemFind;
  601. return -1;
  602. }
  604. // Function name : CTreeMultiColumnCtrl::IsLastChildren
  605. // Description     : Check if iItem is last children
  606. // Return type : BOOL 
  607. // Argument         : int iItem
  608. BOOL CTreeMultiColumnCtrl::IsLastChildren(int iItem)
  609. {
  610. int iParent = GetItemParent(iItem);
  611. int cItem = m_listItems.GetItemCount();
  612. int i = iItem + 1;
  613. while (i < cItem)
  614. {
  615. if (!IsDeleted(i))
  616. if (!IsDeleted(GetItemParent(i)))
  617. if (GetItemParent(i) == iParent)
  618. return FALSE;
  619. i++;
  620. }
  621. return TRUE;
  622. }
  624. //-------------------------------------------------------------------------------//