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

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

ListView/ListBox

开发平台：

Visual C++

QListCtrlCtl.cpp：源码内容
  1. /************************************
  2.   REVISION LOG ENTRY
  3.   Revision By: Mihai Filimon
  4.   Revised on 11/2/98 3:29:27 PM
  5.   Comments: QListCtrlCtl.cpp : Implementation of the CQListCtrlCtrl ActiveX Control class.
  6.  ************************************/
  8. #include "stdafx.h"
  9. #include "QListCtrl.h"
  10. #include "QListCtrlCtl.h"
  11. #include "QListCtrlPpg.h"
  14. #ifdef _DEBUG
  15. #define new DEBUG_NEW
  16. #undef THIS_FILE
  17. static char THIS_FILE[] = __FILE__;
  18. #endif
  20. IMPLEMENT_DYNCREATE(CQListCtrlCtrl, COleControl)
  23. /////////////////////////////////////////////////////////////////////////////
  24. // Message map
  26. BEGIN_MESSAGE_MAP(CQListCtrlCtrl, COleControl)
  27. //{{AFX_MSG_MAP(CQListCtrlCtrl)
  28. ON_WM_CREATE()
  29. ON_WM_DRAWITEM_REFLECT()
  30. ON_WM_MEASUREITEM_REFLECT()
  31. ON_WM_SIZE()
  32. ON_WM_DESTROY()
  33. ON_WM_NCCALCSIZE()
  34. ON_WM_SHOWWINDOW()
  35. ON_WM_VSCROLL()
  36. ON_WM_KEYDOWN()
  37. //}}AFX_MSG_MAP
  38. ON_MESSAGE(OCM_COMMAND, OnOcmCommand)
  39. ON_OLEVERB(AFX_IDS_VERB_PROPERTIES, OnProperties)
  40. END_MESSAGE_MAP()
  43. /////////////////////////////////////////////////////////////////////////////
  44. // Dispatch map
  46. BEGIN_DISPATCH_MAP(CQListCtrlCtrl, COleControl)
  47. //{{AFX_DISPATCH_MAP(CQListCtrlCtrl)
  48. DISP_PROPERTY_NOTIFY(CQListCtrlCtrl, "ItemHeight", m_nItemHeight, OnItemHeightChanged, VT_I4)
  49. DISP_PROPERTY_NOTIFY(CQListCtrlCtrl, "GridLines", m_bGridLines, OnGridLinesChanged, VT_BOOL)
  50. DISP_PROPERTY_NOTIFY(CQListCtrlCtrl, "Header", m_sHeader, OnHeaderChanged, VT_BSTR)
  51. DISP_PROPERTY_NOTIFY(CQListCtrlCtrl, "MultiSelect", m_bMultiSelect, OnMultiSelectChanged, VT_BOOL)
  52. DISP_PROPERTY_NOTIFY(CQListCtrlCtrl, "NoHeader", m_bNoHeader, OnNoHeaderChanged, VT_BOOL)
  53. DISP_PROPERTY_NOTIFY(CQListCtrlCtrl, "SColumn", m_bSColumn, OnSColumnChanged, VT_BOOL)
  54. DISP_FUNCTION(CQListCtrlCtrl, "InitItemsCount", InitItemsCount, VT_EMPTY, VTS_NONE)
  55. DISP_STOCKPROP_FONT()
  56. //}}AFX_DISPATCH_MAP
  57. DISP_FUNCTION_ID(CQListCtrlCtrl, "AboutBox", DISPID_ABOUTBOX, AboutBox, VT_EMPTY, VTS_NONE)
  58. END_DISPATCH_MAP()
  61. /////////////////////////////////////////////////////////////////////////////
  62. // Event map
  64. BEGIN_EVENT_MAP(CQListCtrlCtrl, COleControl)
  65. //{{AFX_EVENT_MAP(CQListCtrlCtrl)
  66. EVENT_CUSTOM("ItemsCount", FireItemsCount, VTS_PI4)
  67. EVENT_CUSTOM("AllItemsLoaded", FireAllItemsLoaded, VTS_NONE)
  68. EVENT_CUSTOM("LoadLabel", FireLoadLabel, VTS_I4  VTS_PBSTR  VTS_PI4)
  69. EVENT_CUSTOM("LoadSubItem", FireLoadSubItem, VTS_I4  VTS_I4  VTS_PBSTR)
  70. //}}AFX_EVENT_MAP
  71. END_EVENT_MAP()
  74. /////////////////////////////////////////////////////////////////////////////
  75. // Property pages
  77. // TODO: Add more property pages as needed.  Remember to increase the count!
  78. BEGIN_PROPPAGEIDS(CQListCtrlCtrl, 2)
  79. PROPPAGEID(CQListCtrlPropPage::guid)
  80. PROPPAGEID(CLSID_CFontPropPage )
  81. END_PROPPAGEIDS(CQListCtrlCtrl)
  84. /////////////////////////////////////////////////////////////////////////////
  85. // Initialize class factory and guid
  87. IMPLEMENT_OLECREATE_EX(CQListCtrlCtrl, "QLISTCTRL.QListCtrlCtrl.1",
  88. 0xbfcc1bc6, 0x7257, 0x11d2, 0x86, 0xe6, 0, 0x40, 0x5, 0x5c, 0x8, 0xd9)
  91. /////////////////////////////////////////////////////////////////////////////
  92. // Type library ID and version
  94. IMPLEMENT_OLETYPELIB(CQListCtrlCtrl, _tlid, _wVerMajor, _wVerMinor)
  97. /////////////////////////////////////////////////////////////////////////////
  98. // Interface IDs
  100. const IID BASED_CODE IID_DQListCtrl =
  101. { 0xbfcc1bc4, 0x7257, 0x11d2, { 0x86, 0xe6, 0, 0x40, 0x5, 0x5c, 0x8, 0xd9 } };
  102. const IID BASED_CODE IID_DQListCtrlEvents =
  103. { 0xbfcc1bc5, 0x7257, 0x11d2, { 0x86, 0xe6, 0, 0x40, 0x5, 0x5c, 0x8, 0xd9 } };
  106. /////////////////////////////////////////////////////////////////////////////
  107. // Control type information
  109. static const DWORD BASED_CODE _dwQListCtrlOleMisc =
  110. OLEMISC_ACTIVATEWHENVISIBLE |
  111. OLEMISC_SETCLIENTSITEFIRST |
  112. OLEMISC_INSIDEOUT |
  113. OLEMISC_CANTLINKINSIDE |
  114. OLEMISC_RECOMPOSEONRESIZE;
  116. IMPLEMENT_OLECTLTYPE(CQListCtrlCtrl, IDS_QLISTCTRL, _dwQListCtrlOleMisc)
  119. /////////////////////////////////////////////////////////////////////////////
  120. // CQListCtrlCtrl::CQListCtrlCtrlFactory::UpdateRegistry -
  121. // Adds or removes system registry entries for CQListCtrlCtrl
  123. // Function name : CQListCtrlCtrl::CQListCtrlCtrlFactory::UpdateRegistry
  124. // Description     : Update the registry
  125. // Return type : BOOL 
  126. // Argument         : BOOL bRegister
  127. BOOL CQListCtrlCtrl::CQListCtrlCtrlFactory::UpdateRegistry(BOOL bRegister)
  128. {
  129. // TODO: Verify that your control follows apartment-model threading rules.
  130. // Refer to MFC TechNote 64 for more information.
  131. // If your control does not conform to the apartment-model rules, then
  132. // you must modify the code below, changing the 6th parameter from
  133. // afxRegApartmentThreading to 0.
  135. if (bRegister)
  136. return AfxOleRegisterControlClass(
  137. AfxGetInstanceHandle(),
  138. m_clsid,
  139. m_lpszProgID,
  140. IDS_QLISTCTRL,
  141. IDB_QLISTCTRL,
  142. afxRegApartmentThreading,
  143. _dwQListCtrlOleMisc,
  144. _tlid,
  145. _wVerMajor,
  146. _wVerMinor);
  147. else
  148. return AfxOleUnregisterClass(m_clsid, m_lpszProgID);
  149. }
  152. /////////////////////////////////////////////////////////////////////////////
  153. // Licensing strings
  155. static const TCHAR BASED_CODE _szLicFileName[] = _T("QListCtrl.lic");
  157. static const WCHAR BASED_CODE _szLicString[] =
  158. L"Copyright (c) 1998 Filimon";
  161. /////////////////////////////////////////////////////////////////////////////
  162. // CQListCtrlCtrl::CQListCtrlCtrlFactory::VerifyUserLicense -
  163. // Checks for existence of a user license
  165. // Function name : CQListCtrlCtrl::CQListCtrlCtrlFactory::VerifyUserLicense
  166. // Description     : Verify license
  167. // Return type : BOOL 
  168. BOOL CQListCtrlCtrl::CQListCtrlCtrlFactory::VerifyUserLicense()
  169. {
  170. return AfxVerifyLicFile(AfxGetInstanceHandle(), _szLicFileName,
  171. _szLicString);
  172. }
  175. /////////////////////////////////////////////////////////////////////////////
  176. // CQListCtrlCtrl::CQListCtrlCtrlFactory::GetLicenseKey -
  177. // Returns a runtime licensing key
  179. BOOL CQListCtrlCtrl::CQListCtrlCtrlFactory::GetLicenseKey(DWORD dwReserved,
  180. BSTR FAR* pbstrKey)
  181. {
  182. if (pbstrKey == NULL)
  183. return FALSE;
  185. *pbstrKey = SysAllocString(_szLicString);
  186. return (*pbstrKey != NULL);
  187. }
  190. /////////////////////////////////////////////////////////////////////////////
  191. // CQListCtrlCtrl::CQListCtrlCtrl - Constructor
  193. // Function name : CQListCtrlCtrl::CQListCtrlCtrl
  194. // Description     : Default constructor
  195. // Return type : 
  196. CQListCtrlCtrl::CQListCtrlCtrl()
  197. {
  198. InitializeIIDs(&IID_DQListCtrl, &IID_DQListCtrlEvents);
  200. m_nItemsCount = -1;
  201. m_nCountLoading  = 0;
  202. m_QuickLoader.SetParent(this);
  203. m_fctLoadFunction = NULL;
  204. }
  207. /////////////////////////////////////////////////////////////////////////////
  208. // CQListCtrlCtrl::~CQListCtrlCtrl - Destructor
  210. // Function name : CQListCtrlCtrl::~CQListCtrlCtrl
  211. // Description     : 
  212. // Return type : 
  213. CQListCtrlCtrl::~CQListCtrlCtrl()
  214. {
  215. // TODO: Cleanup your control's instance data here.
  216. }
  218. // Function name : CQListCtrlCtrl::GetListCtrl
  219. // Description     : 
  220. // Return type : CListCtrl* 
  221. CListCtrl* CQListCtrlCtrl::GetListCtrl()
  222. {
  223. return (CListCtrl*)this;
  224. }
  227. /////////////////////////////////////////////////////////////////////////////
  228. // CQListCtrlCtrl::OnDraw - Drawing function
  230. void CQListCtrlCtrl::OnDraw(
  231. CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)
  232. {
  233. if (m_hWnd != NULL)
  234. {
  235. CRect rcClient;
  236. GetClientRect(&rcClient);
  238. if (rcClient.Size() != rcBounds.Size())
  239. {
  240. pdc->SetMapMode(MM_ANISOTROPIC);
  241. pdc->SetWindowExt(rcClient.right, rcClient.bottom);
  242. pdc->SetViewportExt(rcBounds.Size());
  243. }
  244. pdc->SetWindowOrg(0, 0);
  245. pdc->SetViewportOrg(rcBounds.left, rcBounds.top);
  247. ::CallWindowProc(*GetSuperWndProcAddr(), m_hWnd, WM_PRINT, (WPARAM)(pdc->m_hDC), (LPARAM)(PRF_ERASEBKGND | PRF_CLIENT | PRF_CHILDREN | PRF_NONCLIENT));
  248. }
  249. else
  250. {
  251. CFont* pFont = SelectStockFont(pdc);
  252. CString text;
  253. text.Format(_T("QListCtrl %i.%i Control"), _wVerMajor, _wVerMinor);
  254. pdc->DrawText(text, CRect(rcInvalid), DT_CENTER | DT_VCENTER | DT_SINGLELINE);
  255. pdc->SelectObject(pFont);
  256. }
  257. return;
  258. }
  261. /////////////////////////////////////////////////////////////////////////////
  262. // CQListCtrlCtrl::DoPropExchange - Persistence support
  264. // Function name : CQListCtrlCtrl::DoPropExchange
  265. // Description     : Save/Load the properties
  266. // Return type : void 
  267. // Argument         : CPropExchange* pPX
  268. void CQListCtrlCtrl::DoPropExchange(CPropExchange* pPX)
  269. {
  270. ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor));
  271. COleControl::DoPropExchange(pPX);
  272. PX_Long(pPX, _T("ItemHeight"), m_nItemHeight, defaultItemHeight);
  273. PX_Bool(pPX, _T("GridLines"), m_bGridLines, TRUE);
  274. PX_Bool(pPX, _T("MultiSelect"), m_bMultiSelect, TRUE);
  275. PX_String(pPX, _T("Header"), m_sHeader, _T(""));
  276. PX_Bool(pPX, _T("NoHeader"), m_bNoHeader, FALSE);
  277. PX_Bool(pPX, _T("SColumn"), m_bSColumn, FALSE);
  278. }
  280. /////////////////////////////////////////////////////////////////////////////
  281. // CQListCtrlCtrl::OnResetState - Reset control to default state
  283. // Function name : CQListCtrlCtrl::OnResetState
  284. // Description     : On default value
  285. // Return type : void 
  286. void CQListCtrlCtrl::OnResetState()
  287. {
  288. COleControl::OnResetState();  // Resets defaults found in DoPropExchange
  289. }
  292. /////////////////////////////////////////////////////////////////////////////
  293. // CQListCtrlCtrl::AboutBox - Display an "About" box to the user
  295. // Function name : CQListCtrlCtrl::AboutBox
  296. // Description     : do an about box
  297. // Return type : void 
  298. void CQListCtrlCtrl::AboutBox()
  299. {
  300. CDialog dlgAbout(IDD_ABOUTBOX_QLISTCTRL);
  301. // dlgAbout.DoModal();
  302. LV_COLUMN lColumn; lColumn.mask = LVCF_FMT;
  303. for (int j = 0; j < 32; j++)
  304. {
  305. int nItem = GetListCtrl()->InsertItem(0, RandomString());
  306. for (int i = 1; GetListCtrl()->GetColumn(i, &lColumn); i++)
  307. GetListCtrl()->SetItemText(nItem, i, RandomString());
  308. }
  309. }
  312. /////////////////////////////////////////////////////////////////////////////
  313. // CQListCtrlCtrl::PreCreateWindow - Modify parameters for CreateWindowEx
  315. // Function name : CQListCtrlCtrl::PreCreateWindow
  316. // Description     : Create OLEControl as SysListView32
  317. // Return type : BOOL 
  318. // Argument         : CREATESTRUCT& cs
  319. BOOL CQListCtrlCtrl::PreCreateWindow(CREATESTRUCT& cs)
  320. {
  321. cs.lpszClass = _T("SysListView32");
  322. cs.style |= defaultStyles | (m_bSColumn ? LVS_NOSORTHEADER : 0);
  323. return COleControl::PreCreateWindow(cs);
  324. }
  327. /////////////////////////////////////////////////////////////////////////////
  328. // CQListCtrlCtrl::IsSubclassedControl - This is a subclassed control
  330. // Function name : CQListCtrlCtrl::IsSubclassedControl
  331. // Description     : 
  332. // Return type : BOOL 
  333. BOOL CQListCtrlCtrl::IsSubclassedControl()
  334. {
  335. return TRUE;
  336. }
  339. /////////////////////////////////////////////////////////////////////////////
  340. // CQListCtrlCtrl::OnOcmCommand - Handle command messages
  342. LRESULT CQListCtrlCtrl::OnOcmCommand(WPARAM wParam, LPARAM lParam)
  343. {
  344. #ifdef _WIN32
  345. WORD wNotifyCode = HIWORD(wParam);
  346. #else
  347. WORD wNotifyCode = HIWORD(lParam);
  348. #endif
  350. return 0;
  351. }
  353. /////////////////////////////////////////////////////////////////////////////
  354. // CQListCtrlCtrl message handlers
  356. // Function name : CQListCtrlCtrl::OnInit
  357. // Description     : 
  358. // Return type : void 
  359. void CQListCtrlCtrl::OnInit()
  360. {
  361. OnGridLinesChanged();
  362. OnHeaderChanged();
  363. OnMultiSelectChanged();
  364. OnNoHeaderChanged();
  365. OnSColumnChanged();
  366. }
  368. // Function name : CQListCtrlCtrl::OnDestroy
  369. // Description     : On destroy we will uninstall hook procedure
  370. // Return type : void 
  371. void CQListCtrlCtrl::OnDestroy() 
  372. {
  373. COleControl::OnDestroy();
  374. }
  376. // Function name : CQListCtrlCtrl::OnCreate
  377. // Description     : Call to set opr not the grid lines of control
  378. // Return type : int 
  379. // Argument         : LPCREATESTRUCT lpCreateStruct
  380. int CQListCtrlCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  381. {
  382. if (COleControl::OnCreate(lpCreateStruct) == -1)
  383. return -1;
  385. ASSERT (GetStyle() & (LVS_REPORT | LVS_OWNERDRAWFIXED) );
  387. OnInit();
  389. return 0;
  390. }
  392. // Function name : CQListCtrlCtrl::MeasureItem
  393. // Description     : Measure the item
  394. // Return type : void 
  395. // Argument         : LPMEASUREITEMSTRUCT lpMeasureItemStruct
  396. void CQListCtrlCtrl::MeasureItem( LPMEASUREITEMSTRUCT lpMeasureItemStruct ) 
  397. {
  398. lpMeasureItemStruct->itemHeight = m_nItemHeight;
  399. }
  401. // Function name : CQListCtrlCtrl::FormatColumn
  402. // Description     : Return the draw format for iColumn
  403. // Return type : UINT 
  404. // Argument         : int iColumn
  405. UINT CQListCtrlCtrl::FormatColumn(int iColumn)
  406. {
  407. LV_COLUMN lColumn; lColumn.mask = LVCF_FMT;
  408. if (GetListCtrl()->GetColumn(iColumn, &lColumn))
  409. return lColumn.fmt & LVCFMT_JUSTIFYMASK;
  410. return 0;
  411. }
  413. #define formatDrawText DT_VCENTER | DT_SINGLELINE
  414. // Function name : CQListCtrlCtrl::DrawItem
  415. // Description     : Drawing an item
  416. // Return type : void 
  417. // Argument         : LPDRAWITEMSTRUCT lpDrawItemStruct
  418. void CQListCtrlCtrl::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
  419. {
  420. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  421. CListCtrl* pListCtrl = GetListCtrl();
  422. CRect rectDraw(lpDrawItemStruct->rcItem);
  423. CRect rectItem(rectDraw);
  424. int nItem = lpDrawItemStruct->itemID;
  425. CRect rectAll; pListCtrl->GetItemRect(nItem, rectAll, LVIR_BOUNDS);
  426. CRect rectLabel; pListCtrl->GetItemRect(nItem, rectLabel, LVIR_LABEL);
  427. BOOL bFocused = GetFocus() && (pListCtrl->GetItemState(nItem, LVIS_FOCUSED) == LVIS_FOCUSED);
  428. BOOL bSelected = pListCtrl->GetItemState(nItem, LVIS_SELECTED) == LVIS_SELECTED;
  429. LV_COLUMN lColumn; lColumn.mask = LVCF_WIDTH;
  430. rectItem.left += 2;
  431. pDC->SetTextColor(bSelected & bFocused ? RGB(255,255,255) : RGB(0,0,0));
  432. CBrush brush(bSelected ? (bFocused ? RGB(0,0,128) : RGB(192,192,192)) : RGB(255,255,255));
  433. pDC->FillRect(rectAll, &brush);
  435. // Select the item font
  436. CFont* pFont = SelectStockFont(pDC);
  437. for (int i = 0; pListCtrl->GetColumn(i, &lColumn); i++, rectItem.left += lColumn.cx + 2)
  438. {
  439. rectItem.right = rectItem.left + lColumn.cx - 2;
  440. pDC->DrawText(pListCtrl->GetItemText(nItem, i), rectItem, formatDrawText | FormatColumn(i));
  441. }
  442. pDC->SelectObject(pFont);
  443. pDC->SetTextColor(RGB(0,0,0));
  444. // Deselect the item font
  445. if (bFocused)
  446. {
  447. rectAll.InflateRect(0,-2);
  448. rectAll.bottom++;
  449. pDC->FrameRect(rectAll, &CBrush(RGB(0,0,0)));
  450. }
  451. }
  453. // Function name : CQListCtrlCtrl::OnItemHeightChanged
  454. // Description     : Set the item height
  455. // Return type : void 
  456. void CQListCtrlCtrl::OnItemHeightChanged() 
  457. {
  458. m_nItemHeight = abs(m_nItemHeight);
  459. m_nItemHeight = max(1,m_nItemHeight);
  460. ASSERT (m_nItemHeight > 0);
  461. SetModifiedFlag();
  462. }
  464. // Function name : CQListCtrlCtrl::OnGridLinesChanged
  465. // Description     : Set or not the grid lines
  466. // Return type : void 
  467. void CQListCtrlCtrl::OnGridLinesChanged() 
  468. {
  469. if (::IsWindow(GetSafeHwnd()))
  470. ListView_SetExtendedListViewStyle(m_hWnd, (m_bGridLines ? LVS_EX_GRIDLINES : 0) | LVS_EX_FULLROWSELECT );
  472. SetModifiedFlag();
  473. }
  475. // Function name : CQListCtrlCtrl::OnHeaderChanged
  476. // Description     : Set the new header
  477. // Return type : void 
  478. void CQListCtrlCtrl::OnHeaderChanged() 
  479. {
  480. Header(m_sHeader);
  482. SetModifiedFlag();
  483. }
  485. // Function name : CQListCtrlCtrl::OnMultiSelectChanged
  486. // Description     : Change the style case on m_bMultiSelect
  487. // Return type : void 
  488. void CQListCtrlCtrl::OnMultiSelectChanged() 
  489. {
  490. if (::IsWindow(GetSafeHwnd()))
  491. ModifyStyle(m_bMultiSelect ? LVS_SINGLESEL : 0, m_bMultiSelect ? 0 : LVS_SINGLESEL);
  493. SetModifiedFlag();
  494. }
  496. // Function name : CQListCtrlCtrl::ColumnFormatFromString
  497. // Description     : 
  498. // Return type : UINT 
  499. // Argument         : LCTSTR lpszFormat
  500. UINT CQListCtrlCtrl::ColumnFormatFromString(CString& sFormat)
  501. {
  502. if (sFormat.IsEmpty())
  503. return LVCFMT_LEFT;
  504. if (sFormat.CompareNoCase(CString(_T("Center")).Left(sFormat.GetLength())))
  505. return LVCFMT_CENTER;
  506. if (sFormat.CompareNoCase(CString(_T("Left")).Left(sFormat.GetLength())))
  507. return LVCFMT_LEFT;
  508. if (sFormat.CompareNoCase(CString(_T("Right")).Left(sFormat.GetLength())))
  509. return LVCFMT_RIGHT;
  510. return  LVCFMT_LEFT;
  511. }
  513. // Function name : CQListCtrlCtrl::Header
  514. // Description     : Set the header for control
  515. // Return type : void 
  516. // Argument         : LPCTSTR lpszHeader
  517. // The header is something like this. Column 1:Column 2:Column 3
  518. void CQListCtrlCtrl::Header(LPCTSTR lpszHeader)
  519. {
  520. CListCtrl* pListCtrl = GetListCtrl();
  521. if (::IsWindow(GetSafeHwnd()))
  522. {
  523. while (pListCtrl->DeleteColumn(0));
  524. CString sColumn; int i = 0;
  525. do {
  526. AfxExtractSubString(sColumn, lpszHeader,  i, _separatorColumnHeader);
  527. if (!sColumn.IsEmpty())
  528. {
  529. CString sName, sWidth, sJustify;
  530. AfxExtractSubString(sName, sColumn, 0, _separatorHeader);
  531. AfxExtractSubString(sWidth, sColumn, 1, _separatorHeader);
  532. AfxExtractSubString(sJustify, sColumn, 2, _separatorHeader);
  533. int nWidth = atoi(sWidth); nWidth = nWidth >= 0 ? nWidth : defaultColumnWidth;
  534. pListCtrl->InsertColumn(i, sName, ColumnFormatFromString(sJustify), nWidth);
  535. i++;
  536. }
  537. } while (!sColumn.IsEmpty());
  538. }
  539. }
  541. // Function name : CQListCtrlCtrl::OnSize
  542. // Description     : Change the size of control
  543. // Return type : void 
  544. // Argument         : UINT nType
  545. // Argument         : int cx
  546. // Argument         : int cy
  547. void CQListCtrlCtrl::OnSize(UINT nType, int cx, int cy) 
  548. {
  549. COleControl::OnSize(nType, cx, cy);
  551. Resize();
  553. }
  555. // Function name : CQListCtrlCtrl::GetVisibleCount
  556. // Description     : Return the number of visible items
  557. // Return type : int 
  558. int CQListCtrlCtrl::GetVisibleCount()
  559. {
  560. CRect rect; GetClientRect(rect);
  561. return rect.Height() / m_nItemHeight;
  562. }
  564. // Function name : CQListCtrlCtrl::Resize
  565. // Description     : Calculate the count of items loading. Is called after WM_SIZE occurs
  566. // Return type : void 
  567. void CQListCtrlCtrl::Resize()
  568. {
  569. if (::IsWindow(GetSafeHwnd()))
  570. {
  571. int nCountLoading = minCountLoading * int((GetVisibleCount() + minCountLoading) / minCountLoading);
  572. m_nCountLoading = max( m_nCountLoading, nCountLoading );
  573. OnItemsCountChanged();
  574. }
  575. }
  577. // Function name : CQListCtrlCtrl::OnItemsCountChanged
  578. // Description     : Control ask consumer to give number of items in the control. In this function
  579. // ww will calculate the vertical scroll bar
  580. // Return type : void 
  581. void CQListCtrlCtrl::OnItemsCountChanged()
  582. {
  583. int nVisible = GetVisibleCount();
  584. //If this control need vertical scroll bar, I will create one for this
  585. BOOL bCreated = ::IsWindow(m_sbVert.GetSafeHwnd());
  586. if ( m_nItemsCount >= nVisible)
  587. {
  588. CRect rect; GetClientRect(rect);
  589. rect.left = rect.right - GetSystemMetrics(SM_CXVSCROLL);
  590. if (CWnd* pHeader = GetDlgItem(0))
  591. if (pHeader->GetStyle() & WS_VISIBLE)
  592. {
  593. CRect r; pHeader->GetWindowRect(r);
  594. rect.top += r.Height();
  595. }
  596. if (!bCreated)
  597. bCreated = m_sbVert.Create( WS_CHILD | WS_VISIBLE | SBS_VERT, rect , this , IDSBVERT);
  598. else
  599. m_sbVert.MoveWindow(rect.left,rect.top, rect.Width(), rect.Height());
  600. if (bCreated)
  601. {
  602. SCROLLINFO sInfo;
  603.  sInfo.cbSize = sizeof(sInfo);
  604.  sInfo.fMask = SIF_ALL;
  605.  sInfo.nMin = 0;
  606.  sInfo.nMax = m_nItemsCount - 1;
  607.  sInfo.nPage = nVisible - 1;
  608.  sInfo.nPos = 0;
  609.  sInfo.nTrackPos = 0;
  610. m_sbVert.SetScrollInfo(&sInfo);
  611. }
  612. }
  613. else
  614. if (bCreated)
  615. m_sbVert.DestroyWindow();
  616. }
  618. // Function name : CQListCtrlCtrl::OnSetClientSite
  619. // Description     : Force this m_bMsgReflect to false, because thsi control must refect message
  620. // Return type : void 
  621. void CQListCtrlCtrl::OnSetClientSite( )
  622. {
  623. m_bMsgReflect = FALSE;
  624. }
  626. BOOL CQListCtrlCtrl::CreateControlWindow(HWND hWndParent, const CRect& rcPos, LPCRECT prcClipped)
  627. {
  628. //This function is already called if control receive the focus
  629. if (m_hWnd)
  630. return TRUE;
  631. return COleControl::CreateControlWindow(hWndParent, rcPos, prcClipped);
  632. }
  635. void CQListCtrlCtrl::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
  636. {
  637. if (GetStyle() & WS_VSCROLL)
  638. lpncsp->rgrc[0].right += GetSystemMetrics(SM_CXVSCROLL);
  640. COleControl::OnNcCalcSize(bCalcValidRects, lpncsp);
  641. }
  643. // Function name : CQListCtrlCtrl::OnShowWindow
  644. // Description     : 
  645. // Return type : void 
  646. // Argument         : BOOL bShow
  647. // Argument         : UINT nStatus
  648. void CQListCtrlCtrl::OnShowWindow(BOOL bShow, UINT nStatus) 
  649. {
  650. COleControl::OnShowWindow(bShow, nStatus);
  652. if (bShow)
  653. {
  654. }
  655. }
  656. // Function name : CQListCtrlCtrl::OnVScroll
  657. // Description     : 
  658. // Return type : void 
  659. // Argument         : UINT nSBCode
  660. // Argument         : UINT nPos
  661. // Argument         : CScrollBar* pScrollBar
  662. void CQListCtrlCtrl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  663. {
  664. if (pScrollBar == &m_sbVert)
  665. {
  666. CListCtrl* pListCtrl = GetListCtrl();
  667. int nHM = NULL, nStep = NULL;
  668. switch ( nSBCode )
  669. {
  670. case SB_LINEDOWN:
  671. case SB_PAGEDOWN:
  672. {
  673. nHM = m_nCountLoading;
  674. nStep = (nSBCode == SB_LINEDOWN ? 1 : nHM);
  675. }
  676. case SB_PAGEUP:
  677. case SB_LINEUP:
  678. {
  679. if (!nHM)
  680. {
  681. nHM = -m_nCountLoading;
  682. nStep = (nSBCode == SB_LINEUP ? -1 : nHM);
  683. }
  684. int nPosR = pListCtrl->GetTopIndex();
  685. LoadPartial( nPosR, nHM);
  686. pListCtrl->EnsureVisible(nPosR + nStep, FALSE);
  687. break;
  688. }
  689. case SB_THUMBPOSITION:
  690. {
  691. int nPosR = LoadPartial(nPos, m_nCountLoading);
  692. pListCtrl->EnsureVisible(nPosR, FALSE);
  693. break;
  694. }
  695. }
  696. pScrollBar->SetScrollPos(pListCtrl->GetTopIndex());
  697. }
  698. COleControl::OnVScroll(nSBCode, nPos, pScrollBar);
  699. }
  701. // Function name : CQListCtrlCtrl::OnKeyDown
  702. // Description     : 
  703. // Return type : void 
  704. // Argument         : UINT nChar
  705. // Argument         : UINT nRepCnt
  706. // Argument         : UINT nFlags
  707. void CQListCtrlCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  708. {
  709. if (m_pRectTracker == NULL)
  710. {
  711. BOOL bNeed = FALSE;
  712. switch (nChar)
  713. {
  714. case VK_PRIOR:
  715. case VK_NEXT:
  716. case VK_DOWN:
  717. case VK_UP:
  718. {
  719. LoadPartial(GetListCtrl()->GetTopIndex(), ( (nChar == VK_UP) || (nChar == VK_PRIOR) ? -1 : 1 ) * m_nCountLoading);
  720. bNeed = TRUE;
  721. break;
  722. }
  723. case VK_END:
  724. case VK_HOME:
  725. {
  726. LoadPartial(( nChar == VK_HOME ) ? 0 : GetCountItem() - m_nCountLoading, m_nCountLoading);
  727. bNeed = TRUE;
  728. break;
  729. }
  730. }
  732. COleControl::OnKeyDown(nChar, nRepCnt, nFlags);
  734. if (m_sbVert.GetSafeHwnd())
  735. if (bNeed)
  736. m_sbVert.SetScrollPos(GetListCtrl()->GetTopIndex());
  737. }
  738. }
  740. // Function name : CQListCtrlCtrl::OnNoHeaderChanged
  741. // Description     : 
  742. // Return type : void 
  743. void CQListCtrlCtrl::OnNoHeaderChanged() 
  744. {
  745. if (::IsWindow(GetSafeHwnd()))
  746. ModifyStyle(!m_bNoHeader ? LVS_NOCOLUMNHEADER : 0, m_bNoHeader ? LVS_NOCOLUMNHEADER : 0);
  748. SetModifiedFlag();
  749. }
  752. // Function name : CQListCtrlCtrl::OnSColumnChanged
  753. // Description     : 
  754. // Return type : void 
  755. void CQListCtrlCtrl::OnSColumnChanged() 
  756. {
  757. // Cannot be change in runtime
  758. }
  760. // Function name : CQListCtrlCtrl::InitItemsCount
  761. // Description     : This will generate an event to find number of items
  762. // Return type : void 
  763. void CQListCtrlCtrl::InitItemsCount() 
  764. {
  765. FireItemsCount(&m_nItemsCount);
  766. if (m_nItemsCount > 0)
  767. {
  768. OnItemsCountChanged();
  769. m_fctLoadFunction = LoadPartialListCtrl;
  771. // Load only visible items.
  772. LoadPartial(0, m_nCountLoading);
  773. }
  774. }
  776. // Function name : CQListCtrlCtrl::GetCountItem
  777. // Description     : return the real count of items
  778. // Return type : int 
  779. int CQListCtrlCtrl::GetCountItem()
  780. {
  781. return m_nItemsCount;
  782. }
  784. // Function name : AlreadyLoadPartialListCtrl
  785. // Description     : 
  786. // Return type : int 
  787. // Argument         : int nLineFrom
  788. // Argument         : int nHowMany
  789. int CQListCtrlCtrl::AlreadyLoadPartialListCtrl(int nLineFrom, int nHowMany)
  790. {
  791. return nLineFrom;
  792. }
  794. // Function name : CQListCtrlCtrl::Label
  795. // Description     : Load the text for the label and the lParam user data
  796. // Return type : LPCTSTR 
  797. // Argument         : int nLine
  798. // Argument         : LPARAM& lParamItem
  799. LPCTSTR CQListCtrlCtrl::Label(int nLine, LPARAM& lParamItem)
  800. {
  801. static CString text;
  802. BSTR bText = NULL;
  803. FireLoadLabel(nLine, &bText, &lParamItem);
  804. text = bText;
  805. ::SysFreeString(bText);
  806. return bText ? (LPCSTR)text : NULL;
  807. }
  809. // Function name : CQListCtrlCtrl::LoadRestOfLine
  810. // Description     : 
  811. // Return type : void 
  812. // Argument         : int nLine
  813. void CQListCtrlCtrl::LoadRestOfLine(int nLine, int nTrueLine)
  814. {
  815. LV_COLUMN lvColumn; lvColumn.mask = LVCF_WIDTH;
  816. int i = 0;
  817. CListCtrl* pListCtrl = GetListCtrl();
  818. while (pListCtrl->GetColumn(++i, &lvColumn))
  819. {
  820. BSTR bText = NULL;
  821. FireLoadSubItem(nTrueLine, i, &bText);
  822. pListCtrl->SetItemText(nLine,i, CString(bText));
  823. }
  824. }
  826. int CQListCtrlCtrl::LoadPartial(int nLineFrom, int nHowMany)
  827. {
  828. return (this->*m_fctLoadFunction)(nLineFrom, nHowMany);
  829. }
  831. int CQListCtrlCtrl::LoadPartialListCtrl(int nLineFrom, int nHowMany)
  832. {
  833. return m_QuickLoader.Load(nLineFrom, nHowMany);
  834. }
  836. //QSnapLoader implementation
  837. int CQListCtrlCtrl::QSnapLoader::SNodeItemsInfo::m_nCountRef = 0;
  838. // Function name : CQListCtrlCtrl::QSnapLoader::~QSnapLoader
  839. // Description     : virtual destructor. destory the double linked list.
  840. // Return type : 
  841. CQListCtrlCtrl::QSnapLoader::~QSnapLoader()
  842. {
  843. SNodeItemsInfo* pNodeNext = m_pFirstNode;
  844. while (pNodeNext)
  845. {
  846. SNodeItemsInfo* pNodeDelete = pNodeNext;
  847. pNodeNext = pNodeNext->m_pNextNode;
  848. delete pNodeDelete;
  849. };
  850. }
  852. // Function name : CQListCtrlCtrl::QSnapLoader::QSnapLoader
  853. // Description     : default constructor, create the first node in list
  854. // Return type : 
  855. CQListCtrlCtrl::QSnapLoader::QSnapLoader()
  856. {
  857. m_pFirstNode = new SNodeItemsInfo(0,0,0);
  858. }
  860. // Function name : CQListCtrlCtrl::QSnapLoader::SetParent
  861. // Description     : Set the parent of this structure, to be CQListCtrlCtrl that contains this structure(class).
  862. // Return type : void 
  863. // Argument         : CQListCtrlCtrl * pParent
  864. void CQListCtrlCtrl::QSnapLoader::SetParent(CQListCtrlCtrl* pParent)
  865. {
  866. m_pParent = pParent;
  867. }
  869. // Function name : CQListCtrlCtrl::QSnapLoader::GetListNodes
  870. // Description     : Give as string, all nodes from double linked list. Use for checking
  871. // Return type : CString 
  872. CString CQListCtrlCtrl::QSnapLoader::GetListNodes()
  873. {
  874. CString text;
  875. SNodeItemsInfo* pIncreaseNode = m_pFirstNode;
  876. int s = 0;
  877. while (pIncreaseNode)
  878. {
  879. CString t;
  880. t.Format(_T("(%i,%i,%i, [%i,%i])rn"), pIncreaseNode->m_nItemLine, pIncreaseNode->m_nCount, pIncreaseNode->m_nItemLB, pIncreaseNode->GetLastLine(), pIncreaseNode->GetLastItem());
  881. text += t;
  882. s += pIncreaseNode->m_nCount;
  883. pIncreaseNode = pIncreaseNode->m_pNextNode;
  884. }
  885. CString t;
  886. t.Format(_T("Count loaded: %i, Count items. listctrl() %i"), s, m_pParent->GetListCtrl()->GetItemCount());
  887. text += t;
  888. return text;
  889. }
  891. // Function name : CQListCtrlCtrl::QSnapLoader::Load
  892. // Description     : Function to load some items to this object
  893. // This function will call function Line of the parent object.
  894. // Return type : void 
  895. // Argument         : int nItemFrom
  896. // Argument         : int nHowMany
  897. // This function will return the real position into listctrl.
  898. int CQListCtrlCtrl::QSnapLoader::Load(int nItemFrom, int nHowMany)
  899. {
  900. int nIF = abs(nItemFrom + (nHowMany < 0 ? nHowMany : 0));
  901. int nHM = abs(nHowMany), nResult = nItemFrom;
  902. if (nHM = min(nHM, max(0,m_pParent->GetCountItem() - nIF)))
  903. {
  904. //Something must load
  905. ASSERT (nHM != NULL);
  906. SNodeItemsInfo* pNodeNext = m_pFirstNode;
  907. SNodeItemsInfo* pNodePrev = NULL;
  908. // Already the constructor was called
  909. ASSERT (pNodeNext);
  910. //Find the nodes ie pPrevNext->m_nItemLine <= nIF < pPrevNext->m_nItemLine
  911. while (pNodeNext && (nIF >= pNodeNext->m_nItemLine))
  912. {
  913. pNodePrev = pNodeNext;
  914. pNodeNext = pNodeNext->m_pNextNode;
  915. }
  917. // If in the first block , number of items count is equal with total number of items,
  918. // then this function will not be called again. The next function that will
  919. //be called will be AlreadyLoadPartialListCtrl.
  920. if (m_pFirstNode->m_nCount == m_pParent->GetCountItem())
  921. {
  922. m_pParent->m_fctLoadFunction = m_pParent->AlreadyLoadPartialListCtrl;
  923. // Fire an event to prevent the owner of this control, that all items was loaded
  924. m_pParent->FireAllItemsLoaded();
  925. return nItemFrom;
  926. }
  928. LPCTSTR lpszItemLB = NULL;
  929. LPARAM lParam = NULL;
  930. int nFirst = pNodePrev->GetLastLine(), nItem = pNodePrev->GetLastItem();
  931. CListCtrl* pListCtrl = m_pParent->GetListCtrl();
  932. nResult = pNodePrev->GetLastItem();
  934. if (pNodeNext == NULL)
  935. {
  936. // After the prev node do not exist another node.
  937. BOOL bEnd = TRUE;
  938. if (nIF > nFirst)
  939. {
  940. SNodeItemsInfo* sThis = pNodePrev;
  941. pNodePrev = new SNodeItemsInfo(nIF,0, nResult );
  942. sThis->m_pNextNode = pNodePrev;
  943. pNodePrev->m_pPrevNode = sThis;
  944. nFirst = nIF;
  945. bEnd = FALSE;
  946. }
  947. else
  948. {
  949. nResult = pNodePrev->m_nItemLB + nIF - pNodePrev->m_nItemLine;
  950. }
  951. int i = 0;
  952. for (i = 0; (lpszItemLB = m_pParent->Label(nFirst + i, lParam)) && (i < nHM); i++)
  953. {
  954. pListCtrl->SetItemData(nItem = pListCtrl->InsertItem(nItem, lpszItemLB), lParam);
  955. m_pParent->LoadRestOfLine(nItem, nFirst + i);
  956. pNodePrev->m_nCount++;
  957. nItem++;
  958. }
  959. }
  960. else
  961. {
  962. SNodeItemsInfo* pIncreaseNode = pNodeNext->m_pNextNode;
  963. int nDiff = pNodeNext->m_nItemLine - nFirst;
  964. ASSERT ( nDiff >= 0 );
  965. nItem = nResult; // first item that will be inserted
  966. // {...+..} ___ {...+..}
  967. if (nDiff <= nHM)
  968. {
  969. // The real nHM will be the diference between nHowMany - nDiff
  970. nHM = nDiff;
  971. // Try to restrict these node in only one.
  972. pNodePrev->m_nCount += pNodeNext->m_nCount + nHM;
  973. pNodePrev->m_pNextNode = pNodeNext->m_pNextNode;
  974. delete pNodeNext;
  975. nResult = pNodePrev->m_nItemLB + nIF - pNodePrev->m_nItemLine;
  976. }
  977. else
  978. {
  979. //      nFirst
  980. //        /--- > nHM --
  981. // {...+..} __+________{......}
  982. if (nIF < nFirst)
  983. {
  984. nResult = pNodePrev->m_nItemLB + nIF - pNodePrev->m_nItemLine;
  985. nFirst = pNodePrev->GetLastLine();
  986. pNodePrev->m_nCount += nHM;
  987. pIncreaseNode = pNodeNext;
  988. }
  989. // {......} ______+___ {...+...}
  990. else
  991. if (nIF + nHM >= pNodeNext->m_nItemLine)
  992. {
  993. nHM = pNodeNext->m_nItemLine - nIF;
  994. pNodeNext->m_nItemLine = nIF;
  995. pNodeNext->m_nCount += nHM;
  996. //pNodeNext->m_nItemLB remains constant
  997. nItem = pNodeNext->m_nItemLB;
  998. nFirst = nIF;
  999. nResult = pNodeNext->m_nItemLB;
  1000. }
  1001. // {......} __+____+___ {......}
  1002. else
  1003. {
  1004. SNodeItemsInfo* sThis = new SNodeItemsInfo(nIF, nHM, nResult );
  1005. sThis->m_pPrevNode = pNodePrev;
  1006. sThis->m_pNextNode = pNodeNext;
  1007. pNodePrev->m_pNextNode = sThis;
  1008. pNodeNext->m_pPrevNode = sThis;
  1009. nFirst = nIF;
  1010. pIncreaseNode = pNodeNext;
  1011. }
  1012. }
  1013. // if some items must insert, do it
  1014. if (nHM > 0)
  1015. {
  1016. for (int i = 0; i < nHM; i++)
  1017. {
  1018. lpszItemLB = m_pParent->Label(nFirst + i, lParam);
  1019. // while pNodePrev and pNodeNext exist !
  1020. ASSERT (lpszItemLB);
  1021. pListCtrl->SetItemData(nItem = pListCtrl->InsertItem(nItem, lpszItemLB), lParam);
  1022. m_pParent->LoadRestOfLine(nItem, nFirst + i);
  1023. nItem++;
  1024. }
  1025. while (pIncreaseNode)
  1026. {
  1027. pIncreaseNode->m_nItemLB += nHM;
  1028. pIncreaseNode = pIncreaseNode->m_pNextNode;
  1029. }
  1030. }
  1032. }
  1033. }
  1034. return nResult;
  1035. }
  1037. // Function name : CQListCtrlCtrl::QSnapLoader::GetItemLine
  1038. // Description     : Return the Real line, converts from nItemLB
  1039. // Return type : int 
  1040. // Argument         : int nItemLB
  1041. int CQListCtrlCtrl::QSnapLoader::GetItemLine(int nItemLB)
  1042. {
  1043. nItemLB = max(0,nItemLB);
  1044. SNodeItemsInfo* pNodeNext = m_pFirstNode;
  1045. while (pNodeNext && ( pNodeNext->m_nItemLB > nItemLB ))
  1046. pNodeNext = pNodeNext->m_pNextNode;
  1047. return pNodeNext->m_nItemLine  + nItemLB - pNodeNext->m_nItemLB;
  1048. }