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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
Uictrl.cpp
资源名称：isee_code01231.zip　[点击查看]
上传用户：yatsl7111
上传日期：2007-01-08
资源大小：1433k
文件大小：79k
源码类别：

图形图象

开发平台：

Visual C++

Uictrl.cpp：源码内容
  1. //*******************************************************************************
  2. // COPYRIGHT NOTES
  3. // ---------------
  4. // You may use this source code, compile or redistribute it as part of your application 
  5. // for free. You cannot redistribute it as a part of a software development 
  6. // library without the agreement of the author. If the sources are 
  7. // distributed along with the application, you should leave the original 
  8. // copyright notes in the source code without any changes.
  9. // This code can be used WITHOUT ANY WARRANTIES at your own risk.
  10. // 
  11. // For the latest updates to this code, check this site:
  12. // http://www.masmex.com 
  13. // after Sept 2000
  14. // 
  15. // Copyright(C) 2000 Philip Oldaker <email: philip@masmex.com>
  16. //*******************************************************************************
  18. #include "stdafx.h"
  19. #include "UICtrl.h"
  20. #include "InPlaceEdit.h"
  21. #include "TextProgressCtrl.h"
  22. #include "UIres.h"
  23. #include "ctype.h"
  24. #include "cbformats.h"
  25. #include <yvals.h>
  27. //////////////////////////////////////////////////////
  28. // Temporarily changes the view type
  29. //////////////////////////////////////////////////////
  30. CChangeViewType::CChangeViewType(CUIODListCtrl *pLC,DWORD dwType)
  31. {
  32. m_pLC = pLC;
  33. m_dwType = m_pLC->GetViewType();
  34. m_pLC->SetViewType(dwType);
  35. }
  37. CChangeViewType::~CChangeViewType()
  38. {
  39. m_pLC->SetViewType(m_dwType);
  40. }
  41. //////////////////////////////////////////////////////////
  43. LPCTSTR CUIODListCtrl::szEntryHeadings = _T("Headings");
  44. LPCTSTR CUIODListCtrl::szEntryStyle = _T("Style");
  45. LPCTSTR CUIODListCtrl::szEntryRowSel = _T("RowSelection");
  46. LPCTSTR CUIODListCtrl::szEntryViewType = _T("ViewType");
  47. LPCTSTR CUIODListCtrl::szEntryColumnSizing = _T("ColumnSizing");
  48. LPCTSTR CUIODListCtrl::szEntrySortColumn = _T("SortColumn");
  49. LPCTSTR CUIODListCtrl::szEntrySubItems = _T("Columns");
  50. LPCTSTR CUIODListCtrl::szEntryColOrder = _T("ColumnOrder");
  51. LPCTSTR CUIODListCtrl::szEntryColWidths = _T("ColumnWidths");
  53. IMPLEMENT_SERIAL(CUIODListCtrl, CListCtrl, 0)
  55. #define COLUMN_DELIMITER '|'
  56. #define COLUMN_DELIMITER_STR "|"
  58. const int nMaxDigLen = _MAX_INT_DIG*4;
  60. //////////////////////////////
  61. //
  62. // CUIODListCtrl
  63. //
  64. //////////////////////////////
  65. BEGIN_MESSAGE_MAP(CUIODListCtrl, CListCtrl)
  66. //{{AFX_MSG_MAP(CUIODListCtrl)
  67. ON_MESSAGE(WM_APP_ON_PROPERTIES_KEY,OnAppPropertiesKey)
  68. ON_MESSAGE(WM_APP_ON_DELETE_KEY,OnAppDeleteKey)
  69. ON_MESSAGE(WM_APP_ON_CONTEXT_MENU_KEY,OnAppContextMenuKey)
  70. ON_MESSAGE(WM_APP_ON_BACKSPACE_KEY,OnAppBackspaceKey)
  71. ON_MESSAGE(WM_APP_ON_EDIT_KEY,OnAppEditKey)
  72. ON_MESSAGE(WM_APP_ON_REFRESH_KEY,OnAppRefreshKey)
  74. ON_NOTIFY_REFLECT_EX(LVN_BEGINDRAG, OnBegindrag)
  75. ON_NOTIFY_REFLECT_EX(LVN_BEGINRDRAG, OnBeginRDrag)
  76. ON_WM_CREATE()
  77. ON_WM_DESTROY()
  78. ON_MESSAGE(LVM_SETCOLUMNWIDTH,OnSetColumnWidth)
  79. ON_MESSAGE(LVM_DELETEALLITEMS,OnDeleteAllItems)
  80. ON_MESSAGE(LVM_DELETEITEM,OnDeleteItem)
  81. ON_MESSAGE(LVM_DELETECOLUMN,OnDeleteColumn)
  82. ON_MESSAGE(WM_UPDATEHEADERWIDTH,OnUpdateHeaderWidth)
  83. ON_WM_SIZE()
  84. ON_WM_PAINT()
  85. ON_WM_SETFOCUS()
  86. ON_WM_KILLFOCUS()
  87. ON_WM_CONTEXTMENU()
  88. ON_WM_INITMENUPOPUP()
  89. ON_WM_LBUTTONDOWN()
  90. ON_WM_HSCROLL()
  91. ON_WM_VSCROLL()
  92. ON_COMMAND(ID_UI_VIEW_LARGE_ICONS,OnViewLargeIcons)
  93. ON_COMMAND(ID_UI_VIEW_SMALL_ICONS,OnViewSmallIcons)
  94. ON_COMMAND(ID_UI_VIEW_DETAILS,OnViewDetails)
  95. ON_COMMAND(ID_UI_VIEW_LIST,OnViewList)
  96. ON_COMMAND(ID_UI_VIEW_FULL_ROW_SELECTION,OnViewFullRowSelection)
  97. ON_COMMAND(ID_UI_VIEW_COLUMN_ORDERING,OnViewColumnOrdering)
  98. ON_COMMAND(ID_UI_VIEW_COLUMN_SIZING,OnViewColumnSizing)
  99. ON_COMMAND(ID_UI_VIEW_GRIDLINES,OnViewGridlines)
  100. ON_COMMAND(ID_UI_VIEW_CHECKBOXES,OnViewCheckboxes)
  101. ON_COMMAND(ID_UI_VIEW_TRACK_SELECT,OnViewTrackSelect)
  102. ON_COMMAND(ID_UI_VIEW_EDIT_COLUMN,OnViewEditColumn)
  103. ON_COMMAND(ID_HEADER_REMOVE_COL,OnHeaderRemoveColumn)
  104. ON_COMMAND(ID_HEADER_EDIT_TEXT,OnHeaderEditText)
  105. ON_COMMAND(ID_HEADER_RESET,OnHeaderReset)
  106. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
  107. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
  108. ON_WM_DROPFILES()
  109. ON_MESSAGE(LVM_SETIMAGELIST, OnSetImageList)
  110. ON_MESSAGE(LVM_SETTEXTCOLOR, OnSetTextColor)
  111. ON_MESSAGE(LVM_SETTEXTBKCOLOR, OnSetTextBkColor)
  112. ON_MESSAGE(LVM_SETBKCOLOR, OnSetBkColor)
  113. ON_MESSAGE(LVM_GETITEMTEXT, OnGetItemText)
  114. //}}AFX_MSG_MAP
  115. ON_MESSAGE(WM_APP_OLE_DD_DROP, OnDragDrop)
  116. ON_MESSAGE(WM_APP_OLE_DD_DODRAGDROP, OnDDDoDragDrop)
  117. ON_MESSAGE(WM_APP_OLE_DD_OVER, OnDragOver)
  118. ON_MESSAGE(WM_APP_OLE_DD_ENTER, OnDragEnter)
  119. ON_MESSAGE(WM_APP_OLE_DD_LEAVE, OnDragLeave)
  120. END_MESSAGE_MAP()
  123. CUIODListCtrl::CUIODListCtrl(bool bDragDrop) 
  124. {
  125. m_PopupID = 0;
  126. m_MultiPopupID = 0;
  127. m_bDragDrop = bDragDrop;
  128. m_bDropFiles = true;
  129. m_pColWidths = NULL;
  130. m_pColOrder = NULL;
  131. m_pColTypes = NULL;
  132. m_hOrigFont = NULL;
  133. m_pPopupWnd = NULL;
  134. m_nImageList = LVSIL_SMALL;
  135. m_nColClicked = -1;
  136. m_nSortColumn = 0;
  137. m_nSubItems = 0;
  138. m_nItems = 0;
  139. m_nImage = 0;
  140. m_dwExStyle = LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_INFOTIP;
  141. m_dwViewType = LVS_REPORT;
  142. m_bDelayPaint = false;
  143. m_bColumnSizing=TRUE;
  144. m_bRClickChangeIconSize = TRUE;
  145. // this is toggled on in InitListCtrl
  146. m_bFullRowSel=FALSE;
  147. m_bClientWidthSel=TRUE;
  148. m_bSortAscending=TRUE;
  149. m_bToolTips=FALSE;
  150. m_bEditSubItems = true;
  151. m_cxClient=0;
  152. m_cxStateImageOffset=0;
  154. m_clrText=::GetSysColor(COLOR_WINDOWTEXT);
  155. m_clrTextBk=::GetSysColor(COLOR_WINDOW);
  156. m_clrBkgnd=::GetSysColor(COLOR_WINDOW);
  157. m_strNoItemsMess.LoadString(IDS_NO_ITEMS_MESS);
  158. }
  160. CUIODListCtrl::~CUIODListCtrl()
  161. {
  162. Empty();
  163. }
  165. void CUIODListCtrl::AllItemsDeleted()
  166. {
  168. }
  170. void CUIODListCtrl::Empty()
  171. {
  172. m_objList.DeleteAll();
  173. delete []m_pColWidths;
  174. delete []m_pColOrder;
  175. delete []m_pColTypes;
  176. m_pColWidths = NULL;
  177. m_pColOrder = NULL;
  178. m_pColTypes = NULL;
  179. }
  181. // should be overridden to do any initialization
  182. void CUIODListCtrl::Init()
  183. {
  184. }
  186. void CUIODListCtrl::UpdateEvent(LPARAM lHint,CObject *pHint)
  187. {
  188. GetParent()->SendMessage(WM_APP_UPDATE_ALL_VIEWS,(WPARAM)lHint,(LPARAM)pHint);
  189. }
  191. BOOL CUIODListCtrl::SetViewType(DWORD dwViewType,UINT nFlags)
  192. {
  193. BOOL bRet = ModifyStyle(LVS_TYPEMASK,dwViewType & LVS_TYPEMASK,nFlags);
  194. if (bRet)
  195. SaveProfile();
  196. return bRet;
  197. }
  199. DWORD CUIODListCtrl::GetViewType() const
  200. {
  201. return(GetStyle() & LVS_TYPEMASK);
  202. }
  204. void CUIODListCtrl::ChangeStyle(UINT &dwStyle)
  205. {
  206. LoadProfile();
  207. dwStyle |= LVS_SHOWSELALWAYS | m_dwViewType;
  208. }
  210. // offsets for first and other columns
  211. #define OFFSET_FIRST 2
  212. #define OFFSET_OTHER 6
  214. void CUIODListCtrl::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
  215. {
  216. CDC* pDC=CDC::FromHandle(lpDrawItemStruct->hDC);
  217. CRect rcItem(lpDrawItemStruct->rcItem);
  218. UINT uiFlags=ILD_TRANSPARENT;
  219. CImageList* pImageList;
  220. int nItem=lpDrawItemStruct->itemID;
  221. BOOL bFocus=(GetFocus()==this);
  222. COLORREF clrTextSave, clrBkSave;
  223. COLORREF clrImage=m_clrBkgnd;
  224. static _TCHAR szBuff[MAX_PATH];
  225. LPCTSTR pszText;
  227. if (m_cxClient == 0)
  228. {
  229. CRect rcClient;
  230. GetClientRect(rcClient);
  231. m_cxClient = rcClient.Width();
  232. }
  233. // get item data
  235. LV_ITEM lvi;
  236. lvi.mask=LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_PARAM;
  237. lvi.iItem=nItem;
  238. lvi.iSubItem=0;
  239. lvi.pszText=szBuff;
  240. lvi.cchTextMax=sizeof(szBuff);
  241. lvi.stateMask=0xFFFF; // get all state flags
  242. GetItem(&lvi);
  244. BOOL bSelected=(bFocus || (GetStyle() & LVS_SHOWSELALWAYS)) && lvi.state & LVIS_SELECTED;
  245. bSelected=bSelected || (lvi.state & LVIS_DROPHILITED);
  247. // set colors if item is selected
  249. CRect rcAllLabels;
  250. GetItemRect(nItem,rcAllLabels,LVIR_BOUNDS);
  251. CRect rcLabel;
  252. GetItemRect(nItem,rcLabel,LVIR_LABEL);
  253. rcAllLabels.left=rcLabel.left;
  254. // if(m_bClientWidthSel && rcAllLabels.right<m_cxClient)
  255. // rcAllLabels.right=m_cxClient;
  256. int BkMode = pDC->SetBkMode(TRANSPARENT);
  257. CUIListCtrlData *pData = (CUIListCtrlData*)lvi.lParam;
  258. ASSERT(pData->IsKindOf(RUNTIME_CLASS(CUIListCtrlData)));
  259. CFont *pOldFont = NULL;
  260. if (pData && pData->IsFontSet())
  261. {
  262. pOldFont = pDC->SelectObject((CFont*)pData->GetFont());
  263. }
  264. if(bSelected)
  265. {
  266. if (bFocus) 
  267. {
  268. clrTextSave=pDC->SetTextColor(::GetSysColor(COLOR_HIGHLIGHTTEXT));
  269. clrBkSave=pDC->SetBkColor(::GetSysColor(COLOR_HIGHLIGHT));
  270. pDC->FillRect(rcAllLabels,&CBrush(::GetSysColor(COLOR_HIGHLIGHT)));
  271. }
  272. else 
  273. {
  274. clrTextSave=pDC->GetTextColor();
  275. clrBkSave=pDC->GetBkColor();
  276. DWORD clrTextBk;
  277. if (pData)
  278. {
  279. pDC->SetTextColor(pData->GetTextColor());
  280. clrTextBk = pData->GetBkColor();
  281. }
  282. else 
  283. {
  284. clrTextBk = m_clrTextBk;
  285. pDC->SetTextColor(m_clrText);
  286. }
  287. CRect rc(rcAllLabels);
  288. pDC->FillRect(rcAllLabels,&CBrush(clrTextBk));
  289. pDC->FrameRect(rc,&CBrush(::GetSysColor(COLOR_HIGHLIGHT)));
  290. }
  291. }
  292. else 
  293. {
  294. CUIListCtrlData *pData = (CUIListCtrlData *)lvi.lParam;
  295. if (pData) 
  296. {
  297. ASSERT(pData->IsKindOf(RUNTIME_CLASS(CUIListCtrlData)));
  298. pDC->SetTextColor(pData->GetTextColor());
  299. pDC->SetBkColor(pData->GetBkColor());
  300. pDC->FillRect(rcAllLabels,&CBrush(pData->GetBkColor()));
  301. }
  302. else
  303. pDC->FillRect(rcAllLabels,&CBrush(m_clrTextBk));
  304. }
  305. // set color and mask for the icon
  307. if(lvi.state & LVIS_CUT)
  308. {
  309. clrImage=m_clrBkgnd;
  310. uiFlags|=ILD_BLEND50;
  311. }
  312. else if(bSelected)
  313. {
  314. clrImage=::GetSysColor(COLOR_HIGHLIGHT);
  315. uiFlags|=ILD_BLEND50;
  316. }
  318. // draw state icon
  320. UINT nStateImageMask=lvi.state & LVIS_STATEIMAGEMASK;
  321. if(nStateImageMask)
  322. {
  323. int nImage=(nStateImageMask>>12)-1;
  324. pImageList=GetImageList(LVSIL_STATE);
  325. if(pImageList)
  326. pImageList->Draw(pDC,nImage,CPoint(rcItem.left,rcItem.top),ILD_TRANSPARENT);
  327. }
  329. // draw normal and overlay icon
  331. CRect rcIcon;
  332. GetItemRect(nItem,rcIcon,LVIR_ICON);
  334. pImageList=GetImageList(LVSIL_SMALL);
  335. if(pImageList)
  336. {
  337. UINT nOvlImageMask=lvi.state & LVIS_OVERLAYMASK;
  338. if(rcItem.left<rcItem.right-1)
  339. ImageList_DrawEx(pImageList->m_hImageList,lvi.iImage,pDC->m_hDC,rcIcon.left,rcIcon.top,16,16,m_clrBkgnd,clrImage,uiFlags | nOvlImageMask);
  340. }
  342. // draw item label
  344. GetItemRect(nItem,rcItem,LVIR_LABEL);
  345. rcItem.right-=m_cxStateImageOffset;
  347. pszText=MakeShortString(pDC,szBuff,rcItem.right-rcItem.left,2*OFFSET_FIRST);
  349. rcLabel=rcItem;
  350. rcLabel.left+=OFFSET_FIRST;
  351. rcLabel.right-=OFFSET_FIRST;
  353. pDC->DrawText(pszText,-1,rcLabel,DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP | DT_VCENTER);
  354. // draw labels for extra columns
  356. LV_COLUMN lvc;
  357. lvc.mask=LVCF_FMT | LVCF_WIDTH;
  359. for(int nColumn=1; GetColumn(nColumn,&lvc); nColumn++)
  360. {
  361. rcItem.left=rcItem.right;
  362. rcItem.right+=lvc.cx;
  364. int nRetLen=GetItemText(nItem,nColumn,szBuff,sizeof(szBuff));
  365. if(nRetLen==0) continue;
  367. pszText=MakeShortString(pDC,szBuff,rcItem.right-rcItem.left,2*OFFSET_OTHER);
  369. UINT nJustify=DT_LEFT;
  371. if(pszText==szBuff)
  372. {
  373. switch(lvc.fmt & LVCFMT_JUSTIFYMASK)
  374. {
  375. case LVCFMT_RIGHT:
  376. nJustify=DT_RIGHT;
  377. break;
  378. case LVCFMT_CENTER:
  379. nJustify=DT_CENTER;
  380. break;
  381. default:
  382. break;
  383. }
  384. }
  386. rcLabel=rcItem;
  387. rcLabel.left+=OFFSET_OTHER;
  388. rcLabel.right-=OFFSET_OTHER;
  390. pDC->DrawText(pszText,-1,rcLabel,nJustify | DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP | DT_VCENTER);
  391. }
  392. if (pData->IsKindOf(RUNTIME_CLASS(CUIStrListCtrlData)))
  393. {
  394. CUIStrListCtrlData *pStrData = (CUIStrListCtrlData*)pData;
  395. if (!pStrData->GetExtraString().IsEmpty())
  396. {
  397. rcLabel=rcAllLabels;
  398. rcLabel.top += (m_cySmallIcon+1);
  399. pDC->DrawText(pStrData->GetExtraString(),-1,rcLabel,DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP | DT_VCENTER);
  400. }
  401. }
  402. // draw focus rectangle if item has focus
  404. if(lvi.state & LVIS_FOCUSED && bFocus)
  405. pDC->DrawFocusRect(rcAllLabels);
  407. // set original colors if item was selected
  409. if(bSelected)
  410. {
  411.     pDC->SetTextColor(clrTextSave);
  412. pDC->SetBkColor(clrBkSave);
  413. }
  414. if (pOldFont)
  415. pDC->SelectObject(pOldFont);
  416. pDC->SetBkMode(BkMode);
  417. }
  419. LPCTSTR CUIODListCtrl::MakeShortString(CDC* pDC, LPCTSTR lpszLong, int nColumnLen, int nOffset)
  420. {
  421. static const _TCHAR szThreeDots[]=_T("...");
  423. int nStringLen=lstrlen(lpszLong);
  425. if(nStringLen==0 || pDC->GetTextExtent(lpszLong,nStringLen).cx+nOffset<=nColumnLen)
  426. return(lpszLong);
  428. static _TCHAR szShort[MAX_PATH];
  430. lstrcpy(szShort,lpszLong);
  431. int nAddLen=pDC->GetTextExtent(szThreeDots,sizeof(szThreeDots)).cx;
  433. for(int i=nStringLen-1; i>0; i--)
  434. {
  435. szShort[i]=0;
  436. if(pDC->GetTextExtent(szShort,i).cx+nOffset+nAddLen<=nColumnLen)
  437. break;
  438. }
  440. lstrcat(szShort,szThreeDots);
  442. return(szShort);
  443. }
  445. void CUIODListCtrl::RepaintSelectedItems()
  446. {
  447. CRect rcItem, rcLabel;
  449. // invalidate focused item so it can repaint properly
  451. int nItem=GetNextItem(-1,LVNI_FOCUSED);
  453. if(nItem!=-1)
  454. {
  455. GetItemRect(nItem,rcItem,LVIR_BOUNDS);
  456. GetItemRect(nItem,rcLabel,LVIR_LABEL);
  457. rcItem.left=rcLabel.left;
  459. InvalidateRect(rcItem,FALSE);
  460. }
  462. // if selected items should not be preserved, invalidate them
  464. // if(!(GetStyle() & LVS_SHOWSELALWAYS))
  465. // {
  466. for(nItem=GetNextItem(-1,LVNI_SELECTED);
  467. nItem!=-1; nItem=GetNextItem(nItem,LVNI_SELECTED))
  468. {
  469. GetItemRect(nItem,rcItem,LVIR_BOUNDS);
  470. GetItemRect(nItem,rcLabel,LVIR_LABEL);
  471. rcItem.left=rcLabel.left;
  473. InvalidateRect(rcItem,FALSE);
  474. }
  475. // }
  477. // update changes 
  479. UpdateWindow();
  480. }
  482. void CUIODListCtrl::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItem)
  483. {
  484.     lpMeasureItem->itemHeight = (m_cySmallIcon+1)*3;
  485. }
  488. BOOL CUIODListCtrl::OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  489. {
  490. LPNMHDR pnmh;
  492. switch (message)
  493. {
  494. case WM_DRAWITEM:
  495. ASSERT(pResult == NULL);       
  496. DrawItem((LPDRAWITEMSTRUCT)lParam);
  497. break;
  498. case WM_MEASUREITEM:
  499. ASSERT(pResult == NULL);       
  500. MeasureItem((LPMEASUREITEMSTRUCT)lParam);
  501. break;
  502. case WM_NOTIFY:
  503. pnmh = (LPNMHDR)lParam;
  504. if (pnmh->code == LVN_ITEMCHANGED)
  505. {
  506. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pnmh;
  507. if ((pNMListView->uNewState & LVIS_SELECTED) == LVIS_SELECTED && 
  508. (pNMListView->uNewState & LVIS_FOCUSED) == LVIS_FOCUSED) 
  509. {
  510. return OnSelChanged(pNMListView->iItem,pResult);
  511. }
  512. }
  513. else if (pnmh->code == LVN_GETDISPINFO) 
  514. {
  515. return GetDispInfo((LV_DISPINFO*)pnmh);
  516. }
  517. else if (pnmh->code == LVN_COLUMNCLICK) 
  518. {
  519. return ColumnClick((NM_LISTVIEW*)pnmh);
  520. }
  521. else if (pnmh->code == LVN_ENDLABELEDIT) 
  522. {
  523. return OnEndLabelEdit(pnmh,pResult);
  524. }
  525. else if (pnmh->code == NM_DBLCLK) 
  526. {
  527. return DoubleClick((NM_LISTVIEW*)pnmh);
  528. }
  529. else if (pnmh->code == NM_RETURN) 
  530. {
  531. return OnEnter((NM_LISTVIEW*)pnmh);
  532. }
  533. else if (pnmh->code == NM_CUSTOMDRAW)
  534. {
  535.      LPNMLVCUSTOMDRAW  lplvcd = (LPNMLVCUSTOMDRAW)lParam;
  536.  if(lplvcd->nmcd.dwDrawStage == CDDS_PREPAINT)
  537.  {
  538. //tell the control we want pre-paint notifications for each item
  539. *pResult = CDRF_NOTIFYITEMDRAW;
  540. return TRUE;
  541.  }
  542.  if (lplvcd->nmcd.dwDrawStage == (CDDS_ITEMPREPAINT | CDDS_SUBITEM))
  543.  {
  544.  return SubItemPrePaint(lplvcd,pResult);
  545.  }
  546.  if (lplvcd->nmcd.dwDrawStage == (CDDS_ITEMPOSTPAINT | CDDS_SUBITEM))
  547.  {
  548.  return SubItemPostPaint(lplvcd,pResult);
  549.  }
  550.  if (lplvcd->nmcd.dwDrawStage == CDDS_ITEMPREPAINT)
  551.  {
  552.  return ItemPrePaint(lplvcd,pResult);
  553.  }
  554.  if (lplvcd->nmcd.dwDrawStage == CDDS_ITEMPOSTPAINT)
  555.  {
  556.  return ItemPostPaint(lplvcd,pResult);
  557.  }
  558.         }
  559. }
  560. return CWnd::OnChildNotify(message, wParam, lParam, pResult);
  561. }
  563. LRESULT CUIODListCtrl::OnUpdateHeaderWidth(WPARAM wParam,LPARAM lParam)
  564. {
  565. // lParam = column that has changed its width
  566. int nItem = lParam;
  567. m_pColWidths[nItem] = GetColumnWidth(nItem);
  568.     GetParent()->SendMessage(WM_HEADERWIDTHCHANGED,(WPARAM)GetSafeHwnd(),nItem);
  569. return TRUE;
  570. }
  572. BOOL CUIODListCtrl::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  573. {
  574. LPNMHDR pnmh = (LPNMHDR)lParam;
  575. if ((pnmh->code == HDN_BEGINTRACKW || pnmh->code == HDN_BEGINTRACKA)) 
  576. {
  577. if (m_bColumnSizing == FALSE) 
  578. {
  579. *pResult = TRUE;
  580. return TRUE;
  581. }
  582. LPNMHEADER phdr = (LPNMHEADER)lParam;
  583. if (phdr->pitem->mask & HDI_WIDTH)
  584. {
  585. }
  586. }
  587. if ((pnmh->code == HDN_ITEMCHANGINGW || pnmh->code == HDN_ITEMCHANGINGA)) 
  588. {
  589. LPNMHEADER phdr = (LPNMHEADER)lParam;
  590. }
  591. if ((pnmh->code == HDN_ENDTRACKW || pnmh->code == HDN_ENDTRACKA)) 
  592. {
  593.     HD_NOTIFY *phdn = (HD_NOTIFY*)pnmh;
  594. LPNMHEADER phdr = (LPNMHEADER)lParam;
  595. if (m_bColumnSizing == TRUE && (phdr->pitem->mask & HDI_WIDTH))
  596. PostMessage(WM_UPDATEHEADERWIDTH,(WPARAM)phdn->hdr.hwndFrom,(LPARAM)phdn->iItem);
  597. } 
  598. // wParam is zero for Header ctrl
  599. if( wParam == 0 && pnmh->code == NM_RCLICK )
  600. {
  601. // Right button was clicked on header
  602. CPoint ptScreen(GetMessagePos());
  603. CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);
  604. ASSERT(pHeader);
  605. CPoint ptClient(ptScreen);
  606. pHeader->ScreenToClient(&ptClient);
  608. // Determine the column index
  609. int index=-1;
  610. CRect rcCol;
  611. for( int i=0; Header_GetItemRect(pHeader->m_hWnd, i, &rcCol); i++ )
  612. {
  613. if( rcCol.PtInRect( ptClient ) )
  614. {
  615. index = i;
  616. break;
  617. }
  618. }
  619. OnRClickHeader(ptScreen,index);
  620. }
  621. return CWnd::OnNotify(wParam,lParam,pResult);
  622. }
  624. DWORD CUIODListCtrl::GetItemData(int nIndex) const
  625. {
  626. if (nIndex != LB_ERR)
  627. {
  628. const CUIListCtrlData* pListObj = GetListCtrlData(nIndex);
  629. if (pListObj)
  630. return pListObj->GetExtData();
  631. }
  632. return 0;
  633. }
  635. BOOL CUIODListCtrl::SetItemDataAutoDelete(int nIndex,CObject *pObj)
  636. {
  637. ASSERT_KINDOF(CObject,pObj);
  638. return SetItemData(nIndex,(DWORD)pObj,true);
  639. }
  641. BOOL CUIODListCtrl::SetItemData(int nIndex,DWORD dwData,bool bAutoDelete)
  642. {
  643. if (nIndex != LB_ERR) 
  644. {
  645. CUIListCtrlData* pListObj = GetListCtrlData(nIndex);
  646. if (pListObj) 
  647. {
  648. pListObj->SetExtData(dwData);
  649. pListObj->SetAutoDelete(bAutoDelete);
  650. return TRUE;
  651. }
  652. }
  653. return FALSE;
  654. }
  656. int CUIODListCtrl::SetIcon(int nRow,int nImage)
  657. {
  658. LV_ITEM lvItem;
  659. ZeroMemory(&lvItem,sizeof(LV_ITEM));
  660. lvItem.mask = LVIF_IMAGE;
  661. lvItem.iItem = nRow;
  662. lvItem.iImage = nImage;
  663. SetItem(&lvItem);
  664. return lvItem.iImage;
  665. }
  667. int CUIODListCtrl::SetIcon(int nRow,UINT nIconID)
  668. {
  669. int nImage = GetImageIndex(nIconID);
  670. return SetIcon(nRow,nImage);
  671. }
  673. BOOL CUIODListCtrl::SetColumnFormat(int nCol,int fmt)
  674. {
  675. LVCOLUMN lvCol;
  676. ZeroMemory(&lvCol,sizeof(lvCol));
  677. lvCol.mask = LVCF_FMT;
  678. lvCol.fmt = fmt;
  679. return SetColumn(nCol,&lvCol);
  680. }
  682. void CUIODListCtrl::SetTextColor(int nRow, int nCol, COLORREF TextColor)
  683. {
  684. CUIListCtrlData *pData = GetListCtrlData(nRow);
  685. if (pData)
  686. pData->SetTextColor(TextColor,nCol);
  687. }
  689. void CUIODListCtrl::SetDefaultTextColor(int nRow,int nCol)
  690. {
  691. CUIListCtrlData *pData = GetListCtrlData(nRow);
  692. if (pData)
  693. pData->SetDefaultTextColor(nCol);
  694. }
  696. void CUIODListCtrl::SetBkColor(int nRow,int nCol,COLORREF BkColor)
  697. {
  698. CUIListCtrlData *pData = GetListCtrlData(nRow);
  699. if (pData)
  700. pData->SetBkColor(BkColor,nCol);
  701. }
  703. void CUIODListCtrl::SetDefaultBkColor(int nRow,int nCol)
  704. {
  705. CUIListCtrlData *pData = GetListCtrlData(nRow);
  706. if (pData)
  707. pData->SetDefaultBkColor(nCol);
  708. }
  710. CUIListCtrlData *CUIODListCtrl::GetListCtrlData(int nItem) const
  711. {
  712. CUIListCtrlData *pData = (CUIListCtrlData *)CListCtrl::GetItemData(nItem);
  713. if (pData == NULL)
  714. return NULL;
  715. ASSERT(pData->IsKindOf(RUNTIME_CLASS(CUIListCtrlData)));
  716. return pData;
  717. }
  719. int CUIODListCtrl::AddColumn(LPCTSTR szText)
  720. {
  721. // don't add again
  722. int nCol = FindColumn(szText);
  723. if (nCol >= 0)
  724. return nCol;
  725. nCol = InsertColumn(m_nSubItems,szText);
  726. if (nCol != -1)
  727. {
  728. m_strHeadings += COLUMN_DELIMITER_STR;
  729. m_strHeadings += szText;
  730. m_nSubItems++;
  731. SaveProfile();
  732. LoadProfile();
  733. }
  734. return nCol;
  735. }
  737. int CUIODListCtrl::FindColumn(LPCTSTR pszText)
  738. {
  739. LPCTSTR pszHeadings = m_strHeadings;
  740. int nCol=0;
  741. while (*pszHeadings != '')
  742. {
  743. if (*pszHeadings == COLUMN_DELIMITER)
  744. nCol++;
  745. if (_tcsnicmp(pszHeadings,pszText,_tcslen(pszText)) == 0)
  746. {
  747. break;
  748. }
  749. pszHeadings = _tcsinc(pszHeadings);
  750. }
  751. return *pszHeadings == '' ? -1 : nCol;
  752. }
  754. BOOL CUIODListCtrl::InitListCtrl(UINT IconID,LPCTSTR szHeadings,LPCTSTR pszProfile)
  755. {
  756. static UINT Icons[2];
  758. Icons[0] = IconID;
  759. Icons[1] = 0;
  760. return InitListCtrl(&Icons[0],szHeadings,pszProfile);
  761. }
  763. BOOL CUIODListCtrl::InitListCtrl(LPCTSTR szHeadings,LPCTSTR pszProfile)
  764. {
  765. static UINT Icons[1];
  767. Icons[0] = 0;
  768. return InitListCtrl(&Icons[0],szHeadings,pszProfile);
  769. }
  771. int CUIODListCtrl::InitListCtrl(const UINT *pIconIDs,LPCTSTR szHeadings,LPCTSTR pszProfile)
  772. {
  773. BOOL bFailed = FALSE;
  774. // TODO: Add extra initialization here
  775. if (pszProfile)
  776. {
  777. SetSection(pszProfile);
  778. }
  779. //clean up
  780. if (m_nSubItems) 
  781. {
  782. if (m_strHeadings == szHeadings)
  783. return m_nSubItems;
  784. DeleteAllItems();
  785. int nSubItems=m_nSubItems;
  786. for(int i=0;i < nSubItems;i++)
  787. DeleteColumn(0);
  788. m_nSubItems = 0;
  789. Empty();
  790. }
  791. if (pszProfile == NULL)
  792. {
  793. if (!m_strSection.IsEmpty())
  794. pszProfile = m_strSection;
  795. }
  796. if (pszProfile)
  797. {
  798. LoadProfile();
  799. // Use profile headings if found
  800. if (!m_strHeadings.IsEmpty())
  801. {
  802. if (m_strHeadings != szHeadings)
  803. {
  804. m_strHeadings = szHeadings;
  805. SaveProfile();
  806. }
  807. }
  808. }
  809. if (m_dwExStyle)
  810. SendMessage(LVM_SETEXTENDEDLISTVIEWSTYLE, 0, m_dwExStyle);
  812. // at least one image
  813. if (pIconIDs && *pIconIDs) 
  814. {
  815. // load the icons and add them to the image lists
  816. int i;
  817. for(i=0;*pIconIDs;i++,pIconIDs++) 
  818. {
  819. if (AddIcon(*pIconIDs) == -1)
  820. bFailed = TRUE;
  821. } 
  822. }
  824. // Now initialize the columns we will need
  825. // Initialize the LV_COLUMN structure
  826. // the mask specifies that the .fmt, .ex, width, and .subitem members 
  827. // of the structure are valid,
  828. LV_COLUMN lvC;
  829. lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  830. lvC.fmt = LVCFMT_LEFT;  // left align the column
  832. if (szHeadings)
  833. {
  834. // parse the string, format it and get column count
  835. const int MAX_HEADING_LEN = 512;
  836. TCHAR szHeadingsCopy[MAX_HEADING_LEN]; 
  837. if (_tcslen(szHeadings) >= MAX_HEADING_LEN-1)
  838. {
  839. _tcsncpy(szHeadingsCopy,szHeadings,MAX_HEADING_LEN-1);
  840. szHeadingsCopy[MAX_HEADING_LEN-1] = '';
  841. }
  842. else
  843. _tcscpy(szHeadingsCopy,szHeadings);
  844. LPTSTR p = szHeadingsCopy;
  845. int nCols = 0;
  846. while (*p != '')
  847. {
  848. if (*p == COLUMN_DELIMITER) 
  849. {
  850.  nCols++;
  851.  *p = '';
  852. }
  853. p = _tcsinc(p);
  854. }
  855. if (*szHeadingsCopy)
  856. nCols++;
  857. LPTSTR pszText = szHeadingsCopy;
  858. m_nSubItems = nCols; 
  859. for (int index = 0;index < nCols; index++)
  860. {
  861. lvC.iSubItem = index;
  862. lvC.pszText = pszText;
  863. // lvC.cx = LVSCW_AUTOSIZE_USEHEADER;  
  864. lvC.cx = 100;  
  865. if (InsertColumn(index, &lvC) == -1) 
  866. {
  867. TRACE(_T("InsertColumn failedn"));
  868. m_nSubItems--;
  869. bFailed = TRUE;
  870. }
  871. while (*pszText)
  872.    pszText = _tcsinc(pszText);
  873. pszText = _tcsinc(pszText); // Runs past the end of the buffer
  874. }
  875. // Add the columns.
  876. m_strHeadings = szHeadings;
  877. if (pszProfile)
  878. {
  879. SaveProfile();
  880. LoadProfile();
  881. }
  882. if (m_pColOrder)
  883. {
  884. SendMessage(LVM_SETCOLUMNORDERARRAY,(WPARAM)nCols,(LPARAM)m_pColOrder);
  885. }
  886. if (m_pColWidths)
  887. {
  888. for(int i=0;i < nCols;i++)
  889. {
  890. if (m_pColWidths[i] != 0)
  891. SetColumnWidth(i,m_pColWidths[i]);
  892. }
  893. }
  894. else
  895. {
  896. m_pColWidths = new int[nCols];
  897. for(int i=0;i < nCols;i++)
  898. {
  899. m_pColWidths[i] = GetColumnWidth(i);
  900. }
  901. }
  902. if (m_pColTypes == NULL)
  903. {
  904. // set default column types
  905. m_pColTypes = new int[nCols];
  906. for(int i=0;i < nCols;i++)
  907. {
  908. m_pColTypes[i] = e_Text;
  909. }
  910. }
  911. }
  912. SetSortHeader();
  913. return m_nSubItems;
  914. }
  916. void CUIODListCtrl::GetImageLists(CImageList **pILSmall,CImageList **pILLarge)
  917. {
  918. *pILSmall = GetImageList(LVSIL_SMALL);
  919. if (*pILSmall == NULL)
  920. {
  921. CreateImageLists();
  922. *pILSmall = GetImageList(LVSIL_SMALL);
  923. }
  924. *pILLarge = GetImageList(LVSIL_NORMAL);
  925. ASSERT(*pILSmall);
  926. ASSERT(*pILLarge);
  927. }
  929. void CUIODListCtrl::CreateImageLists()
  930. {
  931. m_cxSmallIcon = ::GetSystemMetrics(SM_CXSMICON);
  932. m_cySmallIcon = ::GetSystemMetrics(SM_CYSMICON);
  933. m_cxLargeIcon = ::GetSystemMetrics(SM_CXICON);
  934. m_cyLargeIcon = ::GetSystemMetrics(SM_CYICON);
  935. if (m_ImageSmall.GetSafeHandle() != NULL)
  936. m_ImageSmall.DeleteImageList();
  937. if (m_ImageLarge.GetSafeHandle() != NULL)
  938. m_ImageLarge.DeleteImageList();
  939. // create the small icon image list
  940. m_ImageSmall.Create(m_cxSmallIcon,
  941. m_cySmallIcon,
  942. ILC_MASK | ILC_COLOR16,
  943. 1,
  944. 1);
  945. // create the large icon image list
  946. m_ImageLarge.Create(m_cxLargeIcon,
  947. m_cyLargeIcon,
  948. ILC_MASK | ILC_COLOR16,
  949. 1,
  950. 1);
  951. // Associate the image lists with the list view
  952. SetImageList(&m_ImageSmall, LVSIL_SMALL);
  953. SetImageList(&m_ImageLarge, LVSIL_NORMAL);
  954. }
  956. void CUIODListCtrl::AddExtraString(int nRow,LPCTSTR pszExtraText)
  957. {
  958. CUIStrListCtrlData *pData = (CUIStrListCtrlData *)GetListCtrlData(nRow);
  959. ASSERT_KINDOF(CUIStrListCtrlData,pData);
  960. pData->AddExtraString(pszExtraText);
  961. }
  963. void CUIODListCtrl::ConvertToTime(CString &str)
  964. {
  965. int nPoint = str.Find(GetDecimalSep());
  966. int nSecs=0;
  967. if (nPoint == -1)
  968. nSecs = _ttoi(str);
  969. else
  970. {
  971. LPTSTR pszStop;
  972. double dSecs = _tcstod(str,&pszStop);
  973. nSecs = dSecs;
  974. }
  975. if (nSecs == 0)
  976. return;
  977. int nMins = nSecs / 60;
  978. nSecs = nSecs % 60;
  979. str.Format(_T("%u:%u"),nMins,nSecs);
  980. }
  982. void CUIODListCtrl::AddThousandSeps(CString &str)
  983. {
  984. CString strTemp;
  985. CString strExp;
  986. CString strNeg;
  987. int nDouble = str.Find(GetDecimalSep());
  988. if (nDouble >= 0)
  989. {
  990. strTemp = str.Left(nDouble);
  991. strExp = str.Right(str.GetLength()-nDouble);
  992. }
  993. else
  994. {
  995. if (str.Find(GetNegativeSign()) == 0)
  996. {
  997. strNeg = str.Left(1);
  998. strTemp = str.Right(str.GetLength()-1);
  999. }
  1000. else
  1001. strTemp = str;
  1002. }
  1003. int len = strTemp.GetLength();
  1004. if (len <= 3 || len > nMaxDigLen)
  1005. return;
  1006. LPCTSTR pBuf = strTemp;
  1007. pBuf += (len-1);
  1008. TCHAR tempbuf[nMaxDigLen+1];
  1009. LPTSTR pTempBuf = tempbuf;
  1010. LPCTSTR pSep = GetThousandSep();
  1011. for(int i=0;i < len;i++)
  1012. {
  1013. if (i && ((i % 3) == 0)) 
  1014. {
  1015. if (*pTempBuf != *pSep)
  1016. {
  1017. *pTempBuf =  *pSep;
  1018. pTempBuf = _tcsinc(pTempBuf);
  1019. }
  1020. }
  1021. *pTempBuf = *pBuf;
  1022. pTempBuf = _tcsinc(pTempBuf);
  1023. pBuf = _tcsdec(strTemp,pBuf);
  1024. }
  1025. *pTempBuf = '';
  1026. _tcsrev(tempbuf);
  1027. str = strNeg;
  1028. str += tempbuf;
  1029. str += strExp;
  1030. }
  1032. BOOL CUIODListCtrl::AddString(int nRow,int nCol,int nValue,CUIODListCtrl::eColTypes type)
  1033. {
  1034. CString sValue;
  1035. sValue.Format(_T("%d"),nValue);
  1036. return AddString(nRow,nCol,sValue,type);
  1037. }
  1039. BOOL CUIODListCtrl::AddString(int nRow,int nCol,double dValue,CUIODListCtrl::eColTypes type)
  1040. {
  1041. char szBuf[nMaxDigLen];
  1042. _gcvt(dValue,_MAX_INT_DIG,szBuf);
  1043. #ifdef _UNICODE
  1044. USES_CONVERSION;
  1045. return AddString(nRow,nCol,A2W(szBuf),type);
  1046. #else
  1047. return AddString(nRow,nCol,szBuf,type);
  1048. #endif
  1049. }
  1051. BOOL CUIODListCtrl::AddString(int nRow,int nCol,COleDateTime &dtValue,CUIODListCtrl::eColTypes type)
  1052. {
  1053. return AddString(nRow,nCol,dtValue.Format(),type);
  1054. }
  1056. BOOL CUIODListCtrl::AddString(int nRow,int nCol,LPCTSTR szItem,CUIODListCtrl::eColTypes type)
  1057. {
  1058. if (m_nItems == 0) 
  1059. {
  1060. TRACE(_T("No rows defined in ODListCtrln")); 
  1061. return FALSE;
  1062. }
  1063. if (nCol >= m_nSubItems) 
  1064. {
  1065. TRACE(_T("Tried to add invalid column number(%d) in ODListCtrln"),nCol); 
  1066. return FALSE;
  1067. }
  1068. SetColType(nCol,type);
  1069. // return SetItemText(nRow,nCol/*+m_nImage*/,szItem);
  1070. CUIStrListCtrlData *pData = (CUIStrListCtrlData *)GetListCtrlData(nRow);
  1071. ASSERT_KINDOF(CUIStrListCtrlData,pData);
  1072. BOOL ret=FALSE;
  1073. if (type == e_NumericFormatComma || type == e_DoubleFormatComma)
  1074. {
  1075. CString sBuf(szItem);
  1076. AddThousandSeps(sBuf);
  1077. ret = pData->AddString(nCol,sBuf);
  1078. }
  1079. else if (type == e_NumericFormatTime || type == e_DoubleFormatTime)
  1080. {
  1081. CString sBuf(szItem);
  1082. ConvertToTime(sBuf);
  1083. ret = pData->AddString(nCol,sBuf);
  1084. }
  1085. else
  1086. ret = pData->AddString(nCol,szItem);
  1087. return ret;
  1088. }   
  1090. void CUIODListCtrl::UpdateString(int nRow)
  1091. { 
  1092. CRect rect;
  1093. if (GetItemRect(nRow,&rect,LVIR_BOUNDS))
  1094. {
  1095. RedrawItems(nRow,nRow);
  1096. UpdateWindow();
  1097. }
  1098. }
  1100. int CUIODListCtrl::AddCallBackItem(DWORD dwData,int nImage)
  1101. {
  1102. if (m_nSubItems == 0) 
  1103. {
  1104. TRACE(_T("No columns defined in ODListCtrln")); 
  1105. return FALSE;
  1106. }
  1107. CUIListCtrlData *pListCtrlData = GetNewListCtrlData(dwData,m_nItems);
  1108. BOOL ret = InsertItem(LPSTR_TEXTCALLBACK,(LPARAM)pListCtrlData,nImage);
  1109. if (ret)
  1110. m_objList.Append(pListCtrlData);
  1111. else
  1112. delete pListCtrlData;
  1113. return ret ? m_nItems-1 : -1;
  1114. }
  1116. int CUIODListCtrl::AddTextItem(int nImage)
  1117. {
  1118. CUIStrListCtrlData *pListCtrlData = new CUIStrListCtrlData(m_nSubItems);
  1119. if (InsertItem(LPSTR_TEXTCALLBACK,(LPARAM)pListCtrlData,nImage))
  1120. {
  1121. m_objList.Append(pListCtrlData);
  1122. return m_nItems-1;
  1123. }
  1124. delete pListCtrlData;
  1125. return -1;
  1126. }
  1128. int CUIODListCtrl::GetImageIndex(UINT nIconID)
  1129. {
  1130. int nImage = 0;
  1131. if (nIconID)
  1132. {
  1133. if (!m_mapImageIndex.Lookup(nIconID,nImage))
  1134. {
  1135. nImage = AddIcon(nIconID);
  1136. }
  1137. }
  1138. return nImage;
  1139. }
  1141. // from handle
  1142. int CUIODListCtrl::AddIcon(HICON hIcon,UINT nIconID)
  1143. {
  1144. CImageList *pILSmall = NULL;
  1145. CImageList *pILLarge = NULL;
  1146. GetImageLists(&pILSmall,&pILLarge);
  1147. int nSmallIndex = pILSmall->Add(hIcon);
  1148. // save the image ID
  1149. if (nIconID)
  1150. m_mapImageIndex[nIconID] = nSmallIndex;
  1151. int nLargeIndex = pILLarge->Add(hIcon); 
  1152. if (nSmallIndex == -1 || nLargeIndex == -1)
  1153. {
  1154. TRACE(_T("Failed to add icon to image list in CUIODListCtrln"));
  1155. return -1;
  1156. }
  1157. return nSmallIndex;
  1158. }
  1160. // from resource id
  1161. int CUIODListCtrl::AddIcon(UINT nIconID)
  1162. {
  1163. HICON hIcon = AfxGetApp()->LoadIcon(nIconID);
  1164. if (hIcon == NULL)
  1165. {
  1166. TRACE(_T("LoadIcon failed in CUIODListCtrln"));
  1167. return -1;
  1168. }
  1169. return AddIcon(hIcon,nIconID);
  1170. }
  1172. // from file
  1173. int CUIODListCtrl::AddIcon(LPCTSTR pszIcon)
  1174. {
  1175. CString sImageFile;
  1176. int nIndex;
  1177. if (m_mapImageFile.Lookup(sImageFile,nIndex))
  1178. {
  1179. return nIndex;
  1180. }
  1181.     HICON hIcon = (HICON)LoadImage(AfxGetInstanceHandle(), 
  1182.             pszIcon,
  1183.             IMAGE_ICON,
  1184.             ::GetSystemMetrics(SM_CXICON),
  1185.             ::GetSystemMetrics(SM_CYICON),
  1186.             LR_LOADFROMFILE);
  1187. if (hIcon == NULL)
  1188. {
  1189. TRACE(_T("LoadImage(Large) failed in CUIODListCtrln"));
  1190. }
  1191.     HICON hIconSm = (HICON)LoadImage(AfxGetInstanceHandle(), 
  1192.             pszIcon,
  1193.             IMAGE_ICON,
  1194.             ::GetSystemMetrics(SM_CXSMICON),
  1195.             ::GetSystemMetrics(SM_CYSMICON),
  1196.             LR_LOADFROMFILE);
  1197. if (hIconSm == NULL)
  1198. {
  1199. TRACE(_T("LoadImage(Small) failed in CUIODListCtrln"));
  1200. }
  1201. if (hIcon == NULL && hIconSm == NULL)
  1202. return -1;
  1203. CImageList *pILSmall = NULL;
  1204. CImageList *pILLarge = NULL;
  1205. GetImageLists(&pILSmall,&pILLarge);
  1206. int nSmallIndex = pILSmall->Add(hIconSm);
  1207. int nLargeIndex = pILLarge->Add(hIcon); 
  1208. if (nSmallIndex == -1 || nLargeIndex == -1)
  1209. {
  1210. TRACE(_T("Failed to add icon to image list in CUIODListCtrln"));
  1211. return -1;
  1212. }
  1213. sImageFile = pszIcon;
  1214. m_mapImageFile[sImageFile] = nSmallIndex;
  1215. return nSmallIndex;
  1216. }
  1218. BOOL CUIODListCtrl::InsertItem(LPTSTR szItem,LPARAM lParam,int nImage)
  1219. {
  1220. LV_ITEM lvi;
  1221. lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE;
  1222. lvi.state = 0;      
  1223. lvi.stateMask = 0;  
  1225. lvi.iItem = m_nItems;
  1226. lvi.iSubItem = 0;
  1227. lvi.pszText = szItem; 
  1228. lvi.cchTextMax = MAX_TEXT;
  1229. lvi.iImage = nImage;
  1230. lvi.lParam = lParam;
  1231. if (CListCtrl::InsertItem(&lvi) == -1) 
  1232. {
  1233. TRACE1("Unable to insert item %u into list controln",m_nItems);
  1234. return FALSE;
  1235. }
  1236. if (nImage) 
  1237. m_nImage = 1;
  1238. m_nItems++;
  1239. return TRUE;
  1240. }
  1242. int CUIODListCtrl::SetCurSel(int nSelect)
  1243. {
  1244. if (GetItemCount() && SetItemState(nSelect,LVIS_SELECTED | LVIS_FOCUSED,LVIS_SELECTED | LVIS_FOCUSED))
  1245. return TRUE;
  1246. return -1;
  1247. }
  1249. // messages
  1250. LRESULT CUIODListCtrl::OnSetColumnWidth(WPARAM wParam,LPARAM lParam)
  1251. {
  1252. Default();
  1253. return TRUE;
  1254. }
  1256. LRESULT CUIODListCtrl::OnDeleteAllItems(WPARAM wParam,LPARAM lParam)
  1257. {
  1258. m_nItems=0;
  1259. m_nImage=0;
  1260. m_hOrigFont=NULL;
  1261. AllItemsDeleted();
  1262. m_objList.DeleteAll();
  1263. TRACE0("All items deleted in CUIODListCtrln");
  1264. Default();
  1265. return TRUE;
  1266. }
  1268. CUIListCtrlData *CUIODListCtrl::GetNewListCtrlData(DWORD dwData,int nItem)
  1269. {
  1270. CUIListCtrlData *pListCtrlData = new CUIListCtrlData(m_nSubItems);
  1271. pListCtrlData->SetExtData(dwData); 
  1272. return pListCtrlData;
  1273. }
  1275. int CUIODListCtrl::FindItem(DWORD dwExtData)
  1276. {
  1277. int count = GetItemCount();
  1278. CUIListCtrlData *pData;
  1279. for(int i=0;i < count;i++) 
  1280. {
  1281. pData = GetListCtrlData(i);
  1282. if (pData->GetExtData() == dwExtData)
  1283. break;
  1284. }
  1285. return i == count ? -1 : i;
  1286. }
  1288. BOOL CUIODListCtrl::GetFullRowSel() const
  1289. {
  1290. return(m_bFullRowSel);
  1291. }
  1293. DWORD CUIODListCtrl::GetExStyle() 
  1294. {
  1295. return SendMessage(LVM_GETEXTENDEDLISTVIEWSTYLE);
  1296. }
  1298. BOOL CUIODListCtrl::SetExStyle(UINT nStyle,BOOL bModify)
  1299. {
  1300. DWORD dwStyle = GetExStyle();
  1301. if (bModify)
  1302. dwStyle |= nStyle;
  1303. else
  1304. dwStyle &= ~nStyle;
  1305. BOOL bRet = SendMessage(LVM_SETEXTENDEDLISTVIEWSTYLE, 0, dwStyle);
  1306. if (bRet)
  1307. SaveProfile();
  1308. return bRet;
  1309. }
  1311. void CUIODListCtrl::SetFullRowSel(bool bSet)
  1312. {
  1313. // no painting during change
  1314. if ((bSet && m_bFullRowSel==TRUE) || (!bSet && m_bFullRowSel==FALSE))
  1315. return;
  1316. m_bFullRowSel=bSet;
  1317. if(!(GetStyle() & LVS_OWNERDRAWFIXED)) 
  1318. {
  1319. SetExStyle(LVS_EX_FULLROWSELECT,m_bFullRowSel);
  1320. }
  1321. RedrawItems(GetCurSel(),GetCurSel());
  1322. SaveProfile();
  1323. }
  1325. void CUIODListCtrl::SetIconSize(int nImageList)
  1326. {
  1327. m_nImageList = nImageList;
  1329. CRect rc;
  1330. GetWindowRect(rc);
  1331. GetParent()->ScreenToClient(rc);
  1332. rc.bottom++; // Force a WM_MEASUREITEM message
  1333. MoveWindow(rc,FALSE);
  1334. rc.bottom--; // We really don't want to resize it
  1335. MoveWindow(rc,TRUE);
  1336. }
  1338. void CUIODListCtrl::ChangeIconSize()
  1339. {
  1340. SetCurSel(0);
  1341. EnsureVisible(0,0);
  1342. if (m_nImageList == LVSIL_NORMAL)
  1343. SetIconSize(LVSIL_SMALL);
  1344. else
  1345. SetIconSize(LVSIL_NORMAL);
  1346. }
  1348. BOOL CUIODListCtrl::GetDispInfo(LV_DISPINFO *pDispInfo)
  1349. {
  1350. CUIStrListCtrlData *pData = (CUIStrListCtrlData*)pDispInfo->item.lParam;
  1351. ASSERT_KINDOF(CUIStrListCtrlData,pData);
  1352. if (!pData->IsKindOf(RUNTIME_CLASS(CUIStrListCtrlData)))
  1353. return FALSE;
  1354. pDispInfo->item.pszText = pData->GetString(pDispInfo->item.iSubItem);
  1355. return TRUE;
  1356. }
  1358. BOOL CUIODListCtrl::PopupMenuItem(int nItem,int nCol,CMenu *pPopup,CPoint point)
  1359. {
  1360. int nCurSel = GetCurSel();
  1361. int nSel = GetNextSel(nCurSel);
  1362. UINT nPopupID = (nSel == -1 ? m_PopupID : m_MultiPopupID);
  1363. if (nPopupID && (nCol == 0 && nItem != -1))
  1364. {
  1365. CMenu menu;
  1366. VERIFY(menu.LoadMenu(nPopupID));
  1367. CMenu* pMyPopup = menu.GetSubMenu(0);
  1368. ASSERT(pMyPopup != NULL);
  1369. if (m_pPopupWnd == NULL)
  1370. m_pPopupWnd = this;
  1371. pMyPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, m_pPopupWnd);
  1372. return TRUE;
  1373. }
  1374. return nSel == -1 ? FALSE : TRUE;
  1375. }
  1377. int CUIODListCtrl::HitTestEx(CPoint &point, int *col) const
  1378. {
  1379. int colnum = 0;
  1380. int row = HitTest( point, NULL );
  1382. if( col ) *col = 0;
  1384. // Make sure that the ListView is in LVS_REPORT
  1385. if( (GetWindowLong(m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
  1386. return row;
  1388. // Get the top and bottom row visible
  1389. row = GetTopIndex();
  1390. int bottom = row + GetCountPerPage();
  1391. if( bottom > GetItemCount() )
  1392. bottom = GetItemCount();
  1394. // Get the number of columns
  1395. CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);
  1396. int nColumnCount = pHeader->GetItemCount();
  1397. CRect rcHeader;
  1398. pHeader->GetClientRect(&rcHeader);
  1399. if (point.y >= 0 && point.y <= rcHeader.Height())
  1400. return -2;
  1402. // Loop through the visible rows
  1403. for( ;row <=bottom;row++)
  1404. {
  1405. // Get bounding rect of item and check whether point falls in it.
  1406. CRect rect;
  1407. GetItemRect( row, &rect, LVIR_BOUNDS );
  1408. if( rect.PtInRect(point) )
  1409. {
  1410. // Now find the column
  1411. for( colnum = 0; colnum < nColumnCount; colnum++ )
  1412. {
  1413. int colwidth = GetColumnWidth(colnum);
  1414. if( point.x >= rect.left 
  1415. && point.x <= (rect.left + colwidth ) )
  1416. {
  1417. if( col ) *col = colnum;
  1418. return row;
  1419. }
  1420. rect.left += colwidth;
  1421. }
  1422. }
  1423. }
  1424. return -1;
  1425. }
  1427. CEdit* CUIODListCtrl::EditSubLabel( int nItem, int nCol )
  1428. {
  1429. // The returned pointer should not be saved
  1430. if (m_bEditSubItems == false || (GetWindowLong(m_hWnd, GWL_STYLE) & LVS_EDITLABELS) != LVS_EDITLABELS)
  1431. {
  1432. return NULL;
  1433. }
  1435. // Make sure that the item is visible
  1436. if( !EnsureVisible( nItem, TRUE ) ) 
  1437. return NULL;
  1439. // Make sure that nCol is valid
  1440. CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);
  1441. if (pHeader == NULL)
  1442. return NULL;
  1443. int nColumnCount = pHeader->GetItemCount();
  1444. if( nCol >= nColumnCount || GetColumnWidth(nCol) < 5 )
  1445. return NULL;
  1447. // Get the column offset
  1448. int offset = 0;
  1449. for( int i = 0; i < nCol; i++ )
  1450. offset += GetColumnWidth( i );
  1452. CRect rect;
  1453. GetItemRect( nItem, &rect, LVIR_BOUNDS );
  1455. // Now scroll if we need to expose the column
  1456. CRect rcClient;
  1457. GetClientRect( &rcClient );
  1458. if( offset + rect.left < 0 || offset + rect.left > rcClient.right )
  1459. {
  1460. CSize size;
  1461. size.cx = offset + rect.left;
  1462. size.cy = 0;
  1463. Scroll( size );
  1464. rect.left -= size.cx;
  1465. }
  1467. // Get Column alignment
  1468. LV_COLUMN lvcol;
  1469. lvcol.mask = LVCF_FMT;
  1470. GetColumn( nCol, &lvcol );
  1471. DWORD dwStyle ;
  1472. if((lvcol.fmt&LVCFMT_JUSTIFYMASK) == LVCFMT_LEFT)
  1473. dwStyle = ES_LEFT;
  1474. else if((lvcol.fmt&LVCFMT_JUSTIFYMASK) == LVCFMT_RIGHT)
  1475. dwStyle = ES_RIGHT;
  1476. else dwStyle = ES_CENTER;
  1478. rect.left += offset+4;
  1479. rect.right = rect.left + GetColumnWidth( nCol ) - 3 ;
  1480. if( rect.right > rcClient.right) rect.right = rcClient.right;
  1482. dwStyle |= WS_BORDER|WS_CHILD|WS_VISIBLE|ES_AUTOHSCROLL;
  1483. CEdit *pEdit = new CInPlaceEdit(nItem, nCol, GetItemText( nItem, nCol ));
  1484. pEdit->Create( dwStyle, rect, this, -1/*IDC_IPEDIT*/ );
  1486. return pEdit;
  1487. }
  1489. void CUIODListCtrl::DeleteProgressBar(int nRow,int nCol)
  1490. {
  1491. CUIListCtrlData *pData = GetListCtrlData(nRow);
  1492. if (pData)
  1493. {
  1494. pData->DestroyCtrl(nCol);
  1495. RedrawItems(nRow,nRow);
  1496. }
  1497. }
  1499. void CUIODListCtrl::UpdateProgressBar(int nRow,int nCol,int nPos)
  1500. {
  1501. CUIListCtrlData *pData = GetListCtrlData(nRow);
  1502. ASSERT(pData);
  1503. if (pData == NULL)
  1504. return;
  1505. CTextProgressCtrl *pCtrl = (CTextProgressCtrl*)pData->GetCtrl(nCol);
  1506. if (pCtrl)
  1507. {
  1508. pCtrl->SetPos(nPos);
  1509. RedrawItems(nRow,nRow);
  1510. }
  1511. }
  1513. CTextProgressCtrl *CUIODListCtrl::AddProgressBar(int nItem,int nCol,int nMin,int nMax)
  1514. {
  1515. // The returned pointer should not be saved
  1516. if (GetViewType() != LVS_REPORT)
  1517. return NULL;
  1518. CUIListCtrlData *pData = GetListCtrlData(nItem);
  1519. if (pData == NULL)
  1520. return NULL;
  1521. CTextProgressCtrl *pCtrl = new CTextProgressCtrl;
  1522. pData->SetCtrl(pCtrl,nCol);
  1523. pCtrl->SetRange(nMin,nMax);
  1524. return pCtrl;
  1525. }
  1527. //
  1528. // Message handlers
  1529. //
  1530. void CUIODListCtrl::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  1531. {
  1532. if (GetFocus() != this) 
  1533. SetFocus();
  1534. CListCtrl::OnHScroll(nSBCode, nPos, pScrollBar);
  1535. }
  1537. void CUIODListCtrl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  1538. {
  1539. if (GetFocus() != this) 
  1540. SetFocus();
  1541. CListCtrl::OnVScroll(nSBCode, nPos, pScrollBar);
  1542. }
  1544. void CUIODListCtrl::OnLButtonDown(UINT nFlags, CPoint point)
  1545. {
  1546. CListCtrl::OnLButtonDown(nFlags, point);
  1547. }
  1549. BOOL CUIODListCtrl::OnSelChanged(int nItem, LRESULT* pResult)
  1550. {
  1551. SelChanged( nItem , pResult );
  1552. return TRUE;
  1553. }
  1555. BOOL CUIODListCtrl::OnEndLabelEdit(NMHDR* pNMHDR, LRESULT* pResult)
  1556. {
  1557. LV_DISPINFO *plvDispInfo = (LV_DISPINFO *)pNMHDR;
  1558. LV_ITEM *plvItem = &plvDispInfo->item;
  1560. if (plvItem->pszText != NULL)
  1561. {
  1562. if (plvItem->iItem == -1)
  1563. {
  1564. CHeaderCtrl *pHeader = (CHeaderCtrl*)GetDlgItem(0);
  1565. if (pHeader)
  1566. {
  1567. CString strText;
  1568. GetHeaderText(pHeader,plvItem->iSubItem,strText);
  1569. HD_ITEM hdItem;
  1570. ZeroMemory(&hdItem,sizeof(hdItem));
  1571. hdItem.mask = HDI_TEXT;
  1572. hdItem.pszText = plvItem->pszText;
  1573. hdItem.cchTextMax = lstrlen(plvItem->pszText);
  1574. ReplaceString(m_strHeadings,strText,plvItem->pszText);
  1575. if (EndLabelEdit(plvItem->iItem,plvItem->iSubItem,plvItem->pszText))
  1576. pHeader->SetItem(plvItem->iSubItem,&hdItem);
  1577. }
  1578. }
  1579. else
  1580. {
  1581. if (EndLabelEdit(plvItem->iItem,plvItem->iSubItem,plvItem->pszText))
  1582. AddString(plvItem->iItem, plvItem->iSubItem, plvItem->pszText);
  1583. }
  1584. }
  1585. *pResult = FALSE;
  1586. return TRUE;
  1587. }
  1589. LRESULT CUIODListCtrl::OnDeleteItem(WPARAM wParam,LPARAM lParam)
  1590. {
  1591. if (m_nItems)
  1592. m_nItems--;
  1593. TRACE(_T("Item deleted %dn"),wParam);
  1594. return Default();
  1595. }
  1597. LRESULT CUIODListCtrl::OnDeleteColumn(WPARAM wParam,LPARAM lParam)
  1598. {
  1599. if (m_nSubItems)
  1600. m_nSubItems--;
  1601. TRACE(_T("Column deleted %dn"),wParam);
  1602. return Default();
  1603. }
  1605. LRESULT CUIODListCtrl::OnSetImageList(WPARAM wParam, LPARAM lParam)
  1606. {
  1607. if((int)wParam==LVSIL_STATE)
  1608. {
  1609. int cx, cy;
  1611. if(::ImageList_GetIconSize((HIMAGELIST)lParam,&cx,&cy))
  1612. m_cxStateImageOffset=cx;
  1613. else
  1614. m_cxStateImageOffset=0;
  1615. }
  1617. return Default();
  1618. }
  1620. LRESULT CUIODListCtrl::OnSetTextColor(WPARAM wParam, LPARAM lParam)
  1621. {
  1622. m_clrText=(COLORREF)lParam;
  1623. return(Default());
  1624. }
  1626. LRESULT CUIODListCtrl::OnSetTextBkColor(WPARAM wParam, LPARAM lParam)
  1627. {
  1628. m_clrTextBk=(COLORREF)lParam;
  1629. return(Default());
  1630. }
  1632. LRESULT CUIODListCtrl::OnSetBkColor(WPARAM wParam, LPARAM lParam)
  1633. {
  1634. m_clrBkgnd=(COLORREF)lParam;
  1635. return(Default());
  1636. }
  1638. void CUIODListCtrl::OnSize(UINT nType, int cx, int cy) 
  1639. {
  1640. m_cxClient=cx;
  1641. CListCtrl::OnSize(nType, cx, cy);
  1642. }
  1644. void CUIODListCtrl::OnPaint() 
  1645. {
  1646. if (m_bDelayPaint)
  1647. return;
  1648. Default();
  1649.     if (GetItemCount() <= 0)
  1650.     {
  1651.         COLORREF clrText = ::GetSysColor(COLOR_WINDOWTEXT);
  1652.         COLORREF clrTextBk = ::GetSysColor(COLOR_WINDOW);
  1654.         CDC* pDC = GetDC();
  1655.         // Save dc state
  1656.         int nSavedDC = pDC->SaveDC();
  1658.         CRect rc;
  1659.         GetWindowRect(&rc);
  1660.         ScreenToClient(&rc);
  1662.         CHeaderCtrl* pHC;
  1663.         pHC = GetHeaderCtrl();
  1664.         if (pHC != NULL)
  1665.         {
  1666.             CRect rcH;
  1667.             pHC->GetItemRect(0, &rcH);
  1668.             rc.top += rcH.bottom;
  1669.         }
  1670.         rc.top += 10;
  1672.         pDC->SetTextColor(clrText);
  1673.         pDC->SetBkColor(clrTextBk);
  1674.         pDC->FillRect(rc, &CBrush(clrTextBk));
  1675.         pDC->SelectStockObject(ANSI_VAR_FONT);
  1676.         pDC->DrawText(m_strNoItemsMess, -1, rc, 
  1677.                       DT_CENTER | DT_WORDBREAK | DT_NOPREFIX | DT_NOCLIP);
  1679.         // Restore dc
  1680.         pDC->RestoreDC(nSavedDC);
  1681.         ReleaseDC(pDC);
  1682.     }
  1683.     // Do not call CListCtrl::OnPaint() for painting messages
  1684. // in full row select mode, we need to extend the clipping region
  1685. // so we can paint a selection all the way to the right
  1686. if(m_bClientWidthSel && (GetStyle() & LVS_TYPEMASK)==LVS_REPORT && GetFullRowSel() && (GetStyle() & LVS_OWNERDRAWFIXED))
  1687. {
  1688. CRect rcAllLabels;
  1689. GetItemRect(0,rcAllLabels,LVIR_BOUNDS);
  1691. if(rcAllLabels.right<m_cxClient)
  1692. {
  1693. // need to call BeginPaint (in CPaintDC c-tor)
  1694. // to get correct clipping rect
  1695. CPaintDC dc(this);
  1697. CRect rcClip;
  1698. dc.GetClipBox(rcClip);
  1700. rcClip.left=min(rcAllLabels.right-1,rcClip.left);
  1701. // rcClip.right=m_cxClient;
  1703. InvalidateRect(rcClip,FALSE);
  1704. // EndPaint will be called in CPaintDC d-tor
  1705. }
  1706. }
  1708. // CListCtrl::OnPaint();
  1709. }
  1711. void CUIODListCtrl::OnSetFocus(CWnd* pOldWnd) 
  1712. {
  1713. CListCtrl::OnSetFocus(pOldWnd);
  1715. if(pOldWnd!=NULL && ::IsWindow(pOldWnd->m_hWnd))
  1716. {
  1717. // check if we are getting focus from label edit box
  1718. if(pOldWnd!=NULL && pOldWnd->GetParent()==this)
  1719. return;
  1720. }
  1721. }
  1723. void CUIODListCtrl::OnKillFocus(CWnd* pNewWnd) 
  1724. {
  1725. CListCtrl::OnKillFocus(pNewWnd);
  1727. // check if we are losing focus to label edit box
  1728. if (pNewWnd!=NULL && pNewWnd->GetParent()==this)
  1729. return;
  1730. }
  1732. void CUIODListCtrl::OnRClickHeader(CPoint point,int nColIndex)
  1733. {
  1734. m_nColClicked = nColIndex;
  1735. CMenu menu;
  1736. VERIFY(menu.LoadMenu(IDR_POPUPMENU_HEADERCTRL));
  1737. CMenu* pPopup = menu.GetSubMenu(0);
  1738. ASSERT(pPopup != NULL);
  1739. pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y,this);
  1740. }
  1742. void CUIODListCtrl::OnHeaderRemoveColumn()
  1743. {
  1744. if (m_nColClicked != -1)
  1745. {
  1746. int nWidth = GetColumnWidth(m_nColClicked);
  1747. if (nWidth)
  1748. {
  1749. m_pColWidths[m_nColClicked] = nWidth;
  1750. SetColumnWidth(m_nColClicked,0);
  1751. }
  1752. m_nColClicked = -1;
  1753. }
  1754. }
  1756. void CUIODListCtrl::OnHeaderEditText()
  1757. {
  1758. CHeaderCtrl *pHeader = (CHeaderCtrl*)GetDlgItem(0);
  1759. if (pHeader == NULL)
  1760. return;
  1762. CString strText;
  1763. int cxy = GetHeaderText(pHeader,m_nColClicked,strText);
  1764. int xPos = 0;
  1765. for(int i=0;i < m_nSubItems;i++)
  1766. {
  1767. if (i == m_nColClicked)
  1768. break;
  1769. xPos += m_pColWidths[i];
  1770. }
  1771. CRect rect;
  1772. rect.left = xPos;
  1773. rect.right = rect.left+cxy;
  1774. rect.top = 0;
  1775. rect.bottom = GetSystemMetrics(SM_CXHSCROLL);
  1776. TRACE2("Creating header edit control at left=%d,right=%dn",rect.left,rect.right);
  1777. DWORD dwStyle = WS_BORDER|WS_CHILD|WS_VISIBLE|ES_AUTOHSCROLL;
  1778. CEdit *pEdit = new CInPlaceEdit(-1, m_nColClicked, strText);
  1779. pEdit->Create( dwStyle, rect, this, -1/*IDC_IPEDIT*/ );
  1780. m_nColClicked = -1;
  1781. }
  1783. int CUIODListCtrl::GetHeaderText(CHeaderCtrl *pHeader,int nPos,CString &strText)
  1784. {
  1785. HD_ITEM hdItem;
  1786. ZeroMemory(&hdItem,sizeof(hdItem));
  1787. int nLen = 128;
  1788. int nRes;
  1789. do
  1790. {
  1791. nLen *= 2;
  1792. hdItem.mask = HDI_TEXT | HDI_WIDTH;
  1793. hdItem.cchTextMax = nLen;
  1794. hdItem.pszText = strText.GetBufferSetLength(nLen);
  1795. pHeader->GetItem(nPos,&hdItem);
  1796. nRes = lstrlen(hdItem.pszText);
  1797. } while (nRes == nLen-1);
  1798. strText.ReleaseBuffer(-1);
  1799. return hdItem.cxy;
  1800. }
  1802. void CUIODListCtrl::OnHeaderReset()
  1803. {
  1804. for(int i=0;i < m_nSubItems;i++)
  1805. {
  1806. SetColumnWidth(i,m_pColWidths[i]);
  1807. }
  1808. m_nColClicked = -1;
  1809. }
  1811. void CUIODListCtrl::OnContextMenu(CWnd *pWnd,CPoint point)
  1812. {
  1813. CPoint ptClient(point);
  1814. ScreenToClient(&ptClient);
  1815. // int nCol;
  1816. int nRow = HitTestEx(ptClient, NULL );
  1817. if (nRow == -2 || nRow == -1 )
  1818. return;
  1819. ShowPopupMenu( nRow , 0 , point );
  1820. }
  1822. void CUIODListCtrl::ShowPopupMenu(int nRow,int nCol,CPoint point)
  1823. {
  1824. CMenu menu;
  1825. VERIFY(menu.LoadMenu(IDR_POPUPMENU_LISTCTRL));
  1826. CMenu* pPopup = menu.GetSubMenu(0);
  1827. ASSERT(pPopup != NULL);
  1828. m_PopupPoint.x = 0;
  1829. m_PopupPoint.y = 0;
  1830. if (PopupMenuItem(nRow,nCol,pPopup,point))
  1831. return;
  1832. m_PopupPoint = point;
  1833. pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y,this);
  1834. }
  1836. void CUIODListCtrl::OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)
  1837. {
  1838. // is it for us?
  1839. if (m_PopupPoint.x == 0 && m_PopupPoint.y == 0)
  1840. return;
  1841. if (pPopupMenu->GetMenuItemID(0) == ID_HEADER_REMOVE_COL)
  1842. {
  1843. if (m_nColClicked == -1)
  1844. {
  1845. pPopupMenu->EnableMenuItem(ID_HEADER_EDIT_TEXT,MF_BYCOMMAND | MF_GRAYED);
  1846. pPopupMenu->EnableMenuItem(ID_HEADER_RESET,MF_BYCOMMAND | MF_GRAYED);
  1847. }
  1848. return;
  1849. }
  1850. // These commands are only available in report mode(detail mode)
  1851. UINT nEnabled = (GetViewType() == LVS_REPORT) ? MF_ENABLED : MF_GRAYED; 
  1852. pPopupMenu->EnableMenuItem(ID_UI_VIEW_FULL_ROW_SELECTION,MF_BYCOMMAND | nEnabled);
  1853. pPopupMenu->EnableMenuItem(ID_UI_VIEW_GRIDLINES,MF_BYCOMMAND | nEnabled);
  1854. pPopupMenu->EnableMenuItem(ID_UI_VIEW_COLUMN_SIZING,MF_BYCOMMAND | nEnabled);
  1855. pPopupMenu->EnableMenuItem(ID_UI_VIEW_COLUMN_ORDERING,MF_BYCOMMAND | nEnabled);
  1856. if (nEnabled == MF_ENABLED)
  1857. pPopupMenu->EnableMenuItem(ID_UI_VIEW_EDIT_COLUMN,MF_BYCOMMAND | (m_bEditSubItems && (GetStyle() & LVS_EDITLABELS)) ? MF_ENABLED : MF_GRAYED);
  1858. else
  1859. pPopupMenu->EnableMenuItem(ID_UI_VIEW_EDIT_COLUMN,MF_BYCOMMAND | MF_GRAYED);
  1860. // won't work with owner draw list control
  1861. if (GetStyle() & LVS_OWNERDRAWFIXED)
  1862. {
  1863. pPopupMenu->EnableMenuItem(ID_UI_VIEW_CHECKBOXES,MF_BYCOMMAND | MF_GRAYED);
  1864. }
  1865. UINT nIDItem=ID_VIEW_DETAILS;
  1866. switch(GetViewType())
  1867. {
  1868. case LVS_ICON:
  1869. nIDItem = ID_UI_VIEW_LARGE_ICONS;
  1870. break;
  1871. case LVS_SMALLICON:
  1872. nIDItem = ID_UI_VIEW_SMALL_ICONS;
  1873. break;
  1874. case LVS_LIST:
  1875. nIDItem = ID_UI_VIEW_LIST;
  1876. break;
  1877. case LVS_REPORT:
  1878. nIDItem = ID_UI_VIEW_DETAILS;
  1879. break;
  1880. }
  1881. pPopupMenu->CheckMenuRadioItem(ID_UI_VIEW_LARGE_ICONS,ID_VIEW_LIST,nIDItem,MF_BYCOMMAND);
  1882. DWORD dwExStyle = GetExStyle();
  1883. if (m_bFullRowSel)
  1884. pPopupMenu->CheckMenuItem(ID_UI_VIEW_FULL_ROW_SELECTION,MF_BYCOMMAND | MF_CHECKED);
  1885. if (m_bColumnSizing)
  1886. pPopupMenu->CheckMenuItem(ID_UI_VIEW_COLUMN_SIZING,MF_BYCOMMAND | MF_CHECKED);
  1887. if ((dwExStyle & LVS_EX_HEADERDRAGDROP))
  1888. pPopupMenu->CheckMenuItem(ID_UI_VIEW_COLUMN_ORDERING,MF_BYCOMMAND | MF_CHECKED);
  1889. if ((dwExStyle & LVS_EX_GRIDLINES))
  1890. pPopupMenu->CheckMenuItem(ID_UI_VIEW_GRIDLINES,MF_BYCOMMAND | MF_CHECKED);
  1891. if ((dwExStyle & LVS_EX_CHECKBOXES))
  1892. pPopupMenu->CheckMenuItem(ID_UI_VIEW_CHECKBOXES,MF_BYCOMMAND | MF_CHECKED);
  1893. if ((dwExStyle & LVS_EX_TRACKSELECT))
  1894. pPopupMenu->CheckMenuItem(ID_UI_VIEW_TRACK_SELECT,MF_BYCOMMAND | MF_CHECKED);
  1895. }
  1897. void CUIODListCtrl::OnViewLargeIcons()
  1898. {
  1899. SetViewType(LVS_ICON);
  1900. }
  1902. void CUIODListCtrl::OnViewSmallIcons()
  1903. {
  1904. SetViewType(LVS_SMALLICON);
  1905. }
  1907. void CUIODListCtrl::OnViewDetails()
  1908. {
  1909. SetViewType(LVS_REPORT);
  1910. }
  1912. void CUIODListCtrl::OnViewList()
  1913. {
  1914. SetViewType(LVS_LIST);
  1915. }
  1917. void CUIODListCtrl::OnViewFullRowSelection()
  1918. {
  1919. ToggleFullRowSel();
  1920. }
  1922. void CUIODListCtrl::OnViewTrackSelect()
  1923. {
  1924. ToggleTrackSelect();
  1925. }
  1927. void CUIODListCtrl::OnViewGridlines()
  1928. {
  1929. ToggleGridLines();
  1930. }
  1932. void CUIODListCtrl::OnViewCheckboxes()
  1933. {
  1934. ToggleCheckBoxes();
  1935. }
  1937. void CUIODListCtrl::OnViewColumnOrdering()
  1938. {
  1939. ToggleHeaderDragDrop();
  1940. }
  1942. void CUIODListCtrl::OnViewColumnSizing()
  1943. {
  1944. ToggleColumnSizing();
  1945. }
  1947. void CUIODListCtrl::OnViewEditColumn()
  1948. {
  1949. int index;
  1950. int colnum;
  1951. CPoint point(m_PopupPoint);
  1952. ScreenToClient(&point);
  1953. if (( index = HitTestEx( point, &colnum )) != -1)
  1954. {
  1955. UINT flag = LVIS_FOCUSED;
  1956. if( (GetItemState( index, flag ) & flag) == flag && colnum > 0)
  1957. {
  1958. // Add check for LVS_EDITLABELS
  1959. EditSubLabel( index, colnum );
  1960. }
  1961. }
  1962. }
  1964. LRESULT CUIODListCtrl::OnGetItemText(WPARAM wParam, LPARAM lParam)
  1965. {
  1966. int iItem = (int)wParam; 
  1967. LV_ITEM *pitem = (LV_ITEM*)lParam;
  1968. int nSubItem = pitem->iSubItem;
  1969. int nLen = pitem->cchTextMax;
  1970. const CUIStrListCtrlData *pData = (CUIStrListCtrlData *)GetListCtrlData(iItem);
  1971. // ASSERT_KINDOF(CUIStrListCtrlData,pData);
  1972. if (!pData->IsKindOf(RUNTIME_CLASS(CUIStrListCtrlData)))
  1973. {
  1974. NMLVDISPINFO di;
  1975. di.hdr.hwndFrom = GetSafeHwnd();
  1976. di.hdr.code = LVN_GETDISPINFO;
  1977. memcpy(&di.item,pitem,sizeof(LVITEM));
  1978. di.item.mask = LVIF_TEXT;
  1979. SendMessage(WM_NOTIFY,0,(LPARAM)&di);
  1980. _tcsncpy(pitem->pszText,di.item.pszText,nLen);
  1981. }
  1982. else
  1983. {
  1984. LPTSTR pStr = ((CUIStrListCtrlData *)pData)->GetString(nSubItem);
  1985. if (pStr)
  1986. {
  1987. _tcsncpy(pitem->pszText,pStr,nLen);
  1988. nLen = min(lstrlen(pStr)+1,nLen);
  1989. pitem->pszText[nLen-1] = '';
  1990. return nLen;
  1991. }
  1992. }
  1993. return 0L;
  1994. }
  1996. int CUIODListCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  1997. {
  1998. if (CListCtrl::OnCreate(lpCreateStruct) == -1)
  1999. return -1;
  2001. // TODO: Add your specialized creation code here
  2002. RegisterDropTarget();
  2004. return 0;
  2005. }
  2007. int CALLBACK CompareFunc(LPARAM lParam1,LPARAM lParam2,LPARAM lParamSort);
  2009. PFNLVCOMPARE CUIODListCtrl::GetCompareFunc()
  2010. {
  2011. return CompareFunc;
  2012. }
  2014. BOOL CUIODListCtrl::ColumnClick(NM_LISTVIEW* pNMListView)
  2015. {
  2016. if (pNMListView->iSubItem != m_nSortColumn)
  2017. m_bSortAscending = TRUE;
  2018. else
  2019. m_bSortAscending = !m_bSortAscending;
  2020. m_nSortColumn = pNMListView->iSubItem;
  2022. m_HeaderCtrl.SetSortImage(m_nSortColumn,m_bSortAscending);
  2023. ASSERT(m_pColTypes);
  2024. CUIODListCtrlSortInfo sortinfo(pNMListView->iSubItem,m_pColTypes[pNMListView->iSubItem],m_bSortAscending);
  2025. SortItems(GetCompareFunc(),(DWORD)&sortinfo);
  2026. int item = GetCurSel();
  2027. EnsureVisible(item,0);
  2028. return TRUE;
  2029. }
  2031. ///////////////////////////////////////////////
  2032. // static callback for sorting when the header is clicked in report mode
  2033. int CALLBACK CompareFunc(LPARAM lParam1,LPARAM lParam2,LPARAM lParamSort)
  2034. {
  2035. CUIStrListCtrlData *pData1 = (CUIStrListCtrlData*)lParam1;
  2036. CUIStrListCtrlData *pData2 = (CUIStrListCtrlData*)lParam2;
  2037. ASSERT(pData1);
  2038. ASSERT(pData2);
  2039. ASSERT_KINDOF(CUIStrListCtrlData,pData1);
  2040. ASSERT_KINDOF(CUIStrListCtrlData,pData2);
  2041. CUIODListCtrlSortInfo *pSortInfo = (CUIODListCtrlSortInfo *)lParamSort;
  2042. int ret=0;
  2043. switch(pSortInfo->GetColType())
  2044. {
  2045. case CUIODListCtrl::e_DateTime:
  2046. {
  2047. COleDateTime time1;
  2048. CString str1(pData1->GetString(pSortInfo->GetColumn()));
  2049. if (!str1.IsEmpty())
  2050. time1.ParseDateTime(str1);
  2051. COleDateTime time2;
  2052. CString str2(pData2->GetString(pSortInfo->GetColumn()));
  2053. if (!str2.IsEmpty())
  2054. time2.ParseDateTime(str2);
  2055. if (time1 > time2)
  2056. ret = 1;
  2057. else if (time1 < time2)
  2058. ret = -1;
  2059. break;
  2060. }
  2061. case CUIODListCtrl::e_NumericFormat:
  2062. {
  2063. int num1 = _ttoi(CUIODListCtrl::StripNonNumeric((LPCTSTR)pData1->GetString(pSortInfo->GetColumn()),CUIODListCtrl::e_Numeric));
  2064. int num2 = _ttoi(CUIODListCtrl::StripNonNumeric((LPCTSTR)pData2->GetString(pSortInfo->GetColumn()),CUIODListCtrl::e_Numeric));
  2065. ret = num1-num2;
  2066. break;
  2067. }
  2068. case CUIODListCtrl::e_Numeric:
  2069. {
  2070. int num1 = _ttoi((LPCTSTR)pData1->GetString(pSortInfo->GetColumn()));
  2071. int num2 = _ttoi((LPCTSTR)pData2->GetString(pSortInfo->GetColumn()));
  2072. ret = num1-num2;
  2073. break;
  2074. }
  2075. case CUIODListCtrl::e_DoubleFormat:
  2076. {
  2077. double num1 = _tcstod(CUIODListCtrl::StripNonNumeric((LPCTSTR)pData1->GetString(pSortInfo->GetColumn()),CUIODListCtrl::e_Double),NULL);
  2078. double num2 = _tcstod(CUIODListCtrl::StripNonNumeric((LPCTSTR)pData2->GetString(pSortInfo->GetColumn()),CUIODListCtrl::e_Double),NULL);
  2079. if (num1 > num2)
  2080. ret = 1;
  2081. else if (num1 < num2)
  2082. ret = -1;
  2083. break;
  2084. }
  2085. case CUIODListCtrl::e_Double:
  2086. {
  2087. double num1 = _tcstod((LPCTSTR)pData1->GetString(pSortInfo->GetColumn()),NULL);
  2088. double num2 = _tcstod((LPCTSTR)pData2->GetString(pSortInfo->GetColumn()),NULL);
  2089. if (num1 > num2)
  2090. ret = 1;
  2091. else if (num1 < num2)
  2092. ret = -1;
  2093. break;
  2094. }
  2095. case CUIODListCtrl::e_Text:
  2096. default:
  2097. ret = CompareString(LOCALE_USER_DEFAULT,NORM_IGNORECASE | NORM_IGNOREKANATYPE,
  2098. (LPCTSTR)pData1->GetString(pSortInfo->GetColumn()),
  2099. pData1->GetStringLen(pSortInfo->GetColumn()),
  2100. (LPCTSTR)pData2->GetString(pSortInfo->GetColumn()),
  2101. pData2->GetStringLen(pSortInfo->GetColumn())) - 2;
  2102. break;
  2103. }
  2104. if (!pSortInfo->Ascending())
  2105. ret = -ret;
  2106. return ret;
  2107. }
  2109. void CUIODListCtrl::ReplaceString(CString &rStr,LPCTSTR pszOldText,LPCTSTR pszNewText)
  2110. {
  2111. int nPos = rStr.Find(pszOldText);
  2112. CString strLeft;
  2113. if (nPos != -1)
  2114. {
  2115. strLeft = rStr.Left(nPos);
  2116. CString strRight(rStr.Right(rStr.GetLength()-(nPos+lstrlen(pszOldText))));
  2117. strLeft += pszNewText;
  2118. strLeft += strRight;
  2119. }
  2120. rStr = strLeft;
  2121. }
  2123. void CUIODListCtrl::Sort()
  2124. {
  2125. ASSERT(m_pColTypes);
  2126. CUIODListCtrlSortInfo sortinfo(m_nSortColumn,m_pColTypes[m_nSortColumn],m_bSortAscending);
  2127. SortItems(GetCompareFunc(),(DWORD)&sortinfo);
  2128. m_HeaderCtrl.SetSortImage(m_nSortColumn,m_bSortAscending);
  2129. TRACE1("Sorting column %dn",m_nSortColumn);
  2130. }
  2132. void CUIODListCtrl::SetColFont(int nRow,int nCol,CFont *pFont)
  2133. {
  2134. CUIListCtrlData* pListObj = GetListCtrlData(nRow);
  2135. if (pListObj)
  2136. {
  2137. ASSERT(pFont);
  2138. if (pFont)
  2139. pListObj->SetFont(pFont,nCol);
  2140. }
  2141. }
  2143. void CUIODListCtrl::SetRowFont(int nRow,CFont *pFont)
  2144. {
  2145. CUIListCtrlData* pListObj = GetListCtrlData(nRow);
  2146. if (pListObj)
  2147. {
  2148. ASSERT(pFont);
  2149. if (pFont)
  2150. pListObj->SetFont(pFont);
  2151. }
  2152. }
  2154. void CUIODListCtrl::SetColBold(int nRow,int nCol,BOOL bBold)
  2155. {
  2156. CUIListCtrlData* pListObj = GetListCtrlData(nRow);
  2157. if (pListObj)
  2158. {
  2159. if (!pListObj->IsFontSet(nCol))
  2160. {
  2161. pListObj->SetFont(GetFont(),nCol);
  2162. }
  2163. const CFont *pFont = pListObj->GetFont(nCol);
  2164. LOGFONT lf;
  2165. ((CFont*)pFont)->GetLogFont(&lf);
  2166. lf.lfWeight = bBold ? FW_BOLD : FW_NORMAL; 
  2167. CFont font;
  2168. font.CreateFontIndirect(&lf);
  2169. pListObj->SetFont(&font,nCol);
  2170. CRect rect;
  2171. RedrawItems(nRow,nRow);
  2172. UpdateWindow();
  2173. }
  2174. }
  2176. void CUIODListCtrl::SetRowBold(int nRow,BOOL bBold)
  2177. {
  2178. CUIListCtrlData* pListObj = GetListCtrlData(nRow);
  2179. if (pListObj)
  2180. {
  2181. if (!pListObj->IsFontSet(-1))
  2182. {
  2183. pListObj->SetFont(GetFont());
  2184. }
  2185. const CFont *pFont = pListObj->GetFont();
  2186. LOGFONT lf;
  2187. ((CFont*)pFont)->GetLogFont(&lf);
  2188. lf.lfWeight = bBold ? FW_BOLD : FW_NORMAL; 
  2189. CFont font;
  2190. font.CreateFontIndirect(&lf);
  2191. pListObj->SetFont(&font);
  2192. CRect rect;
  2193. RedrawItems(nRow,nRow);
  2194. UpdateWindow();
  2195. }
  2196. }
  2198. BOOL CUIODListCtrl::SubItemPostPaint(LPNMLVCUSTOMDRAW lplvcd,LRESULT *pResult)
  2199. {
  2200. if (m_hOrigFont)
  2201. {
  2202. CDC *pDC = CDC::FromHandle(lplvcd->nmcd.hdc);
  2203. pDC->SelectObject(CFont::FromHandle(m_hOrigFont));
  2204. m_hOrigFont = NULL;
  2205. }
  2206. return TRUE;
  2207. }
  2209. BOOL CUIODListCtrl::SubItemPrePaint(LPNMLVCUSTOMDRAW lplvcd,LRESULT *pResult)
  2210. {
  2211. *pResult = CDRF_DODEFAULT;
  2212. int nRow = lplvcd->nmcd.dwItemSpec;
  2213. int nCol = lplvcd->iSubItem;
  2214. CUIListCtrlData* pListObj = GetListCtrlData(nRow);
  2215. if (pListObj == NULL)
  2216. return FALSE;
  2217. *pResult = CDRF_NOTIFYPOSTPAINT;
  2218. lplvcd->clrText = pListObj->GetTextColor(nCol);
  2219. lplvcd->clrTextBk = pListObj->GetBkColor(nCol);
  2220. if (pListObj->IsFontSet(nCol))
  2221. {
  2222. CDC *pDC = CDC::FromHandle(lplvcd->nmcd.hdc);
  2223. CFont *pOldFont = pDC->SelectObject((CFont*)pListObj->GetFont(nCol));
  2224. m_hOrigFont = (HFONT)pOldFont;
  2225. *pResult |= CDRF_NEWFONT;
  2226. }
  2227. CTextProgressCtrl *pWnd = (CTextProgressCtrl*)pListObj->GetCtrl(nCol);
  2228. if (pWnd == NULL)
  2229. return TRUE;
  2230. CRect rcItem;
  2231. GetItemRect(nRow,rcItem,LVIR_LABEL);
  2232. rcItem.left = lplvcd->nmcd.rc.left;
  2233. rcItem.right = lplvcd->nmcd.rc.right;
  2234. CDC *pDC = CDC::FromHandle(lplvcd->nmcd.hdc);
  2235. pWnd->DoPaint(pDC,rcItem,GetItemState(nRow,LVIS_SELECTED) == LVIS_SELECTED);
  2236. *pResult = CDRF_SKIPDEFAULT;
  2237. return TRUE;
  2238. }
  2240. BOOL CUIODListCtrl::ItemPrePaint(LPNMLVCUSTOMDRAW lplvcd,LRESULT *pResult)
  2241. {
  2242.     *pResult = CDRF_NOTIFYSUBITEMDRAW;
  2243. return TRUE;
  2244. }
  2246. BOOL CUIODListCtrl::ItemPostPaint(LPNMLVCUSTOMDRAW lplvcd,LRESULT *pResult)
  2247. {
  2248. *pResult = CDRF_DODEFAULT;
  2249. return TRUE;
  2250. }
  2252. ///////////////////////////////////////////////
  2253. // Persistence
  2254. ///////////////////////////////////////////////
  2255. void CUIODListCtrl::SetSection(LPCTSTR pszSection) 
  2256. {
  2257. if (pszSection == NULL)
  2258. m_strSection.Empty();
  2259. else
  2260. {
  2261. SaveProfile();
  2262. m_strSection = _T("UIODListControl\");
  2263. m_strSection += pszSection;
  2264. }
  2265. }
  2267. LPCTSTR CUIODListCtrl::GetSection() const
  2268. {
  2269. return m_strSection;
  2270. }
  2272. void CUIODListCtrl::LoadProfile() 
  2273. {
  2274. if (m_strSection.IsEmpty())
  2275. return;
  2276. CWinApp *pApp = AfxGetApp();
  2277. if (pApp == NULL)
  2278. return;
  2279. LPCTSTR pszSection = GetSection();
  2281. m_strHeadings = pApp->GetProfileString(pszSection,szEntryHeadings);
  2282. m_dwExStyle = pApp->GetProfileInt(pszSection,szEntryStyle,m_dwExStyle);
  2283. m_bFullRowSel = pApp->GetProfileInt(pszSection,szEntryRowSel,m_bFullRowSel);
  2284. m_dwViewType = pApp->GetProfileInt(pszSection,szEntryViewType,m_dwViewType);
  2285. m_bColumnSizing = pApp->GetProfileInt(pszSection,szEntryColumnSizing,m_bColumnSizing);
  2286. m_nSortColumn = pApp->GetProfileInt(pszSection,szEntrySortColumn,m_nSortColumn);
  2287. int nSubItems = pApp->GetProfileInt(pszSection,szEntrySubItems,0);
  2288. if (nSubItems)
  2289. {
  2290. delete []m_pColOrder;
  2291. delete []m_pColWidths;
  2292. m_pColOrder = new int[nSubItems];
  2293. m_pColWidths = new int[nSubItems];
  2294. CString strEntry;
  2295. for(int i=0;i < nSubItems;i++)
  2296. {
  2297. strEntry.Format(_T("%s%d"),szEntryColOrder,i+1);
  2298. m_pColOrder[i] = pApp->GetProfileInt(pszSection,strEntry,0);
  2299. strEntry.Format(_T("%s%d"),szEntryColWidths,i+1);
  2300. m_pColWidths[i] = pApp->GetProfileInt(pszSection,strEntry,0);
  2301. }
  2302. }
  2303. }
  2305. void CUIODListCtrl::SaveProfile()
  2306. {
  2307. if (m_strSection.IsEmpty())
  2308. return;
  2309. CWinApp *pApp = AfxGetApp();
  2310. if (pApp == NULL)
  2311. return;
  2312. LPCTSTR pszSection = GetSection();
  2314. pApp->WriteProfileString(pszSection,szEntryHeadings,m_strHeadings);
  2315. pApp->WriteProfileInt(pszSection,szEntryStyle,SendMessage(LVM_GETEXTENDEDLISTVIEWSTYLE));
  2316. pApp->WriteProfileInt(pszSection,szEntryRowSel,m_bFullRowSel);
  2317. pApp->WriteProfileInt(pszSection,szEntryViewType,GetViewType());
  2318. pApp->WriteProfileInt(pszSection,szEntryColumnSizing,m_bColumnSizing);
  2319. pApp->WriteProfileInt(pszSection,szEntrySubItems,m_nSubItems);
  2320. pApp->WriteProfileInt(pszSection,szEntrySortColumn,m_nSortColumn);
  2321. if (m_nSubItems)
  2322. {
  2323. delete []m_pColOrder;
  2324. m_pColOrder = new int[m_nSubItems],0;
  2325. SendMessage(LVM_GETCOLUMNORDERARRAY,(WPARAM)m_nSubItems,(LPARAM)m_pColOrder);
  2326. CString strEntry;
  2327. for(int i=0;i < m_nSubItems;i++)
  2328. {
  2329. strEntry.Format(_T("%s%d"),szEntryColOrder,i+1);
  2330. pApp->WriteProfileInt(pszSection,strEntry,m_pColOrder[i]);
  2331. if (m_pColWidths)
  2332. {
  2333. strEntry.Format(_T("%s%d"),szEntryColWidths,i+1);
  2334. pApp->WriteProfileInt(pszSection,strEntry,m_pColWidths[i]);
  2335. }
  2336. }
  2337. }
  2338. }
  2340. void CUIODListCtrl::Serialize(CArchive& ar)
  2341. {
  2342. if (ar.IsStoring())
  2343. {
  2344. ar << m_strHeadings;
  2345. ar << m_nSubItems;
  2346. m_pColOrder = new int[m_nSubItems];
  2347. SendMessage(LVM_GETCOLUMNORDERARRAY,(WPARAM)m_nSubItems,(LPARAM)m_pColOrder);
  2348. for(int i=0;i < m_nSubItems;i++)
  2349. {
  2350. ar << (int)m_pColOrder[i];
  2351. ar << (int)GetColumnWidth(i);
  2352. }
  2353. delete []m_pColOrder;
  2354. m_pColOrder = NULL;
  2355. ar << SendMessage(LVM_GETEXTENDEDLISTVIEWSTYLE);
  2356. ar << m_dwViewType;
  2357. ar << m_bFullRowSel;
  2358. ar << m_bColumnSizing;
  2359. }
  2360. else
  2361. {
  2362. ar >> m_strHeadings;
  2363. ar >> m_nSubItems;
  2364. delete []m_pColOrder;
  2365. delete []m_pColWidths;
  2366. m_pColOrder = new int[m_nSubItems];
  2367. m_pColWidths = new int[m_nSubItems];
  2368. for(int i=0;i < m_nSubItems;i++)
  2369. {
  2370. ar >> (int)m_pColOrder[i];
  2371. ar >> (int)m_pColWidths[i];
  2372. }
  2373. ar >> m_dwExStyle;
  2374. ar >> m_bFullRowSel;
  2375. ar >> m_dwViewType;
  2376. ar >> m_bColumnSizing;
  2377. }
  2378. }
  2379. /////////////////////////////////////////////////////////////////
  2380. // OLE drag and drop
  2381. /////////////////////////////////////////////////////////////////
  2383. /////////////////////////////////////////////////////////////////////////////
  2385. // CUIODListCtrl message handlers
  2386. #include "UIDragImage.h"
  2388. BOOL CUIODListCtrl::OnBeginRDrag(NMHDR* pNMHDR, LRESULT* pResult) 
  2389. {
  2390. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  2391. // TODO: Add your control notification handler code here
  2392. *pResult = 0;
  2393. // DoOleDrag(pNMListView,true);  COMMINT TO DISABLE DRAGDROP
  2394. return TRUE;
  2395. }
  2397. BOOL CUIODListCtrl::OnBegindrag(NMHDR* pNMHDR, LRESULT* pResult) 
  2398. {
  2399. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  2400. // TODO: Add your control notification handler code here
  2401. *pResult = 0;
  2402. // DoOleDrag(pNMListView,false); COMMINT TO DISABLE DRAGDROP
  2403. return TRUE;
  2404. }
  2406. void CUIODListCtrl::DoOleDrag(NM_LISTVIEW* pNMListView,bool bRightMenu)
  2407. {
  2408. int nSelected = GetSelectedCount();
  2409. if (nSelected == 0 || pNMListView->iItem == -1)
  2410. return;
  2411. BOOL bRet=TRUE;
  2412. if (bRet == FALSE)
  2413. return;
  2414. // View type LVS_ICON etc
  2415. int nType = GetViewType();
  2416. // 2 ints(nSelected,nType) + ImageData + CRect 
  2417.     HANDLE hData = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,sizeof(int)*2+sizeof(DD_ImageData)*nSelected+sizeof(CRect));
  2418.     int *pData = (int*)::GlobalLock(hData);
  2419. *pData++ = nType;
  2420. *pData++ = nSelected;
  2421. // add the selections
  2422.     DD_ImageData *pImageData = (DD_ImageData*)pData;
  2423. CRect rcItem;
  2424. CRect rcIcon;
  2425. CRect rcTotalItem;
  2426. int iItem = pNMListView->iItem;
  2427. GetItemRect(iItem,rcItem,LVIR_LABEL); 
  2428. GetItemRect(iItem,rcIcon,LVIR_ICON);
  2429. rcTotalItem.left = rcIcon.left;
  2430. rcTotalItem.top = rcIcon.top;
  2431. rcTotalItem.right = rcIcon.right+rcItem.right;
  2432. rcTotalItem.bottom = 0;
  2433. CPoint point(pNMListView->ptAction);
  2434. CPoint ptHitTest;
  2435. UINT flag=0;
  2436. iItem = GetNextSel(-1);
  2437. int *pRows = new int[nSelected+1];
  2438. pRows[0] = iItem;
  2439. for(int i=1;iItem != -1;i++)
  2440. {
  2441. GetItemRect(iItem,rcItem,LVIR_LABEL); 
  2442. GetItemRect(iItem,rcIcon,LVIR_ICON); 
  2443. ptHitTest.x = rcItem.left;
  2444. ptHitTest.y = rcItem.top;
  2445. HitTest(ptHitTest,&flag);
  2446. if ((flag & LVHT_BELOW) != LVHT_BELOW && (flag & LVHT_ABOVE) != LVHT_ABOVE)
  2447. {
  2448. pImageData->m_rcItem = rcItem;
  2449. pImageData->m_rcIcon = rcIcon;
  2450. pImageData->m_ptDrag = point;
  2451. rcTotalItem.bottom += rcIcon.bottom;
  2452. pImageData++;
  2453. }
  2454. CCF_String ccfText(GetItemText(iItem,0));
  2455. CWDClipboardData::Instance()->SetData(&m_OleDataSource,&ccfText,CWDClipboardData::e_cfString);
  2456. iItem = GetNextSel(iItem);
  2457. pRows[i] = iItem;
  2458. }
  2459. pData = (int*)pImageData;
  2460. *pData++ = rcTotalItem.left;
  2461. *pData++ = rcTotalItem.right;
  2462. *pData++ = rcTotalItem.top;
  2463. *pData = rcTotalItem.bottom;
  2464.     ::GlobalUnlock (hData);
  2465.     m_OleDataSource.CacheGlobalData(m_OleDropTarget.GetClipboardFormat(), hData);
  2466. CCF_RightMenu rm;
  2467. rm.SetRightDrag(bRightMenu);
  2468. CWDClipboardData::Instance()->SetData(&m_OleDataSource,&rm,CWDClipboardData::e_cfRightMenu);
  2469. DWORD dwDragEffect = SendMessage(WM_APP_OLE_DD_DODRAGDROP,(WPARAM)pRows,(LPARAM)&m_OleDataSource);
  2470. if (dwDragEffect == 0)
  2471. dwDragEffect = GetParent()->SendMessage(WM_APP_OLE_DD_DODRAGDROP,(WPARAM)pRows,(LPARAM)&m_OleDataSource);
  2472. if (dwDragEffect)
  2473. {
  2474. // Start the DragDrop
  2475. DROPEFFECT effect = m_OleDataSource.DoDragDrop(dwDragEffect,NULL);
  2476. // Clear the cache
  2477. m_OleDataSource.Empty();        
  2478. }
  2479. delete []pRows;
  2480. }
  2482. void CUIODListCtrl::RegisterDropTarget()
  2483. {
  2484. if (!IsDragDrop())
  2485. return;
  2486. VERIFY(m_OleDropTarget.Register(this));
  2487. if (IsDropFiles())
  2488. DragAcceptFiles();
  2489. }
  2491. DROPEFFECT CUIODListCtrl::SelectCurrentTarget(CDD_OleDropTargetInfo *pInfo)
  2492. {
  2493. // No method to select a list ctrl item during drag and drop
  2494. UINT flags;
  2495. int iItem = HitTest(pInfo->GetPoint(), &flags);
  2496. pInfo->SetItem(iItem);
  2497. // save it
  2498. m_iItemDrop = iItem;
  2499. LRESULT lResult = SendMessage(WM_APP_OLE_DD_OVER,(WPARAM)pInfo);
  2500. if (lResult == 0)
  2501. {
  2502. lResult = GetParent()->SendMessage(WM_APP_OLE_DD_OVER,(WPARAM)pInfo);
  2503. }
  2504. // returns 0 if allowed (so the default is allowed)
  2505. if (lResult)
  2506. {
  2507. // return what was ever set
  2508. return pInfo->GetDropEffect();
  2509. }
  2510. return DROPEFFECT_NONE;
  2511. }
  2513. ///////////////////////////////////////////////
  2515. void CUIODListCtrl::PostNcDestroy() 
  2516. {
  2517. // TODO: Add your specialized code here and/or call the base class
  2519. CListCtrl::PostNcDestroy();
  2520. }
  2522. void CUIODListCtrl::OnDestroy() 
  2523. {
  2524. SaveProfile();
  2526. CListCtrl::OnDestroy();
  2528. // TODO: Add your message handler code here
  2529. }
  2531. void CUIODListCtrl::PreSubclassWindow() 
  2532. {
  2533. CListCtrl::PreSubclassWindow();
  2535. // Add initialization code
  2536. EnableToolTips(m_bToolTips);
  2537. SetSortHeader();
  2538. }
  2540. int CUIODListCtrl::OnToolHitTest(CPoint point, TOOLINFO * pTI) const
  2541. {
  2542. int row, col;
  2543. CRect cellrect;
  2544. row = CellRectFromPoint(point, &cellrect, &col );
  2546. if ( row == -1 ) 
  2547. return -1;
  2548. if (GetStringWidth(GetItemText(row,col))-10 < cellrect.Width())
  2549. return -1;
  2551. CToolTipCtrl* pToolTip = AfxGetThreadState()->m_pToolTip;
  2552. pToolTip->SendMessage(TTM_SETDELAYTIME,TTDT_AUTOPOP,10000);
  2553. pToolTip->SendMessage(TTM_SETMAXTIPWIDTH,0,30);
  2555. pTI->hwnd = m_hWnd;
  2556. pTI->uId = (UINT)((row<<10)+(col&0x3ff)+1);
  2557. pTI->lpszText = LPSTR_TEXTCALLBACK;
  2559. pTI->rect = cellrect;
  2560. return pTI->uId;
  2561. }
  2563. // CellRectFromPoint - Determine the row, col and bounding rect of a cell
  2564. // Returns - row index on success, -1 otherwise// point - point to be tested.
  2565. // cellrect - to hold the bounding rect// col - to hold the column index
  2566. int CUIODListCtrl::CellRectFromPoint(CPoint & point, RECT * cellrect, int * col) const
  2567. {
  2568. int colnum;
  2569. // Make sure that the ListView is in LVS_REPORT
  2570. if( (GetWindowLong(m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
  2571. return -1;
  2572. // Get the top and bottom row visible
  2573. int row = GetTopIndex();
  2574. int bottom = row + GetCountPerPage();
  2575. if( bottom > GetItemCount() )
  2576. bottom = GetItemCount();
  2577. // Get the number of columns
  2578. CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);
  2579. int nColumnCount = pHeader->GetItemCount();
  2580. // Loop through the visible rows
  2581. for( ;row <=bottom;row++)
  2582. {
  2583. // Get bounding rect of item and check whether point falls in it.
  2584. CRect rect;
  2585. GetItemRect( row, &rect, LVIR_BOUNDS );
  2586. if( rect.PtInRect(point) )
  2587. {
  2588. // Now find the column
  2589. for( colnum = 0; colnum < nColumnCount; colnum++ )
  2590. {
  2591. int colwidth = GetColumnWidth(colnum);
  2592. if( point.x >= rect.left && point.x <= (rect.left + colwidth ) )
  2593. {
  2594. RECT rectClient;
  2595. GetClientRect( &rectClient );
  2596. if( col ) 
  2597. {
  2598. CUIODListCtrl *pThis = const_cast<CUIODListCtrl*>(this);
  2599. if (m_pColOrder && pThis->SendMessage(LVM_GETCOLUMNORDERARRAY,(WPARAM)m_nSubItems,(LPARAM)m_pColOrder))
  2600. *col = m_pColOrder[colnum];
  2601. else
  2602. *col = colnum;
  2603. }
  2604. rect.right = rect.left + colwidth;
  2605. // Make sure that the right extent does not exceed
  2606. // the client area
  2607. if( rect.right > rectClient.right ) 
  2608. rect.right = rectClient.right;
  2609. *cellrect = rect;
  2610. return row;
  2611. }
  2612. rect.left += colwidth;
  2613. }
  2614. }
  2615. }
  2616. return -1;
  2617. }
  2619. BOOL CUIODListCtrl::OnToolTipText( UINT id, NMHDR * pNMHDR, LRESULT * pResult )
  2620. {
  2621. // need to handle both ANSI and UNICODE versions of the message
  2622. static WCHAR szToolTipW[256];
  2623. static char szToolTipA[256];
  2624. TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
  2625. TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
  2626. UINT nID = pNMHDR->idFrom;
  2627. if( nID == 0 )
  2628. {
  2629. // Notification in NT from automatically
  2630. return FALSE;   
  2631. }
  2632. // created tooltip
  2633. int row = ((nID-1) >> 10) & 0x3fffff;
  2634. int col = (nID-1) & 0x3ff;
  2635. m_sToolTipText = GetItemText( row, col );
  2636. #ifndef _UNICODE
  2637. // if (pNMHDR->code == TTN_NEEDTEXTA)
  2638. // lstrcpyn(pTTTA->szText, strTipText, 80);
  2639. // else
  2640. // _mbstowcsz(pTTTW->szText, strTipText, 80);
  2641. if (pNMHDR->code == TTN_NEEDTEXTA)
  2642. {
  2643. pTTTA->lpszText = (LPSTR)(LPCSTR)m_sToolTipText;
  2644. }
  2645. else
  2646. {
  2647. _mbstowcsz(szToolTipW, m_sToolTipText, sizeof(szToolTipW)-1);
  2648. pTTTW->lpszText = szToolTipW;
  2649. }
  2650. #else
  2651. if (pNMHDR->code == TTN_NEEDTEXTW)
  2652. {
  2653. pTTTW->lpszText = (LPWSTR)(LPCWSTR)m_sToolTipText;
  2654. }
  2655. else
  2656. {
  2657. _wcstombsz(szToolTipA, m_sToolTipText, sizeof(szToolTipA)-1);
  2658. pTTTA->lpszText = szToolTipA;
  2659. }
  2660. // pTTTA->lpszText = (LPTSTR)(LPCTSTR)m_sToolTipText;
  2661. // if (pNMHDR->code == TTN_NEEDTEXTA)
  2662. // _wcstombsz(pTTTA->szText, strTipText, 80);
  2663. // else
  2664. // lstrcpyn(pTTTW->szText, strTipText, 80);
  2665. #endif
  2666. *pResult = 0;
  2667. return TRUE;    
  2668. // message was handled
  2669. }
  2671. CODHeaderCtrl::CODHeaderCtrl()
  2672. {
  2673. m_nSortCol = -1;
  2674. }
  2676. CODHeaderCtrl::~CODHeaderCtrl()
  2677. {
  2678. }
  2680. int CODHeaderCtrl::SetSortImage(int nCol, BOOL bAsc)
  2681. {
  2682. if (m_hWnd == NULL)
  2683. return -1;
  2684. int nPrevCol = m_nSortCol;
  2686. m_nSortCol = nCol;
  2687. m_bSortAsc = bAsc;
  2688. // Change the item to ownder drawn
  2689. HD_ITEM hditem;
  2690. hditem.mask = HDI_FORMAT;
  2691. GetItem( nCol, &hditem );
  2692. hditem.fmt |= HDF_OWNERDRAW;
  2693. SetItem( nCol, &hditem ); // Invalidate header control so that it gets redrawn
  2694. Invalidate();
  2695. return nPrevCol;
  2696. }
  2698. void CODHeaderCtrl::DrawItem( LPDRAWITEMSTRUCT lpDrawItemStruct )
  2699. {
  2700. CDC dc;
  2702. dc.Attach( lpDrawItemStruct->hDC );
  2704. // Get the column rect
  2705. CRect rcLabel( lpDrawItemStruct->rcItem );
  2707. // Save DC
  2708. int nSavedDC = dc.SaveDC();
  2710. // Set clipping region to limit drawing within column
  2711. CRgn rgn;
  2712. rgn.CreateRectRgnIndirect( &rcLabel );
  2713. dc.SelectObject( &rgn );
  2714. rgn.DeleteObject();
  2716.         // Draw the background
  2717.         dc.FillRect(rcLabel, &CBrush(::GetSysColor(COLOR_3DFACE)));
  2719. // Labels are offset by a certain amount  
  2720. // This offset is related to the width of a space character
  2721. int offset = dc.GetTextExtent(_T(" "), 1 ).cx*2;
  2724. // Get the column text and format
  2725. TCHAR buf[256];
  2726. HD_ITEM hditem;
  2728. hditem.mask = HDI_TEXT | HDI_FORMAT;
  2729. hditem.pszText = buf;
  2730. hditem.cchTextMax = 255;
  2732. GetItem( lpDrawItemStruct->itemID, &hditem );
  2734. // Determine format for drawing column label
  2735. UINT uFormat = DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP 
  2736. | DT_VCENTER | DT_END_ELLIPSIS ;
  2738. if( hditem.fmt & HDF_CENTER)
  2739. uFormat |= DT_CENTER;
  2740. else if( hditem.fmt & HDF_RIGHT)
  2741. uFormat |= DT_RIGHT;
  2742. else
  2743. uFormat |= DT_LEFT;
  2745. // Adjust the rect if the mouse button is pressed on it
  2746. if( lpDrawItemStruct->itemState == ODS_SELECTED )
  2747. {
  2748. rcLabel.left++;
  2749. rcLabel.top += 2;
  2750. rcLabel.right++;
  2751. }
  2753. // Adjust the rect further if Sort arrow is to be displayed
  2754. if( lpDrawItemStruct->itemID == (UINT)m_nSortCol )
  2755. {
  2756. rcLabel.right -= 3 * offset;
  2757. }
  2759. rcLabel.left += offset;
  2760. rcLabel.right -= offset;
  2762. // Draw column label
  2763. if( rcLabel.left < rcLabel.right )
  2764. dc.DrawText(buf,-1,rcLabel, uFormat);
  2766. // Draw the Sort arrow
  2767. if( lpDrawItemStruct->itemID == (UINT)m_nSortCol )
  2768. {
  2769. CRect rcIcon( lpDrawItemStruct->rcItem );
  2771. // Set up pens to use for drawing the triangle
  2772. CPen penLight(PS_SOLID, 1, GetSysColor(COLOR_3DHILIGHT));
  2773. CPen penShadow(PS_SOLID, 1, GetSysColor(COLOR_3DSHADOW));
  2774. CPen *pOldPen = dc.SelectObject( &penLight );
  2776. if( m_bSortAsc )
  2777. {
  2778. // Draw triangle pointing upwards
  2779. dc.MoveTo( rcIcon.right - 2*offset, offset-1);
  2780. dc.LineTo( rcIcon.right - 3*offset/2, rcIcon.bottom - offset );
  2781. dc.LineTo( rcIcon.right - 5*offset/2-2, rcIcon.bottom - offset );
  2782. dc.MoveTo( rcIcon.right - 5*offset/2-1, rcIcon.bottom - offset-1 );
  2784. dc.SelectObject( &penShadow );
  2785. dc.LineTo( rcIcon.right - 2*offset, offset-2);
  2786. }
  2787. else
  2788. {
  2789. // Draw triangle pointing downwords
  2790. dc.MoveTo( rcIcon.right - 3*offset/2, offset-1);
  2791. dc.LineTo( rcIcon.right - 2*offset-1, rcIcon.bottom - offset + 1 );
  2792. dc.MoveTo( rcIcon.right - 2*offset-1, rcIcon.bottom - offset );
  2794. dc.SelectObject( &penShadow );
  2795. dc.LineTo( rcIcon.right - 5*offset/2-1, offset -1 );
  2796. dc.LineTo( rcIcon.right - 3*offset/2, offset -1);
  2797. }
  2799. // Restore the pen
  2800. dc.SelectObject( pOldPen );
  2801. }
  2803. // Restore dc
  2804. dc.RestoreDC( nSavedDC );
  2806. // Detach the dc before returning
  2807. dc.Detach();
  2808. }
  2810. void CUIODListCtrl::SetSortColumn(int nCol,BOOL bAsc)
  2811. {
  2812. m_nSortColumn = nCol;
  2813. m_bSortAscending = bAsc;
  2814. m_HeaderCtrl.SetSortImage(nCol,bAsc);
  2815. }
  2817. void CUIODListCtrl::SetSortHeader()
  2818. {
  2819. if (m_HeaderCtrl.GetSafeHwnd() == NULL && m_hWnd != NULL)
  2820. {
  2821. m_HeaderCtrl.SubclassWindow( ::GetDlgItem(m_hWnd,0) );
  2822. }
  2823. }
  2825. CString CUIODListCtrl::StripNonNumeric(LPCTSTR pszOldNum,CUIODListCtrl::eColTypes type)
  2826. {
  2827. TCHAR szNewNum[255];
  2828. LPTSTR pszNewNum = szNewNum;
  2829. while (*pszOldNum != '')
  2830. {
  2831. if ((type == CUIODListCtrl::e_Double && *pszOldNum == '.') || *pszOldNum == '-' || *pszOldNum == '+' || _istdigit(*pszOldNum))
  2832. {
  2833. *pszNewNum = *pszOldNum;
  2834. pszNewNum = _tcsinc(pszNewNum);
  2835. }
  2836. pszOldNum = _tcsinc(pszOldNum);
  2837. }
  2838. *pszNewNum = '';
  2839. return szNewNum;
  2840. }
  2842. BOOL CUIODListCtrl::PreTranslateMessage(MSG* pMsg)
  2843. {
  2844. if (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN)
  2845. {
  2846. if (pMsg->wParam == VK_F10 && (GetKeyState(VK_SHIFT) < 0))
  2847. {
  2848. PostMessage(WM_APP_ON_CONTEXT_MENU_KEY);
  2849. return TRUE;
  2850. }
  2851. else if (pMsg->wParam == VK_BACK)
  2852. {
  2853. PostMessage(WM_APP_ON_BACKSPACE_KEY);
  2854. return TRUE;
  2855. }
  2856. else if (pMsg->wParam == VK_F2)
  2857. {
  2858. PostMessage(WM_APP_ON_EDIT_KEY);
  2859. return TRUE;
  2860. }
  2861. else if (pMsg->wParam == VK_F5)
  2862. {
  2863. PostMessage(WM_APP_ON_REFRESH_KEY);
  2864. return TRUE;
  2865. }
  2866. else if (pMsg->wParam == VK_DELETE)
  2867. {
  2868. PostMessage(WM_APP_ON_DELETE_KEY);
  2869. return TRUE;
  2870. }
  2871. else if (pMsg->message == WM_SYSKEYDOWN && pMsg->wParam == VK_RETURN)
  2872. {
  2873. PostMessage(WM_APP_ON_PROPERTIES_KEY);
  2874. return TRUE;
  2875. }
  2876. }
  2877. return CListCtrl::PreTranslateMessage(pMsg);
  2878. }
  2880. // User has finished editing a column
  2881. bool CUIODListCtrl::EndLabelEdit(int nRow,int nCol,LPCTSTR pszText)
  2882. {
  2883. return false;
  2884. }
  2886. // Left mouse button double clicked
  2887. BOOL CUIODListCtrl::DoubleClick(NM_LISTVIEW* pNMListView)
  2888. {
  2889. return FALSE;
  2890. }
  2892. // Enter Pressed
  2893. BOOL CUIODListCtrl::OnEnter(NM_LISTVIEW* pNMListView)
  2894. {
  2895. return FALSE;
  2896. }
  2898. // Delete key pressed
  2899. bool CUIODListCtrl::DeleteKey(int nRow)
  2900. {
  2901. return false;
  2902. }
  2904. // ALt-Enter pressed
  2905. void CUIODListCtrl::ShowProperties(int nRow)
  2906. {
  2907. }
  2909. // F5 key pressed
  2910. void CUIODListCtrl::Refresh()
  2911. {
  2912. }
  2914. // Backspace key pressed
  2915. void CUIODListCtrl::GoBack(int nSelRow)
  2916. {
  2917. }
  2919. LRESULT CUIODListCtrl::OnDragDrop(WPARAM wParam,LPARAM lParam)
  2920. {
  2921. if (IsDragDrop() == false)
  2922. return 1L;
  2923. // get the info we need
  2924. CDD_OleDropTargetInfo *pInfo = (CDD_OleDropTargetInfo*)wParam;
  2925. ASSERT(pInfo);
  2926. return DragDrop(pInfo) ? 1 : 0;
  2927. }
  2929. // user is currently over the list view window
  2930. // return 1 if we are interested in the Clipboard format
  2931. LRESULT CUIODListCtrl::OnDragOver(WPARAM wParam,LPARAM lParam)
  2932. {
  2933. if (IsDragDrop() == false)
  2934. return 1L;
  2935. CDD_OleDropTargetInfo *pInfo = (CDD_OleDropTargetInfo*)wParam;
  2936. ASSERT(pInfo);
  2937. return DragOver(pInfo) ? 1 : 0;
  2938. }
  2940. LRESULT CUIODListCtrl::OnDragEnter(WPARAM wParam,LPARAM lParam)
  2941. {
  2942. if (IsDragDrop() == false)
  2943. return 1L;
  2944. CDD_OleDropTargetInfo *pInfo = (CDD_OleDropTargetInfo*)wParam;
  2945. ASSERT(pInfo);
  2946. return DragEnter(pInfo) ? 1 : 0;
  2947. }
  2949. LRESULT CUIODListCtrl::OnDragLeave(WPARAM wParam,LPARAM lParam)
  2950. {
  2951. if (IsDragDrop() == false)
  2952. return 1L;
  2953. CDD_OleDropTargetInfo *pInfo = (CDD_OleDropTargetInfo*)wParam;
  2954. ASSERT(pInfo);
  2955. return DragLeave(pInfo) ? 1 : 0;
  2956. }
  2958. // Drag and drop initiated
  2959. // Return 1 if processed
  2960. LRESULT CUIODListCtrl::OnDDDoDragDrop(WPARAM wParam,LPARAM lParam)
  2961. {
  2962. if (IsDragDrop() == false)
  2963. return 1L;
  2964. COleDataSource *pOleDataSource = (COleDataSource*)lParam;
  2965. int *pRows = (int*)wParam;
  2966. ASSERT(pOleDataSource);
  2967. return DoDragDrop(pRows,pOleDataSource);
  2968. }
  2970. bool CUIODListCtrl::DragDrop(CDD_OleDropTargetInfo *pInfo)
  2971. {
  2972. return false;
  2973. }
  2975. bool CUIODListCtrl::DragOver(CDD_OleDropTargetInfo *pInfo)
  2976. {
  2977. return false;
  2978. }
  2980. bool CUIODListCtrl::DragEnter(CDD_OleDropTargetInfo *pInfo)
  2981. {
  2982. return false;
  2983. }
  2985. bool CUIODListCtrl::DragLeave(CDD_OleDropTargetInfo *pInfo)
  2986. {
  2987. return false;
  2988. }
  2990. DROPEFFECT CUIODListCtrl::DoDragDrop(int *pnRows,COleDataSource *pOleDataSource)
  2991. {
  2992. return true;
  2993. }
  2995. void CUIODListCtrl::OnDropFiles(HDROP hDropInfo)
  2996. {
  2997. UINT wNumFilesDropped = DragQueryFile(hDropInfo, 0XFFFFFFFF, NULL, 0);
  2998. TCHAR szFile[MAX_PATH];
  2999. UINT nLen;
  3000. UINT nFlags;
  3001. POINT pt;
  3002. ::DragQueryPoint(hDropInfo,&pt);
  3003. int nRow = HitTest(CPoint(pt), &nFlags);
  3004. for(UINT i=0; i < wNumFilesDropped;i++)
  3005. {
  3006. nLen = DragQueryFile(hDropInfo,i,szFile,sizeof(szFile)/sizeof(TCHAR));
  3007. if (nLen)
  3008. OnDropFile(nRow,szFile,nFlags);
  3009. }
  3010. }
  3012. void CUIODListCtrl::OnDropFile(int nRow,LPCTSTR pszFile,UINT nFlags)
  3013. {
  3014. }
  3016. LRESULT CUIODListCtrl::OnAppPropertiesKey(WPARAM wParam, LPARAM lParam)
  3017. {
  3018. int item=-1;
  3019. while ((item = GetNextSel(item)) != -1)
  3020. {
  3021. ShowProperties(item);
  3022. }
  3023. return 1L;
  3024. }
  3026. LRESULT CUIODListCtrl::OnAppDeleteKey(WPARAM wParam, LPARAM lParam)
  3027. {
  3028. int nNewItem = -1;
  3029. int item=-1;
  3030. CUIListCtrlData *pData = NULL;
  3031. while ((item = GetNextSel(item)) != -1)
  3032. {
  3033. pData = GetListCtrlData(item);
  3034. if (DeleteKey(item))
  3035. {
  3036. pData->SetDeleted(true);
  3037. }
  3038. nNewItem = item;
  3039. }
  3040. while ((item = GetCurSel()) != -1)
  3041. {
  3042. pData = GetListCtrlData(item);
  3043. if (pData->IsDeleted())
  3044. {
  3045. if (!DeleteItem(item))
  3046. SetItemState(item,0,LVIS_SELECTED);
  3047. }
  3048. else
  3049. {
  3050. SetItemState(item,0,LVIS_SELECTED);
  3051. }
  3052. if (GetItemCount() == 0)
  3053. break;
  3054. }
  3055. if (nNewItem != -1)
  3056. {
  3057. EnsureVisible(nNewItem,0);
  3058. SetCurSel(nNewItem);
  3059. }
  3060. return 1L;
  3061. }
  3063. LRESULT CUIODListCtrl::OnAppRefreshKey(WPARAM wParam, LPARAM lParam)
  3064. {
  3065. Refresh();
  3066. return 1L;
  3067. }
  3069. LRESULT CUIODListCtrl::OnAppEditKey(WPARAM wParam, LPARAM lParam)
  3070. {
  3071. EditLabel(GetCurSel());
  3072. return 1L;
  3073. }
  3075. LRESULT CUIODListCtrl::OnAppContextMenuKey(WPARAM wParam, LPARAM lParam)
  3076. {
  3077. CPoint pt;
  3078. if (GetCurSel() != -1)
  3079. GetItemPosition(GetCurSel(),&pt);
  3080. ClientToScreen(&pt);
  3081. ShowPopupMenu(GetCurSel(),0,pt);
  3082. return 1L;
  3083. }
  3085. LRESULT CUIODListCtrl::OnAppBackspaceKey(WPARAM wParam, LPARAM lParam)
  3086. {
  3087. GoBack(GetCurSel());
  3088. return 1L;
  3089. }
  3091. void CUIODListCtrl::SelChanged(int nItem, LRESULT *pResult)
  3092. {
  3093. *pResult = 0;
  3094. }