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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 远程控制编程 > 查看源码
ReportCtrl.cpp
资源名称：anywhere.zip　[点击查看]
上传用户：zhenhuadz
上传日期：2007-01-07
资源大小：1511k
文件大小：58k
源码类别：

远程控制编程

开发平台：

Visual C++

ReportCtrl.cpp：源码内容
  1. ////////////////////////////////////////////////////////////////////////////
  2. // File: CReportCtrl.cpp
  3. // Version: 1.0.1.0
  4. //
  5. // Author: Maarten Hoeben
  6. // E-mail: hoeben@nwn.com
  7. //
  8. // Implementation of the CReportCtrl and associated classes.
  9. //
  10. // You are free to use, distribute or modify this code
  11. // as long as the header is not removed or modified.
  12. //
  13. // Version history
  14. //
  15. // 1.0.1.0 - Initial release
  16. ////////////////////////////////////////////////////////////////////////////
  18. // ReportCtrl.cpp : implementation file
  19. //
  21. #include "stdafx.h"
  22. #include "ReportCtrl.h"
  24. #ifdef _DEBUG
  25. #define new DEBUG_NEW
  26. #undef THIS_FILE
  27. static char THIS_FILE[] = __FILE__;
  28. #endif
  30. TCHAR* g_szSeparator = _T("|");
  32. /////////////////////////////////////////////////////////////////////////////
  33. // CReportData
  35. CReportData::CReportData()
  36. {
  37. }
  39. CReportData::~CReportData()
  40. {
  41. }
  43. BOOL CReportData::New(INT iSubItems)
  44. {
  45. for(INT i=0;i<iSubItems;i++)
  46. {
  47. CString str;
  48. str.Format(_T("(-1,-1,-1)%s"), g_szSeparator);
  50. *this += str;
  51. }
  53. return TRUE;
  54. }
  56. BOOL CReportData::GetSubItem(INT iSubItem, LPINT lpiImage, LPINT lpiCheck, LPINT lpiColor, LPTSTR lpszText, INT iTextMax)
  57. {
  58. INT i, iPos;
  60. for(i=0,iPos=0;i<iSubItem&&iPos>=0;i++,iPos++)
  61. iPos = Find(g_szSeparator, iPos);
  63. if(iPos<0)
  64. return FALSE;
  66. LPTSTR lpsz = GetBuffer(0);
  67. lpsz = &lpsz[iPos];
  68. VERIFY(_stscanf(lpsz, _T("(%d,%d,%d)"), lpiImage, lpiCheck, lpiColor));
  70. lpsz = _tcspbrk(lpsz, _T(")"))+1;
  71. if(lpsz && lpszText)
  72. {
  73. for(INT iTextSize=0;iTextSize<iTextMax-1 && *lpsz!=g_szSeparator[0];iTextSize++)
  74. lpszText[iTextSize] = *lpsz++;
  76. lpszText[iTextSize] = 0;
  77. }
  79. return TRUE;
  80. }
  82. BOOL CReportData::SetSubItem(INT iSubItem, INT iImage, INT iCheck, INT iColor, LPCTSTR lpszText)
  83. {
  84. if(!InsertSubItem(iSubItem, iImage, iCheck, iColor, lpszText))
  85. return FALSE;
  87. if(!DeleteSubItem(iSubItem+1))
  88. return FALSE;
  90. return TRUE;
  91. }
  93. BOOL CReportData::InsertSubItem(INT iSubItem, INT iImage, INT iCheck, INT iColor, LPCTSTR lpszText)
  94. {
  95. INT i, iPos;
  97. for(i=0,iPos=0;i<iSubItem&&iPos>=0;i++,iPos++)
  98. iPos = Find(g_szSeparator, iPos);
  100. if(iPos<0)
  101. return FALSE;
  103. lpszText = lpszText ? lpszText:_T("");
  105. CString str;
  106. str.Format("(%d,%d,%d)%s%s", iImage, iCheck, iColor, lpszText, g_szSeparator);
  108. Insert(iPos, str);
  109. return TRUE;
  110. }
  112. BOOL CReportData::DeleteSubItem(INT iSubItem)
  113. {
  114. INT i, iPos1, iPos2;
  116. for(i=0,iPos1=0;i<iSubItem&&iPos1>=0;i++,iPos1++)
  117. iPos1 = Find(g_szSeparator, iPos1);
  119. if(iPos1<0)
  120. return FALSE;
  122. iPos2 = Find(g_szSeparator, iPos1);
  123. if(iPos2++<0)
  124. return FALSE;
  126. Delete(iPos1, iPos2-iPos1);
  127. return TRUE;
  128. }
  130. /////////////////////////////////////////////////////////////////////////////
  131. // CReportView
  133. IMPLEMENT_DYNCREATE(CReportView, CView)
  135. CReportView::CReportView()
  136. {
  137. m_bCreated = FALSE;
  138. }
  140. CReportView::~CReportView()
  141. {
  142. }
  144. void CReportView::OnInitialUpdate() 
  145. {
  146. CView::OnInitialUpdate();
  148. if(!m_bCreated)
  149. {
  150. CRect rect;
  151. GetClientRect(rect);
  152. if(m_wndReportCtrl.Create(WS_CHILD|WS_TABSTOP|WS_VISIBLE, rect, this, IDC_REPORTCTRL) == NULL)
  153. AfxThrowMemoryException();
  155. m_bCreated = TRUE;
  156. }
  157. }
  160. BEGIN_MESSAGE_MAP(CReportView, CView)
  161. //{{AFX_MSG_MAP(CReportView)
  162. ON_WM_SIZE()
  163. ON_WM_SETFOCUS()
  164. ON_WM_ERASEBKGND()
  165. //}}AFX_MSG_MAP
  166. END_MESSAGE_MAP()
  168. /////////////////////////////////////////////////////////////////////////////
  169. // CReportView drawing
  171. void CReportView::OnDraw(CDC* pDC)
  172. {
  173. ;
  174. }
  176. /////////////////////////////////////////////////////////////////////////////
  177. // CReportView diagnostics
  179. #ifdef _DEBUG
  180. void CReportView::AssertValid() const
  181. {
  182. CView::AssertValid();
  183. }
  185. void CReportView::Dump(CDumpContext& dc) const
  186. {
  187. CView::Dump(dc);
  188. }
  189. #endif //_DEBUG
  191. /////////////////////////////////////////////////////////////////////////////
  192. // CReportView implementation
  194. CReportCtrl& CReportView::GetReportCtrl()
  195. {
  196. return m_wndReportCtrl;
  197. }
  199. BOOL CReportView::OnEraseBkgnd(CDC* pDC) 
  200. {
  201. return TRUE;
  202. }
  204. void CReportView::OnSize(UINT nType, int cx, int cy) 
  205. {
  206. CView::OnSize(nType, cx, cy);
  208. if(m_wndReportCtrl.GetSafeHwnd())
  209. {
  210. CRect rect;
  211. GetClientRect(rect);
  212. m_wndReportCtrl.MoveWindow(rect);
  213. }
  214. }
  216. void CReportView::OnSetFocus(CWnd* pOldWnd) 
  217. {
  218. m_wndReportCtrl.SetFocus();
  219. }
  221. /////////////////////////////////////////////////////////////////////////////
  222. // CReportCtrl
  224. IMPLEMENT_DYNCREATE(CReportCtrl, CWnd)
  226. CReportCtrl::CReportCtrl()
  227. {
  228. // Register the window class if it has not already been registered.
  229. WNDCLASS wndclass;
  230. HINSTANCE hInst = AfxGetInstanceHandle();
  232. if(!(::GetClassInfo(hInst, REPORTCTRL_CLASSNAME, &wndclass)))
  233. {
  234. // Otherwise we need to register a new class
  235.         wndclass.style = CS_DBLCLKS|CS_HREDRAW|CS_VREDRAW;
  236. wndclass.lpfnWndProc = ::DefWindowProc;
  237. wndclass.cbClsExtra = wndclass.cbWndExtra = 0;
  238. wndclass.hInstance = hInst;
  239. wndclass.hIcon = NULL;
  240. wndclass.hCursor = LoadCursor(hInst, IDC_ARROW);
  241. wndclass.hbrBackground = (HBRUSH)COLOR_WINDOW; 
  242. wndclass.lpszMenuName = NULL;
  243. wndclass.lpszClassName = REPORTCTRL_CLASSNAME;
  245. if (!AfxRegisterClass(&wndclass))
  246. AfxThrowResourceException();
  247. }
  249. m_bSubclassFromCreate = FALSE;
  251. m_bDoubleBuffer = TRUE;
  252. m_iSpacing = 6;
  254.     // Initially use the system message font for the ReportCtrl font
  255. NONCLIENTMETRICS ncm;
  256. ncm.cbSize = sizeof(NONCLIENTMETRICS);
  257. VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0));
  258. m_font.CreateFontIndirect(&(ncm.lfMessageFont));
  260. m_pImageList = NULL;
  261. m_sizeImage.cx = 0;
  262. m_sizeImage.cy = 0;
  263. m_sizeCheck.cx = 8;
  264. m_sizeCheck.cy = 8;
  266. GetSysColors();
  268. m_arrayColors.SetSize(0, 8);
  270. m_iGridStyle = PS_SOLID;
  272. m_strNoItems = _T("There are no items to show in this view.");
  274. m_iDefaultWidth = 200;
  275. m_iDefaultHeight = 10;
  276. m_iVirtualWidth = 0;
  277. m_iVirtualHeight = 0;
  279. m_arraySubItems.SetSize(0, 8);
  280. m_arrayItems.SetSize(0, 128);
  282. m_bColumnsReordered = FALSE;
  283. m_arrayColumns.SetSize(0, 8);
  285. m_bFocus = FALSE;
  286. m_iFocusRow = -1;
  287. m_iSelectRow = 0;
  288. m_arrayRows.SetSize(0, 128);
  290. m_lprclc = NULL;
  291. m_lpfnrvc = NULL;
  292. }
  294. CReportCtrl::~CReportCtrl()
  295. {
  296. if(m_palette.m_hObject)
  297. m_palette.DeleteObject();
  299.     if(m_font.m_hObject)
  300. m_font.DeleteObject();
  301. if(m_fontBold.m_hObject)
  302. m_fontBold.DeleteObject();
  303. }
  305. BOOL CReportCtrl::Create()
  306. {
  307. CRect rect(0, 0, 0, 0);
  308. DWORD dwStyle = HDS_HORZ|HDS_BUTTONS|HDS_FULLDRAG|HDS_DRAGDROP|CCS_TOP;
  309. if(!m_wndHeader.Create(dwStyle, rect, this, IDC_HEADERCTRL))
  310. return FALSE;
  312. CWnd* pWnd = GetParent();
  313. if(pWnd)
  314. {
  315. CFont* pFont = pWnd->GetFont();
  316. if(pFont)
  317. {
  318. LOGFONT lf;
  319. pFont->GetLogFont(&lf);
  321. m_font.DeleteObject();
  322. m_font.CreateFontIndirect(&lf);
  323. }
  324. }
  326. OnSetFont((WPARAM)((HFONT)m_font), FALSE);
  327. m_wndHeader.SetFont(&m_font, FALSE);
  329. GetClientRect(rect);
  330. Layout(rect.Width(), rect.Height());
  332. return TRUE;
  333. }
  335. BOOL CReportCtrl::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext) 
  336. {
  337. m_bSubclassFromCreate = TRUE;
  339. if(!CWnd::Create(REPORTCTRL_CLASSNAME, NULL, dwStyle, rect, pParentWnd, nID, pContext))
  340. return FALSE;
  342. return Create();
  343. }
  345. void CReportCtrl::PreSubclassWindow() 
  346. {
  347. CWnd::PreSubclassWindow();
  349. if(!m_bSubclassFromCreate)
  350. if(!Create())
  351. AfxThrowMemoryException();
  352. }
  354. BEGIN_MESSAGE_MAP(CReportCtrl, CWnd)
  355. //{{AFX_MSG_MAP(CReportCtrl)
  356. ON_WM_SIZE()
  357. ON_WM_ERASEBKGND()
  358. ON_WM_PAINT()
  359. ON_WM_SYSCOLORCHANGE()
  360. ON_NOTIFY(HDN_ITEMCHANGED, IDC_HEADERCTRL, OnHdnItemChanged)
  361. ON_NOTIFY(HDN_ITEMCLICK, IDC_HEADERCTRL, OnHdnItemClick)
  362. ON_NOTIFY(HDN_ENDDRAG, IDC_HEADERCTRL, OnHdnEndDrag)
  363. ON_WM_HSCROLL()
  364. ON_WM_VSCROLL()
  365. ON_WM_LBUTTONDOWN()
  366. ON_WM_SETCURSOR()
  367. ON_WM_KEYDOWN()
  368. ON_WM_GETDLGCODE()
  369. ON_WM_LBUTTONDBLCLK()
  370. ON_WM_QUERYNEWPALETTE()
  371. ON_WM_PALETTECHANGED()
  372. ON_WM_SETFOCUS()
  373. ON_WM_KILLFOCUS()
  374. //}}AFX_MSG_MAP
  375.     ON_MESSAGE(WM_SETFONT, OnSetFont)
  376.     ON_MESSAGE(WM_GETFONT, OnGetFont)
  377. END_MESSAGE_MAP()
  379. /////////////////////////////////////////////////////////////////////////////
  380. // CReportCtrl attributes
  382. BOOL CReportCtrl::ModifyProperty(WPARAM wParam, LPARAM lParam)
  383. {
  384. switch(wParam)
  385. {
  386. case RVP_SPACING:
  387. m_iSpacing = (INT)lParam;
  388. break;
  390. case RVP_CHECK:
  391. m_sizeCheck.cx = LOWORD(lParam);
  392. m_sizeCheck.cy = HIWORD(lParam);
  393. break;
  395. case RVP_NOITEMTEXT:
  396. m_strNoItems = (LPCTSTR)lParam;
  397. break;
  399. case RVP_GRIDSTYLE:
  400. switch(wParam)
  401. {
  402. case RVP_GRIDSTYLE_DOT: m_iGridStyle = PS_DOT; break;
  403. case RVP_GRIDSTYLE_DASH: m_iGridStyle = PS_DASH; break;
  404. case RVP_GRIDSTYLE_SOLID: m_iGridStyle = PS_SOLID; break;
  405. default:
  406. return FALSE;
  407. }
  408. break;
  410. default:
  411. return FALSE;
  412. }
  414. CRect rect;
  415. GetClientRect(rect);
  416. Layout(rect.Width(), rect.Height());
  418. return TRUE;
  419. }
  421. INT CReportCtrl::ActivateColumn(INT iColumn, INT iOrder)
  422. {
  423. ASSERT(iColumn<m_arraySubItems.GetSize());
  425. SUBITEM& subitem = m_arraySubItems[iColumn];
  426. INT iResult = -1;
  428. INT iHeaderItems = m_arrayColumns.GetSize();
  430. HDITEM hdi;
  431. hdi.mask = HDI_LPARAM;
  433. for(INT iItem=0;iItem<iHeaderItems;iItem++)
  434. if(m_wndHeader.GetItem(iItem, &hdi))
  435. if(hdi.lParam == iColumn)
  436. break;
  438. if(iItem == iHeaderItems)
  439. {
  440. try
  441. {
  442. hdi.mask = HDI_FORMAT|HDI_WIDTH|HDI_LPARAM|HDI_ORDER;
  443. hdi.fmt = subitem.nFormat&RVCF_MASK;
  444. hdi.cxy = subitem.iWidth;
  445. hdi.iOrder = iOrder;
  446. hdi.lParam = (LPARAM)iColumn;
  448. if(subitem.nFormat&RVCF_IMAGE)
  449. {
  450. hdi.mask |= HDI_IMAGE;
  451. hdi.iImage = subitem.iImage;
  452. }
  454. if(subitem.nFormat&RVCF_TEXT)
  455. {
  456. hdi.mask |= HDI_TEXT;
  457. hdi.pszText = subitem.strText.GetBuffer(0);
  458. }
  460. iResult = m_wndHeader.InsertItem(iHeaderItems, &hdi);
  461. if(iResult >= 0)
  462. {
  463. m_iVirtualWidth += subitem.iWidth;
  465. HDITEMEX hditemex;
  466. hditemex.nStyle = (subitem.nFormat&RVCF_EX_MASK)>>16;
  467. hditemex.iMinWidth = subitem.iMinWidth;
  468. hditemex.iMaxWidth = subitem.iMaxWidth;
  470. m_wndHeader.SetItemEx(iResult, &hditemex);
  472. hdi.mask = HDI_WIDTH;
  473. m_wndHeader.GetItem(iResult, &hdi);
  474. subitem.iWidth = hdi.cxy;
  476. m_bColumnsReordered = TRUE;
  478. ScrollWindow(SB_HORZ, GetScrollPos32(SB_HORZ));
  479. }
  480. }
  481. catch(CMemoryException* e)
  482. {
  483. e->Delete();
  484. if(iResult >= 0)
  485. m_wndHeader.DeleteItem(iResult);
  486. }
  487. }
  489. return iResult;
  490. }
  492. BOOL CReportCtrl::DeactivateColumn(INT iColumn)
  493. {
  494. ASSERT(iColumn<m_arraySubItems.GetSize());
  496. HDITEM hdi;
  497. hdi.mask = HDI_WIDTH|HDI_LPARAM;
  499. INT iHeaderItems = m_arrayColumns.GetSize();
  500. for(INT iItem=0;iItem<iHeaderItems;iItem++)
  501. if(m_wndHeader.GetItem(iItem, &hdi))
  502. if(hdi.lParam == iColumn)
  503. break;
  505. if(iItem == iHeaderItems)
  506. return FALSE;
  508. ASSERT(iHeaderItems > 1); // At least one column must be active
  510. BOOL bResult = m_wndHeader.DeleteItem(iItem);
  512. m_iVirtualWidth -= hdi.cxy;
  513. m_bColumnsReordered = TRUE;
  515. ScrollWindow(SB_HORZ, GetScrollPos32(SB_HORZ));
  516. return bResult;
  517. }
  519. BOOL CReportCtrl::IsActiveColumn(INT iColumn)
  520. {
  521. INT iHeaderItems = m_arrayColumns.GetSize();
  523. HDITEM hdi;
  524. hdi.mask = HDI_LPARAM;
  526. for(INT iItem=0;iItem<iHeaderItems;iItem++)
  527. if(m_wndHeader.GetItem(iItem, &hdi))
  528. if(hdi.lParam == iColumn)
  529. break;
  531. if(iItem == iHeaderItems)
  532. return FALSE;
  534. return TRUE;
  535. }
  537. BOOL CReportCtrl::GetItem(LPRVITEM lprvi)
  538. {
  539. ASSERT(lprvi->iItem < m_arrayItems.GetSize()); // Specify item
  540. ASSERT(lprvi->iSubItem < m_arraySubItems.GetSize()); // Specify subitem
  542. UINT nMask = lprvi->nMask;
  543. ITEM item = m_arrayItems[lprvi->iItem];
  545. lprvi->nMask = 0;
  546. lprvi->nPreview = item.nPreview;
  547. if(lprvi->nPreview > 0)
  548. lprvi->nMask |= RVIM_PREVIEW;
  550. lprvi->iBkColor = item.iBkColor;
  551. if(lprvi->iBkColor >= 0)
  552. lprvi->nMask |= RVIM_BKCOLOR;
  554. lprvi->lpszText = nMask&RVIM_TEXT ? lprvi->lpszText:NULL;
  555. item.rdData.GetSubItem(lprvi->iSubItem, &lprvi->iImage, &lprvi->iCheck, &lprvi->iTextColor, lprvi->lpszText, lprvi->iTextMax);
  556. if(lprvi->lpszText && _tcslen(lprvi->lpszText))
  557. lprvi->nMask |= RVIM_TEXT;
  559. if(lprvi->iImage >= 0)
  560. lprvi->nMask |= RVIM_IMAGE;
  561. if(lprvi->iCheck >= 0)
  562. lprvi->nMask |= RVIM_CHECK;
  563. if(lprvi->iTextColor >= 0)
  564. lprvi->nMask |= RVIM_TEXTCOLOR;
  566. lprvi->nMask |= RVIM_STATE|RVIM_LPARAM;
  567. lprvi->nState = item.nState;
  568. lprvi->lParam = item.lParam;
  570. return TRUE;
  571. }
  573. BOOL CReportCtrl::SetItem(LPRVITEM lprvi)
  574. {
  575. TCHAR szText[REPORTCTRL_MAX_TEXT];
  576. RVITEM rvi;
  577. rvi.iItem = lprvi->iItem;
  578. rvi.iSubItem = lprvi->iSubItem;
  579. rvi.lpszText = szText;
  580. rvi.iTextMax = REPORTCTRL_MAX_TEXT;
  581. rvi.nMask = RVIM_TEXT;
  582. VERIFY(GetItem(&rvi));
  584. if(lprvi->nMask&RVIM_TEXT)
  585. {
  586. _tcsncpy(rvi.lpszText, lprvi->lpszText, REPORTCTRL_MAX_TEXT-1);
  587. rvi.lpszText[REPORTCTRL_MAX_TEXT-1] = 0;
  588. }
  590. if(lprvi->nMask&RVIM_TEXTCOLOR)
  591. rvi.iTextColor = lprvi->iTextColor;
  593. if(lprvi->nMask&RVIM_IMAGE)
  594. rvi.iImage = lprvi->iImage;
  596. if(lprvi->nMask&RVIM_CHECK)
  597. rvi.iCheck = lprvi->iCheck;
  599. if(lprvi->nMask&RVIM_BKCOLOR)
  600. rvi.iBkColor = lprvi->iBkColor;
  602. if(lprvi->nMask&RVIM_PREVIEW)
  603. rvi.nPreview = lprvi->nPreview;
  605. if(lprvi->nMask&RVIM_STATE)
  606. rvi.nState = lprvi->nState;
  608. if(lprvi->nMask&RVIM_LPARAM)
  609. rvi.lParam = lprvi->lParam;
  611. ITEM item = m_arrayItems[rvi.iItem];
  613. VERIFY(item.rdData.InsertSubItem(rvi.iSubItem, rvi.iImage, rvi.iCheck, rvi.iTextColor, rvi.lpszText));
  614. VERIFY(item.rdData.DeleteSubItem(rvi.iSubItem+1));
  616. item.iBkColor = rvi.iBkColor;
  617. item.nPreview = rvi.nPreview;
  618. item.nState = rvi.nState;
  619. item.lParam = rvi.lParam;
  620. m_arrayItems.SetAt(rvi.iItem, item);
  622. ScrollWindow(SB_VERT, GetScrollPos32(SB_VERT));
  624. RedrawItems(rvi.iItem);
  625. return TRUE;
  626. }
  628. INT CReportCtrl::GetItemText(INT iItem, INT iSubItem, LPTSTR lpszText, INT iLen)
  629. {
  630. RVITEM rvi;
  631. rvi.nMask = RVIM_TEXT;
  632. rvi.iItem = iItem;
  633. rvi.iSubItem = iSubItem;
  634. rvi.lpszText = lpszText;
  635. rvi.iTextMax = iLen;
  636. return GetItem(&rvi) ? _tcslen(rvi.lpszText):0;
  637. }
  639. CString CReportCtrl::GetItemText(INT iItem, INT iSubItem)
  640. {
  641. CString str;
  642. TCHAR szText[REPORTCTRL_MAX_TEXT];
  644. if(GetItemText(iItem, iSubItem, szText, REPORTCTRL_MAX_TEXT))
  645. str = szText;
  647. return str;
  648. }
  650. BOOL CReportCtrl::SetItemText(INT iItem, INT iSubItem, LPTSTR lpszText)
  651. {
  652. RVITEM rvi;
  653. rvi.nMask = RVIM_TEXT;
  654. rvi.iItem = iItem;
  655. rvi.iSubItem = iSubItem;
  656. rvi.lpszText = lpszText;
  657. return SetItem(&rvi);
  658. }
  660. INT CReportCtrl::GetItemImage(INT iItem, INT iSubItem)
  661. {
  662. RVITEM rvi;
  663. rvi.nMask = RVIM_IMAGE;
  664. rvi.iItem = iItem;
  665. rvi.iSubItem = iSubItem;
  666. return GetItem(&rvi) ? rvi.iImage:-1;
  667. }
  669. BOOL CReportCtrl::SetItemImage(INT iItem, INT iSubItem, INT iImage)
  670. {
  671. RVITEM rvi;
  672. rvi.nMask = RVIM_IMAGE;
  673. rvi.iItem = iItem;
  674. rvi.iSubItem = iSubItem;
  675. rvi.iImage = iImage;
  676. return SetItem(&rvi);
  677. }
  679. INT CReportCtrl::GetItemCheck(INT iItem, INT iSubItem)
  680. {
  681. RVITEM rvi;
  682. rvi.nMask = RVIM_CHECK;
  683. rvi.iItem = iItem;
  684. rvi.iSubItem = iSubItem;
  685. return GetItem(&rvi) ? rvi.iCheck:-1;
  686. }
  688. BOOL CReportCtrl::SetItemCheck(INT iItem, INT iSubItem, INT iCheck)
  689. {
  690. RVITEM rvi;
  691. rvi.nMask = RVIM_CHECK;
  692. rvi.iItem = iItem;
  693. rvi.iSubItem = iSubItem;
  694. rvi.iCheck = iCheck;
  695. return SetItem(&rvi);
  696. }
  698. DWORD CReportCtrl::GetItemData(INT iItem)
  699. {
  700. RVITEM rvi;
  701. rvi.nMask = RVIM_LPARAM;
  702. rvi.iItem = iItem;
  703. return GetItem(&rvi) ? rvi.lParam:0;
  704. }
  706. BOOL CReportCtrl::SetItemData(INT iItem, DWORD dwData)
  707. {
  708. RVITEM rvi;
  709. rvi.nMask = RVIM_LPARAM;
  710. rvi.iItem = iItem;
  711. rvi.lParam = dwData;
  712. return SetItem(&rvi);
  713. }
  715. INT CReportCtrl::GetVisibleCount(BOOL bUnobstructed)
  716. {
  717. return GetVisibleRows(bUnobstructed);
  718. }
  720. INT CReportCtrl::GetItemCount()
  721. {
  722. return m_arrayItems.GetSize();
  723. }
  725. INT CReportCtrl::GetFirstSelectedItem()
  726. {
  727. return GetNextSelectedItem(-1);
  728. }
  730. INT CReportCtrl::GetNextSelectedItem(INT iItem)
  731. {
  732. RVITEM rvi;
  733. rvi.nMask = RVIM_STATE;
  735. INT iItems = m_arrayItems.GetSize();
  737. for(iItem++;rvi.iItem<iItems;rvi.iItem++)
  738. if(GetItem(&rvi) && rvi.nState&RVIS_SELECTED)
  739. return rvi.iItem;
  741. return -1;
  742. }
  744. BOOL CReportCtrl::SetImageList(CImageList* pImageList)
  745. {
  746. m_pImageList = pImageList;
  747. m_wndHeader.SetImageList(pImageList);
  749. IMAGEINFO info;
  750. if(pImageList->GetImageInfo(0, &info))
  751. {
  752. m_sizeImage.cx = info.rcImage.right - info.rcImage.left;
  753. m_sizeImage.cy = info.rcImage.bottom - info.rcImage.top;
  755. m_iDefaultHeight = m_sizeImage.cy>m_iDefaultHeight ? m_sizeImage.cy:m_iDefaultHeight;
  757. Invalidate();
  758. return TRUE;
  759. }
  760. else
  761. return FALSE;
  762. }
  764. CImageList* CReportCtrl::GetImageList(void)
  765. {
  766. return m_pImageList;
  767. }
  769. CFlatHeaderCtrl* CReportCtrl::GetHeaderCtrl()
  770. {
  771. return &m_wndHeader;
  772. }
  774. BOOL CReportCtrl::SetReportColumnListCtrl(CReportColumnListCtrl* lprclc)
  775. {
  776. if(m_lprclc != NULL)
  777. {
  778. m_wndHeader.ModifyProperty(FH_PROPERTY_DROPTARGET, NULL);
  779. m_lprclc->SetReportCtrl(NULL);
  780. }
  782. m_lprclc = lprclc;
  783. if(m_lprclc != NULL)
  784. {
  785. m_wndHeader.ModifyProperty(FH_PROPERTY_DROPTARGET, (LPARAM)m_lprclc->m_hWnd);
  786. m_lprclc->SetReportCtrl(this);
  787. }
  789. return TRUE;
  790. }
  792. CReportColumnListCtrl* CReportCtrl::GetReportColumnListCtrl()
  793. {
  794. return m_lprclc;
  795. }
  797. BOOL CReportCtrl::SetSortCallback(LPFNRVCOMPARE lpfnrvc)
  798. {
  799. m_lpfnrvc = lpfnrvc;
  800. return TRUE;
  801. }
  803. LPFNRVCOMPARE CReportCtrl::GetSortCallback()
  804. {
  805. return m_lpfnrvc;
  806. }
  808. BOOL CReportCtrl::WriteProfile(LPCTSTR lpszSection, LPCTSTR lpszEntry)
  809. {
  810. CString str, strProfile;
  812. INT i;
  813. INT iSubItems = m_arraySubItems.GetSize();
  814. INT iColumns = m_arrayColumns.GetSize();
  816. strProfile.Format(_T("(%d,%d)"), iSubItems, iColumns);
  818. for(i=0;i<iSubItems;i++)
  819. {
  820. str.Format(" %d", m_arraySubItems[i].iWidth);
  821. strProfile += str;
  822. }
  824. for(i=0;i<iColumns;i++)
  825. {
  826. HDITEM hdi;
  827. hdi.mask = HDI_LPARAM;
  828. m_wndHeader.GetItem(m_arrayColumns[i], &hdi);
  830. str.Format(" %d", hdi.lParam);
  831. strProfile += str;
  832. }
  835. CWinApp* pApp = AfxGetApp();
  836. return pApp->WriteProfileString(lpszSection, lpszEntry, strProfile);
  837. }
  839. BOOL CReportCtrl::GetProfile(LPCTSTR lpszSection, LPCTSTR lpszEntry)
  840. {
  841. CString str, strProfile;
  843. CWinApp* pApp = AfxGetApp();
  844. strProfile = pApp->GetProfileString(lpszSection, lpszEntry);
  845. if(strProfile.IsEmpty())
  846. return FALSE;
  848. LPTSTR lpsz = strProfile.GetBuffer(0);
  850. INT i;
  851. INT iSubItems;
  852. INT iColumns;
  854. iSubItems = _tcstol(++lpsz, &lpsz, 10);
  855. iColumns = _tcstol(++lpsz, &lpsz, 10);
  857. if(iSubItems != m_arraySubItems.GetSize())
  858. return FALSE;
  860. for(i=0;i<iSubItems;i++)
  861. m_arraySubItems[i].iWidth = _tcstol(++lpsz, &lpsz, 10);
  863. for(i=0;i<iColumns;i++)
  864. ActivateColumn(_tcstol(++lpsz, &lpsz, 10), i);
  866. return TRUE;
  867. }
  869. /////////////////////////////////////////////////////////////////////////////
  870. // CReportCtrl operations
  872. BOOL CReportCtrl::ModifyStyle(DWORD dwRemove, DWORD dwAdd, UINT nFlags)
  873. {
  874. DWORD dwStyle = GetStyle();
  876. if(CWnd::ModifyStyle(dwRemove, dwAdd, nFlags))
  877. {
  878. if(!(dwStyle&RVS_SHOWHGRID) && dwAdd&RVS_SHOWHGRID)
  879. m_iDefaultHeight++;
  881. if(dwStyle&RVS_SHOWHGRID && dwRemove&RVS_SHOWHGRID)
  882. m_iDefaultHeight--;
  884. CRect rect;
  885. GetClientRect(rect);
  886. Layout(rect.Width(), rect.Height());
  888. return TRUE;
  889. }
  891. return FALSE;
  892. }
  894. INT CReportCtrl::DefineColumn(INT iColumn, LPRVCOLUMN lprvc, BOOL bUpdateList)
  895. {
  896. INT i;
  897. INT iColumns = m_arraySubItems.GetSize();
  899. ASSERT(iColumn <= iColumns);
  900. ASSERT(lprvc->lpszText != NULL); // Must supply (descriptive) text for subitem selector
  901. ASSERT(_tcslen(lprvc->lpszText) < FLATHEADER_TEXT_MAX);
  903. try
  904. {
  905. SUBITEM subitem;
  907. subitem.nFormat = lprvc->nFormat;
  908. subitem.iWidth = lprvc->iWidth<0 ? m_iDefaultWidth:lprvc->iWidth;
  909. subitem.iMinWidth = lprvc->iMinWidth;
  910. subitem.iMaxWidth = lprvc->iMaxWidth;
  911. subitem.iImage = lprvc->nFormat&RVCF_IMAGE ? lprvc->iImage:0;
  912. subitem.strText = lprvc->lpszText;
  914. m_arraySubItems.InsertAt(iColumn, subitem);
  916. HDITEM hdi;
  917. hdi.mask = HDI_LPARAM;
  919. INT iHeaderItems = m_arrayColumns.GetSize();
  920. for(i=0;i<iHeaderItems;i++)
  921. if(m_wndHeader.GetItem(i, &hdi))
  922. if(hdi.lParam >= iColumn)
  923. {
  924. hdi.lParam++;
  925. m_wndHeader.SetItem(i, &hdi);
  926. }
  928. INT iItems = m_arrayItems.GetSize();
  929. for(i=0;i<iItems;i++)
  930. VERIFY(m_arrayItems[i].rdData.InsertSubItem(iColumn, -1, -1, -1, NULL));
  932. if(bUpdateList && m_lprclc != NULL)
  933. m_lprclc->UpdateList();
  935. return iColumn;
  936. }
  937. catch(CMemoryException* e)
  938. {
  939. e->Delete();
  940. return -1;
  941. }
  942. }
  944. BOOL CReportCtrl::UndefineColumn(INT iColumn)
  945. {
  946. ASSERT(iColumn<m_arraySubItems.GetSize());
  948. VERIFY(!DeactivateColumn(iColumn));
  949. m_arraySubItems.RemoveAt(iColumn);
  951. HDITEM hdi;
  952. hdi.mask = HDI_LPARAM;
  954. INT i;
  955. INT iHeaderItems = m_arrayColumns.GetSize();
  956. for(i=0;i<iHeaderItems;i++)
  957. if(m_wndHeader.GetItem(i, &hdi))
  958. if(hdi.lParam > iColumn)
  959. {
  960. hdi.lParam--;
  961. m_wndHeader.SetItem(i, &hdi);
  962. }
  964. INT iItems = m_arrayItems.GetSize();
  965. for(i=0;i<iItems;i++)
  966. VERIFY(m_arrayItems[i].rdData.DeleteSubItem(iColumn));
  968. if(m_lprclc != NULL)
  969. m_lprclc->UpdateList();
  971. return TRUE;
  972. }
  975. INT CReportCtrl::InsertItem(INT iItem, LPTSTR lpszText, INT iImage, INT iCheck, INT iTextColor)
  976. {
  977. RVITEM rvi;
  978. rvi.nMask = RVIM_TEXT;
  979. rvi.iItem = iItem;
  980. rvi.iSubItem = 0;
  981. rvi.lpszText = lpszText;
  983. rvi.iTextColor = iTextColor;
  984. rvi.iImage = iImage;
  985. rvi.iCheck = iCheck;
  987. if(iTextColor >= 0)
  988. rvi.nMask |= RVIM_TEXTCOLOR;
  990. if(iImage >= 0)
  991. rvi.nMask |= RVIM_IMAGE;
  993. if(iCheck >= 0)
  994. rvi.nMask |= RVIM_CHECK;
  996. return InsertItem(&rvi);
  997. }
  999. INT CReportCtrl::InsertItem(LPRVITEM lprvi)
  1000. {
  1001. ASSERT(lprvi->iItem <= m_arrayItems.GetSize());
  1002. ASSERT(lprvi->iSubItem < m_arraySubItems.GetSize());
  1004. BOOL bInserted = FALSE;
  1006. try
  1007. {
  1008. ITEM item;
  1009. item.rdData.New(m_arraySubItems.GetSize());
  1011. m_arrayItems.InsertAt(lprvi->iItem, item); bInserted = TRUE;
  1012. m_arrayRows.InsertAt(lprvi->iItem, INT_MIN);
  1014. INT iItems = m_arrayRows.GetSize();
  1015. for(INT i=0;i<iItems;i++)
  1016. if(m_arrayRows[i]>=lprvi->iItem)
  1017. m_arrayRows[i]++;
  1019. m_arrayRows[lprvi->iItem] = lprvi->iItem;
  1021. m_iVirtualHeight++;
  1023. VERIFY(SetItem(lprvi));
  1025. ScrollWindow(SB_VERT, GetScrollPos32(SB_VERT));
  1026. return lprvi->iItem;
  1027. }
  1028. catch(CMemoryException* e)
  1029. {
  1030. if(bInserted)
  1031. m_arrayItems.RemoveAt(lprvi->iItem);
  1033. e->Delete();
  1034. return -1;
  1035. }
  1036. }
  1038. BOOL CReportCtrl::DeleteItem(INT iItem)
  1039. {
  1040. m_arrayItems.RemoveAt(iItem);
  1042. INT iItems = m_arrayRows.GetSize();
  1043. for(INT i=0;i<iItems;i++)
  1044. if(m_arrayRows[i]>iItem)
  1045. m_arrayRows[i]--;
  1047. m_iVirtualHeight--;
  1049. iItems = m_arrayItems.GetSize();
  1050. INT iFirst = GetScrollPos32(SB_VERT), iLast;
  1051. GetVisibleRows(TRUE, &iFirst, &iLast);
  1053. if(iItem<=iFirst || iLast>=iItems-1)
  1054. GetVisibleRows(TRUE, &iFirst, &iLast, TRUE);
  1056. ScrollWindow(SB_VERT, iFirst);
  1057. return TRUE;
  1058. }
  1060. BOOL CReportCtrl::DeleteAllItems()
  1061. {
  1062. m_arrayItems.RemoveAll();
  1063. m_iVirtualHeight = 0;
  1065. ScrollWindow(SB_VERT, 0);
  1066. return TRUE;
  1067. }
  1069. void CReportCtrl::RedrawItems(INT iFirst, INT iLast)
  1070. {
  1071. // TODO: Optimize to redraw indivual rows
  1072. // taking into account that the row height
  1073. // may have changed. Redrawing everything
  1074. // will work as well :)
  1076. Invalidate();
  1077. }
  1079. BOOL CReportCtrl::EnsureVisible(INT iItem, BOOL bUnobstructed)
  1080. {
  1081. INT iFirst = GetScrollPos32(SB_VERT), iLast;
  1082. INT iRow = FindItem(iItem);
  1083. if(iRow < 0)
  1084. return FALSE;
  1086. GetVisibleRows(bUnobstructed, &iFirst, &iLast);
  1088. if(iRow<iFirst)
  1089. ScrollWindow(SB_VERT, iRow);
  1091. if(iRow>iLast)
  1092. {
  1093. iLast = iRow;
  1094. GetVisibleRows(bUnobstructed, &iFirst, &iLast, TRUE);
  1095. ScrollWindow(SB_VERT, iFirst);
  1096. }
  1098. return TRUE;
  1099. }
  1101. INT CReportCtrl::InsertColor(INT iIndex, COLORREF crColor)
  1102. {
  1103. if(m_arrayColors.GetSize() == REPORTCTRL_MAX_COLORS)
  1104. return -1;
  1106. try
  1107. {
  1108. m_arrayColors.InsertAt(iIndex, crColor);
  1109. if(CreatePalette())
  1110. return iIndex;
  1112. return -1;
  1113. }
  1114. catch(CMemoryException* e)
  1115. {
  1116. e->Delete();
  1117. return -1;
  1118. }
  1119. }
  1121. BOOL CReportCtrl::DeleteColor(INT iIndex)
  1122. {
  1123. if(iIndex >= m_arrayColors.GetSize())
  1124. return FALSE;
  1126. m_arrayColors.RemoveAt(iIndex);
  1127. CreatePalette();
  1129. return TRUE;
  1130. }
  1132. INT CReportCtrl::HitTest(LPRVHITTESTINFO lprvhti)
  1133. {
  1134. ASSERT(lprvhti);
  1136. lprvhti->nFlags = 0;
  1137. lprvhti->iItem = -1;
  1138. lprvhti->iSubItem = -1;
  1140. if(m_rectReport.PtInRect(lprvhti->point))
  1141. {
  1142. INT iHPos = GetScrollPos32(SB_HORZ);
  1143. INT iFirst = GetScrollPos32(SB_VERT), iLast;
  1145. if(GetVisibleRows(FALSE, &iFirst, &iLast))
  1146. {
  1147. ITEM item;
  1148. CRect rectItem(
  1149. m_rectReport.left-iHPos, m_rectReport.top, 
  1150. m_rectReport.left-iHPos+m_iVirtualWidth, m_rectReport.top
  1151. );
  1153. for(;iFirst<=iLast;iFirst++)
  1154. {
  1155. item = m_arrayItems[m_arrayRows[iFirst]];
  1156. rectItem.bottom += m_iDefaultHeight+item.nPreview;
  1158. if(rectItem.PtInRect(lprvhti->point))
  1159. break;
  1161. rectItem.top = rectItem.bottom;
  1162. }
  1164. if(iFirst<=iLast)
  1165. {
  1166. if(item.nPreview)
  1167. {
  1168. CRect rectPreview(rectItem);
  1169. rectPreview.top += m_iDefaultHeight;
  1171. if(rectPreview.PtInRect(lprvhti->point))
  1172. {
  1173. lprvhti->iItem = m_arrayRows[iFirst];
  1174. lprvhti->nFlags |= RVHT_ONITEMPREVIEW;
  1175. return lprvhti->iItem;
  1176. }
  1177. }
  1179. INT iHeaderItems = m_arrayColumns.GetSize();
  1181. HDITEM hdi;
  1182. hdi.mask = HDI_WIDTH|HDI_LPARAM;
  1184. rectItem.right = rectItem.left;
  1186. for(INT iHeaderItem=0;iHeaderItem<iHeaderItems;iHeaderItem++)
  1187. {
  1188. m_wndHeader.GetItem(m_arrayColumns[iHeaderItem], &hdi);
  1189. rectItem.right += hdi.cxy;
  1191. if(rectItem.PtInRect(lprvhti->point))
  1192. break;
  1194. rectItem.left = rectItem.right;
  1195. }
  1197. lprvhti->iSubItem = hdi.lParam;
  1199. if(iHeaderItem<iHeaderItems)
  1200. {
  1201. RVITEM rvi;
  1202. rvi.iItem = iFirst;
  1203. rvi.iSubItem = lprvhti->iSubItem;
  1204. GetItem(&rvi);
  1206. lprvhti->iItem = m_arrayRows[iFirst];
  1208. rectItem.right = rectItem.left+m_iSpacing;
  1209. if(rvi.nMask&RVIM_IMAGE)
  1210. {
  1211. rectItem.right += m_sizeImage.cx+m_iSpacing;
  1212. if(lprvhti->point.x < rectItem.right)
  1213. {
  1214. lprvhti->nFlags |= RVHT_ONITEMIMAGE;
  1215. return lprvhti->iItem;
  1216. }
  1217. }
  1219. if(rvi.nMask&RVIM_CHECK)
  1220. {
  1221. rectItem.right += m_sizeCheck.cx+m_iSpacing;
  1222. if(lprvhti->point.x < rectItem.right)
  1223. {
  1224. lprvhti->nFlags |= RVHT_ONITEMCHECK;
  1225. return lprvhti->iItem;
  1226. }
  1227. }
  1229. lprvhti->nFlags |= RVHT_ONITEMTEXT;
  1230. }
  1231. else
  1232. lprvhti->nFlags = RVHT_NOWHERE;
  1233. }
  1234. else
  1235. lprvhti->nFlags = RVHT_NOWHERE;
  1236. }
  1237. else
  1238. lprvhti->nFlags = RVHT_NOWHERE;
  1239. }
  1240. else
  1241. {
  1242. lprvhti->nFlags |= lprvhti->point.y<m_rectReport.top ? RVHT_ABOVE:0;
  1243. lprvhti->nFlags |= lprvhti->point.y>m_rectReport.bottom ? RVHT_BELOW:0;
  1244. lprvhti->nFlags |= lprvhti->point.x<m_rectReport.left ? RVHT_TOLEFT:0;
  1245. lprvhti->nFlags |= lprvhti->point.x>m_rectReport.right ? RVHT_TORIGHT:0;
  1246. }
  1248. return lprvhti->iItem;
  1249. }
  1251. BOOL CReportCtrl::SortItems(INT iColumn, BOOL bAscending)
  1252. {
  1253. INT iHeaderColumn = FindColumnInHeader(iColumn);
  1254. if(iHeaderColumn < 0)
  1255. return FALSE; // Can't sort on columns that are not active
  1257. INT iFocusItem = m_iFocusRow>=0 ? m_arrayRows[m_iFocusRow]:-1;
  1259. INT iRows = m_arrayRows.GetSize();
  1260. if(iRows>1)
  1261. {
  1262. for(INT i=0;i<iRows-1;i++)
  1263. {
  1264. for(INT j=i+1;j<iRows;j++)
  1265. {
  1266. INT iSort = CompareItems(iColumn, m_arrayRows[i], m_arrayRows[j]);
  1267. if((bAscending && iSort>0) ||
  1268.    (!bAscending && iSort<0))
  1269. {
  1270. INT iItem = m_arrayRows[i];
  1271. m_arrayRows[i] = m_arrayRows[j];
  1272. m_arrayRows[j] = iItem;
  1273. }  
  1274. }
  1275. }
  1276. }
  1278. m_wndHeader.SetSortColumn(m_arrayColumns[iHeaderColumn], bAscending);
  1280. if(iFocusItem>=0)
  1281. {
  1282. m_iFocusRow = FindItem(iFocusItem);
  1284. INT iFirst = m_iFocusRow, iLast;
  1285. GetVisibleRows(TRUE, &iFirst, &iLast);
  1286. GetVisibleRows(TRUE, &iFirst, &iLast, TRUE);
  1288. ScrollWindow(SB_VERT, iFirst);
  1289. }
  1291. Invalidate();
  1293. return TRUE;
  1294. }
  1296. INT CReportCtrl::CompareItems(INT iColumn, INT iItem1, INT iItem2)
  1297. {
  1298. if(m_lpfnrvc == NULL)
  1299. {
  1300. RVITEM rvi1, rvi2;
  1302. TCHAR szText1[REPORTCTRL_MAX_TEXT], szText2[REPORTCTRL_MAX_TEXT];
  1304. rvi1.nMask = RVIM_TEXT;
  1305. rvi1.iItem = iItem1;
  1306. rvi1.iSubItem = iColumn;
  1307. rvi1.lpszText = szText1;
  1308. rvi1.iTextMax = REPORTCTRL_MAX_TEXT;
  1309. VERIFY(GetItem(&rvi1));
  1311. rvi2.nMask = RVIM_TEXT;
  1312. rvi2.iItem = iItem2;
  1313. rvi2.iSubItem = iColumn;
  1314. rvi2.lpszText = szText2;
  1315. rvi2.iTextMax = REPORTCTRL_MAX_TEXT;
  1316. VERIFY(GetItem(&rvi2));
  1318. return _tcscmp(szText1, szText2);
  1319. }
  1320. else
  1321. return m_lpfnrvc(iColumn, iItem1, iItem2);
  1322. }
  1324. /////////////////////////////////////////////////////////////////////////////
  1325. // CReportCtrl implementation
  1327. void CReportCtrl::GetSysColors()
  1328. {
  1329. m_crBackground = GetSysColor(COLOR_WINDOW);
  1330. m_crBkSelected = GetSysColor(COLOR_HIGHLIGHT);
  1331. m_crBkSelectedNoFocus = GetSysColor(COLOR_BTNFACE);
  1332. m_crText = GetSysColor(COLOR_WINDOWTEXT);
  1333. m_crTextSelected = GetSysColor(COLOR_HIGHLIGHTTEXT);
  1334. m_crTextSelectedNoFocus = GetSysColor(COLOR_WINDOWTEXT);
  1335. m_crGrid = GetSysColor(COLOR_BTNFACE);
  1336. }
  1338. BOOL CReportCtrl::CreatePalette()
  1339. {
  1340. if(m_palette.m_hObject)
  1341. m_palette.DeleteObject();
  1343. INT iColors = m_arrayColors.GetSize();
  1344. if(iColors)
  1345. {
  1346. struct
  1347. {
  1348. LOGPALETTE    LogPalette;
  1349. PALETTEENTRY  PalEntry[REPORTCTRL_MAX_COLORS];
  1350. } pal;
  1352. LPLOGPALETTE lpLogPalette = (LOGPALETTE*) &pal;
  1353. lpLogPalette->palVersion    = 0x300;
  1354. lpLogPalette->palNumEntries = (WORD)iColors; 
  1356. for(INT i=0;i<iColors;i++)
  1357. {
  1358. lpLogPalette->palPalEntry[i].peRed   = GetRValue(m_arrayColors[i]);
  1359. lpLogPalette->palPalEntry[i].peGreen = GetGValue(m_arrayColors[i]);
  1360. lpLogPalette->palPalEntry[i].peBlue  = GetBValue(m_arrayColors[i]);
  1361. lpLogPalette->palPalEntry[i].peFlags = 0;
  1362. }
  1364. m_palette.CreatePalette(lpLogPalette);
  1365. return TRUE;
  1366. }
  1368. return FALSE;
  1369. }
  1371. BOOL CReportCtrl::Notify(UINT nCode, INT iItem, INT iSubItem, LPARAM lParam)
  1372. {
  1373. NMREPORTVIEW nmrv;
  1374. nmrv.hdr.hwndFrom = m_hWnd;
  1375. nmrv.hdr.idFrom = GetDlgCtrlID();
  1376. nmrv.hdr.code = nCode;
  1378. nmrv.iItem = iItem;
  1379. nmrv.iSubItem = iSubItem;
  1380. nmrv.lParam = lParam;
  1382. CWnd* pWnd = GetParent();
  1383. if(pWnd)
  1384. return pWnd->SendMessage(WM_NOTIFY, 0, (LPARAM)&nmrv);
  1386. return FALSE;
  1387. }
  1389. BOOL CReportCtrl::Notify(UINT nCode, UINT nKeys, LPRVHITTESTINFO lprvhti)
  1390. {
  1391. NMREPORTVIEW nmrv;
  1392. nmrv.hdr.hwndFrom = m_hWnd;
  1393. nmrv.hdr.idFrom = GetDlgCtrlID();
  1394. nmrv.hdr.code = nCode;
  1396. nmrv.nKeys = nKeys;
  1397. nmrv.point = lprvhti->point;
  1399. nmrv.nFlags = lprvhti->nFlags;
  1400. nmrv.iItem = lprvhti->iItem;
  1401. nmrv.iSubItem = lprvhti->iSubItem;
  1403. if(lprvhti->iItem >= 0)
  1404. nmrv.lParam = m_arrayItems[lprvhti->iItem].lParam;
  1406. CWnd* pWnd = GetParent();
  1407. if(pWnd)
  1408. return pWnd->SendMessage(WM_NOTIFY, 0, (LPARAM)&nmrv);
  1410. return FALSE;
  1411. }
  1413. void CReportCtrl::Layout(INT cx, INT cy)
  1414. {
  1415. HDLAYOUT hdl;
  1416. WINDOWPOS wpos;
  1418. hdl.prc = &m_rectReport;
  1419. hdl.pwpos = &wpos;
  1421. m_rectReport.SetRect(0, 0, cx, cy);
  1423. if(IsWindow(m_wndHeader.m_hWnd))
  1424. {
  1425. if(!(GetStyle()&RVS_NOHEADER))
  1426. {
  1427. VERIFY(m_wndHeader.SendMessage(HDM_LAYOUT, 0, (LPARAM)&hdl));
  1429. m_rectHeader.SetRect(wpos.x, wpos.y, wpos.x+wpos.cx, wpos.y+wpos.cy);
  1430. }
  1431. else
  1432. m_rectHeader.SetRect(0, 0, cx, 0);
  1434. ScrollWindow(SB_HORZ, GetScrollPos32(SB_HORZ));
  1435. ScrollWindow(SB_VERT, GetScrollPos32(SB_VERT));
  1436. }
  1437. }
  1439. INT CReportCtrl::FindItem(INT iItem)
  1440. {
  1441. INT iRows = m_arrayRows.GetSize();
  1442. for(INT iRow=0;iRow<iRows;iRow++)
  1443. if(m_arrayRows[iRow] == iItem)
  1444. return iRow;
  1446. return -1;
  1447. }
  1449. INT CReportCtrl::FindColumnInHeader(INT iColumn)
  1450. {
  1451. INT iColumns = m_arrayColumns.GetSize();
  1452. for(INT i=0;i<iColumns;i++)
  1453. {
  1454. HDITEM hdi;
  1455. hdi.mask = HDI_WIDTH|HDI_LPARAM;
  1456. m_wndHeader.GetItem(m_arrayColumns[i], &hdi);
  1457. if(hdi.lParam == iColumn)
  1458. return i;
  1459. }
  1461. return -1;
  1462. }
  1464. INT CReportCtrl::GetVisibleRows(BOOL bUnobstructed, LPINT lpiFirst, LPINT lpiLast, BOOL bReverse)
  1465. {
  1466. INT iHeight = m_rectReport.Height();
  1467. INT iRows = 0;
  1469. if(!bReverse)
  1470. {
  1471. INT iRow;
  1472. INT iMaxRows = m_arrayRows.GetSize();
  1474. if(lpiFirst)
  1475. iRow = *lpiFirst;
  1476. else
  1477. iRow = GetScrollPos32(SB_VERT);
  1479. for(;iRow<iMaxRows&&iHeight>0;iRow++,iRows++)
  1480. {
  1481. iHeight -= m_iDefaultHeight+m_arrayItems[m_arrayRows[iRow]].nPreview;
  1482. if(bUnobstructed && iHeight<=0)
  1483. break;
  1484. }
  1486. if(lpiLast)
  1487. *lpiLast = iRow-1;
  1488. }
  1489. else
  1490. {
  1491. ASSERT(lpiFirst);
  1492. ASSERT(lpiLast);
  1494. for(*lpiFirst=*lpiLast;*lpiFirst>=0&&iHeight>0;*lpiFirst-=1,iRows++)
  1495. {
  1496. iHeight -= m_iDefaultHeight+m_arrayItems[m_arrayRows[*lpiFirst]].nPreview;
  1497. if(bUnobstructed && iHeight<=0)
  1498. break;
  1499. }
  1501. *lpiFirst += 1;
  1502. }
  1504. return iRows;
  1505. }
  1507. void CReportCtrl::SelectRows(INT iFirst, INT iLast, BOOL bSelect, BOOL bKeepSelection, BOOL bInvert)
  1508. {
  1509. INT i;
  1511. if(GetStyle()&RVS_SINGLESELECT)
  1512. {
  1513. iLast = iFirst;
  1514. bKeepSelection = FALSE;
  1515. }
  1517. if(m_iFocusRow>=0 && iFirst!=m_iFocusRow)
  1518. {
  1519. m_arrayItems[m_arrayRows[m_iFocusRow]].nState &= ~RVIS_FOCUSED;
  1520. RedrawItems(m_iFocusRow);
  1521. }
  1523. m_iFocusRow = iFirst;
  1524. m_arrayItems[m_arrayRows[iFirst]].nState |= RVIS_FOCUSED;
  1526. if(iFirst > iLast)
  1527. {
  1528. iLast += iFirst;
  1529. iFirst = iLast - iFirst;
  1530. iLast -= iFirst;
  1531. }
  1533. if(bSelect)
  1534. {
  1535. for(i=iFirst;i<=iLast;i++)
  1536. {
  1537. INT iItem = m_arrayRows[i];
  1538. UINT nOldState, nNewState;
  1540. nOldState = nNewState = m_arrayItems[iItem].nState;
  1542. if(bInvert)
  1543. nNewState ^= RVIS_SELECTED;
  1544. else
  1545. nNewState |= RVIS_SELECTED;
  1547. if(nNewState != nOldState)
  1548. {
  1549. if(Notify(RVN_SELECTIONCHANGING, iItem))
  1550. continue;
  1552. m_arrayItems[iItem].nState = nNewState;
  1553. Notify(RVN_SELECTIONCHANGED, iItem);
  1554. }
  1555. }
  1557. RedrawItems(iFirst, iLast);
  1558. }
  1559. else
  1560. RedrawItems(iFirst);
  1563. if(!bKeepSelection && bSelect)
  1564. {
  1565. INT iRows = m_arrayRows.GetSize();
  1566. for(i=0;i<iRows;i++)
  1567. {
  1568. INT iItem = m_arrayRows[i];
  1569. UINT nOldState, nNewState;
  1571. nOldState = nNewState = m_arrayItems[iItem].nState;
  1573. if((i<iFirst || i>iLast) && nOldState&RVIS_SELECTED)
  1574. {
  1575. nNewState &= ~RVIS_SELECTED;
  1577. if(nNewState != nOldState)
  1578. {
  1579. if(Notify(RVN_SELECTIONCHANGING, iItem))
  1580. continue;
  1582. m_arrayItems[iItem].nState = nNewState;
  1583. Notify(RVN_SELECTIONCHANGED, iItem);
  1585. RedrawItems(i);
  1586. }
  1587. }
  1588. }
  1589. }
  1591. }
  1593. INT CReportCtrl::GetScrollPos32(INT iBar, BOOL bGetTrackPos)
  1594. {
  1595. SCROLLINFO si;
  1596. si.cbSize = sizeof(SCROLLINFO);
  1598. if(bGetTrackPos)
  1599. {
  1600. if(GetScrollInfo(iBar, &si, SIF_TRACKPOS))
  1601. return si.nTrackPos;
  1602. }
  1603. else 
  1604. {
  1605. if(GetScrollInfo(iBar, &si, SIF_POS))
  1606. return si.nPos;
  1607. }
  1609. return 0;
  1610. }
  1612. BOOL CReportCtrl::SetScrollPos32(INT iBar, INT iPos, BOOL bRedraw)
  1613. {
  1614.     SCROLLINFO si;
  1615.     si.cbSize = sizeof(SCROLLINFO);
  1616.     si.fMask  = SIF_POS;
  1617.     si.nPos   = iPos;
  1619.     return SetScrollInfo(iBar, &si, bRedraw);
  1620. }
  1622. void CReportCtrl::ScrollWindow(INT iBar, INT iPos)
  1623. {
  1624. if(m_rectReport.Width()<=0 || m_rectReport.Height()<=0)
  1625. return;
  1627. if(iBar == SB_HORZ)
  1628. {
  1629. SCROLLINFO si;
  1630. INT iWidth = m_rectReport.Width();
  1632. si.cbSize = sizeof(SCROLLINFO);
  1633. si.fMask  = SIF_PAGE|SIF_RANGE|SIF_POS;
  1634. si.nPage = iWidth;
  1635. si.nMin = 0;
  1636. si.nMax = iWidth<m_iVirtualWidth ? m_iVirtualWidth-1:0;
  1637. si.nPos = iPos;
  1638. SetScrollInfo(SB_HORZ, &si, TRUE);
  1640. INT x = GetScrollPos32(SB_HORZ);
  1641. INT cx = iWidth<m_iVirtualWidth ? m_iVirtualWidth:iWidth;
  1643. VERIFY(m_wndHeader.SetWindowPos(&wndTop, -x, m_rectHeader.top, cx, m_rectHeader.Height(), GetStyle()&RVS_NOHEADER ? SWP_HIDEWINDOW:SWP_SHOWWINDOW));
  1644. }
  1646. if(iBar == SB_VERT)
  1647. {
  1648. INT iItems = m_arrayItems.GetSize();
  1649. ASSERT(iPos >= 0 && iPos<=iItems);
  1651. INT iFirst = iPos, iLast;
  1652. GetVisibleRows(TRUE, &iFirst, &iLast);
  1654. SCROLLINFO si;
  1655. si.cbSize = sizeof(SCROLLINFO);
  1656. si.fMask  = SIF_PAGE|SIF_RANGE|SIF_POS;
  1657. si.nPage = (iLast - iFirst + 1);
  1658. si.nMin = 0;
  1659. si.nMax = (iLast - iFirst + 1)<iItems ? iItems-1:0;
  1660. si.nPos = iFirst;
  1661. SetScrollInfo(SB_VERT, &si, TRUE);
  1662. }
  1664. Invalidate();
  1665. }
  1667. void CReportCtrl::DrawCtrl(CDC* pDC)
  1668. {
  1669. CRect rectClip;
  1670. if (pDC->GetClipBox(&rectClip) == ERROR)
  1671. return;
  1673. DWORD dwStyle = GetStyle();
  1675. INT iHPos = GetScrollPos32(SB_HORZ);
  1676. INT iVPos = GetScrollPos32(SB_VERT);
  1678. pDC->FillSolidRect(rectClip, m_crBackground);
  1680. CPen pen(m_iGridStyle, 1, m_crGrid);
  1681. CPen* pPen = pDC->SelectObject(&pen);
  1683. CFont* pFont = pDC->SelectObject(GetFont());
  1685. pDC->SetBkMode(TRANSPARENT);
  1687. CRect rectRow(m_rectReport.left-iHPos, m_rectReport.top, m_rectReport.left-iHPos+m_iVirtualWidth, m_rectReport.top);
  1688. CRect rectItem(rectRow);
  1690. TCHAR szText[REPORTCTRL_MAX_TEXT];
  1691. RVITEM rvi;
  1692. rvi.lpszText = szText;
  1693. rvi.iTextMax = REPORTCTRL_MAX_TEXT;
  1695. NMRVDRAWPREVIEW nmrvdp;
  1696. nmrvdp.hdr.hwndFrom = m_hWnd;
  1697. nmrvdp.hdr.idFrom = GetDlgCtrlID();
  1698. nmrvdp.hdr.code = RVN_ITEMDRAWPREVIEW;
  1699. nmrvdp.hDC = pDC->m_hDC;
  1701. CWnd* pwndParent = GetParent();
  1703. INT iRows = m_arrayRows.GetSize();
  1704. INT iColumns = m_wndHeader.GetItemCount();
  1706. ASSERT(iColumns>0); // Make sure that always one column is active
  1708. if(m_bColumnsReordered)
  1709. {
  1710. LPINT lpi;
  1712. m_arrayColumns.SetSize(iColumns, 8);
  1713. lpi = m_arrayColumns.GetData();
  1714. if(!m_wndHeader.GetOrderArray(lpi, iColumns))
  1715. return;
  1717. if(m_lprclc != NULL)
  1718. m_lprclc->UpdateList();
  1720. m_bColumnsReordered = FALSE;
  1721. }
  1723. if(!iRows)
  1724. {
  1725. rectRow.top += 2;
  1726. rectRow.bottom = rectRow.top + m_iDefaultHeight;
  1728. pDC->SetTextColor(m_crText);
  1729. pDC->DrawText(m_strNoItems, rectRow, DT_CENTER|DT_END_ELLIPSIS);
  1730. return;
  1731. }
  1733. INT iRow = iVPos;
  1734. while(iRow<iRows && rectRow.top<rectClip.bottom)
  1735. {
  1736. rvi.iItem = m_arrayRows[iRow];
  1737. ITEM& item = m_arrayItems[rvi.iItem];
  1739. rectRow.bottom = rectRow.top + m_iDefaultHeight+item.nPreview;
  1740. if(rectRow.bottom >= rectClip.top)
  1741. {
  1742. // You have to insert at least 1 color to use color alternate style.
  1743. ASSERT(!(dwStyle&RVS_SHOWCOLORALTERNATE && !m_arrayColors.GetSize()));
  1745. COLORREF crItem;
  1746. crItem = (dwStyle&RVS_SHOWCOLORALTERNATE && iRow&1) ? m_arrayColors[0]:m_crBackground;
  1747. crItem = item.iBkColor>=0 ? m_arrayColors[item.iBkColor]:crItem;
  1748. if(item.nState&RVIS_SELECTED)
  1749. {
  1750. if(m_bFocus)
  1751. crItem = m_crBkSelected;
  1752. else
  1753. if(dwStyle&RVS_SHOWSELALWAYS)
  1754. crItem = m_crBkSelectedNoFocus;
  1755. }
  1756. pDC->FillSolidRect(rectRow, crItem);
  1757. pDC->SetBkColor(crItem);
  1759. if(item.nState&RVIS_BOLD)
  1760. pDC->SelectObject(&m_fontBold);
  1762. rectItem.SetRect(rectRow.left, rectRow.top, rectRow.left, rectRow.top+m_iDefaultHeight);
  1763. for(INT iColumn=0;iColumn<iColumns&&rectItem.left<rectClip.right;iColumn++)
  1764. {
  1765. HDITEM hdi;
  1766. hdi.mask = HDI_WIDTH|HDI_LPARAM;
  1767. m_wndHeader.GetItem(m_arrayColumns[iColumn], &hdi);
  1769. rvi.iSubItem = hdi.lParam;
  1770. rectItem.right = rectItem.left + hdi.cxy;
  1771. if(rectItem.right > rectClip.left)
  1772. {
  1773. rvi.nMask = RVIM_TEXT;
  1774. VERIFY(GetItem(&rvi));
  1776. COLORREF crText = rvi.nMask&RVIM_TEXTCOLOR ? m_arrayColors[rvi.iTextColor]:m_crText;
  1777. if(item.nState&RVIS_SELECTED)
  1778. {
  1779. if(m_bFocus)
  1780. crText = (dwStyle&RVS_SHOWCOLORALWAYS && rvi.nMask&RVIM_TEXTCOLOR) ? crText:m_crTextSelected;
  1781. else
  1782. if(dwStyle&RVS_SHOWSELALWAYS)
  1783. crText = rvi.nMask&RVIM_TEXTCOLOR && dwStyle&RVS_SHOWCOLORALWAYS ? crText:m_crTextSelectedNoFocus;
  1784. }
  1785. pDC->SetTextColor(crText);
  1787. rectItem.DeflateRect(m_iSpacing, 0);
  1788. DrawItem(pDC, rectItem, &rvi);
  1789. rectItem.InflateRect(m_iSpacing, 0);
  1790. }
  1791. rectItem.left = rectItem.right;
  1792. }
  1794. if(item.nState&RVIS_BOLD)
  1795. pDC->SelectObject(GetFont());
  1797. if(rvi.nMask&RVIM_PREVIEW && item.nPreview && pwndParent)
  1798. {
  1799. nmrvdp.iItem = rvi.iItem;
  1800. nmrvdp.nState = item.nState;
  1801. nmrvdp.rect = rectRow;
  1802. nmrvdp.rect.top += m_iDefaultHeight;
  1803. nmrvdp.lParam = item.lParam;
  1805. pwndParent->SendMessage(WM_NOTIFY, 0, (LPARAM)&nmrvdp);
  1806. }
  1808. if(dwStyle&RVS_SHOWHGRID)
  1809. {
  1810. pDC->MoveTo(rectRow.left, rectRow.bottom-1);
  1811. pDC->LineTo(rectRow.right, rectRow.bottom-1);
  1812. }
  1814. if(m_bFocus && item.nState&RVIS_FOCUSED)
  1815. {
  1816. if(dwStyle&(RVS_SHOWHGRID|RVS_SHOWVGRID))
  1817. rectRow.DeflateRect(1, 0, 1, 1);
  1819. pDC->SetBkColor(m_crBackground);
  1820. pDC->SetTextColor(m_crText);
  1821. pDC->DrawFocusRect(rectRow);
  1823. if(dwStyle&(RVS_SHOWHGRID|RVS_SHOWVGRID))
  1824. rectRow.InflateRect(1, 0, 1, 1);
  1825. }
  1826. }
  1828. rectRow.top = rectRow.bottom;
  1829. iRow++;
  1830. }
  1832. if(dwStyle&(RVS_SHOWHGRID|RVS_SHOWVGRID))
  1833. {
  1834. pDC->MoveTo(rectRow.left, m_rectReport.top);
  1835. pDC->LineTo(rectRow.left, m_rectReport.bottom);
  1837. pDC->MoveTo(rectRow.right-1, m_rectReport.top);
  1838. pDC->LineTo(rectRow.right-1, m_rectReport.bottom);
  1839. }
  1841. if(dwStyle&RVS_SHOWHGRID && iRow>=iRows)
  1842. {
  1843. while(rectRow.bottom<rectClip.bottom)
  1844. {
  1845. pDC->MoveTo(rectRow.left, rectRow.bottom-1);
  1846. pDC->LineTo(rectRow.right, rectRow.bottom-1);
  1848. rectRow.bottom += m_iDefaultHeight;
  1849. }
  1850. }
  1852. if(dwStyle&RVS_SHOWVGRID)
  1853. {
  1854. for(INT iColumn=0;iColumn<iColumns&&rectItem.left<rectClip.right;iColumn++)
  1855. {
  1856. HDITEM hdi;
  1857. hdi.mask = HDI_WIDTH;
  1858. m_wndHeader.GetItem(m_arrayColumns[iColumn], &hdi);
  1860. rectRow.left += hdi.cxy;
  1862. pDC->MoveTo(rectRow.left-1, m_rectReport.top);
  1863. pDC->LineTo(rectRow.left-1, m_rectReport.bottom);
  1864. }
  1865. }
  1867. pDC->SelectObject(pFont);
  1868. pDC->SelectObject(pPen);
  1870. pen.DeleteObject();
  1871. }
  1873. void CReportCtrl::DrawItem(CDC* pDC, CRect rect, LPRVITEM lprvi)
  1874. {
  1875. INT iWidth = 0;
  1877. rect.left += (iWidth = DrawImage(pDC, rect, lprvi)) ? iWidth+m_iSpacing : 0;
  1878. if(lprvi->nMask&RVIM_IMAGE && !iWidth)
  1879. return;
  1880. rect.left += (iWidth = DrawCheck(pDC, rect, lprvi)) ? iWidth+m_iSpacing : 0;
  1881. if(lprvi->nMask&RVIM_CHECK && !iWidth)
  1882. return;
  1883. DrawText(pDC, rect, lprvi);
  1884. }
  1886. INT CReportCtrl::DrawImage(CDC* pDC, CRect rect, LPRVITEM lprvi)
  1887. {
  1888. CImageList* pImageList = GetImageList();
  1889. INT iWidth = 0;
  1891. if(lprvi->nMask&RVIM_IMAGE)
  1892. {
  1893. ASSERT(pImageList);
  1894. ASSERT(lprvi->iImage>=0 && lprvi->iImage<pImageList->GetImageCount());
  1896. if(rect.Width()>0)
  1897. {
  1898. POINT point;
  1900. point.y = rect.CenterPoint().y - (m_sizeImage.cy>>1);
  1901. point.x = rect.left;
  1903. SIZE size;
  1904. size.cx = rect.Width()<m_sizeImage.cx ? rect.Width():m_sizeImage.cx;
  1905. size.cy = m_sizeImage.cy;
  1906. pImageList->DrawIndirect(pDC, lprvi->iImage, point, size, CPoint(0, 0));
  1908. iWidth = m_sizeImage.cx;
  1909. }
  1910. }
  1911. else
  1912. iWidth = m_arraySubItems[lprvi->iSubItem].nFormat&RVCF_SUBITEM_IMAGE ? m_sizeImage.cx:0;
  1914. return iWidth;
  1915. }
  1917. INT CReportCtrl::DrawCheck(CDC* pDC, CRect rect, LPRVITEM lprvi)
  1918. {
  1919. INT iWidth = 0;
  1921. if(lprvi->nMask&RVIM_CHECK)
  1922. {
  1923. if(rect.Width()>m_sizeCheck.cx)
  1924. {
  1925. rect.top = rect.CenterPoint().y - (m_sizeCheck.cy>>1);
  1926. rect.left = rect.left;
  1927. rect.bottom = rect.top + m_sizeCheck.cx;
  1928. rect.right = rect.left + m_sizeCheck.cy;
  1930. pDC->FillSolidRect(rect, m_crBackground); // Fixes visual problem with bigger fonts
  1931. pDC->DrawFrameControl(
  1932. rect, 
  1933. DFC_BUTTON, 
  1934. DFCS_BUTTONCHECK|DFCS_FLAT|(lprvi->iCheck?DFCS_CHECKED:0)
  1935. );
  1937. iWidth = m_sizeCheck.cx;
  1938. }
  1939. }
  1940. else
  1941. iWidth = m_arraySubItems[lprvi->iSubItem].nFormat&RVCF_SUBITEM_CHECK ? m_sizeCheck.cx:0;
  1943. return iWidth;
  1944. }
  1946. INT CReportCtrl::DrawText(CDC* pDC, CRect rect, LPRVITEM lprvi)
  1947. {
  1948. CSize size;
  1950. if(rect.Width()>0 && lprvi->nMask&RVIM_TEXT)
  1951. {
  1952. size = pDC->GetTextExtent(lprvi->lpszText);
  1954. switch(m_arraySubItems[lprvi->iSubItem].nFormat&HDF_JUSTIFYMASK)
  1955. {
  1956. case HDF_LEFT:
  1957. case HDF_LEFT|HDF_RTLREADING:
  1958. pDC->DrawText(lprvi->lpszText, -1, rect, DT_LEFT|DT_END_ELLIPSIS|DT_SINGLELINE|DT_VCENTER);
  1959. break;
  1960. case HDF_CENTER:
  1961. case HDF_CENTER|HDF_RTLREADING:
  1962. pDC->DrawText(lprvi->lpszText, -1, rect, DT_CENTER|DT_END_ELLIPSIS|DT_SINGLELINE|DT_VCENTER);
  1963. break;
  1964. case HDF_RIGHT:
  1965. case HDF_RIGHT|HDF_RTLREADING:
  1966. pDC->DrawText(lprvi->lpszText, -1, rect, DT_RIGHT|DT_END_ELLIPSIS|DT_SINGLELINE|DT_VCENTER);
  1967. break;
  1968. }
  1969. }
  1971. size.cx = rect.Width()>size.cx ? size.cx:rect.Width();
  1972. return size.cx>0 ? size.cx:0;
  1973. }
  1975. /////////////////////////////////////////////////////////////////////////////
  1976. // CReportCtrl message handlers
  1978. BOOL CReportCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  1979. {
  1980. SetCursor(::LoadCursor(NULL, IDC_ARROW));
  1981. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  1982. }
  1984. void CReportCtrl::OnSetFocus(CWnd* pOldWnd) 
  1985. {
  1986. CWnd::OnSetFocus(pOldWnd);
  1988. m_bFocus = TRUE;
  1989. Invalidate();
  1990. }
  1992. void CReportCtrl::OnKillFocus(CWnd* pNewWnd) 
  1993. {
  1994. CWnd::OnKillFocus(pNewWnd);
  1996. m_bFocus = FALSE;
  1997. Invalidate();
  1998. }
  2000. void CReportCtrl::OnSysColorChange() 
  2001. {
  2002. CWnd::OnSysColorChange();
  2003. GetSysColors();
  2004. }
  2006. BOOL CReportCtrl::OnQueryNewPalette() 
  2007. {
  2008. Invalidate();
  2009. return CWnd::OnQueryNewPalette();
  2010. }
  2012. void CReportCtrl::OnPaletteChanged(CWnd* pFocusWnd) 
  2013. {
  2014. CWnd::OnPaletteChanged(pFocusWnd);
  2016. if(pFocusWnd->GetSafeHwnd() != GetSafeHwnd())
  2017. Invalidate();
  2018. }
  2020. void CReportCtrl::OnSize(UINT nType, int cx, int cy) 
  2021. {
  2022. CWnd::OnSize(nType, cx, cy);
  2024. CRect rect;
  2025. GetClientRect(rect);
  2027. Layout(rect.Width(), rect.Height());
  2028. }
  2030. LRESULT CReportCtrl::OnGetFont(WPARAM wParam, LPARAM lParam)
  2031. {
  2032.     return (LRESULT)m_font.m_hObject;
  2033. }
  2035. LRESULT CReportCtrl::OnSetFont(WPARAM wParam, LPARAM lParam)
  2036. {
  2037. LRESULT lResult = Default();
  2039. CFont *pFont = CFont::FromHandle((HFONT)wParam);
  2040. if(pFont)
  2041. {
  2042. LOGFONT lf;
  2043. pFont->GetLogFont(&lf);
  2045. m_font.DeleteObject();
  2046. m_font.CreateFontIndirect(&lf);
  2048. lf.lfWeight = FW_BOLD;
  2049. m_fontBold.DeleteObject();
  2050. m_fontBold.CreateFontIndirect(&lf);
  2051. }
  2053. CDC* pDC = GetDC();
  2054. if (pDC) 
  2055. {
  2056. CFont* pFont = pDC->SelectObject(&m_font);
  2057. TEXTMETRIC tm;
  2058. pDC->GetTextMetrics(&tm);
  2059. pDC->SelectObject(pFont);
  2060. ReleaseDC(pDC);
  2062. m_iDefaultHeight = tm.tmHeight + tm.tmExternalLeading + 2;
  2063. m_iDefaultHeight += GetStyle()&RVS_SHOWHGRID ? 1:0;
  2065. m_sizeCheck.cx = m_iDefaultHeight-2;
  2066. m_sizeCheck.cy = m_iDefaultHeight-2;
  2067. }
  2069. if(::IsWindow(GetSafeHwnd()) && lParam)
  2070. {
  2071. CRect rect;
  2072. GetClientRect(rect);
  2074. Layout(rect.Width(), rect.Height());
  2075. }
  2077. return lResult;
  2078. }
  2081. BOOL CReportCtrl::OnEraseBkgnd(CDC* pDC) 
  2082. {
  2083. return TRUE;
  2084. }
  2086. void CReportCtrl::OnPaint() 
  2087. {
  2088. CPaintDC dc(this);
  2090.     CPalette* pPalette = NULL;
  2091.     if(dc.GetDeviceCaps(RASTERCAPS) & RC_PALETTE)
  2092.     {
  2093.         pPalette = dc.SelectPalette(&m_palette, FALSE);
  2094.         dc.RealizePalette();
  2095.     }
  2097. dc.ExcludeClipRect(m_rectHeader);
  2099.     if(m_bDoubleBuffer)
  2100.     {
  2101.         CMemDC MemDC(&dc);
  2102.         DrawCtrl(&MemDC);
  2103.     }
  2104.     else
  2105.         DrawCtrl(&dc);
  2107.     if(pPalette && dc.GetDeviceCaps(RASTERCAPS) & RC_PALETTE)
  2108.         dc.SelectPalette(pPalette, FALSE);
  2109. }
  2111. void CReportCtrl::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  2112. {
  2113. INT iScrollPos = GetScrollPos32(SB_HORZ);
  2114. INT iScroll;
  2116. switch (nSBCode)
  2117. {
  2118. case SB_LINERIGHT:
  2119. iScroll = min(m_iVirtualWidth-(m_rectReport.Width()+iScrollPos), m_rectReport.Width()>>3);
  2120. ScrollWindow(SB_HORZ, iScrollPos + iScroll);
  2121. break;
  2123. case SB_LINELEFT:
  2124. iScroll = min(iScrollPos, m_rectReport.Width()>>3);
  2125. ScrollWindow(SB_HORZ, iScrollPos - iScroll);
  2126. break;
  2128. case SB_PAGERIGHT:
  2129. iScrollPos = min(m_iVirtualWidth, iScrollPos + m_rectReport.Width());
  2130. ScrollWindow(SB_HORZ, iScrollPos);
  2131. break;
  2133. case SB_PAGELEFT:
  2134. iScrollPos = max(0, iScrollPos - m_rectReport.Width());
  2135. ScrollWindow(SB_HORZ, iScrollPos);
  2136. break;
  2138. case SB_THUMBPOSITION:
  2139. case SB_THUMBTRACK:
  2140. iScrollPos = GetScrollPos32(SB_HORZ, TRUE);
  2141. ScrollWindow(SB_HORZ, iScrollPos);
  2142. break;
  2144. case SB_RIGHT:
  2145. ScrollWindow(SB_HORZ, m_iVirtualWidth);
  2146. break;
  2148. case SB_LEFT:
  2149. ScrollWindow(SB_HORZ, 0);
  2150. break;
  2152. default:
  2153. break;
  2154. }
  2155. }
  2157. void CReportCtrl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  2158. {
  2159. INT iFirst = GetScrollPos32(SB_VERT), iLast;
  2160. INT iItems = GetVisibleRows(TRUE, &iFirst, &iLast);
  2162. switch(nSBCode)
  2163. {
  2164. case SB_LINEUP:
  2165. if(iFirst>0)
  2166. iFirst--;
  2167. break;
  2169. case SB_LINEDOWN:
  2170. if(iFirst+iItems < m_iVirtualHeight)
  2171. iFirst++;
  2172. break;
  2174. case SB_PAGEUP:
  2175. GetVisibleRows(TRUE, &iLast, &iFirst, TRUE);
  2176. iFirst = iLast-1;
  2177. iFirst = iFirst<0 ? 0:iFirst;
  2178. break;
  2180. case SB_PAGEDOWN:
  2181. iFirst += iItems;
  2182. GetVisibleRows(TRUE, &iFirst, &iLast);
  2183. GetVisibleRows(TRUE, &iFirst, &iLast, TRUE);
  2184. break;
  2186. case SB_THUMBPOSITION:
  2187. case SB_THUMBTRACK:
  2188. iFirst = GetScrollPos32(SB_VERT, TRUE);
  2189. GetVisibleRows(TRUE, &iFirst, &iLast);
  2190. GetVisibleRows(TRUE, &iFirst, &iLast, TRUE);
  2191. break;
  2193. case SB_TOP:
  2194. iFirst = 0;
  2195. break;
  2197. case SB_BOTTOM:
  2198. iLast = m_arrayRows.GetSize()-1;
  2199. GetVisibleRows(TRUE, &iFirst, &iLast, TRUE);
  2200. break;
  2202. default:
  2203. return;
  2204. }
  2206. ScrollWindow(SB_VERT, iFirst);
  2207. }
  2209. void CReportCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  2210. {
  2211. SetFocus();
  2213. RVHITTESTINFO rvhti;
  2214. rvhti.point = point;
  2216. HitTest(&rvhti);
  2218. if(Notify(RVN_ITEMCLICK, nFlags, &rvhti))
  2219. {
  2220. CWnd::OnLButtonDown(nFlags, point);
  2221. return;
  2222. }
  2224. if(rvhti.iItem>=0)
  2225. {
  2226. INT iRow = FindItem(rvhti.iItem);
  2227. ASSERT(iRow >= 0);
  2229. switch(nFlags&(MK_CONTROL|MK_SHIFT))
  2230. {
  2231. case MK_CONTROL:
  2232. SelectRows(iRow, iRow, TRUE, TRUE, TRUE);
  2233. m_iSelectRow = iRow;
  2234. break;
  2236. case MK_SHIFT:
  2237. SelectRows(m_iSelectRow, iRow, TRUE);
  2238. break;
  2240. case MK_CONTROL|MK_SHIFT:
  2241. SelectRows(m_iSelectRow, iRow, TRUE, TRUE);
  2242. m_iSelectRow = iRow;
  2243. break;
  2245. default:
  2246. SelectRows(iRow, iRow, TRUE);
  2247. m_iSelectRow = iRow;
  2248. break;
  2249. }
  2250. }
  2251. }
  2253. void CReportCtrl::OnLButtonDblClk(UINT nFlags, CPoint point) 
  2254. {
  2255. RVHITTESTINFO rvhti;
  2256. rvhti.point = point;
  2258. HitTest(&rvhti);
  2260. if(Notify(RVN_ITEMDBCLICK, nFlags, &rvhti))
  2261. {
  2262. CWnd::OnLButtonDblClk(nFlags, point);
  2263. return;
  2264. }
  2265. }
  2267. UINT CReportCtrl::OnGetDlgCode() 
  2268. {
  2269. return DLGC_WANTARROWS;
  2270. }
  2272. #define IsShiftDown() ( (GetKeyState(VK_SHIFT) & (1 << (sizeof(SHORT)*8-1))) != 0   )
  2273. #define IsCtrlDown() ( (GetKeyState(VK_CONTROL) & (1 << (sizeof(SHORT)*8-1))) != 0 )
  2275. void CReportCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  2276. {
  2277. INT iFirst = GetScrollPos32(SB_VERT), iLast;
  2278. GetVisibleRows(TRUE, &iFirst, &iLast);
  2280.     switch (nChar)
  2281.     {
  2282. case VK_SPACE:
  2283. SelectRows(m_iFocusRow, m_iFocusRow, TRUE, TRUE);
  2284. return;
  2286. case VK_LEFT:
  2287. SendMessage(WM_HSCROLL, LOWORD(SB_LINELEFT), NULL);
  2288. return;
  2290. case VK_RIGHT:
  2291. SendMessage(WM_HSCROLL, LOWORD(SB_LINERIGHT), NULL);
  2292. return;
  2294. case VK_DOWN:
  2295. if(m_iFocusRow<m_iVirtualHeight-1)
  2296. {
  2297. if(IsCtrlDown())
  2298. {
  2299. SelectRows(m_iFocusRow+1, m_iFocusRow+1, FALSE);
  2300. m_iSelectRow = m_iFocusRow;
  2301. }
  2302. else if(!IsShiftDown())
  2303. {
  2304. SelectRows(m_iFocusRow+1, m_iFocusRow+1, TRUE);
  2305. m_iSelectRow = m_iFocusRow;
  2306. }
  2307. else
  2308. SelectRows(m_iFocusRow+1, m_iSelectRow, TRUE);
  2310. EnsureVisible(m_arrayRows[m_iFocusRow]);
  2311. }
  2312. return;
  2314. case VK_UP:
  2315. if(m_iFocusRow>0)
  2316. {
  2317. if(IsCtrlDown())
  2318. {
  2319. SelectRows(m_iFocusRow-1, m_iFocusRow-1, FALSE);
  2320. m_iSelectRow = m_iFocusRow;
  2321. }
  2322. else if(!IsShiftDown())
  2323. {
  2324. SelectRows(m_iFocusRow-1, m_iFocusRow-1, TRUE);
  2325. m_iSelectRow = m_iFocusRow;
  2326. }
  2327. else
  2328. SelectRows(m_iFocusRow-1, m_iSelectRow, TRUE);
  2330. EnsureVisible(m_arrayRows[m_iFocusRow]);
  2331. }
  2332. return;
  2334. case VK_NEXT:
  2335. if(m_iFocusRow == iLast)
  2336. {
  2337. SendMessage(WM_VSCROLL, SB_PAGEDOWN, 0);
  2339. iFirst = GetScrollPos32(SB_VERT);
  2340. GetVisibleRows(TRUE, &iFirst, &iLast);
  2341. }
  2343. if(!IsShiftDown())
  2344. {
  2345. iFirst = iLast;
  2346. m_iSelectRow = iLast;
  2347. }
  2348. else
  2349. iFirst = m_iSelectRow;
  2351. SelectRows(iLast, iFirst, TRUE);
  2352. return;
  2354. case VK_PRIOR:
  2355. if(m_iFocusRow == iFirst)
  2356. {
  2357. SendMessage(WM_VSCROLL, SB_PAGEUP, 0);
  2359. iFirst = GetScrollPos32(SB_VERT);
  2360. }
  2362. if(!IsShiftDown())
  2363. {
  2364. iLast = iFirst;
  2365. m_iSelectRow = iFirst;
  2366. }
  2367. else
  2368. iLast = m_iSelectRow;
  2370. SelectRows(iFirst, iLast, TRUE);
  2371. return;
  2373. case VK_HOME:
  2374. if(m_iFocusRow>0)
  2375. {
  2376. SendMessage(WM_VSCROLL, SB_TOP, 0);
  2378. if(!IsShiftDown())
  2379. m_iSelectRow = 0;
  2381. SelectRows(0, m_iSelectRow, TRUE);
  2382. }
  2383. break;
  2385. case VK_END:
  2386. if(m_iFocusRow<m_iVirtualHeight)
  2387. {
  2388. SendMessage(WM_VSCROLL, SB_BOTTOM, 0);
  2390. if(!IsShiftDown())
  2391. m_iSelectRow = m_iVirtualHeight-1;
  2393. SelectRows(m_iSelectRow, m_iVirtualHeight-1, TRUE);
  2394. }
  2395. break;
  2396. }
  2398. CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  2399. }
  2401. void CReportCtrl::OnHdnItemChanged(NMHDR* pNMHDR, LRESULT* pResult) 
  2402. {
  2403. LPHDITEM lphdi = (LPHDITEM)((LPNMHEADER)pNMHDR)->pitem;
  2405. HDITEM hdi;
  2406. hdi.mask = HDI_WIDTH|HDI_LPARAM;
  2407. m_wndHeader.GetItem(((LPNMHEADER)pNMHDR)->iItem, &hdi);
  2409. if(lphdi->mask&HDI_FORMAT)
  2410. m_arraySubItems[hdi.lParam].nFormat = lphdi->fmt&HDF_JUSTIFYMASK;
  2412. if(lphdi->mask&HDI_WIDTH)
  2413. {
  2414. m_iVirtualWidth += lphdi->cxy - m_arraySubItems[hdi.lParam].iWidth;
  2415. ASSERT(m_iVirtualWidth >= 0);
  2417. m_arraySubItems[hdi.lParam].iWidth = lphdi->cxy;
  2418. }
  2420. ScrollWindow(SB_HORZ, GetScrollPos32(SB_HORZ));
  2422. *pResult = FALSE;
  2423. }
  2425. void CReportCtrl::OnHdnItemClick(NMHDR* pNMHDR, LRESULT* pResult) 
  2426. {
  2427. LPHDITEM lphdi = (LPHDITEM)((LPNMHEADER)pNMHDR)->pitem;
  2429. HDITEM hdi;
  2430. hdi.mask = HDI_ORDER|HDI_LPARAM;
  2431. m_wndHeader.GetItem(((LPNMHEADER)pNMHDR)->iItem, &hdi);
  2433. if(!Notify(RVN_COLUMNCLICK, -1, (INT)hdi.lParam))
  2434. {
  2435. if(!(GetStyle()&RVS_NOSORT))
  2436. {
  2437. BOOL bAscending;
  2438. if(((LPNMHEADER)pNMHDR)->iItem == m_wndHeader.GetSortColumn(&bAscending))
  2439. bAscending = !bAscending;
  2440. else
  2441. bAscending = TRUE;
  2443. VERIFY(SortItems((INT)hdi.lParam, bAscending));
  2444. }
  2445. }
  2447. pResult = FALSE;
  2448. }
  2450. void CReportCtrl::OnHdnEndDrag(NMHDR* pNMHDR, LRESULT* pResult) 
  2451. {
  2452. LPNMHEADER lpnmhdr = (LPNMHEADER)pNMHDR;
  2454. if(m_wndHeader.GetDropResult())
  2455. {
  2456. if(GetStyle()&RVS_ALLOWCOLUMNREMOVAL && m_arrayColumns.GetSize()>1)
  2457. DeactivateColumn(lpnmhdr->pitem->lParam);
  2459. *pResult = TRUE;
  2460. }
  2461. else
  2462. {
  2463. m_bColumnsReordered = TRUE;
  2464. Invalidate();
  2466. *pResult = FALSE;
  2467. }
  2468. }
  2470. /////////////////////////////////////////////////////////////////////////////
  2471. // CReportColumnListCtrl
  2473. CReportColumnListCtrl::CReportColumnListCtrl()
  2474. {
  2475. m_pReportCtrl = NULL;
  2477. m_iColumn = -1;
  2478. m_pDragWnd = NULL;
  2479. }
  2481. CReportColumnListCtrl::~CReportColumnListCtrl()
  2482. {
  2483. }
  2486. BEGIN_MESSAGE_MAP(CReportColumnListCtrl, CDragListBox)
  2487. //{{AFX_MSG_MAP(CReportColumnListCtrl)
  2488. //}}AFX_MSG_MAP
  2489. END_MESSAGE_MAP()
  2491. /////////////////////////////////////////////////////////////////////////////
  2492. // CReportColumnListCtrl attributes
  2494. BOOL CReportColumnListCtrl::SetReportCtrl(CReportCtrl* pReportCtrl)
  2495. {
  2496. m_pReportCtrl = pReportCtrl;
  2497. ResetContent();
  2499. return TRUE;
  2500. }
  2502. CReportCtrl* CReportColumnListCtrl::GetReportCtrl()
  2503. {
  2504. return m_pReportCtrl;
  2505. }
  2507. /////////////////////////////////////////////////////////////////////////////
  2508. // CReportColumnListCtrl operations
  2510. BOOL CReportColumnListCtrl::UpdateList()
  2511. {
  2512. INT iColumn, iColumns = m_pReportCtrl->m_arraySubItems.GetSize();
  2514. ResetContent();
  2516. for(iColumn=0;iColumn<iColumns;iColumn++)
  2517. {
  2518. if(!m_pReportCtrl->IsActiveColumn(iColumn) && Include(iColumn))
  2519. {
  2520. INT iItem = AddString(m_pReportCtrl->m_arraySubItems[iColumn].strText);
  2521. SetItemData(iItem, iColumn);
  2522. }
  2523. }
  2525. return TRUE;
  2526. }
  2528. BOOL CReportColumnListCtrl::Include(INT iColumn)
  2529. {
  2530. return TRUE;
  2531. }
  2533. /////////////////////////////////////////////////////////////////////////////
  2534. // CReportColumnListCtrl message handlers
  2536. void CReportColumnListCtrl::PreSubclassWindow() 
  2537. {
  2538. CDragListBox::PreSubclassWindow();
  2540. SetItemHeight(0, GetItemHeight(0)+2);
  2541. }
  2543. void CReportColumnListCtrl::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
  2544. {
  2545. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  2547. CRect rcItem(lpDrawItemStruct->rcItem);
  2549. if(GetCount() > 0)
  2550. {
  2551. pDC->DrawFrameControl(rcItem, DFC_BUTTON, DFCS_BUTTONPUSH);
  2553. rcItem.DeflateRect(2, 2);
  2554. if(lpDrawItemStruct->itemState&ODS_SELECTED)
  2555. {
  2556. pDC->FillRect(rcItem, &CBrush(::GetSysColor(COLOR_3DSHADOW)));
  2557. pDC->SetTextColor(::GetSysColor(COLOR_3DHILIGHT));
  2558. }
  2559. else
  2560. pDC->SetTextColor(::GetSysColor(COLOR_BTNTEXT));
  2562. pDC->SetBkMode(TRANSPARENT);
  2564. pDC->DrawText(
  2565. m_pReportCtrl->m_arraySubItems[lpDrawItemStruct->itemData].strText,
  2566. -1,
  2567. rcItem,
  2568. DT_SINGLELINE|DT_NOPREFIX|DT_NOCLIP|DT_VCENTER|DT_END_ELLIPSIS|DT_LEFT);
  2569. }
  2570. else
  2571. pDC->FillSolidRect(rcItem, ::GetSysColor(COLOR_WINDOW));
  2572. }
  2574. BOOL CReportColumnListCtrl::BeginDrag(CPoint pt)
  2575. {
  2576. if(GetCount() <= 0)
  2577. return FALSE;
  2579. BOOL bAutoScroll = FALSE;
  2580. INT iItem = ItemFromPt(pt);
  2581. if(iItem >= 0)
  2582. {
  2583. GetClientRect(m_rcDragWnd);
  2584. m_rcDragWnd.bottom = m_rcDragWnd.top + GetItemHeight(0);
  2586. m_iColumn = GetItemData(iItem);
  2588. _tcscpy(m_szColumnText, m_pReportCtrl->m_arraySubItems[m_iColumn].strText);
  2590. m_hdiColumn.mask = HDI_WIDTH|HDI_TEXT|HDI_FORMAT;
  2591. m_hdiColumn.cxy = m_rcDragWnd.Width();
  2592. m_hdiColumn.pszText = m_szColumnText;
  2593. m_hdiColumn.cchTextMax = sizeof(m_szColumnText);
  2594. m_hdiColumn.fmt = HDF_STRING|HDF_LEFT;
  2596. m_pDragWnd = new CFHDragWnd;
  2597. if(m_pDragWnd)
  2598. m_pDragWnd->Create(m_rcDragWnd, &m_pReportCtrl->m_wndHeader, -2, &m_hdiColumn);
  2600. GetWindowRect(m_rcDropTarget1);
  2601. m_pReportCtrl->m_wndHeader.GetWindowRect(m_rcDropTarget2);
  2602. }
  2604. m_iDropIndex = -1;
  2606. return TRUE;
  2607. }
  2609. UINT CReportColumnListCtrl::Dragging(CPoint pt)
  2610. {
  2611. CPoint point = pt;
  2612. point.Offset(-(m_rcDragWnd.Width()>>1), -(m_rcDragWnd.Height()>>1));
  2614. if(m_pDragWnd != NULL)
  2615. m_pDragWnd->SetWindowPos(
  2616. &wndTop, 
  2617. point.x, point.y,
  2618.   0, 0, SWP_NOSIZE|SWP_SHOWWINDOW|SWP_NOACTIVATE
  2619. );
  2621. if(m_rcDropTarget1.PtInRect(pt))
  2622. return DL_MOVECURSOR;
  2624. m_iDropIndex = m_pReportCtrl->m_wndHeader.SendMessage(HDM_SETHOTDIVIDER, TRUE, MAKELONG(pt.x, pt.y));
  2626. if(m_rcDropTarget2.PtInRect(pt))
  2627. return DL_MOVECURSOR;
  2629. return DL_STOPCURSOR;
  2630. }
  2632. void CReportColumnListCtrl::CancelDrag(CPoint pt)
  2633. {
  2634. m_pReportCtrl->m_wndHeader.SendMessage(HDM_SETHOTDIVIDER, FALSE, -1);
  2636. if(m_pDragWnd != NULL)
  2637. {
  2638. m_pDragWnd->DestroyWindow();
  2639. m_pDragWnd = NULL;
  2640. }
  2641. }
  2643. void CReportColumnListCtrl::Dropped(INT iSrcIndex, CPoint pt)
  2644. {
  2645. m_pReportCtrl->m_wndHeader.SendMessage(HDM_SETHOTDIVIDER, FALSE, -1);
  2647. if(m_pDragWnd != NULL)
  2648. {
  2649. m_pDragWnd->DestroyWindow();
  2650. m_pDragWnd = NULL;
  2651. }
  2653. if(m_iDropIndex >= 0)
  2654. m_pReportCtrl->ActivateColumn(m_iColumn, m_iDropIndex);
  2655. }