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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 组合框控件 > 查看源码
QComboBox.cpp
资源名称：snapshot_combo_demo.zip　[点击查看]
上传用户：cszhwei
上传日期：2007-01-01
资源大小：37k
文件大小：31k
源码类别：

组合框控件

开发平台：

Visual C++

QComboBox.cpp：源码内容
  1. /************************************
  2.   REVISION LOG ENTRY
  3.   Revision By: Mihai Filimon
  4.   Revised on 9/16/98 2:20:27 PM
  5.   Comments: QComboBox.cpp : implementation file
  6.  ************************************/
  8. #include "stdafx.h"
  9. #include "QComboBox.h"
  10. #include <math.h>
  11. #include <afxpriv.h>
  13. #ifdef _DEBUG
  14. #define new DEBUG_NEW
  15. #undef THIS_FILE
  16. static char THIS_FILE[] = __FILE__;
  17. #endif
  19. /////////////////////////////////////////////////////////////////////////////
  20. // CQComboBox
  22. #define NotifyWindow(pWnd,message,wParam,lParam) if (pWnd) pWnd->SendMessage(message, (WPARAM)wParam, (LPARAM)lParam)
  24. CBrush CQComboBox::m_brBkGnd(defaultRGBBkGnd);
  25. CFont CQComboBox::m_font;
  26. CMap<CQComboBox*,CQComboBox*, BOOL, BOOL> CQComboBox::m_mapUnloadedQCombos;
  28. static const LOGFONT logFontPages =
  29. {
  30. /*LONG lfHeight*/8,
  31. /*LONG lfWidth*/0,
  32. /*LONG lfEscapement*/0,
  33. /*LONG lfOrientation*/0,
  34. /*LONG lfWeight*/FW_NORMAL,
  35. /*BYTE lfItalic*/FALSE,
  36. /*BYTE lfUnderline*/FALSE,
  37. /*BYTE lfStrikeOut*/FALSE,
  38. /*BYTE lfCharSet*/ANSI_CHARSET,
  39. /*BYTE lfOutPrecision*/0,
  40. /*BYTE lfClipPrecision*/0,
  41. /*BYTE lfQuality*/DEFAULT_QUALITY,
  42. /*BYTE lfPitchAndFamily*/DEFAULT_PITCH,
  43. /*CHAR lfFaceName[LF_FACESIZE]*/_T("MS Sans Serif")
  44. };
  46. // Function name : CQComboBox::CQComboBox
  47. // Description     : default constuctor
  48. // Return type : 
  49. CQComboBox::CQComboBox(TLine fctLine, TLinePartial fctLinePartial, LPARAM lParam)
  50. {
  51. m_lParam = lParam;
  52. m_QuickLoader.SetParent(this);
  53. RegClassQComboBox();
  54. m_pListBox = NULL;
  55. m_pEdit = NULL;
  56. m_bCaptured = FALSE;
  57. m_fctLine = fctLine;
  58. m_fctLinePartial = fctLinePartial;
  59. m_nCountVisible = 0;
  60. SetRateWidth(0.0);
  61. SetMultipleHeight();
  62. m_fctLoadFunction = LoadPartialListBox;
  63. m_mapUnloadedQCombos[this] = !IsAlreadyLoad();
  65. //When you callthe contructor, you need to attach two function.
  66. //The first, for giving line number nIndex
  67. //The second, for fiving numer of line which start with a given string.
  68. // If you don't write that functions, especialy m_fctLine, you will have some suprises
  69. ASSERT(m_fctLine);
  70. }
  72. // Function name : CQComboBox::~CQComboBox
  73. // Description     : virtual destructor
  74. // Return type : 
  75. CQComboBox::~CQComboBox()
  76. {
  77. m_mapUnloadedQCombos.RemoveKey(this);
  78. }
  80. BEGIN_MESSAGE_MAP(CQComboBox, CWnd)
  81. //{{AFX_MSG_MAP(CQComboBox)
  82. ON_WM_DESTROY()
  83. ON_WM_LBUTTONDOWN()
  84. ON_WM_WINDOWPOSCHANGED()
  85. ON_WM_PAINT()
  86. ON_WM_LBUTTONUP()
  87. ON_WM_MOUSEMOVE()
  88. ON_WM_SETFOCUS()
  89. ON_WM_CREATE()
  90. ON_WM_TIMER()
  91. //}}AFX_MSG_MAP
  92. END_MESSAGE_MAP()
  94. /////////////////////////////////////////////////////////////////////////////
  95. // CQComboBox message handlers
  96. UINT CQComboBox::m_nSelChange = NULL;
  97. UINT CQComboBox::m_nLoading = NULL;
  98. UINT CQComboBox::m_nLoaded = NULL;
  100. // Function name : CQComboBox::RegClassQComboBox
  101. // Description     : Register this window class
  102. // Return type : BOOL 
  103. BOOL CQComboBox::RegClassQComboBox()
  104. {
  105. WNDCLASS wndClass;
  106. wndClass.style = CS_DBLCLKS;
  107. wndClass.lpfnWndProc = ::DefWindowProc;
  108. wndClass.cbClsExtra = NULL;
  109. wndClass.cbWndExtra = NULL;
  110. wndClass.hInstance = AfxGetInstanceHandle();
  111. wndClass.hIcon = NULL;
  112. wndClass.hCursor = AfxGetApp()->LoadStandardCursor(IDC_ARROW);
  113. wndClass.hbrBackground = (HBRUSH)m_brBkGnd;
  114. wndClass.lpszMenuName = NULL;
  115. wndClass.lpszClassName = wndClassName;
  116. BOOL bResult = AfxRegisterClass(&wndClass);
  117. if (bResult)
  118. {
  119. if (!m_nSelChange)
  120. m_nSelChange = RegisterWindowMessage(defaultSelChange);
  121. if (!m_nLoading)
  122. m_nLoading = RegisterWindowMessage(defaultLoading);
  123. if (!m_nLoaded)
  124. m_nLoaded = RegisterWindowMessage(defaultLoaded);
  125. if (!m_font.GetSafeHandle())
  126. {
  127. //At the first call set the new font
  128. m_font.CreateFontIndirect(&logFontPages);
  129. }
  130. }
  131. return bResult;
  132. }
  134. CQComboBox* CQComboBox::m_pActiveMCBox = NULL;
  135. CQComboBox::CWindowProcs CQComboBox::m_wndProcs;
  136. // Function name : CQComboBox::ListBoxWindowProc
  137. // Description     : ListControl window procedure
  138. // Return type : LRESULT CALLBACK 
  139. // Argument         : HWND hWnd
  140. // Argument         : UINT nMsg
  141. // Argument         : WPARAM wParam
  142. // Argument         : LPARAM lParam
  143. LRESULT CALLBACK CQComboBox::ListBoxWindowProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
  144. {
  145. if (CQComboBox* pOwner = CQComboBox::m_pActiveMCBox)
  146. if (!pOwner->ForwardMessage(nMsg, wParam, lParam))
  147. return NULL;
  148. return CallWindowProc( CQComboBox::m_wndProcs.GetOldListBoxProcedure(hWnd), hWnd, nMsg, wParam, lParam );
  149. }
  151. // Function name : CQComboBox::ParentWindowProc
  152. // Description     : Parent window procedure.
  153. // Return type : LRESULT CALLBACK 
  154. // Argument         : HWND hWnd
  155. // Argument         : UINT nMsg
  156. // Argument         : WPARAM wParam
  157. // Argument         : LPARAM lParam
  158. LRESULT CALLBACK CQComboBox::ParentWindowProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
  159. {
  160. CQComboBox* pOwner = CQComboBox::m_pActiveMCBox;
  161. CQComboBox* pFirst = GetFirstQComboBox();
  163. {
  164. switch (nMsg)
  165. {
  166. case WM_KICKIDLE:
  167. {
  168. //Start to load items, after 3 seconds.
  169. if (pFirst)
  170. pFirst->SetTimer(QIDTIMERSTARTLOADITEMS, QTIMESTARTLOADITEMS, NULL);
  171. break;
  172. }
  173. case WM_COMMAND:
  174. case WM_SYSCOMMAND:
  175. case WM_LBUTTONDOWN:
  176. case WM_NCLBUTTONDOWN:
  177. {
  178. if (pFirst)
  179. {
  180. pFirst->KillTimer(QIDTIMERSTARTLOADITEMS);
  181. pFirst->KillTimer(QIDTIMERLOADITEMS);
  182. };
  184. if (pOwner)
  185. {
  186. BOOL bDropped = pOwner->IsDropedDown();
  187. pOwner->DropDown(FALSE);
  188. if (nMsg == WM_COMMAND)
  189. if (LOWORD(wParam) == IDOK)
  190. {
  191. pOwner->SelectCurrentItem();
  192. return FALSE;
  193. }
  194. else
  195. if (LOWORD(wParam) == IDCANCEL)
  196. if (bDropped)
  197. return FALSE;
  198. break;
  199. }
  200. }
  201. }
  202. };
  203. WNDPROC wndProc = CQComboBox::m_wndProcs.GetOldParentProcedure(hWnd);
  204. ASSERT (wndProc);
  205. return CallWindowProc( wndProc, hWnd, nMsg, wParam, lParam );
  206. }
  208. // Function name : CQComboBox::EditWindowProc
  209. // Description     : Edit window procedure
  210. // Return type : LRESULT CALLBACK 
  211. // Argument         : HWND hWnd
  212. // Argument         : UINT nMsg
  213. // Argument         : WPARAM wParam
  214. // Argument         : LPARAM lParam
  215. LRESULT CALLBACK CQComboBox::EditWindowProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
  216. {
  217. CQComboBox* pOwner = CQComboBox::m_pActiveMCBox;
  218. switch (nMsg)
  219. {
  220. case WM_SETFOCUS:
  221. {
  222. CQComboBox::m_pActiveMCBox = (CQComboBox*)CWnd::FromHandle(::GetParent(hWnd));
  223. break;
  224. }
  225. case WM_KILLFOCUS:
  226. {
  227. if (pOwner)
  228. {
  229. pOwner->DropDown(FALSE);
  230. CQComboBox::m_pActiveMCBox = NULL;
  231. }
  232. break;
  233. }
  234. case WM_KEYDOWN:
  235. case WM_SYSKEYDOWN:
  236. {
  237. int nStep = 0;
  238. if (pOwner)
  239. switch ((int) wParam)
  240. {
  241. case VK_NEXT:
  242. {
  243. if (nStep == 0)
  244. nStep = +pOwner->GetVisibleCount();
  245. }
  246. case VK_PRIOR:
  247. {
  248. if (nStep == 0)
  249. nStep = -pOwner->GetVisibleCount();
  250. }
  251. case VK_UP:
  252. {
  253. if (nStep == 0)
  254. nStep = -1;
  255. }
  256. case VK_DOWN:
  257. {
  258. if (nStep == 0)
  259. nStep = +1;
  260. if (abs(nStep) > 1 || ((abs(nStep) == 1) && GetAsyncKeyState(VK_MENU) >= 0))
  261. {
  262. pOwner->LoadPartial(pOwner->m_QuickLoader.GetItemLine(pOwner->GetCurrentItem()) + nStep, nStep/abs(nStep) * pOwner->GetVisibleCount());
  263. pOwner->SetCurrentItem(pOwner->GetCurrentItem() + nStep);
  264. pOwner->SelectCurrentItem();
  265. break;
  266. }
  267. }
  268. case defaultDropDownKey:
  269. {
  270. pOwner->DropDown(!pOwner->IsDropedDown());
  271. break;
  272. }
  273. }
  274. break;
  275. }
  276. }
  277. return CallWindowProc( CQComboBox::m_wndProcs.GetOldEditProcedure(hWnd), hWnd, nMsg, wParam, lParam );
  278. }
  280. // Function name : CQComboBox::OnInit
  281. // Description     : Init the control
  282. // Return type : BOOL 
  283. BOOL CQComboBox::OnInit()
  284. {
  285. // You must already attach a function who give me a line.
  286. ASSERT (m_fctLine != NULL);
  287. ASSERT (m_font.GetSafeHandle());
  288. SetFont(&m_font);
  289. ModifyStyle(WS_OVERLAPPED , WS_TABSTOP);
  290. m_pEdit = new CEdit();
  291. m_pListBox = new CListBox();
  292. if (m_pEdit->Create(WS_CHILD | WS_VISIBLE | defaultEditStyle, CRect(0,0,0,0), this, IDEDIT ))
  293. {
  294. ModifyStyleEx(0, WS_EX_STATICEDGE);
  295. m_pEdit->SetFont(&m_font);
  296. if (m_pListBox->Create(WS_BORDER | WS_CHILD | defaultListBoxStyle , CRect(0,0,0,0), GetDesktopWindow(), IDListBox))
  297. {
  298. m_pListBox->SetFont(&m_font);
  299. //Set the refernce to this object in user data dword
  300. ::SetWindowLong(m_pListBox->m_hWnd, GWL_USERDATA, (long)this);
  301. ::SetWindowLong(m_pListBox->m_hWnd, GWL_STYLE, GetWindowLong(m_pListBox->m_hWnd, GWL_STYLE) | WS_CLIPSIBLINGS | WS_OVERLAPPED);
  302. m_pListBox->ModifyStyleEx(0, WS_EX_TOOLWINDOW);
  303. m_pListBox->SetWindowPos(&CWnd::wndTopMost,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE);
  304. ListView_SetExtendedListViewStyle(m_pListBox->m_hWnd, LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT);
  305. Resize();
  306. m_wndProcs.AddEdit(GetEdit(), EditWindowProc);
  307. m_wndProcs.AddListBox(GetListBox(), ListBoxWindowProc);
  308. m_wndProcs.AddParent(GetParent(), ParentWindowProc);
  309. m_nCountVisible = GetVisibleCount();
  310. return TRUE;
  311. }
  312. }
  313. return FALSE;
  314. }
  316. // Function name : CQComboBox::PreSubclassWindow
  317. // Description     : Call to subclass window
  318. // Return type : void 
  319. void CQComboBox::PreSubclassWindow() 
  320. {
  321. CWnd::PreSubclassWindow();
  323. OnInit();
  324. }
  326. // Function name : CQComboBox::OnDestroy
  327. // Description     : Remove all dependent datas.
  328. // Return type : void 
  329. void CQComboBox::OnDestroy() 
  330. {
  331. CWnd::OnDestroy();
  333. m_wndProcs.RemoveEdit(GetEdit());
  334. m_wndProcs.RemoveListBox(GetListBox());
  335. m_wndProcs.RemoveParent(GetParent());
  337. if (CListBox* pList = GetListBox())
  338. delete pList;
  340. if (CEdit* pEdit = GetEdit())
  341. delete pEdit;
  343. m_pListBox = NULL;
  344. m_pEdit = NULL;
  346. }
  348. // Function name : CQComboBox::GetListBox
  349. // Description     : return the list control for 
  350. // Return type : CListBox* 
  351. CListBox* CQComboBox::GetListBox()
  352. {
  353. return m_pListBox;
  354. }
  356. // Function name : CQComboBox::GetEdit
  357. // Description     : retirn  pointer to edit control inside of thsi control
  358. // Return type : CEdit* 
  359. CEdit* CQComboBox::GetEdit()
  360. {
  361. return m_pEdit;
  362. }
  364. // Function name : CQComboBox::DrawButton
  365. // Description     : Draw down button
  366. // Return type : void 
  367. // Argument         : CDC * pDC
  368. // Argument         : CRect r
  369. // Argument         : BOOL bDown
  370. void CQComboBox::DrawButton(CDC * pDC, CRect r, BOOL bDown)
  371. {
  372. CPen penWhite(PS_SOLID,1,RGB(255,255,255));
  373. CPen penBlack(PS_SOLID,1,RGB(0,0,0));
  374. pDC->FrameRect(r,&CBrush(RGB(128,128,128)));
  375. if (!bDown)
  376. {
  377. pDC->SelectObject(&penWhite);
  378.  pDC->MoveTo(r.left, r.bottom - 2);
  379.  pDC->LineTo(r.left, r.top);
  380.  pDC->LineTo(r.right - 1, r.top);
  381. }
  382. CBitmap bitmapOEM;
  383. if (bitmapOEM.LoadOEMBitmap(OBM_COMBO))
  384. {
  385. CDC dcMem;
  386. if (dcMem.CreateCompatibleDC(pDC))
  387. {
  388. BITMAP b; bitmapOEM.GetBitmap(&b);
  389. int leftC = max((r.Width() - b.bmWidth) / 2,1);
  390. int topC = max((r.Height() - b.bmHeight) / 2,1);
  391. if (bDown)
  392. {
  393. leftC++;
  394. topC++;
  395. }
  396. CBitmap* pOldBitmap = dcMem.SelectObject(&bitmapOEM);
  397. pDC->BitBlt(r.left + leftC, r.top + topC, r.Width() - (leftC + 1), r.Height() - (topC), &dcMem, 0,0, SRCCOPY);
  398. pOldBitmap = dcMem.SelectObject(pOldBitmap);
  399. }
  400. }
  401. }
  403. // Function name : CQComboBox::OnPaint
  404. // Description     : On Draw function
  405. // Return type : void 
  406. void CQComboBox::OnPaint() 
  407. {
  408. CPaintDC dc(this); // device context for painting
  410. CRect r; GetClientRect(r);
  411. r.right--;
  413. dc.MoveTo(r.left, r.bottom);
  414.  dc.LineTo(r.left, r.top);
  415.  dc.LineTo(r.right, r.top);
  416.  dc.LineTo(r.right, r.bottom);
  418. r.left = r.right - defaultSizeDX;
  419. r.InflateRect(0,-2);r.bottom++;r.right--;r.left++;
  420. m_rectBtn = r;
  422. DrawButton(&dc, m_rectBtn);
  423. }
  425. // Function name : CQComboBox::Resize
  426. // Description     : Call to remove the edit and list controls
  427. // Return type : void 
  428. void CQComboBox::Resize()
  429. {
  430. ASSERT (GetListBox());
  431. CRect r;
  432. GetWindowRect(r);
  433. SetWindowPos(0, 0, 0, r.Width(), defaultSizeDY, SWP_NOMOVE | SWP_NOZORDER | SWP_NOMOVE);
  434. // Set the height and width of edit control
  435. GetClientRect(r);
  436. r.InflateRect(-1,-2); r.bottom++;
  437. r.right -= defaultSizeDX;
  438. GetEdit()->MoveWindow(r.left, r.top, r.Width(), r.Height());
  439. // Set the height and width of list control
  440. GetWindowRect(r);
  441. int dy = r.Height();
  442. r.top = r.bottom;
  443. r.left++;r.right--;
  444. r.bottom += m_nMultipleHeight * dy;
  445. r.right += int(m_dWidthList * r.Width());
  446. GetListBox()->MoveWindow(r.left, r.top, r.Width(), r.Height());
  447. }
  449. // Function name : CQComboBox::DropDown
  450. // Description     : DropDown
  451. // Return type : void 
  452. // Argument         : BOOL bDown
  453. void CQComboBox::DropDown(BOOL bDown)
  454. {
  455. if (IsWindowVisible())
  456. if (IsDropedDown() != bDown)
  457. {
  458. Resize();
  459. LoadPartial(0, +GetVisibleCount());
  460. GetListBox()->ShowWindow(bDown ? SW_SHOW : SW_HIDE);
  461. if (bDown)
  462. GetEdit()->SetFocus();
  463. }
  464. }
  466. // Function name : CQComboBox::IsDropedDown
  467. // Description     : If the list control is dropped downd, return TRUE
  468. // Return type : BOOL 
  469. BOOL CQComboBox::IsDropedDown()
  470. {
  471. return GetListBox()->IsWindowVisible();
  472. }
  474. // Function name : CQComboBox::OnWindowPosChanged
  475. // Description     : 
  476. // Return type : void 
  477. // Argument         : WINDOWPOS FAR* lpwndpos
  478. void CQComboBox::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos) 
  479. {
  480. CWnd::OnWindowPosChanged(lpwndpos);
  481. Resize();
  482. }
  484. // Function name : CQComboBox::OnLButtonDown
  485. // Description     : 
  486. // Return type : void 
  487. // Argument         : UINT nFlags
  488. // Argument         : CPoint point
  489. void CQComboBox::OnLButtonDown(UINT nFlags, CPoint point) 
  490. {
  491. if (m_rectBtn.PtInRect(point))
  492. {
  493. SetButton();
  494. DropDown(!IsDropedDown());
  495. }
  497. CWnd::OnLButtonDown(nFlags, point);
  498. }
  500. // Function name : CQComboBox::OnLButtonUp
  501. // Description     : 
  502. // Return type : void 
  503. // Argument         : UINT nFlags
  504. // Argument         : CPoint point
  505. void CQComboBox::OnLButtonUp(UINT nFlags, CPoint point) 
  506. {
  507. ReleaseButton();
  509. CWnd::OnLButtonUp(nFlags, point);
  510. }
  512. // Function name : CQComboBox::OnMouseMove
  513. // Description     : 
  514. // Return type : void 
  515. // Argument         : UINT nFlags
  516. // Argument         : CPoint point
  517. void CQComboBox::OnMouseMove(UINT nFlags, CPoint point) 
  518. {
  519. if (m_bCaptured)
  520. {
  521. CPoint p; ::GetCursorPos(&p);
  522. ScreenToClient(&p);
  523. if (!m_rectBtn.PtInRect(p))
  524. ReleaseButton();
  525. }
  527. CWnd::OnMouseMove(nFlags, point);
  528. }
  530. // Function name : CQComboBox::ReleaseButton
  531. // Description     : Call to release the capture and image of button. After SetButton()
  532. // Return type : void 
  533. void CQComboBox::ReleaseButton()
  534. {
  535. if (m_bCaptured)
  536. {
  537. ReleaseCapture();
  538. CDC* pDC = GetDC();
  539. DrawButton(pDC, m_rectBtn);
  540. ReleaseDC(pDC);
  541. m_bCaptured = FALSE;
  542. }
  543. }
  545. // Function name : CQComboBox::SetButton
  546. // Description     : 
  547. // Return type : void 
  548. void CQComboBox::SetButton()
  549. {
  550. if (!m_bCaptured)
  551. {
  552. SetCapture();
  553. CDC* pDC = GetDC();
  554. DrawButton(pDC, m_rectBtn, TRUE);
  555. ReleaseDC(pDC);
  556. m_bCaptured = TRUE;
  557. }
  558. }
  560. // Function name : CQComboBox::ForwardMessage
  561. // Description     : This function is called by ListBoxWindowProc
  562. // Return type : void 
  563. // Argument         : UINT nMsg
  564. // Argument         : WPARAM wParam
  565. // Argument         : LPARAM lParam
  566. BOOL CQComboBox::ForwardMessage(UINT nMsg, WPARAM wParam, LPARAM lParam)
  567. {
  568. ASSERT (GetListBox());
  569. switch (nMsg)
  570. {
  571. case WM_MOUSEMOVE:
  572. case WM_LBUTTONDOWN:
  573. {
  574. BOOL bOutside = TRUE;
  575. int nIndex = GetListBox()->ItemFromPoint(CPoint(LOWORD(wParam), HIWORD(lParam)), bOutside);
  576. if (GetCurrentItem() != nIndex)
  577. SetCurrentItem(nIndex);
  578. if (nMsg == WM_LBUTTONDOWN)
  579. {
  580. DropDown(FALSE);
  581. SelectCurrentItem();
  582. }
  583. break;
  584. }
  585. case WM_VSCROLL:
  586. {
  587. CListBox* pListBox = GetListBox();
  588. UINT nScrollCode =  (int) LOWORD(wParam);
  589. int nHM = NULL, nStep = NULL;
  590. switch ( nScrollCode )
  591. {
  592. case SB_LINEDOWN:
  593. case SB_PAGEDOWN:
  594. {
  595. nHM = GetVisibleCount();
  596. nStep = (nScrollCode == SB_LINEDOWN ? 1 : nHM);
  597. }
  598. case SB_PAGEUP:
  599. case SB_LINEUP:
  600. {
  601. if (!nHM)
  602. {
  603. nHM = -GetVisibleCount();
  604. nStep = (nScrollCode == SB_LINEUP ? -1 : nHM);
  605. }
  606. int nPos = pListBox->GetTopIndex();
  607. LoadPartial( nPos, nHM);
  608. pListBox->SetTopIndex(nPos + nStep);
  609. pListBox->SetScrollPos(SB_VERT,  pListBox->GetTopIndex());
  610. break;
  611. }
  612. case SB_THUMBPOSITION:
  613. {
  614. int nPos = LoadPartial(HIWORD(wParam), GetVisibleCount());
  615. pListBox->SetScrollPos(SB_VERT,  HIWORD(wParam));
  616. pListBox->SetTopIndex(nPos);
  617. break;
  618. }
  619. }
  620. return FALSE;
  621. break;
  622. }
  623. }
  624. return TRUE;
  625. }
  627. // Function name : CQComboBox::OnSetFocus
  628. // Description     : When control have focus then edit will take the focus
  629. // Return type : void 
  630. // Argument         : CWnd* pOldWnd
  631. void CQComboBox::OnSetFocus(CWnd* pOldWnd) 
  632. {
  633. CWnd::OnSetFocus(pOldWnd);
  635. GetEdit()->SetFocus();
  637. }
  639. // Function name : CQComboBox::OnCommand
  640. // Description     : When something is happen in edit control, notify the list control
  641. // Return type : BOOL 
  642. // Argument         : WPARAM wParam
  643. // Argument         : LPARAM lParam
  644. BOOL CQComboBox::OnCommand(WPARAM wParam, LPARAM lParam) 
  645. {
  646. if (LOWORD(wParam) == IDEDIT)
  647. if (HIWORD(wParam) == EN_CHANGE)
  648. {
  649. ASSERT( GetEdit() && GetEdit()->GetDlgCtrlID() == IDEDIT);
  650. CString text,t ;
  651. GetEdit()->GetWindowText(t);
  652. Search(t);
  653. }
  655. return CWnd::OnCommand(wParam, lParam);
  656. }
  658. // Function name : CQComboBox::Search
  659. // Description     : Look for the lpszFindItem
  660. // Return type : void 
  661. // Argument         : LPCTSTR lpszFindItem
  662. void CQComboBox::Search(LPCTSTR lpszFindItem)
  663. {
  664. if (CListBox* pListBox = GetListBox())
  665. {
  666. LoadPartial(0, GetVisibleCount());
  667. int nItem = pListBox->FindString(-1, lpszFindItem);
  668. if (nItem < 0)
  669. {
  670. int tLine = LinePartial(lpszFindItem);
  671. LoadPartial(tLine - GetVisibleCount(), 2 * GetVisibleCount());
  672. nItem = pListBox->FindString(-1, lpszFindItem);
  673. }
  674. SetCurrentItem(nItem);
  675. }
  676. }
  678. // Function name : CQComboBox::SelectCurrentItem
  679. // Description     : Select the current item of list. Called if user click the mouse, oor press ENTER
  680. // Return type : void 
  681. void CQComboBox::SelectCurrentItem()
  682. {
  683. int nIndex = GetCurrentItem();
  684. if (nIndex != LB_ERR)
  685. {
  686. CString sItem; GetListBox()->GetText(nIndex, sItem);
  687. GetListBox()->SetScrollPos(SB_VERT, GetListBox()->GetTopIndex());
  688. GetEdit()->SetWindowText(sItem);
  689. //Notify the parent that one item was changed
  690. if (nIndex >= 0)
  691. if (CWnd* pParent = GetParent())
  692. pParent->SendMessage(m_nSelChange, (WPARAM)GetDlgCtrlID(), (LPARAM)m_hWnd);
  693. }
  694. }
  696. // Function name : CQComboBox::GetCurrentItem
  697. // Description     : Get current item from list control
  698. // Return type : int 
  699. int CQComboBox::GetCurrentItem()
  700. {
  701. return GetListBox()->GetCurSel();
  702. }
  704. // Function name : CQComboBox::SetCurrentItem
  705. // Description     : Set current item from list control to nIndex
  706. // Return type : void 
  707. // Argument         : int nIndex
  708. void CQComboBox::SetCurrentItem(int nIndex)
  709. {
  710. GetListBox()->SetCurSel(nIndex);
  711. }
  713. // Function name : CQComboBox::OnCreate
  714. // Description     : Call OnInit if control is created dynamically
  715. // Return type : int 
  716. // Argument         : LPCREATESTRUCT lpCreateStruct
  717. int CQComboBox::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  718. {
  719. if (CWnd::OnCreate(lpCreateStruct) == -1)
  720. return -1;
  722. OnInit();
  724. return 0;
  725. }
  727. // Function name : CQComboBox::SetRateWidth
  728. // Description     : This function will changes the width of inside listcontrol
  729. // Return type : double 
  730. // Argument         : double dWidthList
  731. double CQComboBox::SetRateWidth(double dWidthList)
  732. {
  733. double dResult = m_dWidthList;
  734. m_dWidthList = fabs(dWidthList);
  735. return dResult;
  736. }
  738. // Function name : CQComboBox::SetMultipleHeight
  739. // Description     : 
  740. // Return type : int 
  741. // Argument         : int nMHeight
  742. int CQComboBox::SetMultipleHeight(int nMHeight)
  743. {
  744. int nResult = m_nMultipleHeight;
  745. m_nMultipleHeight = abs(nMHeight);
  746. if (::IsWindow(m_hWnd))
  747. {
  748. Resize();
  749. m_nCountVisible = GetVisibleCount();
  750. }
  751. return nResult;
  752. }
  754. // Function name : CQComboBox::GetCountItem
  755. // Description     : 
  756. // Return type : int 
  757. int CQComboBox::GetCountItem()
  758. {
  759. return m_nCountItems;
  760. }
  762. // Function name : CQComboBox::SetCountItems
  763. // Description     : Set the count of items list box.
  764. // Return type : void 
  765. // Argument         : int nCount
  766. void CQComboBox::SetCountItems(int nCount)
  767. {
  768. // Already, you must call GetVisibleCount()
  769. ASSERT (m_nCountVisible != 0);
  770. m_nCountItems = nCount;
  771. // If this need vertical scroll bar, I will put WS_VSCROLL style
  772. if ( m_nCountItems >= m_nCountVisible)
  773. {
  774. CWnd* pWnd = GetListBox();
  775. // Already you must call OnInit, in fact, you must call SubclassDlgItem , or Create function
  776. ASSERT (pWnd != NULL);
  777. pWnd->ModifyStyle(0, WS_VSCROLL);
  778. SCROLLINFO sInfo;
  779.  sInfo.cbSize = sizeof(sInfo);
  780.  sInfo.fMask = SIF_ALL;
  781.  sInfo.nMin = 0;
  782.  sInfo.nMax = m_nCountItems - 1;
  783.  sInfo.nPage = m_nCountVisible - 1;
  784.  sInfo.nPos = 0;
  785.  sInfo.nTrackPos = 0;
  786. pWnd->SetScrollInfo(SB_VERT, &sInfo);
  787. }
  788. }
  790. // Function name : CQComboBox::GetVisibleCount
  791. // Description     : Get count of visible items.
  792. // Return type : int 
  793. int CQComboBox::GetVisibleCount()
  794. {
  795. CListBox* pListBox = GetListBox();
  796. ASSERT( pListBox );
  797. CRect r;
  798. if (pListBox->GetItemRect(0, r) == LB_ERR)
  799. {
  800. int nItem = pListBox->AddString(_T(""));
  801. pListBox->GetItemRect(0, r);
  802. pListBox->DeleteString(nItem);
  803. }
  804. CRect rClient; pListBox->GetClientRect(rClient);
  805. return rClient.Height() / r.Height() + 1;
  806. }
  808. // Function name : CQComboBox::AlreadyLoadPartialListBox
  809. // Description     : 
  810. // Return type : void 
  811. // Argument         : int nLineFrom
  812. // Argument         : int nHowMany
  813. int CQComboBox::AlreadyLoadPartialListBox(int nLineFrom, int nHowMany)
  814. {
  815. //Already the load was made
  816. return nLineFrom;
  817. }
  819. // Function name : CQComboBox::GetFirstQComboBox
  820. // Description     : Statical function. Return first element as QComboBox
  821. // Return type : CQComboBox* 
  822. CQComboBox* CQComboBox::GetFirstQComboBox()
  823. {
  824. if (POSITION position = m_mapUnloadedQCombos.GetStartPosition())
  825. {
  826. CQComboBox* pCombo = NULL;
  827. BOOL bLoaded = TRUE;
  828. m_mapUnloadedQCombos.GetNextAssoc(position, pCombo, bLoaded);
  829. return pCombo;
  830. }
  831. return NULL;
  832. }
  834. // Function name : CQComboBox::OnTimer
  835. // Description     : 
  836. // Return type : void 
  837. // Argument         : UINT nIDEvent
  838. void CQComboBox::OnTimer(UINT nIDEvent) 
  839. {
  840. switch (nIDEvent)
  841. {
  842. case QIDTIMERSTARTLOADITEMS:
  843. {
  844. KillTimer(QIDTIMERSTARTLOADITEMS);
  845. SetTimer(QIDTIMERLOADITEMS, QTIMELOADITEMS, NULL);
  846. }
  847. case QIDTIMERLOADITEMS:
  848. {
  849. POSITION position = m_mapUnloadedQCombos.GetStartPosition();
  850. while (position)
  851. {
  852. CQComboBox* pCombo = NULL;
  853. BOOL bLoaded = TRUE;
  854. m_mapUnloadedQCombos.GetNextAssoc(position, pCombo, bLoaded);
  855. if (pCombo->IsAlreadyLoad())
  856. m_mapUnloadedQCombos.RemoveKey(pCombo);
  857. else
  858. {
  859. pCombo->LoadPartial(0, GetVisibleCount());
  860. }
  861. }
  862. break;
  863. }
  864. }
  866. CWnd::OnTimer(nIDEvent);
  867. }
  869. // Function name : CQComboBox::IsAlreadyLoad
  870. // Description     : Return TRUE if listvox is already loaded.
  871. // Return type : BOOL 
  872. BOOL CQComboBox::IsAlreadyLoad()
  873. {
  874. return m_fctLoadFunction == AlreadyLoadPartialListBox;
  875. }
  877. // Function name : CQComboBox::LoadPartial
  878. // Description     : 
  879. // Return type : void 
  880. // Argument         : int nLineFrom
  881. // Argument         : int nHowMany
  882. int CQComboBox::LoadPartial(int nLineFrom, int nHowMany)
  883. {
  884. return (this->*m_fctLoadFunction)(nLineFrom, nHowMany);
  885. }
  888. // Function name : CQComboBox::LoadPartialListBox
  889. // Description     : 
  890. // Return type : void 
  891. int CQComboBox::LoadPartialListBox(int nLineFrom, int nHowMany)
  892. {
  893. return m_QuickLoader.Load(nLineFrom, nHowMany);
  894. }
  896. // Function name : CQComboBox::Line
  897. // Description     : Return line nLine, by calling own statical function
  898. // Return type : LPCTSTR 
  899. // Argument         : int nLine
  900. // Argument         : LPARAM & lParam
  901. LPCTSTR CQComboBox::Line(int nLine, LPARAM& lParamItem)
  902. {
  903. return m_fctLine(nLine, lParamItem, m_lParam);
  904. }
  906. // Function name : CQComboBox::LinePartial
  907. // Description     : return the index of real line, which has string equal with lpszItemPartial
  908. // Return type : int 
  909. // Argument         : LPCTSTR lpszItemPartial
  910. int CQComboBox::LinePartial(LPCTSTR lpszItemPartial)
  911. {
  912. if (m_fctLinePartial)
  913. return m_fctLinePartial(lpszItemPartial, m_lParam);
  914. return 0;
  915. }
  917. //QSnapLoader implementation
  918. int CQComboBox::QSnapLoader::SNodeItemsInfo::m_nCountRef = 0;
  919. // Function name : CQComboBox::QSnapLoader::~QSnapLoader
  920. // Description     : virtual destructor
  921. // Return type : 
  922. CQComboBox::QSnapLoader::~QSnapLoader()
  923. {
  924. SNodeItemsInfo* pNodeNext = m_pFirstNode;
  925. while (pNodeNext)
  926. {
  927. SNodeItemsInfo* pNodeDelete = pNodeNext;
  928. pNodeNext = pNodeNext->m_pNextNode;
  929. delete pNodeDelete;
  930. };
  931. }
  933. // Function name : CQComboBox::QSnapLoader::QSnapLoader
  934. // Description     : default constructor
  935. // Return type : 
  936. CQComboBox::QSnapLoader::QSnapLoader()
  937. {
  938. m_pFirstNode = new SNodeItemsInfo(0,0,0);
  939. }
  941. // Function name : CQComboBox::QSnapLoader::SetParent
  942. // Description     : Set the parent of this structure
  943. // Return type : void 
  944. // Argument         : CQComboBox * pParent
  945. void CQComboBox::QSnapLoader::SetParent(CQComboBox * pParent)
  946. {
  947. m_pParent = pParent;
  948. }
  950. // Function name : CQComboBox::QSnapLoader::GetListNodes
  951. // Description     : 
  952. // Return type : CString 
  953. CString CQComboBox::QSnapLoader::GetListNodes()
  954. {
  955. CString text;
  956. SNodeItemsInfo* pIncreaseNode = m_pFirstNode;
  957. int s = 0;
  958. while (pIncreaseNode)
  959. {
  960. CString t;
  961. t.Format(_T("(%i,%i,%i, [%i,%i])rn"), pIncreaseNode->m_nItemLine, pIncreaseNode->m_nCount, pIncreaseNode->m_nItemLB, pIncreaseNode->GetLastLine(), pIncreaseNode->GetLastItem());
  962. text += t;
  963. s += pIncreaseNode->m_nCount;
  964. pIncreaseNode = pIncreaseNode->m_pNextNode;
  965. }
  966. CString t;
  967. t.Format(_T("Count loaded: %i, Count items. listbox() %i"), s, m_pParent->GetListBox()->GetCount());
  968. text += t;
  969. return text;
  970. }
  972. // Function name : CQComboBox::QSnapLoader::Load
  973. // Description     : 
  974. // Return type : void 
  975. // Argument         : int nItemFrom
  976. // Argument         : int nHowMany
  977. // This function will return the real position into listbox.
  978. int CQComboBox::QSnapLoader::Load(int nItemFrom, int nHowMany)
  979. {
  980. int nIF = abs(nItemFrom + (nHowMany < 0 ? nHowMany : 0));
  981. int nHM = abs(nHowMany), nResult = nItemFrom;
  982. CWnd* pWndParentWindowOfCombo = m_pParent->GetParent();
  983. if (nHM = min(nHM, max(0,m_pParent->GetCountItem() - nIF)))
  984. {
  985. //Something must load
  986. ASSERT (nHM != NULL);
  987. SNodeItemsInfo* pNodeNext = m_pFirstNode;
  988. SNodeItemsInfo* pNodePrev = NULL;
  989. // Already the constructor was called
  990. ASSERT (pNodeNext);
  991. //Find the nodes ie pPrevNext->m_nItemLine <= nIF < pPrevNext->m_nItemLine
  992. while (pNodeNext && (nIF >= pNodeNext->m_nItemLine))
  993. {
  994. pNodePrev = pNodeNext;
  995. pNodeNext = pNodeNext->m_pNextNode;
  996. }
  998. // If in the first block , number of items count is equal with total number of items,
  999. // then this function will not be called again. The next function that will
  1000. //be called will be AlreadyLoadPartialListBox.
  1001. if (m_pFirstNode->m_nCount == m_pParent->GetCountItem())
  1002. {
  1003. m_pParent->m_fctLoadFunction = m_pParent->AlreadyLoadPartialListBox;
  1004. return nItemFrom;
  1005. }
  1007. LPCTSTR lpszItemLB = NULL;
  1008. LPARAM lParam = NULL;
  1009. int nFirst = pNodePrev->GetLastLine(), nItem = pNodePrev->GetLastItem();
  1010. CListBox* pListBox = m_pParent->GetListBox();
  1011. nResult = pNodePrev->GetLastItem();
  1013. if (pNodeNext == NULL)
  1014. {
  1015. // After the prev node do not exist another node.
  1016. BOOL bEnd = TRUE;
  1017. if (nIF > nFirst)
  1018. {
  1019. SNodeItemsInfo* sThis = pNodePrev;
  1020. pNodePrev = new SNodeItemsInfo(nIF,0, nResult );
  1021. sThis->m_pNextNode = pNodePrev;
  1022. pNodePrev->m_pPrevNode = sThis;
  1023. nFirst = nIF;
  1024. bEnd = FALSE;
  1025. }
  1026. else
  1027. {
  1028. nResult = pNodePrev->m_nItemLB + nIF - pNodePrev->m_nItemLine;
  1029. }
  1030. NotifyWindow(pWndParentWindowOfCombo, m_nLoading, m_pParent->m_hWnd, nFirst);
  1031. int i = 0;
  1032. for (i = 0; (lpszItemLB = m_pParent->Line(nFirst + i, lParam)) && (i < nHM); i++)
  1033. {
  1034. pListBox->SetItemData(nItem = pListBox->InsertString(nItem, lpszItemLB), lParam);
  1035. pNodePrev->m_nCount++;
  1036. nItem++;
  1037. }
  1038. NotifyWindow(pWndParentWindowOfCombo, m_nLoaded, m_pParent->m_hWnd, i);
  1039. }
  1040. else
  1041. {
  1042. SNodeItemsInfo* pIncreaseNode = pNodeNext->m_pNextNode;
  1043. int nDiff = pNodeNext->m_nItemLine - nFirst;
  1044. ASSERT ( nDiff >= 0 );
  1045. nItem = nResult; // first item that will be inserted
  1046. // {...+..} ___ {...+..}
  1047. if (nDiff <= nHM)
  1048. {
  1049. // The real nHM will be the diference between nHowMany - nDiff
  1050. nHM = nDiff;
  1051. // Try to restrict these node in only one.
  1052. pNodePrev->m_nCount += pNodeNext->m_nCount + nHM;
  1053. pNodePrev->m_pNextNode = pNodeNext->m_pNextNode;
  1054. delete pNodeNext;
  1055. nResult = pNodePrev->m_nItemLB + nIF - pNodePrev->m_nItemLine;
  1056. }
  1057. else
  1058. {
  1059. //      nFirst
  1060. //        /--- > nHM --
  1061. // {...+..} __+________{......}
  1062. if (nIF < nFirst)
  1063. {
  1064. nResult = pNodePrev->m_nItemLB + nIF - pNodePrev->m_nItemLine;
  1065. nFirst = pNodePrev->GetLastLine();
  1066. pNodePrev->m_nCount += nHM;
  1067. pIncreaseNode = pNodeNext;
  1068. }
  1069. // {......} ______+___ {...+...}
  1070. else
  1071. if (nIF + nHM >= pNodeNext->m_nItemLine)
  1072. {
  1073. nHM = pNodeNext->m_nItemLine - nIF;
  1074. pNodeNext->m_nItemLine = nIF;
  1075. pNodeNext->m_nCount += nHM;
  1076. //pNodeNext->m_nItemLB remains constant
  1077. nItem = pNodeNext->m_nItemLB;
  1078. nFirst = nIF;
  1079. nResult = pNodeNext->m_nItemLB;
  1080. }
  1081. // {......} __+____+___ {......}
  1082. else
  1083. {
  1084. SNodeItemsInfo* sThis = new SNodeItemsInfo(nIF, nHM, nResult );
  1085. sThis->m_pPrevNode = pNodePrev;
  1086. sThis->m_pNextNode = pNodeNext;
  1087. pNodePrev->m_pNextNode = sThis;
  1088. pNodeNext->m_pPrevNode = sThis;
  1089. nFirst = nIF;
  1090. pIncreaseNode = pNodeNext;
  1091. }
  1092. }
  1093. // if some items must insert, do it
  1094. if (nHM > 0)
  1095. {
  1096. NotifyWindow(pWndParentWindowOfCombo, m_nLoading, m_pParent->m_hWnd, nFirst);
  1097. for (int i = 0; i < nHM; i++)
  1098. {
  1099. lpszItemLB = m_pParent->Line(nFirst + i, lParam);
  1100. // while pNodePrev and pNodeNext exist !
  1101. ASSERT (lpszItemLB);
  1102. pListBox->SetItemData(nItem = pListBox->InsertString(nItem, lpszItemLB), lParam);
  1103. nItem++;
  1104. }
  1105. while (pIncreaseNode)
  1106. {
  1107. pIncreaseNode->m_nItemLB += nHM;
  1108. pIncreaseNode = pIncreaseNode->m_pNextNode;
  1109. }
  1110. NotifyWindow(pWndParentWindowOfCombo, m_nLoaded, m_pParent->m_hWnd, nHM);
  1111. }
  1113. }
  1114. }
  1115. return nResult;
  1116. }
  1118. // Function name : CQComboBox::QSnapLoader::GetItemLine
  1119. // Description     : return the real line, converts from nItemLB
  1120. // Return type : int 
  1121. // Argument         : int nItemLB
  1122. int CQComboBox::QSnapLoader::GetItemLine(int nItemLB)
  1123. {
  1124. nItemLB = max(0,nItemLB);
  1125. SNodeItemsInfo* pNodeNext = m_pFirstNode;
  1126. while (pNodeNext && ( pNodeNext->m_nItemLB > nItemLB ))
  1127. pNodeNext = pNodeNext->m_pNextNode;
  1128. return pNodeNext->m_nItemLine  + nItemLB - pNodeNext->m_nItemLB;
  1129. }