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

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

ListView/ListBox

开发平台：

Visual C++

supergridctrl.cpp：源码内容
  1. // SuperGridCtrl.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "SuperGrid.h"
  6. #include "SuperGridCtrl.h"
  7. #include "ListEditCtrl.h"
  11. #ifdef _DEBUG
  12. #define new DEBUG_NEW
  13. #undef THIS_FILE
  14. static char THIS_FILE[] = __FILE__;
  15. #endif
  17. /*
  18.     SuperGrid, YALC (yet another listview control) 
  20. Written by me(Allan Nielsen), that is .. if the code works :)
  21. mailto:allan@object-oriented.com
  23. Copyright (c) 1999.
  25. If you find bugs, please notify me and I'll contact the author who wrote the darn thing :)
  27.     You may use it, abuse it, redistribute it, in any way you desire, but
  28. if you choose to use this control in any commercial or non commercial application then please 
  29. send me an email letting me know, makes me :) . 
  32. HISTORY 
  34. what's new since last update: 
  36. 4 dec. 1998.
  38. - MeasureItem now uses current font
  39. - Combobox support in CItemInfo
  40.   see the ShowList in MySuperGrid.h/cpp, PreTranslateMessage functions
  41.   and the file ComboInListView.cpp/h
  42.                 - function to indicate the precens of a combobox it draws a down arrow ..see DrawComboBox
  43.   the idea came from Robert Bouwens. :)
  44. - in file TestTreeDlg.cpp:  due to the MeasureItem message-reflection
  45.   the listctrl is now created in the CDialog::OnCreate function and later on resized
  46. - LVIS_DROPHILITED support when dragging items
  47. - Support for LVS_EX_CHECKBOXES   
  48. - Added some examples on how to print preview selected item(or at least to get some information from of the grid)
  49.   the sample is in the CMySuperGrid.h/cpp which is derived from CSuperGridCtrl it shows you
  50.   how to initalize the grid, sort items, search for items and subitems, select and delete thems
  51. - added virtual GetIcon function to set your default icon handler for a listview index.
  52. - added virtual GetCellRGB() to set the color for current selected cell
  53. - renamed CTreeNode to CTreeItem, sorry ;-(
  54. - the nested class CTreeItem has been stripped down to nothing but simple (struct)data members
  55.   only servering as a linked list of lists now :-)
  56. - well.. moved all the importent stuff from CTreeItem to CSuperGridCtrl e.g
  57.   all operations on a CTreeItem now resides in the CSuperGridCtrl, much more OO-like ;-)
  58. - added Quicksort function
  59. - got rid of TheOpenCloseThing function.
  60. - added virtual function OnUpdateListViewItem..called when ever an Item is about to be updated
  61. - added virtual function OnControlLButtonDown...called when ever LButtondown in a cell
  62. - added virtual function CreateDragImageEx...
  64. 11 jan 1999:
  65. - added SetFocus in OnDblclk and in OnLButtonDown, big thank you to Dieter Gollwitzer 
  66. - fixed a minor hittest error in the HitTestOnSign(), again thanks to Dieter Gollwitzer 
  69. 16 jan 1999: 
  70. - added virtual OnItemExpanding(....
  71. - added virtual OnItemExpanded(...
  72. - added virtual OnCollapsing(....
  73. - added virtual OnItemCollapsed(...
  74. - added virtual OnDeleteItem(....
  75. - added virtual OnVKMultiply(...
  76. - added virtual OnVkSubTract(..
  77. - added virtual OnVKAdd(....
  78. - added SetChildrenFlag();
  80. 1 feb 1999:
  81. - CItemInfo now supports individual cell-color
  82. - fixed some bugs in regards to listdata associated with in each cell
  83. - added virtual BOOL OnVkReturn(........
  84. - added virtual BOOL OnItemLButtonDown(.....
  86. 4 mai 1999  - moved to Switzerland to work as a systemdeveloper for 2-3 years :).
  87. - new email :)
  88. - added new class for encapsulating drawing + - buttons.
  90.    22.june 1999 - Added GetCount()
  91. - removed support for VC++ 5.0.
  92. - added GetTreeItem(.....) 
  93. - GetSelectedItem(.....)
  94. - Howto disable Drag/drop in CMySuperGrid
  95. - level 4 compiled
  96. - Clean up some redudant code crap
  98. 30.june 99  - fixed minor error in DrawItem, a drawing error occurred when 1.st column was hidden, 
  99.   it was previous fixed, but some how it was introduced again :).
  102. 9. juli 99  - CRAIG SCHMIDT "the beachboy":)
  104.   Craig did the implementation of the Multiple Root request
  105.   his email are "craig_a_schmidt@yahoo.com" if you have any Questions
  106.   in regards to multiple roots implementation, although I think I can help too :).
  108.   he added the following functions :
  110.   - CTreeItem*  InsertRootItem(.....
  111.   - void DeleteRootItem(....
  112.   - BOOL IsRoot(...
  113.   - CTreeItem* GetRootItem(..
  114.   - int GetRootIndex(..
  115.   - int GetRootCount(...
  116.   - and a member variable, CPtrList m_RootItems which of course are a collection of ..ta da RootItems a.k.a CTreeItem.
  117.   see the file CMySuperGrid.cpp for usage of the InsertRootItem.
  119.     10.juli 99    added simple wrappers for the rootitems collection
  121.   - Added GetRootHeadPosition(...)
  122.   - Added GetRootTailPosition();
  123.   - Added CTreeItem* GetNextRoot(...
  124.   - Added CTreeItem* GetPrevRoot(...
  127. 12. juli 99  - fixed minor error in CreateDragImageEx, an error occurred when 1st column was hidden and a drag operation was initiated
  129. 13. juli 99  - Added void DeleteAll()...deletes all items in the grid, uhh
  130.  - Removed GetNextSiblingItem(...), GetPrevSiblingItem(...) due to support for multiple roots. 
  131.  - Added CTreeItem *GetNext(...) and CTreeItem* GetPrev(..) due to support for multiple roots.
  133. 14. juli 99  - Fixed a memory leak in CMySuperGrid::HowToInsertItemsAfterTheGridHasBeenInitialized....
  137. WHAT'S UP :
  138. - Vacation
  139. - ATL VERSION COMMING UP.
  140. - Better documentation :)
  141. - Peace on earth.
  142. - service pack 4 for VC++ 6.0 :=|
  143. - Windows 3000 :)
  144. */
  146. /////////////////////////////////////////////////////////////////////////////
  147. // CSuperGridCtrl
  148. CSuperGridCtrl::CSuperGridCtrl()
  149. {
  150. m_cxImage = m_cyImage = m_bIsDragging = m_CurSubItem = 0;
  151.     m_nDragTarget=m_nDragItem = -1;
  152. m_psTreeLine.CreatePen(PS_SOLID, 1, RGB(192,192,192));
  153. m_psRectangle.CreatePen(PS_SOLID, 1, RGB(198,198,198));
  154. m_psPlusMinus.CreatePen(PS_SOLID, 1, RGB(0,0,0));
  155. m_brushErase.CreateSolidBrush(RGB(255,255,255));
  156. m_himl = NULL;
  157. }
  160. CSuperGridCtrl::~CSuperGridCtrl()
  161. {
  162. m_psPlusMinus.DeleteObject();
  163. m_psRectangle.DeleteObject();
  164. m_psTreeLine.DeleteObject();
  165. m_brushErase.DeleteObject();
  167. while(m_RootItems.GetCount())
  168. {
  169. CTreeItem * root = (CTreeItem*)m_RootItems.RemoveHead();
  170. if(root!=NULL && GetData(root) != NULL)
  171. delete GetData(root);
  172. delete root;
  173. }
  174. m_RootItems.RemoveAll();
  175. }
  179. BEGIN_MESSAGE_MAP(CSuperGridCtrl, CListCtrl)
  180. //{{AFX_MSG_MAP(CSuperGridCtrl)
  181. ON_NOTIFY_REFLECT(NM_DBLCLK, OnDblclk)
  182. ON_NOTIFY_REFLECT(LVN_ENDLABELEDIT, OnEndlabeledit)
  183. ON_WM_CREATE()
  184. ON_WM_HSCROLL()
  185. ON_WM_LBUTTONDOWN()
  186. ON_WM_MOUSEMOVE()
  187. ON_WM_TIMER()
  188. ON_WM_VSCROLL()
  189. ON_WM_LBUTTONUP()
  190. ON_NOTIFY_REFLECT(LVN_KEYDOWN, OnKeydown)
  191. ON_NOTIFY_REFLECT(LVN_BEGINDRAG, OnBegindrag)
  192. ON_WM_MEASUREITEM_REFLECT()
  193. ON_WM_DRAWITEM_REFLECT()
  194. ON_WM_SYSCOLORCHANGE()
  195. //}}AFX_MSG_MAP
  196. END_MESSAGE_MAP()
  198. /////////////////////////////////////////////////////////////////////////////
  199. // CSuperGridCtrl message handlers
  201. BOOL CSuperGridCtrl::PreCreateWindow(CREATESTRUCT& cs) 
  202. {
  203. cs.style |= LVS_REPORT | LVS_SINGLESEL | LVS_SHAREIMAGELISTS | LVS_OWNERDRAWFIXED | LVS_SHOWSELALWAYS;
  204. return CListCtrl::PreCreateWindow(cs);
  205. }
  209. int CSuperGridCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  210. {
  211. if (CListCtrl::OnCreate(lpCreateStruct) == -1)
  212. return -1;
  214. return 0;
  215. }
  219. #define OFFSET_FIRST 2 
  220. #define OFFSET_OTHER 6
  221. void CSuperGridCtrl::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
  222. {
  223. if (lpDrawItemStruct->CtlType != ODT_LISTVIEW)
  224.         return;
  226. if(lpDrawItemStruct->itemAction == ODA_DRAWENTIRE)
  227. {
  228. if(m_himl==NULL)
  229. {
  230. m_himl = (HIMAGELIST)::SendMessage(m_hWnd, LVM_GETIMAGELIST, (WPARAM)(int)(LVSIL_SMALL), 0L);
  231. if(m_himl==NULL)
  232. return;
  233. }
  235. LV_ITEM lvi;
  236. static _TCHAR szBuff[MAX_PATH];
  237. LPCTSTR pszText;
  239. int nItem = lpDrawItemStruct->itemID;
  240. CRect rcItem(lpDrawItemStruct->rcItem);
  242. lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_INDENT | LVIF_PARAM; 
  243. lvi.iItem = nItem;
  244. lvi.iSubItem =0;
  245. lvi.pszText = szBuff;
  246. lvi.cchTextMax = sizeof(szBuff);
  247. lvi.stateMask = 0xFFFF;
  248. GetItem(&lvi);
  250. CTreeItem *pSelItem = (CTreeItem*)lpDrawItemStruct->itemData;
  252. CRect rcLabel;
  253. GetItemRect(nItem, rcLabel, LVIR_LABEL);
  255. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  256. ASSERT(pDC);
  258. CRect rcClipBox;
  259. pDC->GetClipBox(rcClipBox);
  261. COLORREF crBackground, crText;
  263. if (lpDrawItemStruct->itemState & ODS_SELECTED)
  264. {
  265. // Set the text background and foreground colors
  266. crBackground = GetSysColor (COLOR_HIGHLIGHT);
  267. crText = GetSysColor (COLOR_HIGHLIGHTTEXT);
  268. }
  269. else
  270. {
  271. // Set the text background and foreground colors to the standard window
  272. // colors
  273. crBackground = GetSysColor (COLOR_WINDOW);
  274. crText = GetSysColor (COLOR_WINDOWTEXT);
  275. }
  277. //Get current Icon, you have overridden this I hope :-)
  278. int iImage = GetIcon(pSelItem);
  279. if(iImage!=-1)
  280. {
  281. if(lvi.iImage!=iImage)
  282. {
  283. LV_ITEM lvItem;
  284. lvItem.mask =  LVIF_IMAGE;
  285. lvItem.iImage = iImage;
  286. lvItem.iItem = nItem;
  287. lvItem.iSubItem = 0;
  288. SetItem(&lvItem);
  289. lvi.iImage = iImage; 
  290. }
  291. }
  293. CRect rc;
  294. GetItemRect(nItem, rc, LVIR_BOUNDS);
  296. CRect rcIcon;
  297. GetItemRect(nItem, rcIcon, LVIR_ICON);
  298. //Draw Current image
  299. int nOffset = (rcItem.Height() - m_cyImage)/2;
  300. int nY = rcItem.bottom - m_cyImage - nOffset;
  301. int nWidth = m_cxImage;//def icon size
  302. //do not draw icon out side 1.st column.
  303. int iTryIndent = GetIndent(pSelItem) * m_cxImage + m_cxImage;
  304. if(rc.left + iTryIndent  > GetColumnWidth(0)-2/*looks better -2*/)
  305. nWidth = (rc.left + iTryIndent) - GetColumnWidth(0);
  307. UINT uiFlags = ILD_TRANSPARENT;
  309. if( GetItemState(nItem, LVIF_STATE) & LVIS_DROPHILITED)//if dragging show a SelectDropTarget alike effect :)
  310. uiFlags |= ILD_BLEND50;
  312. if((nWidth=m_cxImage-nWidth) >-1)//calc width of icon
  313. {
  314. ImageList_DrawEx(m_himl, lvi.iImage, pDC->m_hDC,  
  315.  rc.left + (GetIndent(pSelItem) * m_cxImage), 
  316.  nY, 
  317.  nWidth,
  318.  m_cyImage,
  319.  CLR_DEFAULT, 
  320.  CLR_DEFAULT, 
  321.  uiFlags);
  322. DrawTreeItem(pDC, pSelItem, nItem, rc);
  323. }
  325. //Draw selection bar (erase old selection too)
  326. pDC->SetBkColor(crBackground);
  328. CRect rcClip = lpDrawItemStruct->rcItem;
  329. rcClip.left += GetIndent(pSelItem) * m_cxImage + m_cxImage + 2;
  330. if(rcClip.left > GetColumnWidth(0))
  331. rcClip.left = GetColumnWidth(0);
  332. //fill background color
  333. ExtTextOut(pDC->GetSafeHdc(), 0, 0, ETO_OPAQUE, rcClip, NULL, 0, NULL);
  335. //draw color in first col if any
  336. rcClip.right = rcLabel.right;
  337. CItemInfo *pItemInfo = GetData(pSelItem);
  338. COLORREF clf = pItemInfo->GetItemClr();
  339. if(clf!=-1)
  340. {
  341. CBrush br(clf);
  342. pDC->FillRect(rcClip, &br);
  343. }
  344. //draw selection rect in 1.st col if selected
  345. if ((lpDrawItemStruct->itemState & ODS_SELECTED) && (m_CurSubItem==0))
  346. {
  347. CBrush br(GetCellRGB());
  348. pDC->FillRect(rcClip,&br);
  349. pDC->DrawFocusRect(rcClip);
  350. }
  352. //if checkbox style
  353. UINT nStateImageMask = lvi.state & LVIS_STATEIMAGEMASK;
  354. if (nStateImageMask)
  355. {
  356. int nImage = (nStateImageMask>>12) - 1;
  357. CImageList *pImageList = GetImageList(LVSIL_STATE);
  358. if (pImageList)
  359. {
  360. int cxIcon,cyIcon=0;
  361. ImageList_GetIconSize(pImageList->m_hImageList, &cxIcon, &cyIcon);
  362. if(rc.left + (GetIndent(pSelItem) * m_cxImage) + m_cxImage + cxIcon < GetColumnWidth(0))
  363. pImageList->Draw(pDC, nImage,CPoint(rc.left + (GetIndent(pSelItem) * m_cxImage) + cxIcon, nY), ILD_TRANSPARENT);
  364. }
  365. }
  368. //draw 1. item
  369. GetItemRect(nItem, rcItem, LVIR_LABEL);
  370. pszText = MakeShortString(pDC, szBuff, rcItem.right - rcItem.left, 2*OFFSET_FIRST);
  371. rcLabel = rcItem;
  372. rcLabel.left+=OFFSET_FIRST;
  373. rcLabel.right-=OFFSET_FIRST;
  375. pDC->SetBkColor (crBackground);
  376. pDC->SetTextColor (crText);
  377. pDC->DrawText(pszText,-1, rcLabel,DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_EXTERNALLEADING);
  379. //draw subitems..
  380. LV_COLUMN lvc;
  381. lvc.mask = LVCF_FMT | LVCF_WIDTH;
  382. for(int nColumn=1; GetColumn(nColumn, &lvc); nColumn++)
  383. {
  384. rcItem.left=rcItem.right;
  385. rcItem.right+=lvc.cx;
  386. if (rcItem.left < rcClipBox.right && rcItem.right > rcClipBox.left && rcItem.right > rcItem.left)
  387. {
  388. //support for colors in each cell
  389. COLORREF clf = pItemInfo->GetBkColor(nColumn-1);
  390. if(clf!=-1)
  391. {
  392. CBrush br(clf);
  393. pDC->FillRect(rcItem, &br);
  394. }
  396. int nRetLen = GetItemText(nItem, nColumn, szBuff, sizeof(szBuff));
  397. if(nRetLen==0)
  398. pszText=NULL;
  399. else
  400. pszText=MakeShortString(pDC,szBuff,rcItem.right-rcItem.left,2*OFFSET_OTHER);
  402. UINT nJustify=DT_LEFT;
  404. if(pszText==szBuff)
  405. {
  406. switch(lvc.fmt & LVCFMT_JUSTIFYMASK)
  407. {
  408. case LVCFMT_RIGHT:
  409. nJustify=DT_RIGHT;
  410. break;
  411. case LVCFMT_CENTER:
  412. nJustify=DT_CENTER;
  413. break;
  414. default:
  415. break;
  416. }
  417. }
  418. rcLabel=rcItem;
  419. rcLabel.left+=OFFSET_OTHER;
  420. rcLabel.right-=OFFSET_OTHER;
  421. if (lpDrawItemStruct->itemState & ODS_SELECTED && !m_bIsDragging)
  422. DrawFocusCell(pDC, lpDrawItemStruct->itemID, nColumn);
  423. if(pszText!=NULL)
  424. pDC->DrawText(pszText,-1,rcLabel, nJustify | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_EXTERNALLEADING);
  425. }//if
  427. //draw down arrow if combobox regardless of rcClipBox rgn
  428. if (lpDrawItemStruct->itemState & ODS_SELECTED)
  429. DrawComboBox(pDC, pSelItem, nItem, nColumn);
  430. }//for
  431. }//ODA_DRAWENTIRE
  432. }
  436. void CSuperGridCtrl::DrawComboBox(CDC* pDC, CTreeItem *pSelItem, int nItem, int nColumn)
  437. {
  438. CItemInfo* pInfo = GetData(pSelItem);
  439. CItemInfo::CONTROLTYPE ctrlType;
  440. if(pInfo->GetControlType(nColumn-1, ctrlType))
  441. {
  442. if(ctrlType == pInfo->CONTROLTYPE::combobox) 
  443. {
  444. CRect rect;
  445. GetSubItemRect(nItem, nColumn, LVIR_BOUNDS, rect);
  446. rect.left=rect.right - GetSystemMetrics(SM_CYVSCROLL);
  447. pDC->DrawFrameControl(rect, DFC_SCROLL, DFCS_SCROLLDOWN);
  448. }
  449. }
  450. }
  453. //this piece of code is borrowed from the wndproc.c file in the odlistvw.exe example from MSDN and was converted to mfc-style
  454. void CSuperGridCtrl::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
  455. {
  456.     if (lpMeasureItemStruct->CtlType != ODT_LISTVIEW)
  457.         return;
  459. TEXTMETRIC tm;
  460. CClientDC dc(this);
  461. CFont* pFont = GetFont();
  462. CFont* pOldFont = dc.SelectObject(pFont);
  463. dc.GetTextMetrics(&tm);
  464. int nItemHeight = tm.tmHeight + tm.tmExternalLeading;
  465. lpMeasureItemStruct->itemHeight = nItemHeight + 4; //or should I go for max(nItemheight+4, m_cxImage+2);
  466. dc.SelectObject(pOldFont);
  467. }
  471. //the basic rutine making the ... thing snatched it from some tedious code example some where in MSDN call odlistvw.exe
  472. LPCTSTR CSuperGridCtrl::MakeShortString(CDC* pDC, LPCTSTR lpszLong, int nColumnLen, int nOffset)
  473. {
  474. static const _TCHAR szThreeDots[]=_T("...");
  476. int nStringLen=lstrlen(lpszLong);
  478. if(nStringLen==0 || pDC->GetTextExtent(lpszLong,nStringLen).cx + nOffset < nColumnLen)
  479. return(lpszLong);
  481. static _TCHAR szShort[MAX_PATH];
  483. lstrcpy(szShort,lpszLong);
  484. int nAddLen = pDC->GetTextExtent(szThreeDots,sizeof(szThreeDots)).cx;
  486. for(int i=nStringLen-1; i > 0; i--)
  487. {
  488. szShort[i]=0;
  489. if(pDC->GetTextExtent(szShort,i).cx + nOffset + nAddLen < nColumnLen)
  490. break;
  491. }
  492. lstrcat(szShort,szThreeDots);
  493. return(szShort);
  494. }
  499. void CSuperGridCtrl::OnKeydown(NMHDR* pNMHDR, LRESULT* pResult) 
  500. {
  501. LV_KEYDOWN* pLVKeyDow = (LV_KEYDOWN*)pNMHDR;
  502. switch(pLVKeyDow->wVKey)
  503. {
  504. case VK_SPACE: 
  505. {
  506. if(GetExtendedStyle() & LVS_EX_CHECKBOXES)
  507. {
  508. int nIndex = GetSelectedItem();
  509. if(nIndex !=-1)
  510. {
  511. CTreeItem* pItem = GetTreeItem(nIndex);
  512. if(pItem!=NULL)
  513. {
  514. CItemInfo *pInfo = GetData(pItem);
  515. pInfo->SetCheck(!pInfo->GetCheck());
  516. }
  517. }
  518. }
  519. }break;
  521. case VK_DELETE: 
  522. {
  523. int nItem = GetSelectedItem();
  524. if(nItem!=-1)
  525. {
  526. CTreeItem* pSelItem = GetTreeItem(nItem);
  527. if(pSelItem != NULL)
  528. {
  529. if(OnDeleteItem(pSelItem, nItem))
  530. DeleteItemEx(pSelItem, nItem);
  531. }
  532. }
  533. } break;
  536. case VK_MULTIPLY:
  537. {  
  538. int nIndex = GetSelectedItem();
  539. if(nIndex != -1)
  540. {
  541. CWaitCursor wait;
  542. SetRedraw(0);
  543. CTreeItem *pParent = GetTreeItem(nIndex);
  544. int nScroll=0;
  545. if(OnVKMultiply(pParent, nIndex))
  546. {
  547. ExpandAll(pParent, nScroll);
  548. }
  549. SetRedraw(1);
  550. RedrawItems(nIndex, nScroll);
  551. EnsureVisible(nScroll, TRUE);
  552.  }
  553.  }break;
  555. case VK_ADD:
  556. {
  557. int nIndex = GetSelectedItem();
  558. if(nIndex!=-1)
  559. {
  560. CWaitCursor wait;
  561. CTreeItem *pSelItem = GetTreeItem(nIndex);
  562. int nScrollIndex = 0;
  563. if(OnVKAdd(pSelItem, nIndex))
  564. {
  565.  nScrollIndex = Expand(pSelItem, nIndex);
  566. }
  567. CRect rc;
  568. GetItemRect(nIndex, rc, LVIR_BOUNDS);
  569. InvalidateRect(rc);
  570. UpdateWindow();
  571. EnsureVisible(nScrollIndex, 1);
  572. }
  574. }break;
  577. case VK_SUBTRACT:
  578. {
  579. int nIndex = GetSelectedItem();
  580. if(nIndex!=-1)
  581. {
  582. CWaitCursor wait;
  583. CTreeItem *pSelItem = GetTreeItem(nIndex);
  584. if(OnVkSubTract(pSelItem, nIndex))
  585. {
  586. Collapse(pSelItem);
  587. }
  588. CRect rc;
  589. GetItemRect(nIndex, rc, LVIR_BOUNDS);
  590. InvalidateRect(rc);
  591. UpdateWindow();
  592. }
  593. }break;
  594. default :break;
  595. }
  596. *pResult = 0;
  597. }
  602. BOOL CSuperGridCtrl::HitTestOnSign(CPoint point, LVHITTESTINFO& ht)
  603. {
  604. ht.pt = point;
  605. // Test which subitem was clicked.
  606. SubItemHitTest(&ht);
  607. if(ht.iItem!=-1)
  608. {
  609. //first hittest on checkbox
  610. BOOL bHit = FALSE;
  611. if(GetExtendedStyle() & LVS_EX_CHECKBOXES)
  612. {
  613. if (ht.flags == LVHT_ONITEM && (GetStyle() & LVS_OWNERDRAWFIXED))//isn't this allways ownerdrawfixed :-)
  614. {
  615. CRect rcIcon,rcLabel;
  616. GetItemRect(ht.iItem, rcIcon, LVIR_ICON);//has to be between these two ....right :)
  617. GetItemRect(ht.iItem, rcLabel, LVIR_LABEL);
  618. // check if hit was on a state icon 
  619. if (point.x > rcIcon.left && point.x < rcLabel.left)
  620. bHit = TRUE;
  621. }
  622. else if (ht.flags & LVHT_ONITEMSTATEICON)
  623. bHit = TRUE;
  624. }
  626. CTreeItem* pItem = GetTreeItem(ht.iItem);
  627. if(pItem!=NULL)
  628. {
  629. if(bHit)//if checkbox
  630. {
  631. //yes I know..have to maintain to sets of checkstates here...
  632. //one for listview statemask and one for CTreeItem..but its located here so no harm done
  633. SetCheck(ht.iItem,!GetCheck(ht.iItem));
  634. CItemInfo *pInfo = GetData(pItem);
  635. pInfo->SetCheck(!pInfo->GetCheck());
  636. }
  637. //if haschildren and clicked on + or - then expand/collapse
  638. if(ItemHasChildren(pItem))
  639. {
  640. //hittest on the plus/sign "button" 
  641. CRect rcBounds;
  642. GetItemRect(ht.iItem, rcBounds, LVIR_BOUNDS);
  643. CRectangle rect(this, NULL, GetIndent(pItem), rcBounds);
  644. BOOL bRedraw=0;//if OnItemExpanding or OnCollapsing returns false, dont redraw
  645. if(rect.HitTest(point))
  646. {
  647. SetRedraw(0);
  648. int nScrollIndex=0;
  649. if(IsCollapsed(pItem))
  650. {
  651. if(OnItemExpanding(pItem, ht.iItem))
  652. {
  653. nScrollIndex = Expand(pItem, ht.iItem);
  654. OnItemExpanded(pItem, ht.iItem);
  655. bRedraw=1;
  656. }
  657. }
  658. else {
  659.    if(OnCollapsing(pItem))
  660.    {
  661. Collapse(pItem);
  662. OnItemCollapsed(pItem);
  663. bRedraw=1;
  664.    }
  665. }
  666. SetRedraw(1);
  667. if(bRedraw)
  668. {
  669. CRect rc;
  670. GetItemRect(ht.iItem, rc, LVIR_BOUNDS);
  671. InvalidateRect(rc);
  672. UpdateWindow();
  673. EnsureVisible(nScrollIndex, 1);
  674. return 0;
  675. }
  676. }
  677. }//has kids
  678. }//pItem!=NULL
  679. }
  680. return 1;
  681. }
  685. void CSuperGridCtrl::OnDblclk(NMHDR* pNMHDR, LRESULT* pResult) 
  686. {
  687. if( GetFocus() != this) 
  688. SetFocus();
  690. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  692. LVHITTESTINFO ht;
  693. ht.pt = pNMListView->ptAction;
  694. SubItemHitTest(&ht);
  695. if(OnItemLButtonDown(ht))
  696. {
  697. BOOL bSelect=1;
  698. bSelect = HitTestOnSign(pNMListView->ptAction, ht);
  699. //normal selection
  700. if(bSelect && ht.iItem !=-1)
  701. {
  702. int nIndex = GetSelectedItem();
  703. if(nIndex!=-1)
  704. {
  705. CTreeItem *pSelItem = GetTreeItem(nIndex);
  706. if (pSelItem != NULL)
  707. {
  708. BOOL bRedraw=0;
  709. if(ItemHasChildren(pSelItem))
  710. {
  711. SetRedraw(0);
  712. int nScrollIndex=0;
  713. if(IsCollapsed(pSelItem))
  714. {
  715. if(OnItemExpanding(pSelItem, nIndex))
  716. {
  717. nScrollIndex = Expand(pSelItem, nIndex);
  718. OnItemExpanded(pSelItem, nIndex);
  719. bRedraw=1;
  720. }
  721. }
  723. else 
  724. {
  725.    if(OnCollapsing(pSelItem))
  726.    {
  727. Collapse(pSelItem);
  728. OnItemCollapsed(pSelItem);
  729. bRedraw=1;
  730.    }
  731. }
  732. SetRedraw(1);
  734. if(bRedraw)
  735. {
  736. CRect rc;
  737. GetItemRect(nIndex,rc,LVIR_BOUNDS);
  738. InvalidateRect(rc);
  739. UpdateWindow();
  740. EnsureVisible(nScrollIndex,1);
  741. }
  742. }//ItemHasChildren
  743. }//!=NULL
  744. }
  745. }
  746. }
  747. *pResult = 0;
  748. }
  752. void CSuperGridCtrl::OnBegindrag(NMHDR* pNMHDR, LRESULT* pResult) 
  753. {
  754. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  755. if(pNMListView->iItem != -1)
  756. {
  757. m_nDragItem = pNMListView->iItem;
  758. CImageList* pDragImage=NULL;
  759. pDragImage = CreateDragImageEx(m_nDragItem);//override this if you want another dragimage or none at all.
  760. if(pDragImage)
  761. {
  762. pDragImage->BeginDrag(0, CPoint(0,0));
  763. pDragImage->DragEnter(this, pNMListView->ptAction);
  764. SetCapture();
  765. m_bIsDragging = TRUE;
  766. }
  767. delete pDragImage;
  768. }
  769. *pResult = 0;
  770. }
  775. //Create dragimage : Icon + the itemtext
  776. CImageList *CSuperGridCtrl::CreateDragImageEx(int nItem)
  777. {
  778.     CImageList *pList = new CImageList;          
  779. //get image index
  780. LV_ITEM lvItem;
  781. lvItem.mask =  LVIF_IMAGE;
  782. lvItem.iItem = nItem;
  783. lvItem.iSubItem = 0;
  784. GetItem(&lvItem);
  786. CRect rc;
  787. GetItemRect(nItem, &rc, LVIR_BOUNDS);         
  789. CString str;
  790. str = GetItemText(nItem, 0);
  791. CFont *pFont = GetFont();
  793. rc.OffsetRect(-rc.left, -rc.top);            
  794. rc.right = GetColumnWidth(0);                
  795. pList->Create(rc.Width(), rc.Height(),ILC_COLOR24| ILC_MASK , 1, 1);
  796. CDC *pDC = GetDC();                          
  797. if(pDC) 
  798. {
  799. CDC dc;       
  800. dc.CreateCompatibleDC(pDC);      
  801. CBitmap bmpMap;
  802. bmpMap.CreateCompatibleBitmap(pDC, rc.Width(), rc.Height());
  804. CBitmap *pOldBmp = dc.SelectObject(&bmpMap);
  805. CFont *pOldFont = dc.SelectObject(pFont);
  806. dc.FillSolidRect(rc, GetSysColor(COLOR_WINDOW));
  807. CImageList *pImgList = GetImageList(LVSIL_SMALL);
  808. if(pImgList)
  809. pImgList->Draw(&dc, lvItem.iImage, CPoint(0,0), ILD_TRANSPARENT);
  810. dc.TextOut(m_cxImage + 4, 0, str);
  811. dc.SelectObject(pOldFont);
  812. dc.SelectObject(pOldBmp);                 
  813. //causes an error if the 1st column is hidden so must check the imagelist
  814. if(pList->m_hImageList != NULL)
  815. pList->Add(&bmpMap, RGB(255,255,255));
  816. else { 
  817. delete pList;
  818. pList=NULL;
  819. }
  820. ReleaseDC(pDC);   
  821. }   
  822. return pList;
  823. }
  827. void CSuperGridCtrl::OnMouseMove(UINT nFlags, CPoint point) 
  828. {
  829.     if(m_bIsDragging)
  830.     {
  832. KillTimer(1);
  833. if (CWnd::GetCapture() != this)
  834. m_bIsDragging=0;
  836. if(nFlags==MK_RBUTTON || nFlags==MK_MBUTTON)
  837. m_bIsDragging=0;
  840. if(GetKeyState(VK_ESCAPE) < 0)
  841. m_bIsDragging=0;
  843. if(!m_bIsDragging)//why not put this in a funtion :)
  844. {
  845. SetItemState (m_nDragTarget, 0, LVIS_DROPHILITED);
  846. CImageList::DragLeave(this);
  847. CImageList::EndDrag();
  848. ReleaseCapture();
  849. InvalidateRect(NULL);
  850. UpdateWindow();
  851. }
  852. else
  853. {
  854. CPoint ptList(point);
  855. MapWindowPoints(this, &ptList, 1);
  856. CImageList::DragMove(ptList);
  857. UINT uHitTest = LVHT_ONITEM;
  858. m_nDragTarget = HitTest(ptList, &uHitTest);
  859. // try turn off hilight for previous DROPHILITED state
  860. int nPrev = GetNextItem(-1,LVNI_DROPHILITED);
  861. if(nPrev != m_nDragTarget)//prevents flicker 
  862. SetItemState(nPrev, 0, LVIS_DROPHILITED);
  864. CRect rect;
  865. GetClientRect (rect);
  866. int cy = rect.Height();
  867. if(m_nDragTarget!=-1)
  868. {
  869. SetItemState(m_nDragTarget, LVIS_DROPHILITED, LVIS_DROPHILITED);
  870. CTreeItem* pTarget = GetTreeItem(m_nDragTarget);
  871. if ((point.y >= 0 && point.y <= m_cyImage) || (point.y >= cy - m_cyImage && point.y <= cy) || 
  872. ( pTarget!=NULL && ItemHasChildren(pTarget) && IsCollapsed(pTarget)))
  873. {
  874. SetTimer(1,300,NULL);
  875. }
  876. }
  877. }
  878.     }
  879. CListCtrl::OnMouseMove(nFlags, point);
  880. }
  885. void CSuperGridCtrl::OnTimer(UINT nIDEvent) 
  886. {
  887. CListCtrl::OnTimer(nIDEvent);
  888. if(nIDEvent==1)
  889. {
  890. if(CWnd::GetCapture()!=this)
  891. {
  892. SetItemState(m_nDragTarget, 0, LVIS_DROPHILITED);
  893. m_bIsDragging=0;
  894. CImageList::DragLeave(this);
  895. CImageList::EndDrag();
  896. ReleaseCapture();
  897. InvalidateRect(NULL);
  898. UpdateWindow();
  899. KillTimer(1);
  900. return;
  901. }
  903. SetTimer(1,300,NULL);//reset timer
  904. DWORD dwPos = ::GetMessagePos();
  905. CPoint ptList(LOWORD(dwPos),HIWORD(dwPos));
  906. ScreenToClient(&ptList);
  908. CRect rect;
  909. GetClientRect(rect);
  910. int cy = rect.Height();
  911. //
  912. // perform autoscroll if the cursor is near the top or bottom.
  913. //
  914. if (ptList.y >= 0 && ptList.y <= m_cyImage) 
  915. {
  916. int n = GetTopIndex(); 
  917. CImageList::DragShowNolock(0);
  918. SendMessage(WM_VSCROLL, MAKEWPARAM(SB_LINEUP, 0), NULL);
  919. CImageList::DragShowNolock(1);
  920. if (GetTopIndex()== n)
  921. KillTimer (1);
  922. else {
  923. CImageList::DragShowNolock(0);
  924. CImageList::DragMove(ptList);
  925. CImageList::DragShowNolock(1);
  926. return;
  927. }
  928. }
  929. else if (ptList.y >= cy - m_cyImage && ptList.y <= cy) 
  930. {
  931. int n = GetTopIndex(); 
  932. CImageList::DragShowNolock(0);
  933. SendMessage(WM_VSCROLL, MAKEWPARAM(SB_LINEDOWN, 0), NULL);
  934. CImageList::DragShowNolock(1);
  935. if (GetTopIndex()== n)
  936. KillTimer (1);
  937. else {
  938. CImageList::DragShowNolock(0);
  939. CImageList::DragMove(ptList);
  940. CImageList::DragShowNolock(1);
  941. return;
  942. }
  943. }
  944. //Hover test 
  945. CImageList::DragMove(ptList);
  946. UINT uHitTest = LVHT_ONITEM;
  947. m_nDragTarget = HitTest(ptList, &uHitTest);
  949. if(m_nDragTarget!=-1)
  950. {
  951. //if the target has children
  952. //expand them
  953. CTreeItem* pTarget=GetTreeItem(m_nDragTarget);
  954. if(pTarget != NULL && ItemHasChildren(pTarget) && IsCollapsed(pTarget) && (m_nDragItem!=-1))
  955. {
  956. CImageList::DragShowNolock(0);
  957. CTreeItem* pSource = GetTreeItem(m_nDragItem);
  959. SetRedraw(0);
  960. int nScrollIndex=0;
  961. if(ItemHasChildren(pTarget) && IsCollapsed(pTarget))
  962. {
  963. if(OnItemExpanding(pTarget, m_nDragTarget))
  964. {
  965. nScrollIndex = Expand(pTarget, m_nDragTarget);
  966. OnItemExpanded(pTarget, m_nDragTarget);
  967. }
  968. }
  969. m_nDragItem = NodeToIndex(pSource);
  970. SetRedraw(1);
  971. EnsureVisible(nScrollIndex, 1);
  972. InvalidateRect(NULL);
  973. UpdateWindow();
  974. CImageList::DragShowNolock(1);
  975. KillTimer(1);
  976. return;
  977. }
  978. }
  979. KillTimer(1);
  980. }
  981. }
  985. void CSuperGridCtrl::OnLButtonUp(UINT nFlags, CPoint point) 
  986. {
  987. if(m_bIsDragging == TRUE)
  988.     {
  989. KillTimer(1);
  990.         CImageList::DragLeave(this);
  991.         CImageList::EndDrag();
  992.         ReleaseCapture();
  993.         m_bIsDragging = FALSE;
  994. SetItemState(m_nDragTarget, 0, LVIS_DROPHILITED);
  995.         if((m_nDragTarget != -1) && (m_nDragTarget != m_nDragItem) && (m_nDragItem!=-1))//no drop on me self
  996.         {
  998. CTreeItem* pSource = GetTreeItem(m_nDragItem);
  999. CTreeItem* pTarget = GetTreeItem(m_nDragTarget);
  1000. if(IsRoot(pSource))
  1001. return;
  1002. CTreeItem* pParent = GetParentItem(pSource);
  1003. if(pParent==pTarget) //can't drag child to parent
  1004. return;
  1006. if(!IsChildOf(pSource, pTarget))//can't drag parent to child
  1007. {
  1008. CWaitCursor wait;
  1009. SetRedraw(0);
  1010. if(DoDragDrop(pTarget, pSource))
  1011. {
  1012. UINT uflag = LVIS_SELECTED | LVIS_FOCUSED;
  1013. SetItemState(m_nDragTarget, uflag, uflag);
  1014. m_nDragItem=-1;
  1015. //delete source
  1016. int nIndex = NodeToIndex(pSource);
  1017. DeleteItem(nIndex);
  1018. HideChildren(pSource, TRUE, nIndex);
  1019. Delete(pSource);
  1020. InternaleUpdateTree();
  1021. SetRedraw(1);
  1022. InvalidateRect(NULL);
  1023. UpdateWindow();
  1024. }else
  1025. SetRedraw(1);
  1026. }
  1027.     }
  1028.     }
  1029.     else
  1030. CListCtrl::OnLButtonUp(nFlags, point);
  1031. }
  1035. //used with the drag/drop operation
  1036. void CSuperGridCtrl::CopyChildren(CTreeItem* pDest, CTreeItem* pSrc)
  1037. {
  1038. if (ItemHasChildren(pSrc))
  1039. {
  1040. POSITION pos = pSrc->m_listChild.GetHeadPosition();
  1041. while (pos != NULL)
  1042. {
  1043. CTreeItem* pItem = (CTreeItem *)pSrc->m_listChild.GetNext(pos);
  1044. CItemInfo* lp = CopyData(GetData(pItem));
  1045. CTreeItem* pNewItem = InsertItem(pDest, lp);
  1046. CopyChildren(pNewItem, pItem);
  1047. }
  1048. }
  1049. }
  1052. //hmmm 
  1053. BOOL CSuperGridCtrl::DoDragDrop(CTreeItem* pTarget, CTreeItem* pSource)
  1054. {
  1055. if(pTarget==NULL)
  1056. return 0;
  1058. BOOL bUpdate=FALSE;
  1059. if(!IsCollapsed(pTarget))
  1060. bUpdate=TRUE; //children are expanded, want to see update right away
  1062. //make a copy of the source data
  1063. CItemInfo* lp = CopyData(GetData(pSource));
  1064. //create new node with the source data and make pTarget the parent
  1066. CTreeItem* pNewParent = InsertItem(pTarget, lp, bUpdate);
  1067. //if the source has children copy all source data and make the newly create item the parent
  1068. if(ItemHasChildren(pSource))
  1069. CopyChildren(pNewParent, pSource);
  1071. return 1;
  1072. }
  1075. void CSuperGridCtrl::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  1076. {
  1077. //its not meself
  1078. if( GetFocus() != this) 
  1079. SetFocus();
  1081. CListCtrl::OnHScroll(nSBCode, nPos, pScrollBar);
  1082. }
  1087. void CSuperGridCtrl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  1088. {
  1089. if( GetFocus() != this) 
  1090. SetFocus();
  1091. CListCtrl::OnVScroll(nSBCode, nPos, pScrollBar);
  1092. }
  1097. BOOL CSuperGridCtrl::PreTranslateMessage(MSG* pMsg) 
  1098. {
  1099. if(pMsg->message == WM_KEYDOWN)
  1100. {
  1101. if(GetFocus()==this)
  1102. {
  1103. switch( pMsg->wParam )
  1104. {
  1105. case VK_LEFT:
  1106. {
  1107. // Decrement the order number.
  1108. m_CurSubItem--;
  1109. if(m_CurSubItem < 0) 
  1110. m_CurSubItem = 0;
  1111. else{
  1113. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1114. // Make the column visible.
  1115. // We have to take into account that the header may be reordered.
  1116. MakeColumnVisible( Header_OrderToIndex( pHeader->m_hWnd, m_CurSubItem));
  1117. // Invalidate the item.
  1118. int iItem = GetSelectedItem();
  1119. if( iItem != -1 )
  1120. {
  1121. CRect rcBounds;
  1122. GetItemRect(iItem, rcBounds, LVIR_BOUNDS);
  1123. InvalidateRect(&rcBounds);
  1124. UpdateWindow();
  1125. }
  1126. }
  1127. }
  1128. return TRUE;
  1130. case VK_RIGHT:
  1131. {
  1132. // Increment the order number.
  1133. m_CurSubItem++;
  1134. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1135. int nColumnCount = pHeader->GetItemCount();
  1136. // Don't go beyond the last column.
  1137. if( m_CurSubItem > nColumnCount -1 ) 
  1138. m_CurSubItem = nColumnCount-1;
  1139. else
  1140. {
  1141. MakeColumnVisible(Header_OrderToIndex( pHeader->m_hWnd, m_CurSubItem));
  1142.  
  1143. int iItem = GetSelectedItem();
  1144. // Invalidate the item.
  1145. if( iItem != -1 )
  1146. {
  1147. CRect rcBounds;
  1148. GetItemRect(iItem, rcBounds, LVIR_BOUNDS);
  1149. InvalidateRect(&rcBounds);
  1150. UpdateWindow();
  1151. }
  1152. }
  1153. }
  1154. return TRUE;
  1156. case VK_RETURN://edit itemdata
  1157. {
  1158. BOOL bResult = OnVkReturn();
  1159. if(!bResult)
  1160. {
  1161. int iItem = GetSelectedItem();
  1162. if( m_CurSubItem != -1 && iItem != -1)
  1163. {
  1164. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1165. int iSubItem = Header_OrderToIndex(pHeader->m_hWnd, m_CurSubItem);
  1166. if(iSubItem==0)//that's just me saying all nodes in col 0 are edit-controls, you may modify this
  1167. {
  1168. CRect rcItem;
  1169. GetItemRect(iItem, rcItem, LVIR_LABEL);
  1170. DWORD dwStyle = WS_BORDER | WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL|ES_LEFT;
  1171. CEdit *pEdit = new CListEditCtrl(iItem, iSubItem, GetItemText(iItem, iSubItem));
  1172. pEdit->Create(dwStyle, rcItem, this, 0x1233);
  1173. }
  1174. else
  1175. EditLabelEx(iItem, iSubItem);
  1176. return 1;
  1177. }
  1178. }
  1179. }
  1180. break;
  1181. default:
  1182. break;
  1183. }
  1184. }
  1185. }
  1186. return CListCtrl::PreTranslateMessage(pMsg);
  1187. }
  1191. #define IDC_EDITCTRL 0x1234
  1192. CEdit* CSuperGridCtrl::EditLabelEx(int nItem, int nCol)
  1193. {
  1194. CRect rect;
  1195. int offset = 0;
  1196. if(!EnsureVisible(nItem, TRUE)) 
  1197. return NULL;
  1198. GetSubItemRect(nItem, nCol, LVIR_BOUNDS, rect);
  1199. // Now scroll if we need to expose the column
  1200. CRect rcClient;
  1201. GetClientRect(rcClient);
  1202. if( offset + rect.left < 0 || offset + rect.left > rcClient.right )
  1203. {
  1204. CSize size(offset + rect.left,0);
  1205. Scroll(size);
  1206. rect.left -= size.cx;
  1207. }
  1208. rect.left += offset;
  1209. rect.right = rect.left + GetColumnWidth(nCol);
  1210. if(rect.right > rcClient.right) 
  1211.    rect.right = rcClient.right;
  1213. // Get Column alignment
  1214. LV_COLUMN lvcol;
  1215. lvcol.mask = LVCF_FMT;
  1216. GetColumn(nCol, &lvcol);
  1218. DWORD dwStyle;
  1219. if((lvcol.fmt & LVCFMT_JUSTIFYMASK) == LVCFMT_LEFT)
  1220. dwStyle = ES_LEFT;
  1221. else if((lvcol.fmt & LVCFMT_JUSTIFYMASK) == LVCFMT_RIGHT)
  1222. dwStyle = ES_RIGHT;
  1223. else 
  1224. dwStyle = ES_CENTER;
  1227. dwStyle |=WS_BORDER|WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL;
  1228. CEdit *pEdit = new CListEditCtrl(nItem, nCol, GetItemText(nItem, nCol));
  1229. pEdit->Create(dwStyle, rect, this, IDC_EDITCTRL);
  1230. //pEdit->ModifyStyleEx(0,WS_EX_CLIENTEDGE); //funny thing happend here, uncomment this, 
  1231. //and then edit an item, 
  1232. //enter a long text so that the ES_AUTOHSCROLL comes to rescue
  1233. //yes that's look funny, ???.
  1234. return pEdit;
  1235. }
  1240. void CSuperGridCtrl::OnEndlabeledit(NMHDR* pNMHDR, LRESULT* pResult) 
  1241. {
  1242. LV_DISPINFO *plvDispInfo = (LV_DISPINFO*)pNMHDR;
  1243.   LV_ITEM *plvItem = &plvDispInfo->item;
  1244. if (plvItem->pszText != NULL)//valid text
  1245. {
  1246. if(plvItem->iItem != -1) //valid item
  1247. {
  1248. CTreeItem*pSelItem = GetTreeItem(plvItem->iItem);
  1249. if(pSelItem != NULL)
  1250. {
  1251. OnUpdateListViewItem(pSelItem, plvItem);
  1252. }
  1253. }
  1254. }
  1255. *pResult = 0;
  1256. }
  1260. int CSuperGridCtrl::GetNumCol()
  1261. {
  1262. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1263. return pHeader ? pHeader->GetItemCount() : 0;
  1264. }
  1268. //Think Rex Myer is spooking here
  1269. void CSuperGridCtrl::MakeColumnVisible(int nCol)
  1270. {
  1271. if(nCol < 0)
  1272. return;
  1273. // Get the order array to total the column offset.
  1274. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1276. int nColCount = pHeader->GetItemCount();
  1277. ASSERT( nCol < nColCount);
  1278. int *pOrderarray = new int[nColCount];
  1279. Header_GetOrderArray(pHeader->m_hWnd, nColCount, pOrderarray);
  1280. // Get the column offset
  1281. int offset = 0;
  1282. for(int i = 0; pOrderarray[i] != nCol; i++)
  1283. offset += GetColumnWidth(pOrderarray[i]);
  1285. int colwidth = GetColumnWidth(nCol);
  1286. delete[] pOrderarray;
  1288. CRect rect;
  1289. GetItemRect(0, &rect, LVIR_BOUNDS);
  1290. // Now scroll if we need to show the column
  1291. CRect rcClient;
  1292. GetClientRect(&rcClient);
  1293. if(offset + rect.left < 0 || offset + colwidth + rect.left > rcClient.right)
  1294. {
  1295. CSize size(offset + rect.left,0);
  1296. Scroll(size);
  1297. InvalidateRect(NULL);
  1298. UpdateWindow();
  1299. }
  1300. }
  1304. //Think Rex Myer is spooking here
  1305. int CSuperGridCtrl::IndexToOrder( int iIndex )
  1306. {
  1307. // This translates a column index value to a column order value.
  1308. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1309. int nColCount = pHeader->GetItemCount();
  1310. int *pOrderarray = new int[nColCount];
  1311. Header_GetOrderArray(pHeader->m_hWnd, nColCount, pOrderarray);
  1312. for(int i=0; i<nColCount; i++)
  1313. {
  1314. if(pOrderarray[i] == iIndex )
  1315. {
  1316. delete[] pOrderarray;
  1317. return i;
  1318. }
  1319. }
  1320. delete[] pOrderarray;
  1321. return -1;
  1322. }
  1326. void CSuperGridCtrl::DrawFocusCell(CDC *pDC, int nItem, int iSubItem)
  1327. {
  1328. if(iSubItem==m_CurSubItem)
  1329. {
  1330. CRect rect;
  1331. GetSubItemRect(nItem, iSubItem, LVIR_BOUNDS, rect);
  1332. CBrush br(GetCellRGB());
  1333. if(iSubItem==0)
  1334. GetItemRect(iSubItem, rect, LVIR_LABEL);
  1335. pDC->FillRect(rect, &br);
  1336. pDC->DrawFocusRect(rect);
  1337. }
  1338. }
  1343. //insert item and return new parent pointer.
  1344. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::InsertItem(CTreeItem *pParent, CItemInfo* lpInfo,  BOOL bUpdate)
  1345. {
  1346. if(pParent==NULL)
  1347. return NULL;
  1349. CTreeItem *pItem = NULL;
  1350. pItem =  new CTreeItem();
  1352. if(lpInfo==NULL)
  1353. lpInfo = new CItemInfo;
  1355. UpdateData(pItem, lpInfo);
  1356. SetIndent(pItem, GetIndent(pParent)+1);
  1357. SetParentItem(pItem, pParent);
  1358. //add as the last child 
  1359. pParent->m_listChild.AddTail(pItem);
  1361. if(!bUpdate)
  1362.  Hide(pParent, TRUE);
  1363. else
  1364. {
  1365. //calc listview index for the new node
  1366. int nIndex = NodeToIndex(pItem);
  1367. CString str = GetData(pItem)->GetItemText();
  1368. LV_ITEM     lvItem;
  1369. lvItem.mask = LVIF_TEXT | LVIF_INDENT | LVIF_PARAM;
  1370. lvItem.pszText = str.GetBuffer(1); 
  1371. //insert item
  1372. lvItem.iItem = nIndex;
  1373. lvItem.iSubItem = 0;
  1374. lvItem.lParam = (LPARAM)pItem;
  1375. lvItem.iIndent = GetIndent(pItem);
  1376. CListCtrl::InsertItem(&lvItem);
  1377. if(lpInfo->GetCheck())
  1378. SetCheck(nIndex);
  1379. //Get subitems
  1380. int nSize = GetData(pItem)->GetItemCount();
  1381. for(int i=0; i < nSize;i++)
  1382. {
  1383.    CString str = GetData(pItem)->GetSubItem(i);
  1384.    lvItem.mask = LVIF_TEXT;
  1385.    lvItem.iSubItem = i+1;
  1386.    lvItem.pszText = str.GetBuffer(1);
  1387.    SetItem(&lvItem);
  1388. }
  1389. InternaleUpdateTree();//better do this
  1390. }
  1391. return pItem;
  1392. }
  1396. void CSuperGridCtrl::InternaleUpdateTree()
  1397. {
  1398. int nItems = GetItemCount();
  1399. for(int nItem=0; nItem < nItems; nItem++)
  1400. {
  1401. CTreeItem* pItem = GetTreeItem(nItem);
  1402. SetCurIndex(pItem, nItem);
  1403. }
  1404. }
  1407. int CSuperGridCtrl::NodeToIndex(CTreeItem *pNode)
  1408. {
  1409. int nStartIndex=0;
  1410. POSITION pos = m_RootItems.GetHeadPosition();
  1411. while(pos!=NULL)
  1412. {
  1413. CTreeItem * root = (CTreeItem*)m_RootItems.GetNext(pos);
  1414. int ret = _NodeToIndex(root, pNode, nStartIndex);
  1415. if(ret != -1)
  1416. return ret;
  1417. }
  1418. return -1;
  1419. }
  1424. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetRootItem(int nIndex)
  1425. {
  1426. POSITION pos = m_RootItems.FindIndex(nIndex);
  1427. if(pos==NULL)
  1428. return NULL;
  1429. return (CTreeItem*)m_RootItems.GetAt(pos);
  1430. }
  1434. int CSuperGridCtrl::GetRootIndex(CTreeItem * root)
  1435. {
  1436. int nIndex = 0;
  1437. POSITION pos = m_RootItems.GetHeadPosition();
  1438. while(pos != NULL)
  1439. {
  1440. CTreeItem * pItem = (CTreeItem*)m_RootItems.GetNext(pos);
  1441. if(pItem== root)
  1442. return nIndex;
  1443. nIndex++;
  1444. }
  1445. return -1;
  1446. }
  1450. BOOL CSuperGridCtrl::IsRoot(CTreeItem * lpItem)
  1451. {
  1452. return m_RootItems.Find(lpItem) != NULL;
  1453. }
  1456. void CSuperGridCtrl::DeleteRootItem(CTreeItem * root)
  1457. {
  1458. POSITION pos = m_RootItems.Find(root);
  1459. if(pos!=NULL)
  1460. {
  1461. CTreeItem* pRoot=(CTreeItem*)m_RootItems.GetAt(pos);
  1462. if(pRoot->m_lpNodeInfo!=NULL)
  1463. delete pRoot->m_lpNodeInfo;
  1464. delete pRoot;
  1465. m_RootItems.RemoveAt(pos);
  1466. }
  1467. }
  1471. CSuperGridCtrl::CTreeItem*  CSuperGridCtrl::InsertRootItem(CItemInfo * lpInfo)
  1472. {
  1473. if(lpInfo==NULL)
  1474. lpInfo = new CItemInfo;
  1476. CTreeItem* pRoot = NULL;
  1478. pRoot =  new CTreeItem();
  1480. CleanMe(pRoot);
  1481. UpdateData(pRoot, lpInfo);
  1482. SetIndent(pRoot, 1);
  1483. SetCurIndex(pRoot, GetItemCount());
  1484. SetParentItem(pRoot, NULL);
  1486. CItemInfo* lp = GetData(pRoot);
  1487. LV_ITEM lvItem;
  1488. lvItem.mask = LVIF_TEXT | LVIF_INDENT | LVIF_PARAM;
  1489. CString strItem = lp->GetItemText();
  1490. lvItem.pszText = strItem.GetBuffer(1); 
  1491. lvItem.iItem = GetItemCount();
  1492. lvItem.lParam = (LPARAM)pRoot;
  1493. lvItem.iIndent = 1;
  1494. lvItem.iSubItem = 0;
  1495. CListCtrl::InsertItem(&lvItem);
  1496. int nSize = lp->GetItemCount();
  1497. for(int i=0; i < nSize;i++)
  1498. {
  1499.    CString str = lp->GetSubItem(i);
  1500.    lvItem.mask = LVIF_TEXT;
  1501.    lvItem.iSubItem = i+1;
  1502.    lvItem.pszText = str.GetBuffer(1);
  1503.    SetItem(&lvItem);
  1504. }
  1505. m_RootItems.AddTail(pRoot);
  1506. return pRoot;
  1507. }
  1511. void CSuperGridCtrl::DrawTreeItem(CDC* pDC, CTreeItem* pSelItem, int nListItem, const CRect& rcBounds)
  1512. {
  1513. int nColWidth = GetColumnWidth(0);
  1514. int yDown = rcBounds.top;
  1515.     CPen* pPenTreeLine = pDC->SelectObject(&m_psTreeLine);
  1516. int iIndent = GetIndent(pSelItem);
  1517. int nHalfImage = (m_cxImage >> 1);
  1518. int nBottomDown = yDown + nHalfImage + ((rcBounds.Height() - m_cyImage) >> 1);
  1519. //
  1520. BOOL bChild = ItemHasChildren(pSelItem);
  1521. BOOL bCollapsed = IsCollapsed(pSelItem);
  1522. //draw outline
  1523. while(1)
  1524. {
  1525. CTreeItem* pParent = GetParentItem(pSelItem);
  1526. if(pParent==NULL)//no more parents, stop
  1527. break;
  1529. POSITION pos = pParent->m_listChild.GetTailPosition();
  1530. while(pos!=NULL)
  1531. {
  1532. CTreeItem *pLastChild = (CTreeItem*)pParent->m_listChild.GetPrev(pos);
  1533. int nIndex = GetCurIndex(pLastChild);
  1534. int nCurIndent = GetIndent(pLastChild);
  1535. if(nListItem > nIndex && iIndent > nCurIndent)//no need to go further in this loop
  1536. break;
  1538. //no drawing outside the 1st columns right
  1539. int xLine =  rcBounds.left + nCurIndent * m_cxImage - nHalfImage;
  1540. if(nIndex == nListItem && nCurIndent==iIndent)
  1541. {
  1542. //draw '-
  1543. int x;
  1544. pDC->MoveTo(xLine, yDown);
  1545. pDC->LineTo(xLine, nBottomDown);
  1546. // -
  1547. xLine + nHalfImage > nColWidth ? x = nColWidth: x = xLine + nHalfImage;
  1549. pDC->MoveTo(xLine, nBottomDown);
  1550. pDC->LineTo(x, nBottomDown);
  1551. break;
  1552. }
  1553. else
  1554. if(nIndex > nListItem && nCurIndent==iIndent)
  1555. {
  1556. //draw |-
  1557. int x;
  1558. xLine + nHalfImage > nColWidth ? x = nColWidth : x = xLine + nHalfImage;
  1559. pDC->MoveTo(xLine, nBottomDown);
  1560. pDC->LineTo(x, nBottomDown);
  1561. //-
  1562. pDC->MoveTo(xLine, yDown);
  1563. pDC->LineTo(xLine, rcBounds.bottom);
  1564. break;
  1565. }
  1566. else
  1567. if(nIndex > nListItem && nCurIndent < iIndent)
  1568. {
  1569. //draw |
  1570. pDC->MoveTo(xLine, yDown);
  1571. pDC->LineTo(xLine, rcBounds.bottom);
  1572. break;
  1573. }
  1574. }
  1575. pSelItem = pParent;//next
  1576. }
  1578. //draw plus/minus sign
  1579. if(bChild)
  1580. {
  1581. CRectangle rect(this, pDC, iIndent, rcBounds);
  1583. rect.DrawRectangle(this);
  1585. CPen* pPenPlusMinus = pDC->SelectObject(&m_psPlusMinus);
  1586. if(bCollapsed)
  1587. rect.DrawPlus();
  1588. else {
  1589. rect.DrawMinus();
  1590. //draw line up to parent folder
  1591. CPen* pLine = pDC->SelectObject(&m_psTreeLine);
  1592. int nOffset = (rcBounds.Height() - m_cyImage)/2;
  1593. pDC->MoveTo(rect.GetLeft()+ m_cxImage, rcBounds.top + m_cyImage+nOffset);
  1594. pDC->LineTo(rect.GetLeft() + m_cxImage, rcBounds.bottom);
  1595. pDC->SelectObject(pLine);
  1596. }
  1597. pDC->SelectObject(pPenPlusMinus);
  1598. }
  1599. pDC->SelectObject(pPenTreeLine);
  1600. }
  1604. //walk all over the place setting the hide/show flag of the nodes.
  1605. //it also deletes items from the listviewctrl.
  1606. void CSuperGridCtrl::HideChildren(CTreeItem *pItem, BOOL bHide,int nItem)
  1607. {
  1608. if(!IsCollapsed(pItem))
  1609. if(ItemHasChildren(pItem))
  1610. {
  1611. Hide(pItem, bHide);
  1612. POSITION pos = pItem->m_listChild.GetHeadPosition();
  1613. while (pos != NULL)
  1614. {
  1615. HideChildren((CTreeItem *)pItem->m_listChild.GetNext(pos),bHide,nItem+1);
  1616. DeleteItem(nItem);
  1618. }
  1619. }
  1620. }
  1625. void CSuperGridCtrl::Collapse(CTreeItem *pItem)
  1626. {
  1627. if(pItem != NULL && ItemHasChildren(pItem))
  1628. {
  1629. SetRedraw(0);
  1630. int nIndex = NodeToIndex(pItem);
  1631. HideChildren(pItem, TRUE, nIndex+1);
  1632. InternaleUpdateTree();
  1633. SetRedraw(1);
  1634. }
  1635. }
  1638. void CSuperGridCtrl::ExpandAll(CTreeItem *pItem, int& nScroll)
  1639. {
  1640. const int nChildren = pItem->m_listChild.GetCount();
  1641. if (nChildren > 0)
  1642. {
  1643. int nIndex = NodeToIndex(pItem);
  1644. nScroll = Expand(pItem, nIndex);
  1645. }
  1647. POSITION pos = pItem->m_listChild.GetHeadPosition();
  1648. while (pos)
  1649. {
  1650. CTreeItem *pChild = (CTreeItem*)pItem->m_listChild.GetNext(pos);
  1651. ExpandAll(pChild, nScroll);
  1652. }
  1654. }
  1658. int CSuperGridCtrl::Expand(CTreeItem* pSelItem, int nIndex)
  1659. {
  1660. if(ItemHasChildren(pSelItem) && IsCollapsed(pSelItem))
  1661. {
  1662. LV_ITEM lvItem;
  1663. lvItem.mask = LVIF_INDENT;
  1664. lvItem.iItem = nIndex;
  1665. lvItem.iSubItem = 0;
  1666. lvItem.lParam=(LPARAM)pSelItem;
  1667. lvItem.iIndent = GetIndent(pSelItem);
  1668. SetItem(&lvItem);
  1670. Hide(pSelItem, FALSE);
  1671. //expand children
  1672. POSITION pos = pSelItem->m_listChild.GetHeadPosition();
  1673. while(pos != NULL)
  1674. {
  1675. CTreeItem* pNextNode = (CTreeItem*)pSelItem->m_listChild.GetNext(pos);
  1676. CString str = GetData(pNextNode)->GetItemText();
  1677. LV_ITEM lvItem;
  1678. lvItem.mask = LVIF_TEXT | LVIF_INDENT | LVIF_PARAM;
  1679. lvItem.pszText =str.GetBuffer(1); 
  1680. lvItem.iItem = nIndex + 1;
  1681. lvItem.iSubItem = 0;
  1682. lvItem.lParam=(LPARAM)pNextNode;
  1683. lvItem.iIndent = GetIndent(pSelItem)+1;
  1684. CListCtrl::InsertItem(&lvItem);
  1685. if(GetData(pNextNode)->GetCheck())
  1686. SetCheck(nIndex + 1);
  1687. //get subitems
  1688. int nSize = GetData(pNextNode)->GetItemCount();
  1689. for(int i=0; i< nSize;i++)
  1690. {
  1691.    CString str=GetData(pNextNode)->GetSubItem(i);
  1692.    lvItem.mask = LVIF_TEXT;
  1693.    lvItem.iSubItem = i+1;
  1694.    lvItem.pszText=str.GetBuffer(1);
  1695.    SetItem(&lvItem);
  1696. }
  1697. nIndex++;
  1698. }
  1699. }
  1700. InternaleUpdateTree();
  1701. return nIndex;
  1702. }
  1707. int CSuperGridCtrl::SelectNode(CTreeItem *pLocateNode)
  1708. {
  1709. if(IsRoot(pLocateNode))
  1710. {
  1711. UINT uflag = LVIS_SELECTED | LVIS_FOCUSED;
  1712. SetItemState(0, uflag, uflag);
  1713. return 0;
  1714. }
  1715. int nSelectedItem=-1;
  1716. CTreeItem* pNode = pLocateNode;
  1717. CTreeItem* pTopLevelParent=NULL;
  1718. //Get top parent
  1719. while(1)
  1720. {
  1721. CTreeItem *pParent = GetParentItem(pLocateNode);
  1722. if(IsRoot(pParent))
  1723. break;
  1724. pLocateNode = pParent;
  1725. }
  1726. pTopLevelParent = pLocateNode;//on top of all
  1727. //Expand the folder
  1728. if(pTopLevelParent != NULL)
  1729. {
  1730. SetRedraw(0);
  1731. CWaitCursor wait;
  1732. CTreeItem *pRoot = GetParentItem(pTopLevelParent);
  1734. if(IsCollapsed(pRoot))
  1735. Expand(pRoot,0);
  1737. ExpandUntil(pTopLevelParent, pNode);
  1739. UINT uflag = LVIS_SELECTED | LVIS_FOCUSED;
  1740. nSelectedItem = NodeToIndex(pNode);
  1742. SetItemState(nSelectedItem, uflag, uflag);
  1744. SetRedraw(1);
  1745. EnsureVisible(nSelectedItem, TRUE);
  1746. }
  1747. return nSelectedItem;
  1748. }
  1753. void CSuperGridCtrl::ExpandUntil(CTreeItem *pItem, CTreeItem* pStopAt)
  1754. {
  1755. const int nChildren = pItem->m_listChild.GetCount();
  1756. if (nChildren > 0)
  1757. {
  1758. POSITION pos = pItem->m_listChild.GetHeadPosition();
  1759. while (pos)
  1760. {
  1761. CTreeItem *pChild = (CTreeItem*)pItem->m_listChild.GetNext(pos);
  1762. if(pChild == pStopAt)
  1763. {
  1764. int nSize = GetIndent(pChild);
  1765. CTreeItem** ppParentArray = new CTreeItem*[nSize];
  1766. int i=0;
  1767. while(1)
  1768. {
  1769. CTreeItem *pParent = GetParentItem(pChild);
  1771. if(IsRoot(pParent))
  1772. break;
  1773. pChild = pParent;
  1774. ppParentArray[i] = pChild;
  1775. i++;
  1776. }
  1778. for(int x=i; x > 0; x--)
  1779. {
  1780. CTreeItem *pParent = ppParentArray[x-1];
  1781. Expand(pParent, NodeToIndex(pParent));
  1782. }
  1783. delete [] ppParentArray;
  1784. return;
  1785. }
  1786. }
  1787. }
  1789. POSITION pos = pItem->m_listChild.GetHeadPosition();
  1790. while (pos)
  1791. {
  1792. CTreeItem *pChild = (CTreeItem*)pItem->m_listChild.GetNext(pos);
  1793. ExpandUntil(pChild, pStopAt);
  1794. }
  1796. }
  1800. void CSuperGridCtrl::DeleteItemEx(CTreeItem *pSelItem, int nItem)
  1801. {
  1802. SetRedraw(0);
  1803. DeleteItem(nItem);//delete cur item in listview
  1804. //delete/hide all children in pSelItem
  1805. HideChildren(pSelItem, TRUE, nItem);
  1806. //delete all internal nodes
  1807. // If root, must delete from m_rootData
  1808. if(GetParentItem(pSelItem) == NULL )
  1809. {
  1810. DeleteRootItem(pSelItem);
  1811. }
  1812. else
  1813. Delete(pSelItem);
  1815. InternaleUpdateTree();
  1816. if(nItem-1<0)//no more items in list
  1817. {
  1818. SetRedraw(1); 
  1819. InvalidateRect(NULL);
  1820. UpdateWindow();
  1821. return;
  1822. }
  1824. UINT uflag = LVIS_SELECTED | LVIS_FOCUSED;
  1825. CRect rcTestIfItemIsValidToSelectOtherWiseSubtrackOneFromItem;//just to get the documention right :)
  1826. GetItemRect(nItem, rcTestIfItemIsValidToSelectOtherWiseSubtrackOneFromItem ,LVIR_LABEL) ? SetItemState(nItem, uflag, uflag) : SetItemState(nItem-1, uflag, uflag);
  1828. SetRedraw(1);
  1829. InvalidateRect(NULL);
  1830. UpdateWindow();
  1831. }
  1835. void CSuperGridCtrl::CleanMe(CTreeItem *pItem)
  1836. {
  1837. // delete child nodes
  1838. POSITION pos = pItem->m_listChild.GetHeadPosition();
  1839. while (pos != NULL)
  1840. {
  1841. CTreeItem* pItemData = (CTreeItem*)pItem->m_listChild.GetNext(pos);
  1842. if(pItemData!=NULL)
  1843. {
  1844. if(pItemData->m_lpNodeInfo!=NULL)
  1845. delete pItemData->m_lpNodeInfo;
  1847. pItemData->m_listChild.RemoveAll();
  1848. delete pItemData;
  1849. }
  1850. }
  1851. pItem->m_listChild.RemoveAll();
  1852. }
  1857. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetNext(CTreeItem* pStartAt, CTreeItem* pNode, BOOL bInit, BOOL bDontIncludeHidden)
  1858. {
  1859. static BOOL bFound;
  1860. if (bInit)
  1861. bFound = FALSE;
  1863. if (pNode == pStartAt)
  1864. bFound = TRUE;
  1866. if(bDontIncludeHidden)
  1867. {
  1868. if (!IsCollapsed(pStartAt))
  1869. {
  1870. POSITION pos = pStartAt->m_listChild.GetHeadPosition();
  1871. while (pos != NULL)
  1872. {
  1873. CTreeItem* pChild = (CTreeItem*)pStartAt->m_listChild.GetNext(pos);
  1874. if (bFound)
  1875. return pChild;
  1876. pChild = GetNext(pChild, pNode, FALSE, TRUE);
  1877. if (pChild != NULL)
  1878. return pChild;
  1879. }
  1880. }
  1881. }
  1882. else {
  1883. POSITION pos = pStartAt->m_listChild.GetHeadPosition();
  1884. while (pos != NULL)
  1885. {
  1886. CTreeItem* pChild = (CTreeItem*)pStartAt->m_listChild.GetNext(pos);
  1887. if (bFound)
  1888. return pChild;
  1889. pChild = GetNext(pChild, pNode, FALSE,FALSE);
  1890. if (pChild != NULL)
  1891. return pChild;
  1892. }
  1893. }
  1894. // if reached top and last level return original
  1895. if (bInit)
  1896. return pNode;
  1897. else
  1898. return NULL;
  1899. }
  1903. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetPrev(CTreeItem* pStartAt, CTreeItem* pNode, BOOL bInit, BOOL bDontIncludeHidden)
  1904. {
  1905. static CTreeItem* pPrev;
  1906. if (bInit)
  1907. pPrev = pStartAt;
  1909. if (pNode == pStartAt)
  1910. return pPrev;
  1912. pPrev = pStartAt;
  1914. if(bDontIncludeHidden)
  1915. {
  1916. if (!IsCollapsed(pStartAt))
  1917. {
  1918. POSITION pos = pStartAt->m_listChild.GetHeadPosition();
  1919. while (pos != NULL)
  1920. {
  1921. CTreeItem* pCur = (CTreeItem*)pStartAt->m_listChild.GetNext(pos);
  1922. CTreeItem* pChild = GetPrev(pCur,pNode, FALSE,TRUE);
  1923. if (pChild != NULL)
  1924. return pChild;
  1925. }
  1926. }
  1927. }
  1928. else {
  1929. POSITION pos = pStartAt->m_listChild.GetHeadPosition();
  1930. while (pos != NULL)
  1931. {
  1932. CTreeItem* pCur = (CTreeItem*)pStartAt->m_listChild.GetNext(pos);
  1933. CTreeItem* pChild = GetPrev(pCur,pNode, FALSE,FALSE);
  1934. if (pChild != NULL)
  1935. return pChild;
  1936. }
  1937. }
  1939. if (bInit)
  1940. return pPrev;
  1941. else
  1942. return NULL;
  1943. }
  1946. int CSuperGridCtrl::_NodeToIndex(CTreeItem *pStartpos, CTreeItem* pNode, int& nIndex, BOOL binit)
  1947. {
  1948. static BOOL bFound;
  1949. // Account for other root nodes
  1950. if(GetParentItem(pStartpos) == NULL && GetRootIndex(pStartpos) !=0)
  1951. nIndex++;
  1953. if(binit)
  1954. bFound=FALSE;
  1956. if(pStartpos==pNode)
  1957. bFound=TRUE;
  1959. if(!IsCollapsed(pStartpos))
  1960. {
  1961. POSITION pos = GetHeadPosition(pStartpos);
  1962. while (pos)
  1963. {
  1964. CTreeItem *pChild = GetNextChild(pStartpos, pos);
  1965. if(bFound)
  1966. return nIndex;
  1968. // Craig Schmidt: Cannot set nIndex as return value.  Worked find with single root but
  1969. //    the calling function get confused since the return value may indicate
  1970. //    that the next root needs to be searched.  Didn'd spend much time on
  1971. //    this so there is probably a better way of doing this.
  1972. // nIndex = _NodeToIndex(pChild, pNode, nIndex, binit);
  1973. _NodeToIndex(pChild, pNode, nIndex, binit);
  1974. nIndex++;
  1975. }
  1976. }
  1977. if(binit && bFound)
  1978. return nIndex;
  1979. else
  1980. return -1;
  1981. }
  1984. BOOL CSuperGridCtrl::Delete(CTreeItem* pNode, BOOL bClean)
  1985. {
  1986. POSITION pos = m_RootItems.GetHeadPosition();
  1987. while(pos!=NULL)
  1988. {
  1989. CTreeItem * pRoot = (CTreeItem*)m_RootItems.GetNext(pos);
  1990. if(_Delete(pRoot, pNode, bClean))
  1991. return TRUE;
  1992. }
  1993. return FALSE;
  1994. }
  1998. BOOL CSuperGridCtrl::_Delete(CTreeItem* pStartAt, CTreeItem* pNode, BOOL bClean)
  1999. {
  2000. POSITION pos = pStartAt->m_listChild.GetHeadPosition();
  2001. while (pos != NULL)
  2002. {
  2003. POSITION posPrev = pos;
  2004. CTreeItem *pChild = (CTreeItem*)pStartAt->m_listChild.GetNext(pos);
  2005. if (pChild == pNode)
  2006. {
  2007. pStartAt->m_listChild.RemoveAt(posPrev);
  2008. if(bClean)
  2009. {
  2010. if(GetData(pNode)!=NULL)
  2011. delete GetData(pNode);
  2012. delete pNode;
  2013. }
  2014. return TRUE;
  2015. }
  2016. if (_Delete(pChild, pNode) == TRUE)
  2017. return TRUE;
  2018. }
  2019. return FALSE;
  2020. }
  2025. BOOL CSuperGridCtrl::IsChildOf(const CTreeItem* pParent, const CTreeItem* pChild) const
  2026. {
  2027. if (pChild == pParent)
  2028. return TRUE;
  2029. POSITION pos = pParent->m_listChild.GetHeadPosition();
  2030. while (pos != NULL)
  2031. {
  2032. CTreeItem* pNode = (CTreeItem*)pParent->m_listChild.GetNext(pos);
  2033. if (IsChildOf(pNode, pChild))
  2034. return TRUE;
  2035. }
  2036. return FALSE;
  2037. }
  2041. void CSuperGridCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  2042. {
  2043. if( GetFocus() != this) 
  2044. SetFocus();
  2046. LVHITTESTINFO ht;
  2047. ht.pt = point;
  2048. SubItemHitTest(&ht);
  2049. if(OnItemLButtonDown(ht))
  2050. {
  2051. BOOL bSelect=1;
  2052. bSelect = HitTestOnSign(point, ht);
  2053. if(bSelect && ht.iItem!=-1)
  2054. {
  2055. m_CurSubItem = IndexToOrder(ht.iSubItem);
  2056. CHeaderCtrl* pHeader = GetHeaderCtrl();
  2057. // Make the column fully visible.
  2058. MakeColumnVisible(Header_OrderToIndex(pHeader->m_hWnd, m_CurSubItem));
  2059. CListCtrl::OnLButtonDown(nFlags, point);
  2060. OnControlLButtonDown(nFlags, point, ht);
  2061. //update row anyway for selection bar
  2062. CRect rc;
  2063. GetItemRect(ht.iItem, rc, LVIR_BOUNDS);
  2064. InvalidateRect(rc);
  2065. UpdateWindow();
  2066. }
  2067. }
  2068. }
  2071. void CSuperGridCtrl::OnUpdateListViewItem(CTreeItem* lpItem, LV_ITEM *plvItem)
  2072. {
  2073. //default implementation you would go for this 9 out of 10 times
  2074. CItemInfo *lp = GetData(lpItem);
  2075. CString str = (CString)plvItem->pszText;
  2076. if(lp!=NULL)
  2077. {
  2078. if(plvItem->iSubItem==0)
  2079. lp->SetItemText(str);
  2080. else //subitem data 
  2081. lp->SetSubItemText(plvItem->iSubItem-1, str);
  2082.    UpdateData(lpItem, lp);
  2083. }
  2084. SetItemText(plvItem->iItem, plvItem->iSubItem, plvItem->pszText);
  2085. }
  2089. void CSuperGridCtrl::DeleteAll()
  2090. {
  2091. POSITION pos = m_RootItems.GetHeadPosition();
  2092. while(pos!=NULL)
  2093. {
  2094. CTreeItem * pRoot = (CTreeItem*)m_RootItems.GetNext(pos);
  2095. if(pRoot!=NULL)
  2096. DeleteItemEx(pRoot, 0);
  2097. }
  2098. }
  2101. POSITION CSuperGridCtrl::GetRootHeadPosition() const
  2102. {
  2103. return m_RootItems.GetHeadPosition();
  2104. }
  2107. POSITION CSuperGridCtrl::GetRootTailPosition() const
  2108. {
  2109. return m_RootItems.GetTailPosition();
  2110. }
  2113. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetNextRoot(POSITION& pos) const
  2114. {
  2115. return (CTreeItem*)m_RootItems.GetNext(pos);
  2116. }
  2119. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetPrevRoot(POSITION& pos) const
  2120. {
  2121. return (CTreeItem*)m_RootItems.GetNext(pos);
  2122. }
  2125. POSITION CSuperGridCtrl::GetHeadPosition(CTreeItem* pItem) const
  2126. {
  2127. return pItem->m_listChild.GetHeadPosition();
  2128. }
  2132. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetNextChild(CTreeItem *pItem, POSITION& pos) const
  2133. {
  2134. return (CTreeItem*)pItem->m_listChild.GetNext(pos);
  2135. }
  2139. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetPrevChild(CTreeItem *pItem, POSITION& pos) const
  2140. {
  2141. return (CTreeItem*)pItem->m_listChild.GetPrev(pos);
  2142. }
  2146. POSITION CSuperGridCtrl::GetTailPosition(CTreeItem *pItem) const
  2147. {
  2148. return pItem->m_listChild.GetTailPosition();
  2149. }
  2153. void CSuperGridCtrl::AddTail(CTreeItem *pParent, CTreeItem *pChild)
  2154. {
  2155. pParent->m_listChild.AddTail(pChild);
  2156. }
  2159. inline int StrComp(const CString* pElement1, const CString* pElement2)
  2160. {
  2161. return pElement1->Compare(*pElement2);
  2162. }
  2166. int CSuperGridCtrl::CompareChildren(const void* p1, const void* p2)
  2167. {
  2168. CTreeItem * pChild1 = *(CTreeItem**)p1;
  2169. CTreeItem * pChild2 = *((CTreeItem**)p2);
  2170. CItemInfo *pItem1=(*pChild1).m_lpNodeInfo;
  2171. CItemInfo *pItem2=(*pChild2).m_lpNodeInfo;
  2172. return StrComp(&(pItem1->GetItemText()), &(pItem2->GetItemText()));
  2173. }
  2176. void CSuperGridCtrl::Sort(CTreeItem* pParent, BOOL bSortChildren)
  2177. {
  2178. const int nChildren = NumChildren(pParent);
  2179. if (nChildren > 1)
  2180. {
  2181. CTreeItem** ppSortArray = new CTreeItem*[nChildren];
  2182. // Fill in array with pointers to our children.
  2183. POSITION pos = pParent->m_listChild.GetHeadPosition();
  2184. for (int i=0; pos; i++)
  2185. {
  2186. ASSERT(i < nChildren);
  2187. ppSortArray[i] = (CTreeItem*)pParent->m_listChild.GetAt(pos);
  2188. pParent->m_listChild.GetNext(pos);
  2189. }
  2191. qsort(ppSortArray, nChildren, sizeof(CTreeItem*), CompareChildren);
  2192. // reorg children with new sorted list
  2193. pos = pParent->m_listChild.GetHeadPosition();
  2194. for (i=0; pos; i++)
  2195. {
  2196. ASSERT(i < nChildren);
  2197. pParent->m_listChild.SetAt(pos, ppSortArray[i]);
  2198. pParent->m_listChild.GetNext(pos);
  2199. }
  2201. delete [] ppSortArray;
  2202. }
  2204. if(bSortChildren)
  2205. {
  2206. POSITION pos = pParent->m_listChild.GetHeadPosition();
  2207. while (pos)
  2208. {
  2209. CTreeItem *pChild = (CTreeItem*)pParent->m_listChild.GetNext(pos);
  2210. Sort(pChild, TRUE);
  2211. }
  2212. }
  2213. }
  2217. int CSuperGridCtrl::NumChildren(const CTreeItem *pItem) const
  2218. {
  2219. return pItem->m_listChild.GetCount();
  2220. }
  2224. BOOL CSuperGridCtrl::ItemHasChildren(const CTreeItem* pItem) const
  2225. { 
  2226. BOOL bChildren = pItem->m_listChild.GetCount() != 0;
  2227. //see if we have a flag
  2228. int nFlag = pItem->m_bSetChildFlag;
  2229. if(nFlag!=-1)
  2230. return 1;
  2231. else
  2232. return bChildren;
  2233. }
  2236. void CSuperGridCtrl::SetChildrenFlag(CTreeItem *pItem, int nFlag) const
  2237. {
  2238. pItem->m_bSetChildFlag = nFlag;
  2239. }
  2242. BOOL CSuperGridCtrl::IsCollapsed(const CTreeItem* pItem) const
  2243. {
  2244. return pItem->m_bHideChildren;//e.g not visible
  2245. }
  2248. void CSuperGridCtrl::Hide(CTreeItem* pItem, BOOL bFlag)
  2249. {
  2250. pItem->m_bHideChildren=bFlag;
  2251. }
  2254. int CSuperGridCtrl::GetIndent(const CTreeItem* pItem) const
  2255. {
  2256. return pItem->m_nIndent;
  2257. }
  2260. void CSuperGridCtrl::SetIndent(CTreeItem *pItem, int iIndent)
  2261. {
  2262. pItem->m_nIndent = iIndent;
  2263. }
  2267. int CSuperGridCtrl::GetCurIndex(const CTreeItem *pItem) const
  2268. {
  2269. return pItem->m_nIndex;
  2270. }
  2273. void CSuperGridCtrl::SetCurIndex(CTreeItem* pItem, int nIndex) 
  2274. {
  2275. pItem->m_nIndex = nIndex;
  2276. }
  2279. void CSuperGridCtrl::SetParentItem(CTreeItem*pItem, CTreeItem* pParent)
  2280. {
  2281. pItem->m_pParent=pParent;
  2283. }
  2286. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetParentItem(const CTreeItem* pItem) 
  2287. {
  2288. return pItem->m_pParent;
  2289. };
  2293. CItemInfo* CSuperGridCtrl::GetData(const CTreeItem* pItem) 
  2294. {
  2295. return pItem->m_lpNodeInfo;
  2296. }
  2300. void CSuperGridCtrl::UpdateData(CTreeItem* pItem, CItemInfo* lpInfo)
  2301. {
  2302. pItem->m_lpNodeInfo = lpInfo;
  2303. }
  2306. //overrides
  2307. CItemInfo* CSuperGridCtrl::CopyData(CItemInfo* lpSrc)
  2308. {
  2309. ASSERT(FALSE);//debug
  2310. return NULL;  //release
  2311. }
  2313. //default implementation for setting icons
  2314. int CSuperGridCtrl::GetIcon(const CTreeItem* pItem)
  2315. {
  2317. return 0;//just take the first item in CImageList ..what ever that is
  2318. }
  2321. void CSuperGridCtrl::OnControlLButtonDown(UINT nFlags, CPoint point, LVHITTESTINFO& ht)
  2322. {
  2323. if(ht.iSubItem==0)
  2324. {
  2325. CRect rcItem;
  2326. GetItemRect(ht.iItem, rcItem, LVIR_LABEL);
  2327. DWORD dwStyle = WS_BORDER | WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL|ES_LEFT;
  2328. CEdit *pEdit = new CListEditCtrl(ht.iItem, ht.iSubItem, GetItemText(ht.iItem, ht.iSubItem));
  2329. pEdit->Create(dwStyle, rcItem, this, 0x1233);
  2330. }
  2331. else
  2332. EditLabelEx(ht.iItem, ht.iSubItem);
  2333. }
  2336. COLORREF CSuperGridCtrl::GetCellRGB()
  2337. {
  2338. return RGB(192,0,0);
  2339. }
  2342. BOOL CSuperGridCtrl::OnVKMultiply(CTreeItem *pItem, int nIndex)
  2343. {
  2344. return 1;
  2345. }
  2349. BOOL CSuperGridCtrl::OnVkSubTract(CTreeItem *pItem, int nIndex)
  2350. {
  2351. return 1;
  2352. }
  2356. BOOL CSuperGridCtrl::OnVKAdd(CTreeItem *pItem, int nIndex)
  2357. {
  2358. return 1;
  2359. }
  2362. BOOL CSuperGridCtrl::OnDeleteItem(CTreeItem* pItem, int nIndex)
  2363. {
  2364. return 1;
  2365. }
  2369. BOOL CSuperGridCtrl::OnItemExpanding(CTreeItem *pItem, int iItem)
  2370. {
  2371. return 1;
  2372. }
  2375. BOOL CSuperGridCtrl::OnItemExpanded(CTreeItem* pItem, int iItem)
  2376. {
  2377. return 1;
  2378. }
  2381. BOOL CSuperGridCtrl::OnCollapsing(CTreeItem *pItem)
  2382. {
  2383. return 1;
  2384. }
  2387. BOOL CSuperGridCtrl::OnItemCollapsed(CTreeItem *pItem)
  2388. {
  2389. return 1;
  2390. }
  2393. BOOL CSuperGridCtrl::OnItemLButtonDown(LVHITTESTINFO& ht)
  2394. {
  2395. return 1;
  2396. }
  2399. BOOL CSuperGridCtrl::OnVkReturn(void)
  2400. {
  2401. return 0;
  2402. }
  2405. void CSuperGridCtrl::OnSysColorChange() 
  2406. {
  2407. CListCtrl::OnSysColorChange();
  2408. //nop nothing yet
  2409. }
  2413. UINT CSuperGridCtrl::_GetCount(CTreeItem* pItem, UINT& nCount)
  2414. {
  2415. POSITION pos = pItem->m_listChild.GetHeadPosition();
  2416. while (pos)
  2417. {
  2418. CTreeItem *pChild = (CTreeItem*)pItem->m_listChild.GetNext(pos);
  2419. nCount = _GetCount(pChild, nCount);
  2420. nCount++;
  2421. }
  2422. return nCount;
  2423. }
  2427. UINT CSuperGridCtrl::GetCount(void) 
  2428. {
  2429. UINT nCount=0;
  2430. UINT _nCount=0;
  2431. POSITION pos = m_RootItems.GetHeadPosition();
  2432. while(pos!=NULL)
  2433. {
  2434. CTreeItem * pRoot = (CTreeItem*)m_RootItems.GetNext(pos);
  2435. nCount += _GetCount(pRoot, _nCount) + 1;
  2436. }
  2437. return nCount;
  2438. }
  2442. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetTreeItem(int nIndex /*nIndex must be valid of course*/ ) 
  2443. {
  2444. return reinterpret_cast<CTreeItem*>(GetItemData(nIndex));
  2445. }
  2449. int CSuperGridCtrl::GetSelectedItem(void) const
  2450. {
  2451. return GetNextItem(-1, LVNI_ALL | LVNI_SELECTED); 
  2452. }
  2454. //////////////////////////////////////////////////////////////////////////
  2455. //
  2456. // not much but ... 
  2457. //
  2458. //////////////////////////////////////////////////////////////////////////
  2460. CSuperGridCtrl::CTreeItem::~CTreeItem()
  2461. {
  2462. // delete child nodes
  2463. POSITION pos = m_listChild.GetHeadPosition();
  2464. while (pos != NULL)
  2465. {
  2466. CTreeItem* pItem = (CTreeItem*)m_listChild.GetNext(pos);
  2467. if(pItem!=NULL)
  2468. {
  2469. if(pItem->m_lpNodeInfo!=NULL)
  2470. delete pItem->m_lpNodeInfo;
  2471. delete pItem;
  2472. }
  2473. }
  2474. m_listChild.RemoveAll();
  2475. }
  2479. //////////////////////////////////////////////////////////////////////////
  2480. //
  2481. // Simple class CRectangle for the + - sign, 
  2482. //
  2483. //////////////////////////////////////////////////////////////////////////
  2485. CRectangle::CRectangle(CSuperGridCtrl* pCtrl, CDC* pDC, int iIndent, const CRect& rcBounds)
  2486. {
  2487. m_pDC=pDC;
  2488. int nHalfImage = (pCtrl->m_cxImage >> 1);
  2489. int nBottomDown = rcBounds.top + nHalfImage + ((rcBounds.Height() - pCtrl->m_cyImage) >> 1);
  2490. m_right_bottom.cx = (pCtrl->m_cxImage>>1)+2+1;
  2491. m_right_bottom.cy = (pCtrl->m_cyImage>>1)+2+1;
  2492. m_left = rcBounds.left  + iIndent * pCtrl->m_cxImage - nHalfImage;
  2493. m_top = nBottomDown - (m_right_bottom.cy >> 1);
  2494. m_left_top.x = m_left -  (m_right_bottom.cx >> 1);
  2495. m_left_top.y = m_top;
  2496. m_topdown = nBottomDown;
  2497. }
  2500. void CRectangle::DrawRectangle(CSuperGridCtrl* pCtrl)
  2501. {
  2502. //erase bkgrnd
  2503. CRect rc(m_left_top, m_right_bottom);
  2504. m_pDC->FillRect(rc, &pCtrl->m_brushErase);
  2505. //draw rectangle
  2506. CPen* pPenRectangle = m_pDC->SelectObject(&pCtrl->m_psRectangle);
  2507. m_pDC->Rectangle(rc);
  2508. m_pDC->SelectObject(pPenRectangle);
  2509. }
  2512. CRectangle::~CRectangle()
  2513. {
  2514. }
  2517. BOOL CRectangle::HitTest(CPoint pt)
  2518. {
  2519. CRect rc = GetHitTestRect();
  2520. return rc.PtInRect(pt);
  2521. }
  2524. void CRectangle::DrawPlus(void)
  2525. {
  2526. m_pDC->MoveTo(m_left, m_topdown-2);
  2527. m_pDC->LineTo(m_left, m_topdown+3);
  2529. m_pDC->MoveTo(m_left-2, m_topdown);
  2530. m_pDC->LineTo(m_left+3, m_topdown);
  2531. }
  2534. void CRectangle::DrawMinus(void)
  2535. {
  2536. m_pDC->MoveTo(m_left-2, m_topdown);
  2537. m_pDC->LineTo(m_left+3, m_topdown);
  2538. }