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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
supergridctrl.cpp
资源名称：MiniCA2.rar　[点击查看]
上传用户：dengkfang
上传日期：2008-12-30
资源大小：5233k
文件大小：64k
源码类别：

CA认证

开发平台：

Visual C++

supergridctrl.cpp：源码内容
  1. // SuperGridCtrl.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "SuperGridCtrl.h"
  9. #ifdef _DEBUG
  10. #define new DEBUG_NEW
  11. #undef THIS_FILE
  12. static char THIS_FILE[] = __FILE__;
  13. #endif
  15. /*
  16.     SuperGrid, YALC (yet another listview control) 
  18. Written by me(Allan Nielsen), that is .. if the code works :)
  19. mailto:allan@object-oriented.com
  21. Copyright (c) 1999.
  23. If you find bugs, please notify me and I'll contact the author who wrote the darn thing :)
  25.     You may use it, abuse it, redistribute it, in any way you desire, but
  26. if you choose to use this control in any commercial or non commercial application then please 
  27. send me an email letting me know, makes me :) . 
  30. HISTORY 
  32. what's new since last update: 
  34. 4 dec. 1998.
  36. - MeasureItem now uses current font
  37. - Combobox support in CItemInfo
  38.   see the ShowList in MySuperGrid.h/cpp, PreTranslateMessage functions
  39.   and the file ComboInListView.cpp/h
  40.                 - function to indicate the precens of a combobox it draws a down arrow ..see DrawComboBox
  41.   the idea came from Robert Bouwens. :)
  42. - in file TestTreeDlg.cpp:  due to the MeasureItem message-reflection
  43.   the listctrl is now created in the CDialog::OnCreate function and later on resized
  44. - LVIS_DROPHILITED support when dragging items
  45. - Support for LVS_EX_CHECKBOXES   
  46. - Added some examples on how to print preview selected item(or at least to get some information from of the grid)
  47.   the sample is in the CTreeList.h/cpp which is derived from CSuperGridCtrl it shows you
  48.   how to initalize the grid, sort items, search for items and subitems, select and delete thems
  49. - added virtual GetIcon function to set your default icon handler for a listview index.
  50. - added virtual GetCellRGB() to set the color for current selected cell
  51. - renamed CTreeNode to CTreeItem, sorry ;-(
  52. - the nested class CTreeItem has been stripped down to nothing but simple (struct)data members
  53.   only servering as a linked list of lists now :-)
  54. - well.. moved all the importent stuff from CTreeItem to CSuperGridCtrl e.g
  55.   all operations on a CTreeItem now resides in the CSuperGridCtrl, much more OO-like ;-)
  56. - added Quicksort function
  57. - got rid of TheOpenCloseThing function.
  58. - added virtual function OnUpdateListViewItem..called when ever an Item is about to be updated
  59. - added virtual function OnControlLButtonDown...called when ever LButtondown in a cell
  60. - added virtual function CreateDragImageEx...
  62. 11 jan 1999:
  63. - added SetFocus in OnDblclk and in OnLButtonDown, big thank you to Dieter Gollwitzer 
  64. - fixed a minor hittest error in the HitTestOnSign(), again thanks to Dieter Gollwitzer 
  67. 16 jan 1999: 
  68. - added virtual OnItemExpanding(....
  69. - added virtual OnItemExpanded(...
  70. - added virtual OnCollapsing(....
  71. - added virtual OnItemCollapsed(...
  72. - added virtual OnDeleteItem(....
  73. - added virtual OnVKMultiply(...
  74. - added virtual OnVkSubTract(..
  75. - added virtual OnVKAdd(....
  76. - added SetChildrenFlag();
  78. 1 feb 1999:
  79. - CItemInfo now supports individual cell-color
  80. - fixed some bugs in regards to listdata associated with in each cell
  81. - added virtual BOOL OnVkReturn(........
  82. - added virtual BOOL OnItemLButtonDown(.....
  84. 4 mai 1999  - moved to Switzerland to work as a systemdeveloper for 2-3 years :).
  85. - new email :)
  86. - added new class for encapsulating drawing + - buttons.
  88.    22.june 1999 - Added GetCount()
  89. - removed support for VC++ 5.0.
  90. - added GetTreeItem(.....) 
  91. - GetSelectedItem(.....)
  92. - Howto disable Drag/drop in CTreeList
  93. - level 4 compiled
  94. - Clean up some redudant code crap
  96. 30.june 99  - fixed minor error in DrawItem, a drawing error occurred when 1.st column was hidden, 
  97.   it was previous fixed, but some how it was introduced again :).
  100. 9. juli 99  - CRAIG SCHMIDT "the beachboy":)
  102.   Craig did the implementation of the Multiple Root request
  103.   his email are "craig_a_schmidt@yahoo.com" if you have any Questions
  104.   in regards to multiple roots implementation, although I think I can help too :).
  106.   he added the following functions :
  108.   - CTreeItem*  InsertRootItem(.....
  109.   - void DeleteRootItem(....
  110.   - BOOL IsRoot(...
  111.   - CTreeItem* GetRootItem(..
  112.   - int GetRootIndex(..
  113.   - int GetRootCount(...
  114.   - and a member variable, CPtrList m_RootItems which of course are a collection of ..ta da RootItems a.k.a CTreeItem.
  115.   see the file CTreeList.cpp for usage of the InsertRootItem.
  117.     10.juli 99    added simple wrappers for the rootitems collection
  119.   - Added GetRootHeadPosition(...)
  120.   - Added GetRootTailPosition();
  121.   - Added CTreeItem* GetNextRoot(...
  122.   - Added CTreeItem* GetPrevRoot(...
  125. 12. juli 99  - fixed minor error in CreateDragImageEx, an error occurred when 1st column was hidden and a drag operation was initiated
  127. 13. juli 99  - Added void DeleteAll()...deletes all items in the grid, uhh
  128.  - Removed GetNextSiblingItem(...), GetPrevSiblingItem(...) due to support for multiple roots. 
  129.  - Added CTreeItem *GetNext(...) and CTreeItem* GetPrev(..) due to support for multiple roots.
  131. 14. juli 99  - Fixed a memory leak in CTreeList::HowToInsertItemsAfterTheGridHasBeenInitialized....
  135. WHAT'S UP :
  136. - Vacation
  137. - ATL VERSION COMMING UP.
  138. - Better documentation :)
  139. - Peace on earth.
  140. - service pack 4 for VC++ 6.0 :=|
  141. - Windows 3000 :)
  142. */
  144. /////////////////////////////////////////////////////////////////////////////
  145. // CSuperGridCtrl
  146. CSuperGridCtrl::CSuperGridCtrl()
  147. {
  148. m_cxImage = m_cyImage = 16;
  149. m_bIsDragging = m_CurSubItem = 0;
  150.     m_nDragTarget=m_nDragItem = -1;
  151. m_psTreeLine.CreatePen(PS_SOLID, 1, RGB(192,192,192));
  152. m_psRectangle.CreatePen(PS_SOLID, 1, RGB(198,198,198));
  153. m_psPlusMinus.CreatePen(PS_SOLID, 1, RGB(0,0,0));
  154. m_brushErase.CreateSolidBrush(RGB(255,255,255));
  155. m_himl = NULL;
  156. }
  159. CSuperGridCtrl::~CSuperGridCtrl()
  160. {
  161. m_psPlusMinus.DeleteObject();
  162. m_psRectangle.DeleteObject();
  163. m_psTreeLine.DeleteObject();
  164. m_brushErase.DeleteObject();
  166. while(m_RootItems.GetCount())
  167. {
  168. CTreeItem * root = (CTreeItem*)m_RootItems.RemoveHead();
  169. if(root!=NULL && GetData(root) != NULL)
  170. delete GetData(root);
  171. delete root;
  172. }
  173. m_RootItems.RemoveAll();
  174. }
  178. BEGIN_MESSAGE_MAP(CSuperGridCtrl, CListCtrl)
  179. //{{AFX_MSG_MAP(CSuperGridCtrl)
  180. // ON_NOTIFY_REFLECT(NM_DBLCLK, OnDblclk)
  181. // ON_NOTIFY_REFLECT(LVN_ENDLABELEDIT, OnEndlabeledit)
  182. ON_WM_CREATE()
  183. ON_WM_HSCROLL()
  184. ON_WM_LBUTTONDOWN()
  185. ON_WM_MOUSEMOVE()
  186. ON_WM_TIMER()
  187. ON_WM_VSCROLL()
  188. ON_WM_LBUTTONUP()
  189. // ON_NOTIFY_REFLECT(LVN_KEYDOWN, OnKeydown)
  190. // ON_NOTIFY_REFLECT(LVN_BEGINDRAG, OnBegindrag)
  191. ON_WM_MEASUREITEM_REFLECT()
  192. ON_WM_DRAWITEM_REFLECT()
  193. ON_WM_SYSCOLORCHANGE()
  194. // ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnCustomDraw)
  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. // cs.dwExStyle |= LVS_EX_GRIDLINES;
  205. return CListCtrl::PreCreateWindow(cs);
  206. }
  210. int CSuperGridCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  211. {
  212. if (CListCtrl::OnCreate(lpCreateStruct) == -1)
  213. return -1;
  215. return 0;
  216. }
  218. #define OFFSET_FIRST 2 
  219. #define OFFSET_OTHER 6
  220. void CSuperGridCtrl::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
  221. {
  222. if (lpDrawItemStruct->CtlType != ODT_LISTVIEW)
  223.         return;
  225. if(lpDrawItemStruct->itemAction == ODA_DRAWENTIRE)
  226. {
  227. if(m_himl==NULL)
  228. {
  229. m_himl = (HIMAGELIST)::SendMessage(m_hWnd, LVM_GETIMAGELIST, (WPARAM)(int)(LVSIL_SMALL), 0L);
  230. if(m_himl==NULL)
  231. return;
  232. }
  234. LV_ITEM lvi;
  235. static _TCHAR szBuff[MAX_PATH];
  236. LPCTSTR pszText;
  238. int nItem = lpDrawItemStruct->itemID;
  239. CRect rcItem(lpDrawItemStruct->rcItem);
  241. lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_INDENT | LVIF_PARAM; 
  242. lvi.iItem = nItem;
  243. lvi.iSubItem =0;
  244. lvi.pszText = szBuff;
  245. lvi.cchTextMax = sizeof(szBuff);
  246. lvi.stateMask = 0xFFFF;
  247. GetItem(&lvi);
  249. CTreeItem *pSelItem = (CTreeItem*)lpDrawItemStruct->itemData;
  251. CRect rcLabel;
  252. GetItemRect(nItem, rcLabel, LVIR_LABEL);
  254. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  255. ASSERT(pDC);
  257. CRect rcClipBox;
  258. pDC->GetClipBox(rcClipBox);
  260. COLORREF crBackground, crText;
  262. if (lpDrawItemStruct->itemState & ODS_SELECTED)
  263. {
  264. // Set the text background and foreground colors
  265. crBackground = GetSysColor (COLOR_HIGHLIGHT);
  266. crText = GetSysColor (COLOR_HIGHLIGHTTEXT);
  267. }
  268. else
  269. {
  270. // Set the text background and foreground colors to the standard window
  271. // colors
  272. crBackground = GetSysColor (COLOR_WINDOW);
  273. crText = GetSysColor (COLOR_WINDOWTEXT);
  274. }
  276. //Get current Icon, you have overridden this I hope :-)
  277. /* int iImage = GetIcon(pSelItem);
  278. // iImage =  4;
  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. }
  683. /*void CSuperGridCtrl::OnDblclk(NMHDR* pNMHDR, LRESULT* pResult) 
  684. {
  685. if( GetFocus() != this) 
  686. SetFocus();
  688. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  690. LVHITTESTINFO ht;
  691. ht.pt = pNMListView->ptAction;
  692. SubItemHitTest(&ht);
  693. if(OnItemLButtonDown(ht))
  694. {
  695. BOOL bSelect=1;
  696. bSelect = HitTestOnSign(pNMListView->ptAction, ht);
  697. //normal selection
  698. if(bSelect && ht.iItem !=-1)
  699. {
  700. int nIndex = GetSelectedItem();
  701. if(nIndex!=-1)
  702. {
  703. CTreeItem *pSelItem = GetTreeItem(nIndex);
  704. if (pSelItem != NULL)
  705. {
  706. BOOL bRedraw=0;
  707. if(ItemHasChildren(pSelItem))
  708. {
  709. SetRedraw(0);
  710. int nScrollIndex=0;
  711. if(IsCollapsed(pSelItem))
  712. {
  713. if(OnItemExpanding(pSelItem, nIndex))
  714. {
  715. nScrollIndex = Expand(pSelItem, nIndex);
  716. OnItemExpanded(pSelItem, nIndex);
  717. bRedraw=1;
  718. }
  719. }
  721. else 
  722. {
  723.    if(OnCollapsing(pSelItem))
  724.    {
  725. Collapse(pSelItem);
  726. OnItemCollapsed(pSelItem);
  727. bRedraw=1;
  728.    }
  729. }
  730. SetRedraw(1);
  732. if(bRedraw)
  733. {
  734. CRect rc;
  735. GetItemRect(nIndex,rc,LVIR_BOUNDS);
  736. InvalidateRect(rc);
  737. UpdateWindow();
  738. EnsureVisible(nScrollIndex,1);
  739. }
  740. }//ItemHasChildren
  741. }//!=NULL
  742. }
  743. }
  744. }
  745. *pResult = 0;
  746. }*/
  750. /*void CSuperGridCtrl::OnBegindrag(NMHDR* pNMHDR, LRESULT* pResult) 
  751. {
  752. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  753. if(pNMListView->iItem != -1)
  754. {
  755. m_nDragItem = pNMListView->iItem;
  756. CImageList* pDragImage=NULL;
  757. pDragImage = CreateDragImageEx(m_nDragItem);//override this if you want another dragimage or none at all.
  758. if(pDragImage)
  759. {
  760. pDragImage->BeginDrag(0, CPoint(0,0));
  761. pDragImage->DragEnter(this, pNMListView->ptAction);
  762. SetCapture();
  763. m_bIsDragging = TRUE;
  764. }
  765. delete pDragImage;
  766. }
  767. *pResult = 0;
  768. }*/
  770. //Create dragimage : Icon + the itemtext
  771. CImageList *CSuperGridCtrl::CreateDragImageEx(int nItem)
  772. {
  773.     CImageList *pList = new CImageList;          
  774. //get image index
  775. LV_ITEM lvItem;
  776. lvItem.mask =  LVIF_IMAGE;
  777. lvItem.iItem = nItem;
  778. lvItem.iSubItem = 0;
  779. GetItem(&lvItem);
  781. CRect rc;
  782. GetItemRect(nItem, &rc, LVIR_BOUNDS);         
  784. CString str;
  785. str = GetItemText(nItem, 0);
  786. CFont *pFont = GetFont();
  788. rc.OffsetRect(-rc.left, -rc.top);            
  789. rc.right = GetColumnWidth(0);                
  790. pList->Create(rc.Width(), rc.Height(),ILC_COLOR24| ILC_MASK , 1, 1);
  791. CDC *pDC = GetDC();                          
  792. if(pDC) 
  793. {
  794. CDC dc;       
  795. dc.CreateCompatibleDC(pDC);      
  796. CBitmap bmpMap;
  797. bmpMap.CreateCompatibleBitmap(pDC, rc.Width(), rc.Height());
  799. CBitmap *pOldBmp = dc.SelectObject(&bmpMap);
  800. CFont *pOldFont = dc.SelectObject(pFont);
  801. dc.FillSolidRect(rc, GetSysColor(COLOR_WINDOW));
  802. CImageList *pImgList = GetImageList(LVSIL_SMALL);
  803. if(pImgList)
  804. pImgList->Draw(&dc, lvItem.iImage, CPoint(0,0), ILD_TRANSPARENT);
  805. dc.TextOut(m_cxImage + 4, 0, str);
  806. dc.SelectObject(pOldFont);
  807. dc.SelectObject(pOldBmp);                 
  808. bmpMap.DeleteObject(); //hpxs 添加的销毁代码
  809. //causes an error if the 1st column is hidden so must check the imagelist
  810. if(pList->m_hImageList != NULL)
  811. pList->Add(&bmpMap, RGB(255,255,255));
  812. else
  813. { 
  814. delete pList;
  815. pList=NULL;
  816. }
  817. dc.DeleteDC(); //hpxs 添加的销毁DC代码
  818. ReleaseDC(pDC);   
  819. }   
  820. return pList;
  821. }
  825. /*void CSuperGridCtrl::OnMouseMove(UINT nFlags, CPoint point) 
  826. {
  827.     if(m_bIsDragging)
  828.     {
  830. KillTimer(1);
  831. if (CWnd::GetCapture() != this)
  832. m_bIsDragging=0;
  834. if(nFlags==MK_RBUTTON || nFlags==MK_MBUTTON)
  835. m_bIsDragging=0;
  838. if(GetKeyState(VK_ESCAPE) < 0)
  839. m_bIsDragging=0;
  841. if(!m_bIsDragging)//why not put this in a funtion :)
  842. {
  843. SetItemState (m_nDragTarget, 0, LVIS_DROPHILITED);
  844. CImageList::DragLeave(this);
  845. CImageList::EndDrag();
  846. ReleaseCapture();
  847. InvalidateRect(NULL);
  848. UpdateWindow();
  849. }
  850. else
  851. {
  852. CPoint ptList(point);
  853. MapWindowPoints(this, &ptList, 1);
  854. CImageList::DragMove(ptList);
  855. UINT uHitTest = LVHT_ONITEM;
  856. m_nDragTarget = HitTest(ptList, &uHitTest);
  857. // try turn off hilight for previous DROPHILITED state
  858. int nPrev = GetNextItem(-1,LVNI_DROPHILITED);
  859. if(nPrev != m_nDragTarget)//prevents flicker 
  860. SetItemState(nPrev, 0, LVIS_DROPHILITED);
  862. CRect rect;
  863. GetClientRect (rect);
  864. int cy = rect.Height();
  865. if(m_nDragTarget!=-1)
  866. {
  867. SetItemState(m_nDragTarget, LVIS_DROPHILITED, LVIS_DROPHILITED);
  868. CTreeItem* pTarget = GetTreeItem(m_nDragTarget);
  869. if ((point.y >= 0 && point.y <= m_cyImage) || (point.y >= cy - m_cyImage && point.y <= cy) || 
  870. ( pTarget!=NULL && ItemHasChildren(pTarget) && IsCollapsed(pTarget)))
  871. {
  872. SetTimer(1,300,NULL);
  873. }
  874. }
  875. }
  876.     }
  877. CListCtrl::OnMouseMove(nFlags, point);
  878. }*/
  883. /*void CSuperGridCtrl::OnTimer(UINT nIDEvent) 
  884. {
  885. CListCtrl::OnTimer(nIDEvent);
  886. if(nIDEvent==1)
  887. {
  888. if(CWnd::GetCapture()!=this)
  889. {
  890. SetItemState(m_nDragTarget, 0, LVIS_DROPHILITED);
  891. m_bIsDragging=0;
  892. CImageList::DragLeave(this);
  893. CImageList::EndDrag();
  894. ReleaseCapture();
  895. InvalidateRect(NULL);
  896. UpdateWindow();
  897. KillTimer(1);
  898. return;
  899. }
  901. SetTimer(1,300,NULL);//reset timer
  902. DWORD dwPos = ::GetMessagePos();
  903. CPoint ptList(LOWORD(dwPos),HIWORD(dwPos));
  904. ScreenToClient(&ptList);
  906. CRect rect;
  907. GetClientRect(rect);
  908. int cy = rect.Height();
  909. //
  910. // perform autoscroll if the cursor is near the top or bottom.
  911. //
  912. if (ptList.y >= 0 && ptList.y <= m_cyImage) 
  913. {
  914. int n = GetTopIndex(); 
  915. CImageList::DragShowNolock(0);
  916. SendMessage(WM_VSCROLL, MAKEWPARAM(SB_LINEUP, 0), NULL);
  917. CImageList::DragShowNolock(1);
  918. if (GetTopIndex()== n)
  919. KillTimer (1);
  920. else {
  921. CImageList::DragShowNolock(0);
  922. CImageList::DragMove(ptList);
  923. CImageList::DragShowNolock(1);
  924. return;
  925. }
  926. }
  927. else if (ptList.y >= cy - m_cyImage && ptList.y <= cy) 
  928. {
  929. int n = GetTopIndex(); 
  930. CImageList::DragShowNolock(0);
  931. SendMessage(WM_VSCROLL, MAKEWPARAM(SB_LINEDOWN, 0), NULL);
  932. CImageList::DragShowNolock(1);
  933. if (GetTopIndex()== n)
  934. KillTimer (1);
  935. else {
  936. CImageList::DragShowNolock(0);
  937. CImageList::DragMove(ptList);
  938. CImageList::DragShowNolock(1);
  939. return;
  940. }
  941. }
  942. //Hover test 
  943. CImageList::DragMove(ptList);
  944. UINT uHitTest = LVHT_ONITEM;
  945. m_nDragTarget = HitTest(ptList, &uHitTest);
  947. if(m_nDragTarget!=-1)
  948. {
  949. //if the target has children
  950. //expand them
  951. CTreeItem* pTarget=GetTreeItem(m_nDragTarget);
  952. if(pTarget != NULL && ItemHasChildren(pTarget) && IsCollapsed(pTarget) && (m_nDragItem!=-1))
  953. {
  954. CImageList::DragShowNolock(0);
  955. CTreeItem* pSource = GetTreeItem(m_nDragItem);
  957. SetRedraw(0);
  958. int nScrollIndex=0;
  959. if(ItemHasChildren(pTarget) && IsCollapsed(pTarget))
  960. {
  961. if(OnItemExpanding(pTarget, m_nDragTarget))
  962. {
  963. nScrollIndex = Expand(pTarget, m_nDragTarget);
  964. OnItemExpanded(pTarget, m_nDragTarget);
  965. }
  966. }
  967. m_nDragItem = NodeToIndex(pSource);
  968. SetRedraw(1);
  969. EnsureVisible(nScrollIndex, 1);
  970. InvalidateRect(NULL);
  971. UpdateWindow();
  972. CImageList::DragShowNolock(1);
  973. KillTimer(1);
  974. return;
  975. }
  976. }
  977. KillTimer(1);
  978. }
  979. }*/
  983. void CSuperGridCtrl::OnLButtonUp(UINT nFlags, CPoint point) 
  984. {
  985. if(m_bIsDragging == TRUE)
  986.     {
  987. KillTimer(1);
  988.         CImageList::DragLeave(this);
  989.         CImageList::EndDrag();
  990.         ReleaseCapture();
  991.         m_bIsDragging = FALSE;
  992. SetItemState(m_nDragTarget, 0, LVIS_DROPHILITED);
  993.         if((m_nDragTarget != -1) && (m_nDragTarget != m_nDragItem) && (m_nDragItem!=-1))//no drop on me self
  994.         {
  996. CTreeItem* pSource = GetTreeItem(m_nDragItem);
  997. CTreeItem* pTarget = GetTreeItem(m_nDragTarget);
  998. if(IsRoot(pSource))
  999. return;
  1000. CTreeItem* pParent = GetParentItem(pSource);
  1001. if(pParent==pTarget) //can't drag child to parent
  1002. return;
  1004. if(!IsChildOf(pSource, pTarget))//can't drag parent to child
  1005. {
  1006. CWaitCursor wait;
  1007. SetRedraw(0);
  1008. if(DoDragDrop(pTarget, pSource))
  1009. {
  1010. UINT uflag = LVIS_SELECTED | LVIS_FOCUSED;
  1011. SetItemState(m_nDragTarget, uflag, uflag);
  1012. m_nDragItem=-1;
  1013. //delete source
  1014. int nIndex = NodeToIndex(pSource);
  1015. DeleteItem(nIndex);
  1016. HideChildren(pSource, TRUE, nIndex);
  1017. Delete(pSource);
  1018. InternaleUpdateTree();
  1019. SetRedraw(1);
  1020. InvalidateRect(NULL);
  1021. UpdateWindow();
  1022. }else
  1023. SetRedraw(1);
  1024. }
  1025.     }
  1026.     }
  1027.     else
  1028. CListCtrl::OnLButtonUp(nFlags, point);
  1029. }
  1033. //used with the drag/drop operation
  1034. void CSuperGridCtrl::CopyChildren(CTreeItem* pDest, CTreeItem* pSrc)
  1035. {
  1036. if (ItemHasChildren(pSrc))
  1037. {
  1038. POSITION pos = pSrc->m_listChild.GetHeadPosition();
  1039. while (pos != NULL)
  1040. {
  1041. CTreeItem* pItem = (CTreeItem *)pSrc->m_listChild.GetNext(pos);
  1042. CItemInfo* lp = CopyData(GetData(pItem));
  1043. CTreeItem* pNewItem = InsertItem(pDest, lp);
  1044. CopyChildren(pNewItem, pItem);
  1045. }
  1046. }
  1047. }
  1050. //hmmm 
  1051. BOOL CSuperGridCtrl::DoDragDrop(CTreeItem* pTarget, CTreeItem* pSource)
  1052. {
  1053. if(pTarget==NULL)
  1054. return 0;
  1056. BOOL bUpdate=FALSE;
  1057. if(!IsCollapsed(pTarget))
  1058. bUpdate=TRUE; //children are expanded, want to see update right away
  1060. //make a copy of the source data
  1061. CItemInfo* lp = CopyData(GetData(pSource));
  1062. //create new node with the source data and make pTarget the parent
  1064. CTreeItem* pNewParent = InsertItem(pTarget, lp, bUpdate);
  1065. //if the source has children copy all source data and make the newly create item the parent
  1066. if(ItemHasChildren(pSource))
  1067. CopyChildren(pNewParent, pSource);
  1069. return 1;
  1070. }
  1073. void CSuperGridCtrl::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  1074. {
  1075. //its not meself
  1076. if( GetFocus() != this) 
  1077. SetFocus();
  1079. CListCtrl::OnHScroll(nSBCode, nPos, pScrollBar);
  1080. }
  1085. void CSuperGridCtrl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  1086. {
  1087. if( GetFocus() != this) 
  1088. SetFocus();
  1089. CListCtrl::OnVScroll(nSBCode, nPos, pScrollBar);
  1090. }
  1095. BOOL CSuperGridCtrl::PreTranslateMessage(MSG* pMsg) 
  1096. {
  1097. if(pMsg->message == WM_KEYDOWN)
  1098. {
  1099. if(GetFocus()==this)
  1100. {
  1101. switch( pMsg->wParam )
  1102. {
  1103. case VK_LEFT:
  1104. {
  1105. // Decrement the order number.
  1106. m_CurSubItem--;
  1107. if(m_CurSubItem < 0) 
  1108. m_CurSubItem = 0;
  1109. else{
  1111. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1112. // Make the column visible.
  1113. // We have to take into account that the header may be reordered.
  1114. MakeColumnVisible( Header_OrderToIndex( pHeader->m_hWnd, m_CurSubItem));
  1115. // Invalidate the item.
  1116. int iItem = GetSelectedItem();
  1117. if( iItem != -1 )
  1118. {
  1119. CRect rcBounds;
  1120. GetItemRect(iItem, rcBounds, LVIR_BOUNDS);
  1121. InvalidateRect(&rcBounds);
  1122. UpdateWindow();
  1123. }
  1124. }
  1125. }
  1126. return TRUE;
  1128. case VK_RIGHT:
  1129. {
  1130. // Increment the order number.
  1131. m_CurSubItem++;
  1132. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1133. int nColumnCount = pHeader->GetItemCount();
  1134. // Don't go beyond the last column.
  1135. if( m_CurSubItem > nColumnCount -1 ) 
  1136. m_CurSubItem = nColumnCount-1;
  1137. else
  1138. {
  1139. MakeColumnVisible(Header_OrderToIndex( pHeader->m_hWnd, m_CurSubItem));
  1140.  
  1141. int iItem = GetSelectedItem();
  1142. // Invalidate the item.
  1143. if( iItem != -1 )
  1144. {
  1145. CRect rcBounds;
  1146. GetItemRect(iItem, rcBounds, LVIR_BOUNDS);
  1147. InvalidateRect(&rcBounds);
  1148. UpdateWindow();
  1149. }
  1150. }
  1151. }
  1152. return TRUE;
  1154. case VK_RETURN://edit itemdata
  1155. {
  1156. BOOL bResult = OnVkReturn();
  1157. if(!bResult)
  1158. {
  1159. int iItem = GetSelectedItem();
  1160. if( m_CurSubItem != -1 && iItem != -1)
  1161. {
  1162. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1163. int iSubItem = Header_OrderToIndex(pHeader->m_hWnd, m_CurSubItem);
  1164. if(iSubItem==0)//that's just me saying all nodes in col 0 are edit-controls, you may modify this
  1165. {
  1166. CRect rcItem;
  1167. GetItemRect(iItem, rcItem, LVIR_LABEL);
  1168. DWORD dwStyle = WS_BORDER | WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL|ES_LEFT;
  1169. // CEdit *pEdit = new CListEditCtrl(iItem, iSubItem, GetItemText(iItem, iSubItem));
  1170. // pEdit->Create(dwStyle, rcItem, this, 0x1233);
  1171. }
  1172. // else
  1173. // EditLabelEx(iItem, iSubItem);
  1174. return 1;
  1175. }
  1176. }
  1177. }
  1178. break;
  1179. default:
  1180. break;
  1181. }
  1182. }
  1183. }
  1184. return CListCtrl::PreTranslateMessage(pMsg);
  1185. }
  1189. #define IDC_EDITCTRL 0x1234
  1190. /*CEdit* CSuperGridCtrl::EditLabelEx(int nItem, int nCol)
  1191. {
  1192. CRect rect;
  1193. int offset = 0;
  1194. if(!EnsureVisible(nItem, TRUE)) 
  1195. return NULL;
  1196. GetSubItemRect(nItem, nCol, LVIR_BOUNDS, rect);
  1197. // Now scroll if we need to expose the column
  1198. CRect rcClient;
  1199. GetClientRect(rcClient);
  1200. if( offset + rect.left < 0 || offset + rect.left > rcClient.right )
  1201. {
  1202. CSize size(offset + rect.left,0);
  1203. Scroll(size);
  1204. rect.left -= size.cx;
  1205. }
  1206. rect.left += offset;
  1207. rect.right = rect.left + GetColumnWidth(nCol);
  1208. if(rect.right > rcClient.right) 
  1209.    rect.right = rcClient.right;
  1211. // Get Column alignment
  1212. LV_COLUMN lvcol;
  1213. lvcol.mask = LVCF_FMT;
  1214. GetColumn(nCol, &lvcol);
  1216. DWORD dwStyle;
  1217. if((lvcol.fmt & LVCFMT_JUSTIFYMASK) == LVCFMT_LEFT)
  1218. dwStyle = ES_LEFT;
  1219. else if((lvcol.fmt & LVCFMT_JUSTIFYMASK) == LVCFMT_RIGHT)
  1220. dwStyle = ES_RIGHT;
  1221. else 
  1222. dwStyle = ES_CENTER;
  1225. dwStyle |=WS_BORDER|WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL;
  1226. CEdit *pEdit = new CListEditCtrl(nItem, nCol, GetItemText(nItem, nCol));
  1227. pEdit->Create(dwStyle, rect, this, IDC_EDITCTRL);
  1228. //pEdit->ModifyStyleEx(0,WS_EX_CLIENTEDGE); //funny thing happend here, uncomment this, 
  1229. //and then edit an item, 
  1230. //enter a long text so that the ES_AUTOHSCROLL comes to rescue
  1231. //yes that's look funny, ???.
  1232. return pEdit;
  1233. }*/
  1238.  /*void CSuperGridCtrl::OnEndlabeledit(NMHDR* pNMHDR, LRESULT* pResult) 
  1239. {
  1240. LV_DISPINFO *plvDispInfo = (LV_DISPINFO*)pNMHDR;
  1241. LV_ITEM *plvItem = &plvDispInfo->item;
  1242. if (plvItem->pszText != NULL)//valid text
  1243. {
  1244. if(plvItem->iItem != -1) //valid item
  1245. {
  1246. CTreeItem*pSelItem = GetTreeItem(plvItem->iItem);
  1247. if(pSelItem != NULL)
  1248. {
  1249. OnUpdateListViewItem(pSelItem, plvItem);
  1250. }
  1251. }
  1252. }
  1253. *pResult = 0;
  1254. }*/
  1258. int CSuperGridCtrl::GetNumCol()
  1259. {
  1260. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1261. return pHeader ? pHeader->GetItemCount() : 0;
  1262. }
  1266. //Think Rex Myer is spooking here
  1267. void CSuperGridCtrl::MakeColumnVisible(int nCol)
  1268. {
  1269. if(nCol < 0)
  1270. return;
  1271. // Get the order array to total the column offset.
  1272. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1274. int nColCount = pHeader->GetItemCount();
  1275. ASSERT( nCol < nColCount);
  1276. int *pOrderarray = new int[nColCount];
  1277. Header_GetOrderArray(pHeader->m_hWnd, nColCount, pOrderarray);
  1278. // Get the column offset
  1279. int offset = 0;
  1280. for(int i = 0; pOrderarray[i] != nCol; i++)
  1281. offset += GetColumnWidth(pOrderarray[i]);
  1283. int colwidth = GetColumnWidth(nCol);
  1284. delete[] pOrderarray;
  1286. CRect rect;
  1287. GetItemRect(0, &rect, LVIR_BOUNDS);
  1288. // Now scroll if we need to show the column
  1289. CRect rcClient;
  1290. GetClientRect(&rcClient);
  1291. if(offset + rect.left < 0 || offset + colwidth + rect.left > rcClient.right)
  1292. {
  1293. CSize size(offset + rect.left,0);
  1294. Scroll(size);
  1295. InvalidateRect(NULL);
  1296. UpdateWindow();
  1297. }
  1298. }
  1302. //Think Rex Myer is spooking here
  1303. int CSuperGridCtrl::IndexToOrder( int iIndex )
  1304. {
  1305. // This translates a column index value to a column order value.
  1306. CHeaderCtrl* pHeader = GetHeaderCtrl();
  1307. int nColCount = pHeader->GetItemCount();
  1308. int *pOrderarray = new int[nColCount];
  1309. Header_GetOrderArray(pHeader->m_hWnd, nColCount, pOrderarray);
  1310. for(int i=0; i<nColCount; i++)
  1311. {
  1312. if(pOrderarray[i] == iIndex )
  1313. {
  1314. delete[] pOrderarray;
  1315. return i;
  1316. }
  1317. }
  1318. delete[] pOrderarray;
  1319. return -1;
  1320. }
  1324. void CSuperGridCtrl::DrawFocusCell(CDC *pDC, int nItem, int iSubItem)
  1325. {
  1326. if(iSubItem==m_CurSubItem)
  1327. {
  1328. CRect rect;
  1329. GetSubItemRect(nItem, iSubItem, LVIR_BOUNDS, rect);
  1330. CBrush br(GetCellRGB());
  1331. if(iSubItem==0)
  1332. GetItemRect(iSubItem, rect, LVIR_LABEL);
  1333. pDC->FillRect(rect, &br);
  1334. pDC->DrawFocusRect(rect);
  1335. }
  1336. }
  1341. //insert item and return new parent pointer.
  1342. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::InsertItem(CTreeItem *pParent, CItemInfo* lpInfo,
  1343.   BOOL bUpdate)
  1344. {
  1345. if(pParent==NULL)
  1346. return NULL;
  1348. CTreeItem *pItem = NULL;
  1349. pItem =  new CTreeItem();
  1351. if(lpInfo==NULL)
  1352. lpInfo = new CItemInfo;
  1354. UpdateData(pItem, lpInfo);
  1355. SetIndent(pItem, GetIndent(pParent)+1);
  1356. SetParentItem(pItem, pParent);
  1357. //add as the last child 
  1358. pParent->m_listChild.AddTail(pItem);
  1360. if(!bUpdate)
  1361.  Hide(pParent, TRUE);
  1362. else
  1363. {
  1364. //calc listview index for the new node
  1365. int nIndex = NodeToIndex(pItem);
  1366. CString str = GetData(pItem)->GetItemText();
  1367. LV_ITEM     lvItem;
  1368. lvItem.mask = LVIF_TEXT | LVIF_INDENT | LVIF_PARAM  | LVIF_IMAGE;
  1369. lvItem.pszText = str.GetBuffer(1); 
  1370. //insert item
  1371. lvItem.iItem = nIndex;
  1372. lvItem.iSubItem = 0;
  1373. lvItem.lParam = (LPARAM)pItem;
  1374. lvItem.iIndent = GetIndent(pItem);
  1375. lvItem.iImage = lpInfo->GetImage();
  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 | LVIF_IMAGE;
  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. lvItem.iImage = lpInfo->GetImage();
  1497. CListCtrl::InsertItem(&lvItem);
  1498. int nSize = lp->GetItemCount();
  1499. for(int i=0; i < nSize;i++)
  1500. {
  1501.    CString str = lp->GetSubItem(i);
  1502.    lvItem.mask = LVIF_TEXT;
  1503.    lvItem.iSubItem = i+1;
  1504.    lvItem.pszText = str.GetBuffer(1);
  1505.    SetItem(&lvItem);
  1506. }
  1507. m_RootItems.AddTail(pRoot);
  1508. return pRoot;
  1509. }
  1513. void CSuperGridCtrl::DrawTreeItem(CDC* pDC, CTreeItem* pSelItem, int nListItem, const CRect& rcBounds)
  1514. {
  1515. int nColWidth = GetColumnWidth(0);
  1516. int yDown = rcBounds.top;
  1517.     CPen* pPenTreeLine = pDC->SelectObject(&m_psTreeLine);
  1518. int iIndent = GetIndent(pSelItem);
  1519. int nHalfImage = (m_cxImage >> 1);
  1520. int nBottomDown = yDown + nHalfImage + ((rcBounds.Height() - m_cyImage) >> 1);
  1521. //
  1522. BOOL bChild = ItemHasChildren(pSelItem);
  1523. BOOL bCollapsed = IsCollapsed(pSelItem);
  1524. //draw outline
  1525. while(1)
  1526. {
  1527. CTreeItem* pParent = GetParentItem(pSelItem);
  1528. if(pParent==NULL)//no more parents, stop
  1529. break;
  1531. POSITION pos = pParent->m_listChild.GetTailPosition();
  1532. while(pos!=NULL)
  1533. {
  1534. CTreeItem *pLastChild = (CTreeItem*)pParent->m_listChild.GetPrev(pos);
  1535. int nIndex = GetCurIndex(pLastChild);
  1536. int nCurIndent = GetIndent(pLastChild);
  1537. if(nListItem > nIndex && iIndent > nCurIndent)//no need to go further in this loop
  1538. break;
  1540. //no drawing outside the 1st columns right
  1541. int xLine =  rcBounds.left + nCurIndent * m_cxImage - nHalfImage;
  1542. if(nIndex == nListItem && nCurIndent==iIndent)
  1543. {
  1544. //draw '-
  1545. int x;
  1546. pDC->MoveTo(xLine, yDown);
  1547. pDC->LineTo(xLine, nBottomDown);
  1548. // -
  1549. xLine + nHalfImage > nColWidth ? x = nColWidth: x = xLine + nHalfImage;
  1551. pDC->MoveTo(xLine, nBottomDown);
  1552. pDC->LineTo(x, nBottomDown);
  1553. break;
  1554. }
  1555. else
  1556. if(nIndex > nListItem && nCurIndent==iIndent)
  1557. {
  1558. //draw |-
  1559. int x;
  1560. xLine + nHalfImage > nColWidth ? x = nColWidth : x = xLine + nHalfImage;
  1561. pDC->MoveTo(xLine, nBottomDown);
  1562. pDC->LineTo(x, nBottomDown);
  1563. //-
  1564. pDC->MoveTo(xLine, yDown);
  1565. pDC->LineTo(xLine, rcBounds.bottom);
  1566. break;
  1567. }
  1568. else
  1569. if(nIndex > nListItem && nCurIndent < iIndent)
  1570. {
  1571. //draw |
  1572. pDC->MoveTo(xLine, yDown);
  1573. pDC->LineTo(xLine, rcBounds.bottom);
  1574. break;
  1575. }
  1576. }
  1577. pSelItem = pParent;//next
  1578. }
  1580. //draw plus/minus sign
  1581. if(bChild)
  1582. {
  1583. CRectangle rect(this, pDC, iIndent, rcBounds);
  1585. rect.DrawRectangle(this);
  1587. CPen* pPenPlusMinus = pDC->SelectObject(&m_psPlusMinus);
  1588. if(bCollapsed)
  1589. rect.DrawPlus();
  1590. else {
  1591. rect.DrawMinus();
  1592. //draw line up to parent folder
  1593. CPen* pLine = pDC->SelectObject(&m_psTreeLine);
  1594. int nOffset = (rcBounds.Height() - m_cyImage)/2;
  1595. pDC->MoveTo(rect.GetLeft()+ m_cxImage, rcBounds.top + m_cyImage+nOffset);
  1596. pDC->LineTo(rect.GetLeft() + m_cxImage, rcBounds.bottom);
  1597. pDC->SelectObject(pLine);
  1598. }
  1599. pDC->SelectObject(pPenPlusMinus);
  1600. }
  1601. pDC->SelectObject(pPenTreeLine);
  1602. }
  1606. //walk all over the place setting the hide/show flag of the nodes.
  1607. //it also deletes items from the listviewctrl.
  1608. void CSuperGridCtrl::HideChildren(CTreeItem *pItem, BOOL bHide,int nItem)
  1609. {
  1610. if(!IsCollapsed(pItem))
  1611. if(ItemHasChildren(pItem))
  1612. {
  1613. Hide(pItem, bHide);
  1614. POSITION pos = pItem->m_listChild.GetHeadPosition();
  1615. while (pos != NULL)
  1616. {
  1617. HideChildren((CTreeItem *)pItem->m_listChild.GetNext(pos),bHide,nItem+1);
  1618. DeleteItem(nItem);
  1620. }
  1621. }
  1622. }
  1627. void CSuperGridCtrl::Collapse(CTreeItem *pItem)
  1628. {
  1629. if(pItem != NULL && ItemHasChildren(pItem))
  1630. {
  1631. SetRedraw(0);
  1632. int nIndex = NodeToIndex(pItem);
  1633. HideChildren(pItem, TRUE, nIndex+1);
  1634. InternaleUpdateTree();
  1635. SetRedraw(1);
  1636. }
  1637. }
  1640. void CSuperGridCtrl::ExpandAll(CTreeItem *pItem, int& nScroll)
  1641. {
  1642. const int nChildren = pItem->m_listChild.GetCount();
  1643. if (nChildren > 0)
  1644. {
  1645. int nIndex = NodeToIndex(pItem);
  1646. nScroll = Expand(pItem, nIndex);
  1647. }
  1649. POSITION pos = pItem->m_listChild.GetHeadPosition();
  1650. while (pos)
  1651. {
  1652. CTreeItem *pChild = (CTreeItem*)pItem->m_listChild.GetNext(pos);
  1653. ExpandAll(pChild, nScroll);
  1654. }
  1656. }
  1660. int CSuperGridCtrl::Expand(CTreeItem* pSelItem, int nIndex)
  1661. {
  1662. if(ItemHasChildren(pSelItem) && IsCollapsed(pSelItem))
  1663. {
  1664. LV_ITEM lvItem;
  1665. lvItem.mask = LVIF_INDENT ;
  1666. lvItem.iItem = nIndex;
  1667. lvItem.iSubItem = 0;
  1668. lvItem.lParam=(LPARAM)pSelItem;
  1669. lvItem.iIndent = GetIndent(pSelItem);
  1670. // lvItem.iImage = pSelItem->m_lpNodeInfo->m_iImage;
  1671. SetItem(&lvItem);
  1673. Hide(pSelItem, FALSE);
  1674. //expand children
  1675. POSITION pos = pSelItem->m_listChild.GetHeadPosition();
  1676. while(pos != NULL)
  1677. {
  1678. CTreeItem* pNextNode = (CTreeItem*)pSelItem->m_listChild.GetNext(pos);
  1679. CString str = GetData(pNextNode)->GetItemText();
  1680. LV_ITEM lvItem;
  1681. lvItem.mask = LVIF_TEXT | LVIF_INDENT | LVIF_PARAM | LVIF_IMAGE;
  1682. lvItem.pszText =str.GetBuffer(1); 
  1683. lvItem.iItem = nIndex + 1;
  1684. lvItem.iSubItem = 0;
  1685. lvItem.lParam=(LPARAM)pNextNode;
  1686. lvItem.iIndent = GetIndent(pSelItem)+1;
  1687. lvItem.iImage = pNextNode->m_lpNodeInfo->GetImage();
  1688. CListCtrl::InsertItem(&lvItem);
  1689. if(GetData(pNextNode)->GetCheck())
  1690. SetCheck(nIndex + 1);
  1691. //get subitems
  1692. int nSize = GetData(pNextNode)->GetItemCount();
  1693. for(int i=0; i< nSize;i++)
  1694. {
  1695.    CString str=GetData(pNextNode)->GetSubItem(i);
  1696.    lvItem.mask = LVIF_TEXT;
  1697.    lvItem.iSubItem = i+1;
  1698.    lvItem.pszText=str.GetBuffer(1);
  1699.    SetItem(&lvItem);
  1700. }
  1701. nIndex++;
  1702. }
  1703. }
  1704. InternaleUpdateTree();
  1705. return nIndex;
  1706. }
  1711. int CSuperGridCtrl::SelectNode(CTreeItem *pLocateNode)
  1712. {
  1713. if(IsRoot(pLocateNode))
  1714. {
  1715. UINT uflag = LVIS_SELECTED | LVIS_FOCUSED;
  1716. SetItemState(0, uflag, uflag);
  1717. return 0;
  1718. }
  1719. int nSelectedItem=-1;
  1720. CTreeItem* pNode = pLocateNode;
  1721. CTreeItem* pTopLevelParent=NULL;
  1722. //Get top parent
  1723. while(1)
  1724. {
  1725. CTreeItem *pParent = GetParentItem(pLocateNode);
  1726. if(IsRoot(pParent))
  1727. break;
  1728. pLocateNode = pParent;
  1729. }
  1730. pTopLevelParent = pLocateNode;//on top of all
  1731. //Expand the folder
  1732. if(pTopLevelParent != NULL)
  1733. {
  1734. SetRedraw(0);
  1735. CWaitCursor wait;
  1736. CTreeItem *pRoot = GetParentItem(pTopLevelParent);
  1738. if(IsCollapsed(pRoot))
  1739. //old Expand(pRoot,0);
  1740. Expand(pRoot, NodeToIndex(pRoot)); // Yep! Now it's right!
  1743. ExpandUntil(pTopLevelParent, pNode);
  1745. UINT uflag = LVIS_SELECTED | LVIS_FOCUSED;
  1746. nSelectedItem = NodeToIndex(pNode);
  1748. SetItemState(nSelectedItem, uflag, uflag);
  1750. SetRedraw(1);
  1751. EnsureVisible(nSelectedItem, TRUE);
  1752. }
  1753. return nSelectedItem;
  1754. }
  1759. void CSuperGridCtrl::ExpandUntil(CTreeItem *pItem, CTreeItem* pStopAt)
  1760. {
  1761. const int nChildren = pItem->m_listChild.GetCount();
  1762. if (nChildren > 0)
  1763. {
  1764. POSITION pos = pItem->m_listChild.GetHeadPosition();
  1765. while (pos)
  1766. {
  1767. CTreeItem *pChild = (CTreeItem*)pItem->m_listChild.GetNext(pos);
  1768. if(pChild == pStopAt)
  1769. {
  1770. int nSize = GetIndent(pChild);
  1771. CTreeItem** ppParentArray = new CTreeItem*[nSize];
  1772. int i=0;
  1773. while(1)
  1774. {
  1775. CTreeItem *pParent = GetParentItem(pChild);
  1777. if(IsRoot(pParent))
  1778. break;
  1779. pChild = pParent;
  1780. ppParentArray[i] = pChild;
  1781. i++;
  1782. }
  1784. for(int x=i; x > 0; x--)
  1785. {
  1786. CTreeItem *pParent = ppParentArray[x-1];
  1787. Expand(pParent, NodeToIndex(pParent));
  1788. }
  1789. delete [] ppParentArray;
  1790. return;
  1791. }
  1792. }
  1793. }
  1795. POSITION pos = pItem->m_listChild.GetHeadPosition();
  1796. while (pos)
  1797. {
  1798. CTreeItem *pChild = (CTreeItem*)pItem->m_listChild.GetNext(pos);
  1799. ExpandUntil(pChild, pStopAt);
  1800. }
  1802. }
  1806. void CSuperGridCtrl::DeleteItemEx(CTreeItem *pSelItem, int nItem)
  1807. {
  1808. SetRedraw(0);
  1809. DeleteItem(nItem);//delete cur item in listview
  1810. //delete/hide all children in pSelItem
  1811. HideChildren(pSelItem, TRUE, nItem);
  1812. //delete all internal nodes
  1813. // If root, must delete from m_rootData
  1814. if(GetParentItem(pSelItem) == NULL )
  1815. {
  1816. DeleteRootItem(pSelItem);
  1817. }
  1818. else
  1819. Delete(pSelItem);
  1821. InternaleUpdateTree();
  1822. if(nItem-1<0)//no more items in list
  1823. {
  1824. SetRedraw(1); 
  1825. InvalidateRect(NULL);
  1826. UpdateWindow();
  1827. return;
  1828. }
  1830. UINT uflag = LVIS_SELECTED | LVIS_FOCUSED;
  1831. CRect rcTestIfItemIsValidToSelectOtherWiseSubtrackOneFromItem;//just to get the documention right :)
  1832. GetItemRect(nItem, rcTestIfItemIsValidToSelectOtherWiseSubtrackOneFromItem ,LVIR_LABEL) ? SetItemState(nItem, uflag, uflag) : SetItemState(nItem-1, uflag, uflag);
  1834. SetRedraw(1);
  1835. InvalidateRect(NULL);
  1836. UpdateWindow();
  1837. }
  1841. void CSuperGridCtrl::CleanMe(CTreeItem *pItem)
  1842. {
  1843. // delete child nodes
  1844. POSITION pos = pItem->m_listChild.GetHeadPosition();
  1845. while (pos != NULL)
  1846. {
  1847. CTreeItem* pItemData = (CTreeItem*)pItem->m_listChild.GetNext(pos);
  1848. if(pItemData!=NULL)
  1849. {
  1850. if(pItemData->m_lpNodeInfo!=NULL)
  1851. delete pItemData->m_lpNodeInfo;
  1853. pItemData->m_listChild.RemoveAll();
  1854. delete pItemData;
  1855. }
  1856. }
  1857. pItem->m_listChild.RemoveAll();
  1858. }
  1863. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetNext(CTreeItem* pStartAt, CTreeItem* pNode, BOOL bInit, BOOL bDontIncludeHidden)
  1864. {
  1865. static BOOL bFound;
  1866. if (bInit)
  1867. bFound = FALSE;
  1869. if (pNode == pStartAt)
  1870. bFound = TRUE;
  1872. if(bDontIncludeHidden)
  1873. {
  1874. if (!IsCollapsed(pStartAt))
  1875. {
  1876. POSITION pos = pStartAt->m_listChild.GetHeadPosition();
  1877. while (pos != NULL)
  1878. {
  1879. CTreeItem* pChild = (CTreeItem*)pStartAt->m_listChild.GetNext(pos);
  1880. if (bFound)
  1881. return pChild;
  1882. pChild = GetNext(pChild, pNode, FALSE, TRUE);
  1883. if (pChild != NULL)
  1884. return pChild;
  1885. }
  1886. }
  1887. }
  1888. else {
  1889. POSITION pos = pStartAt->m_listChild.GetHeadPosition();
  1890. while (pos != NULL)
  1891. {
  1892. CTreeItem* pChild = (CTreeItem*)pStartAt->m_listChild.GetNext(pos);
  1893. if (bFound)
  1894. return pChild;
  1895. pChild = GetNext(pChild, pNode, FALSE,FALSE);
  1896. if (pChild != NULL)
  1897. return pChild;
  1898. }
  1899. }
  1900. // if reached top and last level return original
  1901. if (bInit)
  1902. return pNode;
  1903. else
  1904. return NULL;
  1905. }
  1909. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetPrev(CTreeItem* pStartAt, CTreeItem* pNode, BOOL bInit, BOOL bDontIncludeHidden)
  1910. {
  1911. static CTreeItem* pPrev;
  1912. if (bInit)
  1913. pPrev = pStartAt;
  1915. if (pNode == pStartAt)
  1916. return pPrev;
  1918. pPrev = pStartAt;
  1920. if(bDontIncludeHidden)
  1921. {
  1922. if (!IsCollapsed(pStartAt))
  1923. {
  1924. POSITION pos = pStartAt->m_listChild.GetHeadPosition();
  1925. while (pos != NULL)
  1926. {
  1927. CTreeItem* pCur = (CTreeItem*)pStartAt->m_listChild.GetNext(pos);
  1928. CTreeItem* pChild = GetPrev(pCur,pNode, FALSE,TRUE);
  1929. if (pChild != NULL)
  1930. return pChild;
  1931. }
  1932. }
  1933. }
  1934. else {
  1935. POSITION pos = pStartAt->m_listChild.GetHeadPosition();
  1936. while (pos != NULL)
  1937. {
  1938. CTreeItem* pCur = (CTreeItem*)pStartAt->m_listChild.GetNext(pos);
  1939. CTreeItem* pChild = GetPrev(pCur,pNode, FALSE,FALSE);
  1940. if (pChild != NULL)
  1941. return pChild;
  1942. }
  1943. }
  1945. if (bInit)
  1946. return pPrev;
  1947. else
  1948. return NULL;
  1949. }
  1952. int CSuperGridCtrl::_NodeToIndex(CTreeItem *pStartpos, CTreeItem* pNode, int& nIndex, BOOL binit)
  1953. {
  1954. static BOOL bFound;
  1955. // Account for other root nodes
  1956. if(GetParentItem(pStartpos) == NULL && GetRootIndex(pStartpos) !=0)
  1957. nIndex++;
  1959. if(binit)
  1960. bFound=FALSE;
  1962. if(pStartpos==pNode)
  1963. bFound=TRUE;
  1965. if(!IsCollapsed(pStartpos))
  1966. {
  1967. POSITION pos = GetHeadPosition(pStartpos);
  1968. while (pos)
  1969. {
  1970. CTreeItem *pChild = GetNextChild(pStartpos, pos);
  1971. if(bFound)
  1972. return nIndex;
  1974. // Craig Schmidt: Cannot set nIndex as return value.  Worked find with single root but
  1975. //    the calling function get confused since the return value may indicate
  1976. //    that the next root needs to be searched.  Didn'd spend much time on
  1977. //    this so there is probably a better way of doing this.
  1978. // nIndex = _NodeToIndex(pChild, pNode, nIndex, binit);
  1979. _NodeToIndex(pChild, pNode, nIndex, binit);
  1980. nIndex++;
  1981. }
  1982. }
  1983. if(binit && bFound)
  1984. return nIndex;
  1985. else
  1986. return -1;
  1987. }
  1990. BOOL CSuperGridCtrl::Delete(CTreeItem* pNode, BOOL bClean)
  1991. {
  1992. POSITION pos = m_RootItems.GetHeadPosition();
  1993. while(pos!=NULL)
  1994. {
  1995. CTreeItem * pRoot = (CTreeItem*)m_RootItems.GetNext(pos);
  1996. if(_Delete(pRoot, pNode, bClean))
  1997. return TRUE;
  1998. }
  1999. return FALSE;
  2000. }
  2004. BOOL CSuperGridCtrl::_Delete(CTreeItem* pStartAt, CTreeItem* pNode, BOOL bClean)
  2005. {
  2006. POSITION pos = pStartAt->m_listChild.GetHeadPosition();
  2007. while (pos != NULL)
  2008. {
  2009. POSITION posPrev = pos;
  2010. CTreeItem *pChild = (CTreeItem*)pStartAt->m_listChild.GetNext(pos);
  2011. if (pChild == pNode)
  2012. {
  2013. pStartAt->m_listChild.RemoveAt(posPrev);
  2014. if(bClean)
  2015. {
  2016. if(GetData(pNode)!=NULL)
  2017. delete GetData(pNode);
  2018. delete pNode;
  2019. }
  2020. return TRUE;
  2021. }
  2022. if (_Delete(pChild, pNode) == TRUE)
  2023. return TRUE;
  2024. }
  2025. return FALSE;
  2026. }
  2031. BOOL CSuperGridCtrl::IsChildOf(const CTreeItem* pParent, const CTreeItem* pChild) const
  2032. {
  2033. if (pChild == pParent)
  2034. return TRUE;
  2035. POSITION pos = pParent->m_listChild.GetHeadPosition();
  2036. while (pos != NULL)
  2037. {
  2038. CTreeItem* pNode = (CTreeItem*)pParent->m_listChild.GetNext(pos);
  2039. if (IsChildOf(pNode, pChild))
  2040. return TRUE;
  2041. }
  2042. return FALSE;
  2043. }
  2047. void CSuperGridCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  2048. {
  2049. if( GetFocus() != this) 
  2050. SetFocus();
  2052. LVHITTESTINFO ht;
  2053. ht.pt = point;
  2054. SubItemHitTest(&ht);
  2055. if(OnItemLButtonDown(ht))
  2056. {
  2057. BOOL bSelect=1;
  2058. bSelect = HitTestOnSign(point, ht);
  2059. if(bSelect && ht.iItem!=-1)
  2060. {
  2061. m_CurSubItem = IndexToOrder(ht.iSubItem);
  2062. CHeaderCtrl* pHeader = GetHeaderCtrl();
  2063. // Make the column fully visible.
  2064. MakeColumnVisible(Header_OrderToIndex(pHeader->m_hWnd, m_CurSubItem));
  2065. CListCtrl::OnLButtonDown(nFlags, point);
  2066. OnControlLButtonDown(nFlags, point, ht);
  2067. //update row anyway for selection bar
  2068. CRect rc;
  2069. GetItemRect(ht.iItem, rc, LVIR_BOUNDS);
  2070. InvalidateRect(rc);
  2071. UpdateWindow();
  2072. }
  2073. }
  2074. }
  2077. void CSuperGridCtrl::OnUpdateListViewItem(CTreeItem* lpItem, LV_ITEM *plvItem)
  2078. {
  2079. //default implementation you would go for this 9 out of 10 times
  2080. CItemInfo *lp = GetData(lpItem);
  2081. CString str = (CString)plvItem->pszText;
  2082. if(lp!=NULL)
  2083. {
  2084. if(plvItem->iSubItem==0)
  2085. lp->SetItemText(str);
  2086. else //subitem data 
  2087. lp->SetSubItemText(plvItem->iSubItem-1, str);
  2088.    UpdateData(lpItem, lp);
  2089. }
  2090. SetItemText(plvItem->iItem, plvItem->iSubItem, plvItem->pszText);
  2091. }
  2095. void CSuperGridCtrl::DeleteAll()
  2096. {
  2097. POSITION pos = m_RootItems.GetHeadPosition();
  2098. while(pos!=NULL)
  2099. {
  2100. CTreeItem * pRoot = (CTreeItem*)m_RootItems.GetNext(pos);
  2101. if(pRoot!=NULL)
  2102. DeleteItemEx(pRoot, 0);
  2103. }
  2104. }
  2107. POSITION CSuperGridCtrl::GetRootHeadPosition() const
  2108. {
  2109. return m_RootItems.GetHeadPosition();
  2110. }
  2113. POSITION CSuperGridCtrl::GetRootTailPosition() const
  2114. {
  2115. return m_RootItems.GetTailPosition();
  2116. }
  2119. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetNextRoot(POSITION& pos) const
  2120. {
  2121. return (CTreeItem*)m_RootItems.GetNext(pos);
  2122. }
  2125. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetPrevRoot(POSITION& pos) const
  2126. {
  2127. return (CTreeItem*)m_RootItems.GetNext(pos);
  2128. }
  2131. POSITION CSuperGridCtrl::GetHeadPosition(CTreeItem* pItem) const
  2132. {
  2133. return pItem->m_listChild.GetHeadPosition();
  2134. }
  2138. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetNextChild(CTreeItem *pItem, POSITION& pos) const
  2139. {
  2140. return (CTreeItem*)pItem->m_listChild.GetNext(pos);
  2141. }
  2145. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetPrevChild(CTreeItem *pItem, POSITION& pos) const
  2146. {
  2147. return (CTreeItem*)pItem->m_listChild.GetPrev(pos);
  2148. }
  2152. POSITION CSuperGridCtrl::GetTailPosition(CTreeItem *pItem) const
  2153. {
  2154. return pItem->m_listChild.GetTailPosition();
  2155. }
  2159. void CSuperGridCtrl::AddTail(CTreeItem *pParent, CTreeItem *pChild)
  2160. {
  2161. pParent->m_listChild.AddTail(pChild);
  2162. }
  2165. inline int StrComp(const CString* pElement1, const CString* pElement2)
  2166. {
  2167. return pElement1->Compare(*pElement2);
  2168. }
  2172. int CSuperGridCtrl::CompareChildren(const void* p1, const void* p2)
  2173. {
  2174. CTreeItem * pChild1 = *(CTreeItem**)p1;
  2175. CTreeItem * pChild2 = *((CTreeItem**)p2);
  2176. CItemInfo *pItem1=(*pChild1).m_lpNodeInfo;
  2177. CItemInfo *pItem2=(*pChild2).m_lpNodeInfo;
  2178. return StrComp(&(pItem1->GetItemText()), &(pItem2->GetItemText()));
  2179. }
  2182. void CSuperGridCtrl::Sort(CTreeItem* pParent, BOOL bSortChildren)
  2183. {
  2184. const int nChildren = NumChildren(pParent);
  2185. if (nChildren > 1)
  2186. {
  2187. CTreeItem** ppSortArray = new CTreeItem*[nChildren];
  2188. // Fill in array with pointers to our children.
  2189. POSITION pos = pParent->m_listChild.GetHeadPosition();
  2190. for (int i=0; pos; i++)
  2191. {
  2192. ASSERT(i < nChildren);
  2193. ppSortArray[i] = (CTreeItem*)pParent->m_listChild.GetAt(pos);
  2194. pParent->m_listChild.GetNext(pos);
  2195. }
  2197. qsort(ppSortArray, nChildren, sizeof(CTreeItem*), CompareChildren);
  2198. // reorg children with new sorted list
  2199. pos = pParent->m_listChild.GetHeadPosition();
  2200. for (i=0; pos; i++)
  2201. {
  2202. ASSERT(i < nChildren);
  2203. pParent->m_listChild.SetAt(pos, ppSortArray[i]);
  2204. pParent->m_listChild.GetNext(pos);
  2205. }
  2207. delete [] ppSortArray;
  2208. }
  2210. if(bSortChildren)
  2211. {
  2212. POSITION pos = pParent->m_listChild.GetHeadPosition();
  2213. while (pos)
  2214. {
  2215. CTreeItem *pChild = (CTreeItem*)pParent->m_listChild.GetNext(pos);
  2216. Sort(pChild, TRUE);
  2217. }
  2218. }
  2219. }
  2223. int CSuperGridCtrl::NumChildren(const CTreeItem *pItem) const
  2224. {
  2225. return pItem->m_listChild.GetCount();
  2226. }
  2230. BOOL CSuperGridCtrl::ItemHasChildren(const CTreeItem* pItem) const
  2231. { 
  2232. BOOL bChildren = pItem->m_listChild.GetCount() != 0;
  2233. //see if we have a flag
  2234. int nFlag = pItem->m_bSetChildFlag;
  2235. if(nFlag!=-1)
  2236. return 1;
  2237. else
  2238. return bChildren;
  2239. }
  2242. void CSuperGridCtrl::SetChildrenFlag(CTreeItem *pItem, int nFlag) const
  2243. {
  2244. pItem->m_bSetChildFlag = nFlag;
  2245. }
  2248. BOOL CSuperGridCtrl::IsCollapsed(const CTreeItem* pItem) const
  2249. {
  2250. return pItem->m_bHideChildren;//e.g not visible
  2251. }
  2254. void CSuperGridCtrl::Hide(CTreeItem* pItem, BOOL bFlag)
  2255. {
  2256. pItem->m_bHideChildren=bFlag;
  2257. }
  2260. int CSuperGridCtrl::GetIndent(const CTreeItem* pItem) const
  2261. {
  2262. return pItem->m_nIndent;
  2263. }
  2266. void CSuperGridCtrl::SetIndent(CTreeItem *pItem, int iIndent)
  2267. {
  2268. pItem->m_nIndent = iIndent;
  2269. }
  2273. int CSuperGridCtrl::GetCurIndex(const CTreeItem *pItem) const
  2274. {
  2275. return pItem->m_nIndex;
  2276. }
  2279. void CSuperGridCtrl::SetCurIndex(CTreeItem* pItem, int nIndex) 
  2280. {
  2281. pItem->m_nIndex = nIndex;
  2282. }
  2285. void CSuperGridCtrl::SetParentItem(CTreeItem*pItem, CTreeItem* pParent)
  2286. {
  2287. pItem->m_pParent=pParent;
  2289. }
  2292. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetParentItem(const CTreeItem* pItem) 
  2293. {
  2294. return pItem->m_pParent;
  2295. };
  2299. CItemInfo* CSuperGridCtrl::GetData(const CTreeItem* pItem) 
  2300. {
  2301. return pItem->m_lpNodeInfo;
  2302. }
  2306. void CSuperGridCtrl::UpdateData(CTreeItem* pItem, CItemInfo* lpInfo)
  2307. {
  2308. pItem->m_lpNodeInfo = lpInfo;
  2309. }
  2312. //overrides
  2313. CItemInfo* CSuperGridCtrl::CopyData(CItemInfo* lpSrc)
  2314. {
  2315. ASSERT(FALSE);//debug
  2316. return NULL;  //release
  2317. }
  2319. //default implementation for setting icons
  2320. int CSuperGridCtrl::GetIcon(const CTreeItem* pItem)
  2321. {
  2323. return 0;//just take the first item in CImageList ..what ever that is
  2324. }
  2327. void CSuperGridCtrl::OnControlLButtonDown(UINT nFlags, CPoint point, LVHITTESTINFO& ht)
  2328. {
  2329. if(ht.iSubItem==0)
  2330. {
  2331. CRect rcItem;
  2332. GetItemRect(ht.iItem, rcItem, LVIR_LABEL);
  2333. DWORD dwStyle = WS_BORDER | WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL|ES_LEFT;
  2334. // CEdit *pEdit = new CListEditCtrl(ht.iItem, ht.iSubItem, GetItemText(ht.iItem, ht.iSubItem));
  2335. // pEdit->Create(dwStyle, rcItem, this, 0x1233);
  2336. }
  2337. // else
  2338. // EditLabelEx(ht.iItem, ht.iSubItem);
  2339. }
  2342. COLORREF CSuperGridCtrl::GetCellRGB()
  2343. {
  2344. return RGB(192,0,0);
  2345. }
  2348. BOOL CSuperGridCtrl::OnVKMultiply(CTreeItem *pItem, int nIndex)
  2349. {
  2350. return 1;
  2351. }
  2355. BOOL CSuperGridCtrl::OnVkSubTract(CTreeItem *pItem, int nIndex)
  2356. {
  2357. return 1;
  2358. }
  2362. BOOL CSuperGridCtrl::OnVKAdd(CTreeItem *pItem, int nIndex)
  2363. {
  2364. return 1;
  2365. }
  2368. BOOL CSuperGridCtrl::OnDeleteItem(CTreeItem* pItem, int nIndex)
  2369. {
  2370. return 1;
  2371. }
  2375. BOOL CSuperGridCtrl::OnItemExpanding(CTreeItem *pItem, int iItem)
  2376. {
  2377. return 1;
  2378. }
  2381. BOOL CSuperGridCtrl::OnItemExpanded(CTreeItem* pItem, int iItem)
  2382. {
  2383. return 1;
  2384. }
  2387. BOOL CSuperGridCtrl::OnCollapsing(CTreeItem *pItem)
  2388. {
  2389. return 1;
  2390. }
  2393. BOOL CSuperGridCtrl::OnItemCollapsed(CTreeItem *pItem)
  2394. {
  2395. return 1;
  2396. }
  2399. BOOL CSuperGridCtrl::OnItemLButtonDown(LVHITTESTINFO& ht)
  2400. {
  2401. return 1;
  2402. }
  2405. BOOL CSuperGridCtrl::OnVkReturn(void)
  2406. {
  2407. return 0;
  2408. }
  2411. void CSuperGridCtrl::OnSysColorChange() 
  2412. {
  2413. CListCtrl::OnSysColorChange();
  2414. //nop nothing yet
  2415. }
  2419. UINT CSuperGridCtrl::_GetCount(CTreeItem* pItem, UINT& nCount)
  2420. {
  2421. POSITION pos = pItem->m_listChild.GetHeadPosition();
  2422. while (pos)
  2423. {
  2424. CTreeItem *pChild = (CTreeItem*)pItem->m_listChild.GetNext(pos);
  2425. nCount = _GetCount(pChild, nCount);
  2426. nCount++;
  2427. }
  2428. return nCount;
  2429. }
  2433. UINT CSuperGridCtrl::GetCount(void) 
  2434. {
  2435. UINT nCount=0;
  2436. POSITION pos = m_RootItems.GetHeadPosition();
  2437. while(pos!=NULL)
  2438. {
  2439. CTreeItem * pRoot = (CTreeItem*)m_RootItems.GetNext(pos);
  2440. UINT _nCount=0;
  2441. nCount += _GetCount(pRoot, _nCount) + 1;
  2442. }
  2443. return nCount;
  2444. }
  2448. CSuperGridCtrl::CTreeItem* CSuperGridCtrl::GetTreeItem(int nIndex /*nIndex must be valid of course*/ ) 
  2449. {
  2450. return reinterpret_cast<CTreeItem*>(GetItemData(nIndex));
  2451. }
  2455. int CSuperGridCtrl::GetSelectedItem(void) const
  2456. {
  2457. return GetNextItem(-1, LVNI_ALL | LVNI_SELECTED); 
  2458. }
  2460. //////////////////////////////////////////////////////////////////////////
  2461. //
  2462. // not much but ... 
  2463. //
  2464. //////////////////////////////////////////////////////////////////////////
  2466. CSuperGridCtrl::CTreeItem::~CTreeItem()
  2467. {
  2468. // delete child nodes
  2469. POSITION pos = m_listChild.GetHeadPosition();
  2470. while (pos != NULL)
  2471. {
  2472. CTreeItem* pItem = (CTreeItem*)m_listChild.GetNext(pos);
  2473. if(pItem!=NULL)
  2474. {
  2475. if(pItem->m_lpNodeInfo!=NULL)
  2476. delete pItem->m_lpNodeInfo;
  2477. delete pItem;
  2478. }
  2479. }
  2480. m_listChild.RemoveAll();
  2481. }
  2483. void CSuperGridCtrl::DrawProgressBar(CDC* pDC, int iItem, int iSubItem)
  2484. {
  2485. ASSERT(pDC);
  2487. CRect rect;
  2489. BOOL bRC = CListCtrl::GetSubItemRect(iItem, iSubItem, LVIR_LABEL, rect);
  2491. // GetProgressRect(id, rect, false);
  2494. //First, fill area outside progress bar with background color
  2495. {
  2496. CRect outrect;
  2497. GetSubItemRect(iItem, iSubItem, LVIR_BOUNDS, outrect);
  2499. // GetTextRect(id, outrect);
  2501. pDC->SaveDC();
  2502. pDC->ExcludeClipRect(&rect);
  2503. FillSolidRect(pDC, outrect, RGB(0,0,0));
  2505. pDC->RestoreDC(-1);
  2506. }
  2508. // if(id.m_edge != 0)
  2509. {
  2510. // draw border
  2511. pDC->DrawEdge(&rect, EDGE_SUNKEN, BF_RECT);
  2512. }
  2514. // GetProgressRect(id, rect, true);
  2516. // fill interior with background color
  2517. FillSolidRect(pDC, rect, RGB(128,0,0)); //id.m_progressBar.m_fillColor==DEFAULTCOLOR));
  2519. // if (id.m_value > 0)
  2520. {
  2521. // draw progress bar and text
  2522. // rect.right = rect.left + GetBarSize(id, rect);
  2524. COLORREF fill = ::GetSysColor(COLOR_GRAYTEXT);
  2526. FillSolidRect(pDC, rect, fill);
  2527. }
  2528. }
  2530. //Custom draw
  2531. /*void CSuperGridCtrl::OnCustomDraw(NMHDR* pNMHDR, LRESULT* pResult)
  2532. {
  2533. NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );
  2535.   //  *pResult = 0; return;
  2537.     // If this is the beginning of the control's paint cycle, request
  2538.     // notifications for each item.
  2540.     if ( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage )
  2541. {
  2542.         *pResult = CDRF_NOTIFYITEMDRAW;
  2543. }
  2544.     else if ( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage )
  2545. {
  2546.         // This is the pre-paint stage for an item.  We need to make another
  2547.         // request to be notified during the post-paint stage.
  2548.         *pResult = CDRF_NOTIFYSUBITEMDRAW;;
  2549. }
  2551.     else if ( (CDDS_ITEMPREPAINT| CDDS_SUBITEM) == pLVCD->nmcd.dwDrawStage )
  2552. {
  2553. CDC* pDC = CDC::FromHandle(pLVCD->nmcd.hdc);
  2555. DrawProgressBar(pDC, static_cast<int> (pLVCD->nmcd.dwItemSpec), pLVCD->iSubItem);
  2556. *pResult = CDRF_SKIPDEFAULT; // We've painted everything.
  2557. }
  2558. }*/
  2560. //////////////////////////////////////////////////////////////////////////
  2561. //
  2562. // Simple class CRectangle for the + - sign, 
  2563. //
  2564. //////////////////////////////////////////////////////////////////////////
  2566. CRectangle::CRectangle(CSuperGridCtrl* pCtrl, CDC* pDC, int iIndent, const CRect& rcBounds)
  2567. {
  2568. m_pDC=pDC;
  2569. int nHalfImage = (pCtrl->m_cxImage >> 1);
  2570. int nBottomDown = rcBounds.top + nHalfImage + ((rcBounds.Height() - pCtrl->m_cyImage) >> 1);
  2571. m_right_bottom.cx = (pCtrl->m_cxImage>>1)+2+1;
  2572. m_right_bottom.cy = (pCtrl->m_cyImage>>1)+2+1;
  2573. m_left = rcBounds.left  + iIndent * pCtrl->m_cxImage - nHalfImage;
  2574. m_top = nBottomDown - (m_right_bottom.cy >> 1);
  2575. m_left_top.x = m_left -  (m_right_bottom.cx >> 1);
  2576. m_left_top.y = m_top;
  2577. m_topdown = nBottomDown;
  2578. }
  2581. void CRectangle::DrawRectangle(CSuperGridCtrl* pCtrl)
  2582. {
  2583. //erase bkgrnd
  2584. CRect rc(m_left_top, m_right_bottom);
  2585. m_pDC->FillRect(rc, &pCtrl->m_brushErase);
  2586. //draw rectangle
  2587. CPen* pPenRectangle = m_pDC->SelectObject(&pCtrl->m_psRectangle);
  2588. m_pDC->Rectangle(rc);
  2589. m_pDC->SelectObject(pPenRectangle);
  2590. }
  2593. CRectangle::~CRectangle()
  2594. {
  2595. }
  2598. BOOL CRectangle::HitTest(CPoint pt)
  2599. {
  2600. CRect rc = GetHitTestRect();
  2601. return rc.PtInRect(pt);
  2602. }
  2605. void CRectangle::DrawPlus(void)
  2606. {
  2607. m_pDC->MoveTo(m_left, m_topdown-2);
  2608. m_pDC->LineTo(m_left, m_topdown+3);
  2610. m_pDC->MoveTo(m_left-2, m_topdown);
  2611. m_pDC->LineTo(m_left+3, m_topdown);
  2612. }
  2615. void CRectangle::DrawMinus(void)
  2616. {
  2617. m_pDC->MoveTo(m_left-2, m_topdown);
  2618. m_pDC->LineTo(m_left+3, m_topdown);
  2619. }