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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTHeaderCtrl.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：18k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTHeaderCtrl.cpp：源码内容
  1. // XTHeaderCtrl.cpp : implementation of the CXTHeaderCtrl class.
  2. //
  3. // This file is a part of the XTREME CONTROLS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "Common/XTPResourceManager.h"
  23. #include "Common/XTPWinThemeWrapper.h"
  24. #include "Common/XTPColorManager.h"
  25. #include "Common/XTPDrawHelpers.h"
  26. #include "Common/XTPImageManager.h"
  28. #include "XTGlobal.h"
  29. #include "Resource.h"
  30. #include "XTVC50Helpers.h"
  32. #include "XTHeaderCtrlTheme.h"
  33. #include "XTHeaderCtrl.h"
  34. #include "XTFunctions.h"
  36. #ifdef _DEBUG
  37. #define new DEBUG_NEW
  38. #undef THIS_FILE
  39. static char THIS_FILE[] = __FILE__;
  40. #endif
  42. IMPLEMENT_THEME_HOST(CXTHeaderCtrl)
  43. IMPLEMENT_THEME_REFRESH(CXTHeaderCtrl, CHeaderCtrl)
  45. /////////////////////////////////////////////////////////////////////////////
  46. // CXTHeaderCtrl
  48. CXTHeaderCtrl::CXTHeaderCtrl()
  49. : CXTThemeManagerStyleHost(GetThemeFactoryClass())
  50. , m_iMinSize(0)
  51. , m_nPos(0)
  52. , m_iOverIndex(-1)
  53. , m_nSortedCol(-1)
  54. , m_bRTL(DetermineRTL())
  55. , m_bAutoSize(false)
  56. , m_bEnableMenus(TRUE)
  57. , m_bAscending(TRUE)
  58. , m_bLBtnDown(FALSE)
  59. , m_bPainted(FALSE)
  60. , m_popupMenuID(0)
  61. , m_pt(CPoint(0, 0))
  62. {
  63. m_pImageManager = NULL;
  64. }
  66. CXTHeaderCtrl::~CXTHeaderCtrl()
  67. {
  68. CMDTARGET_RELEASE(m_pImageManager);
  69. }
  71. void CXTHeaderCtrl::SetImageManager(CXTPImageManager* pImageManager)
  72. {
  73. CMDTARGET_RELEASE(m_pImageManager);
  74. m_pImageManager = pImageManager;
  75. }
  77. BEGIN_MESSAGE_MAP(CXTHeaderCtrl, CHeaderCtrl)
  78. //{{AFX_MSG_MAP(CXTHeaderCtrl)
  79. ON_WM_WINDOWPOSCHANGING()
  80. ON_WM_SETCURSOR()
  81. ON_WM_PAINT()
  82. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  83. ON_WM_ERASEBKGND()
  84. ON_WM_LBUTTONDOWN()
  85. ON_WM_LBUTTONUP()
  86. ON_WM_MOUSEMOVE()
  87. ON_WM_TIMER()
  88. ON_WM_DESTROY()
  89. ON_WM_RBUTTONDOWN()
  90. ON_NOTIFY_REFLECT_EX(HDN_ITEMCHANGING, OnItemchanging)
  91. ON_COMMAND(XT_IDC_SORTASC, OnSortAsc)
  92. ON_COMMAND(XT_IDC_SORTDSC, OnSortDsc)
  93. ON_COMMAND(XT_IDC_ALIGNLEFT, OnAlignLeft)
  94. ON_COMMAND(XT_IDC_ALIGNCENTER, OnAlignCenter)
  95. ON_COMMAND(XT_IDC_ALIGNRIGHT, OnAlignRight)
  96. ON_MESSAGE(HDM_LAYOUT, OnLayout)
  97. //}}AFX_MSG_MAP
  98. END_MESSAGE_MAP()
  100. IMPLEMENT_DYNAMIC(CXTHeaderCtrl, CHeaderCtrl)
  102. /////////////////////////////////////////////////////////////////////////////
  103. // CXTHeaderCtrl message handlers
  105. void CXTHeaderCtrl::OnThemeChanged()
  106. {
  107. RecalcLayout();
  108. }
  110. BOOL CXTHeaderCtrl::IsThemeValid() const
  111. {
  112. return (GetTheme() != NULL);
  113. }
  115. void CXTHeaderCtrl::ApplyFieldWidths(int iNewWidth)
  116. {
  117. CListCtrl* pListCtrl = (CListCtrl*)GetParent();
  118. ASSERT_VALID(pListCtrl);
  120. int iItemCount = GetItemCount();
  121. int iFrozenCount = (int)m_arFrozenCols.GetCount();
  122. int iThawedCount = iItemCount - iFrozenCount;
  124. if (iThawedCount <= 0)
  125. return;
  127. int iWidth = iNewWidth/iThawedCount;
  129. int iItem;
  130. for (iItem = 0; iItem < iItemCount; iItem++)
  131. {
  132. if (IsColFrozen(iItem))
  133. continue;
  135. if (iWidth > m_iMinSize)
  136. pListCtrl->SetColumnWidth(iItem, iWidth);
  138. iNewWidth -= iWidth;
  139. }
  140. }
  142. void CXTHeaderCtrl::ResizeColumnsToFit()
  143. {
  144. FitFieldWidths(0);
  145. }
  147. void CXTHeaderCtrl::FitFieldWidths(int iNewWidth)
  148. {
  149. if (iNewWidth <= 0)
  150. {
  151. CXTPWindowRect rc(this);
  152. iNewWidth = rc.Width();
  153. }
  155. // adjust for vertical scroll bar.
  156. DWORD dwStyle = ::GetWindowLong(::GetParent(m_hWnd), GWL_STYLE);
  157. if ((dwStyle & WS_VSCROLL) == WS_VSCROLL)
  158. iNewWidth -= ::GetSystemMetrics(SM_CXVSCROLL);
  160. // adjust for frozen columns.
  161. iNewWidth -= GetFrozenColWidth();
  163. ApplyFieldWidths(iNewWidth);
  164. }
  166. void CXTHeaderCtrl::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos)
  167. {
  168. if (m_bAutoSize)
  169. {
  170. int iCount = GetItemCount();
  171. if (iCount > 0)
  172. {
  173. if (GetCapture() != GetParent()) // indicates scrolling
  174. {
  175. // is the window size changing?
  176. CXTPWindowRect rc(this);
  177. if (rc.Width() != lpwndpos->cx)
  178. {
  179. FitFieldWidths(lpwndpos->cx);
  180. }
  181. }
  182. }
  183. }
  184. else
  185. {
  186. CHeaderCtrl::OnWindowPosChanging(lpwndpos);
  187. }
  188. }
  190. void CXTHeaderCtrl::EnableAutoSize(bool bEnable/*=true*/)
  191. {
  192. m_bAutoSize = bEnable;
  193. }
  195. void CXTHeaderCtrl::FreezeColumn(int iCol)
  196. {
  197. m_arFrozenCols.AddTail(iCol);
  198. }
  200. void CXTHeaderCtrl::ThawColumn(int iCol)
  201. {
  202. for (POSITION pos = m_arFrozenCols.GetHeadPosition(); pos; m_arFrozenCols.GetNext(pos))
  203. {
  204. int iNext = m_arFrozenCols.GetAt(pos);
  205. if (iNext == iCol)
  206. {
  207. m_arFrozenCols.RemoveAt(pos);
  208. break;
  209. }
  210. }
  211. }
  213. void CXTHeaderCtrl::ThawAllColumns()
  214. {
  215. m_arFrozenCols.RemoveAll();
  216. }
  218. BOOL CXTHeaderCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  219. {
  220. if (m_arFrozenCols.GetCount())
  221. {
  222. CPoint pt;
  223. ::GetCursorPos(&pt);
  225. CPoint ptClient = pt;
  226. ScreenToClient(&ptClient);
  228. HDHITTESTINFO hti;
  229. ::ZeroMemory(&hti, sizeof(hti));
  230. hti.pt.x = ptClient.x;
  231. hti.pt.y = ptClient.y;
  233. int nIndex = (int)::SendMessage(GetSafeHwnd(),
  234. HDM_HITTEST, 0L, (LPARAM)&hti);
  236. if (nIndex > -1)
  237. {
  238. // if we are over one of the frozen columns, we can stop
  239. if (IsColFrozen(nIndex))
  240. {
  241. ::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  242. return TRUE;
  243. }
  245. else
  246. {
  247. // determine if the current index is adjacent to a frozen column index.
  248. // if columns are resized by dragging to the right, test for the frozen column on the left.
  249. // if columns are resized by dragging to the left, test for the frozen column on the right.
  251. int iAdjIndex = nIndex + (m_bRTL ? 1 : -1);
  252. if ((iAdjIndex > -1) && IsColFrozen(iAdjIndex))
  253. {
  254. CRect r;
  255. Header_GetItemRect(m_hWnd, nIndex, &r);
  256. int nMidPoint = (r.left + (r.Width()/2));
  258. // if columns resize to the right and the point is the right half of the header item...
  259. if (!m_bRTL && (ptClient.x <= nMidPoint))
  260. {
  261. ::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  262. return TRUE;
  263. }
  265. // if columns resize to the left and the point is the left half of the header item...
  266. else if (m_bRTL && (ptClient.x >= nMidPoint))
  267. {
  268. ::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  269. return TRUE;
  270. }
  271. }
  272. }
  273. }
  274. }
  276. return CHeaderCtrl::OnSetCursor(pWnd, nHitTest, message);
  277. }
  279. BOOL CXTHeaderCtrl::OnItemchanging(NMHDR* pNMHDR, LRESULT* pResult)
  280. {
  281. HD_NOTIFY* pHDN = (HD_NOTIFY*)pNMHDR;
  282. *pResult = FALSE;
  284. if (pHDN && (pHDN->pitem->mask & HDI_WIDTH) != 0)
  285. {
  286. // if sizing is disabled for this column, keep the user from resizing
  287. if (m_arFrozenCols.GetCount() && IsColFrozen(pHDN->iItem))
  288. *pResult = TRUE;
  290. // if the column is smaller than the minimum size, keep the user from resizing
  291. if (pHDN->pitem->mask & HDI_WIDTH && pHDN->pitem->cxy < m_iMinSize)
  292. *pResult = TRUE;
  293. }
  295. return BOOL(*pResult);
  296. }
  298. bool CXTHeaderCtrl::IsColFrozen(int iCol)
  299. {
  300. for (POSITION pos = m_arFrozenCols.GetHeadPosition(); pos; m_arFrozenCols.GetNext(pos))
  301. {
  302. int iNext = m_arFrozenCols.GetAt(pos);
  303. if (iNext == iCol)
  304. {
  305. return true;
  306. }
  307. }
  309. return false;
  310. }
  312. bool CXTHeaderCtrl::DetermineRTL()
  313. {
  314. CWindowDC dc(NULL);
  316. // determine if columns are resized by dragging them right (most languages) or
  317. // left (RTL languages like Arabic & Hebrew).
  319. UINT nAlign = dc.GetTextAlign();
  320. ASSERT(nAlign != GDI_ERROR);
  322. // will only be true for RTL languages, text is laid out right to left and
  323. // columns resize to the left
  324. if ((nAlign != GDI_ERROR) && (nAlign & TA_RTLREADING))
  325. {
  326. return true;
  327. }
  329. return false;
  330. }
  332. int CXTHeaderCtrl::GetFrozenColWidth()
  333. {
  334. int iFrozenWidth = 0;
  336. for (POSITION pos = m_arFrozenCols.GetHeadPosition(); pos; m_arFrozenCols.GetNext(pos))
  337. {
  338. int iCol = m_arFrozenCols.GetAt(pos);
  340. CRect r;
  341. Header_GetItemRect(m_hWnd, iCol, &r);
  342. iFrozenWidth += r.Width();
  343. }
  345. return iFrozenWidth;
  346. }
  348. void CXTHeaderCtrl::SetMinSize(int iMinSize)
  349. {
  350. m_iMinSize = iMinSize;
  351. }
  353. void CXTHeaderCtrl::OnPaint()
  354. {
  355. CPaintDC dc(this);
  357. if (IsThemeValid())
  358. {
  359. CXTPBufferDC memDC(dc);
  360. GetTheme()->DrawHeader(&memDC, this);
  361. }
  362. else
  363. {
  364. CHeaderCtrl::DefWindowProc(WM_PAINT, (WPARAM)dc.m_hDC, 0);
  365. }
  366. }
  368. LRESULT CXTHeaderCtrl::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  369. {
  370. CDC* pDC = CDC::FromHandle((HDC)wParam);
  371. if (pDC && IsThemeValid())
  372. {
  373. GetTheme()->DrawHeader(pDC, this);
  374. return TRUE;
  375. }
  377. return Default();
  378. }
  380. BOOL CXTHeaderCtrl::OnEraseBkgnd(CDC* /*pDC*/)
  381. {
  382. return TRUE;
  383. }
  385. void CXTHeaderCtrl::OnLButtonDown(UINT nFlags, CPoint point)
  386. {
  387. m_bLBtnDown = TRUE;
  388. CHeaderCtrl::OnLButtonDown(nFlags, point);
  389. }
  391. void CXTHeaderCtrl::OnLButtonUp(UINT nFlags, CPoint point)
  392. {
  393. m_bLBtnDown = FALSE;
  394. CHeaderCtrl::OnLButtonUp(nFlags, point);
  395. }
  397. void CXTHeaderCtrl::OnMouseMove(UINT nFlags, CPoint point)
  398. {
  399. if (IsThemeValid() && GetTheme()->UseWinXPThemes(this))
  400. {
  401. SetTimer(1, 10, NULL);
  402. }
  404. CHeaderCtrl::OnMouseMove(nFlags, point);
  405. }
  407. int CXTHeaderCtrl::HitTest(CPoint pt, UINT* pFlags/*=NULL*/) const
  408. {
  409. HDHITTESTINFO hti;
  410. hti.pt.x = pt.x;
  411. hti.pt.y = pt.y;
  413. int iItem = (int)::SendMessage(m_hWnd, HDM_HITTEST, 0, (LPARAM)(&hti));
  415. if (pFlags != NULL)
  416. *pFlags = hti.flags;
  418. return iItem;
  419. }
  421. BOOL CXTHeaderCtrl::ItemPressed(int iItem)
  422. {
  423. if (m_bLBtnDown)
  424. {
  425. CPoint point;
  426. ::GetCursorPos(&point);
  427. ScreenToClient(&point);
  429. UINT uFlags;
  430. if (HitTest(point, &uFlags) == iItem)
  431. return ((uFlags & HHT_ONHEADER) == HHT_ONHEADER);
  432. }
  434. return FALSE;
  435. }
  437. void CXTHeaderCtrl::OnTimer(UINT_PTR nIDEvent)
  438. {
  439. if (nIDEvent == 1)
  440. {
  441. CPoint pt;
  442. ::GetCursorPos(&pt);
  443. ScreenToClient(&pt);
  445. int iOverIndex = HitTest(pt);
  446. if (iOverIndex == -1)
  447. {
  448. KillTimer(1);
  450. if (m_bPainted == TRUE)
  451. {
  452. RedrawWindow();
  453. }
  455. m_bPainted = false;
  456. return;
  457. }
  459. if (iOverIndex != m_iOverIndex)
  460. {
  461. m_iOverIndex = iOverIndex;
  462. m_bPainted = false;
  463. }
  465. if (!m_bPainted)
  466. {
  467. RedrawWindow();
  468. m_bPainted = true;
  469. }
  470. }
  472. CHeaderCtrl::OnTimer(nIDEvent);
  473. }
  475. LRESULT CXTHeaderCtrl::OnLayout(WPARAM wParam, LPARAM lParam)
  476. {
  477. if (IsThemeValid())
  478. {
  479. return (LRESULT)GetTheme()->Layout(
  480. (LPHDLAYOUT)lParam, this);
  481. }
  483. return CHeaderCtrl::DefWindowProc(HDM_LAYOUT, wParam, lParam);
  484. }
  486. int CXTHeaderCtrl::SetSortImage(int iSortCol, BOOL bSortAsc)
  487. {
  488. ASSERT(iSortCol < GetItemCount());
  490. int nPrevCol = m_nSortedCol;
  491. m_nSortedCol = iSortCol;
  492. m_bAscending = bSortAsc;
  494. RedrawWindow();
  495. return nPrevCol;
  496. }
  498. int CXTHeaderCtrl::GetSortedCol(BOOL* pbSortAsc/*=NULL*/)
  499. {
  500. if (pbSortAsc)
  501. *pbSortAsc = m_bAscending;
  503. return m_nSortedCol;
  504. }
  506. BOOL CXTHeaderCtrl::RecalcLayout()
  507. {
  508. if (!::IsWindow(m_hWnd))
  509. return FALSE;
  511. HD_LAYOUT hdl;
  513. CXTPClientRect rcClient(this);
  514. hdl.prc = &rcClient;
  516. WINDOWPOS wp;
  517. ZeroMemory(&wp, sizeof(WINDOWPOS));
  518. hdl.pwpos = &wp;
  520. if (!Header_Layout(m_hWnd, &hdl))
  521. return FALSE;
  523. // Set the size, position, and visibility of the header window.
  524. ::SetWindowPos(m_hWnd, wp.hwndInsertAfter, wp.x, wp.y,
  525. wp.cx, wp.cy, wp.flags | SWP_FRAMECHANGED);
  527. CWnd* pWndParent = GetParent();
  528. if (!::IsWindow(pWndParent->GetSafeHwnd()))
  529. return FALSE;
  531. // Force list control to recalculate it's layout.
  532. CXTPWindowRect rcWindow(pWndParent);
  534. const int cx = rcWindow.Width();
  535. const int cy = rcWindow.Height();
  537. pWndParent->SetWindowPos(NULL, 0, 0, cx, cy+1,
  538. SWP_NOMOVE | SWP_FRAMECHANGED);
  540. pWndParent->SetWindowPos(NULL, 0, 0, cx, cy,
  541. SWP_NOMOVE | SWP_FRAMECHANGED);
  543. return TRUE;
  544. }
  546. void CXTHeaderCtrl::OnDestroy()
  547. {
  548. if (IsThemeValid())
  549. GetTheme()->CleanUp(this);
  551. CHeaderCtrl::OnDestroy();
  552. }
  554. void CXTHeaderCtrl::SetBitmap(int iCol, UINT uBitmapID, DWORD dwRemove/*=NULL*/)
  555. {
  556. if (dwRemove)
  557. {
  558. HD_ITEM hdi;
  559. hdi.mask = HDI_FORMAT;
  560. GetItem(iCol, &hdi);
  561. hdi.fmt &= ~dwRemove;
  562. SetItem(iCol, &hdi);
  563. }
  565. SetBitmap(iCol, uBitmapID, FALSE, RGB(192, 192, 192));
  566. }
  568. void CXTHeaderCtrl::SetBitmap(int iCol, UINT uBitmapID, BOOL bRemove, COLORREF crMask)
  569. {
  570. if (IsThemeValid())
  571. {
  572. GetTheme()->SetBitmap(iCol, uBitmapID, bRemove, crMask, this);
  573. }
  574. }
  576. void CXTHeaderCtrl::InitializeHeader(BOOL bBoldFont)
  577. {
  578. SetFont(bBoldFont ? &XTAuxData().fontBold : &XTAuxData().font);
  579. RedrawWindow();
  580. }
  582. void CXTHeaderCtrl::OnRButtonDown(UINT nFlags, CPoint point)
  583. {
  584. CPoint pt = m_pt = point;
  585. ClientToScreen(&pt);
  587. // If no sort headers are defined for the parent control or popup menus
  588. // has been disabled, call the base class and return.
  589. CWnd* pParentWnd = GetParent();
  590. if (pParentWnd->GetStyle() & LVS_NOSORTHEADER || m_bEnableMenus == FALSE)
  591. {
  592. CHeaderCtrl::OnRButtonDown(nFlags, point);
  593. return;
  594. }
  596. // No menu was defined use default
  597. if (!m_popupMenuID)
  598. {
  599. // Get the index to the header item under the cursor.
  600. int iIndex = HitTest(m_pt);
  602. if (iIndex != -1)
  603. {
  604. CMenu menu;
  605. VERIFY(XTPResourceManager()->LoadMenu(&menu, XT_IDM_POPUP));
  607. CMenu* pPopup = menu.GetSubMenu(2);
  608. ASSERT(pPopup != NULL);
  609. if (!pPopup)
  610. return;
  612. if (m_nSortedCol == iIndex && m_bAscending == TRUE)
  613. pPopup->CheckMenuItem(XT_IDC_SORTASC, MF_CHECKED | MF_BYCOMMAND);
  615. else if (m_nSortedCol == iIndex && m_bAscending == FALSE)
  616. pPopup->CheckMenuItem(XT_IDC_SORTDSC, MF_CHECKED | MF_BYCOMMAND);
  618. if (pParentWnd && (
  619. pParentWnd->IsKindOf(RUNTIME_CLASS(CListCtrl)) ||
  620. pParentWnd->IsKindOf(RUNTIME_CLASS(CListView))))
  621. {
  622. LVCOLUMN lvc;
  623. lvc.mask = LVCF_FMT;
  625. ListView_GetColumn(pParentWnd->m_hWnd, iIndex, &lvc);
  627. switch (lvc.fmt & LVCFMT_JUSTIFYMASK)
  628. {
  629. case LVCFMT_LEFT:
  630. pPopup->CheckMenuItem(XT_IDC_ALIGNLEFT, MF_CHECKED | MF_BYCOMMAND);
  631. break;
  632. case LVCFMT_CENTER:
  633. pPopup->CheckMenuItem(XT_IDC_ALIGNCENTER, MF_CHECKED | MF_BYCOMMAND);
  634. break;
  635. case LVCFMT_RIGHT:
  636. pPopup->CheckMenuItem(XT_IDC_ALIGNRIGHT, MF_CHECKED | MF_BYCOMMAND);
  637. break;
  638. }
  639. }
  641. XTFuncContextMenu(pPopup, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, this, XT_IDR_TBAR_HDR);
  642. }
  643. }
  644. else
  645. {
  646. CMenu menu;
  647. VERIFY(menu.LoadMenu(m_popupMenuID));
  649. CMenu* pPopup = menu.GetSubMenu(m_nPos);
  650. ASSERT(pPopup != NULL);
  651. if (!pPopup)
  652. return;
  654. pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON,
  655. pt.x, pt.y, GetOwner());
  656. }
  657. }
  659. void CXTHeaderCtrl::SetMenuID(UINT popupMenuID, int nPos)
  660. {
  661. m_popupMenuID = popupMenuID;
  662. m_nPos = nPos;
  663. }
  665. void CXTHeaderCtrl::SendNotify(int iIndex)
  666. {
  667. CWnd* pParentWnd = GetParent();
  668. if (!pParentWnd || !::IsWindow(pParentWnd->m_hWnd))
  669. return;
  671. if (pParentWnd->IsKindOf(RUNTIME_CLASS(CListCtrl)) ||
  672. pParentWnd->IsKindOf(RUNTIME_CLASS(CListView)))
  673. {
  674. TCHAR  lpBuffer[256];
  676. HDITEM hdi;
  677. hdi.mask = HDI_TEXT | HDI_BITMAP | HDI_FORMAT | HDI_IMAGE | HDI_LPARAM | HDI_ORDER | HDI_WIDTH;
  678. hdi.pszText = lpBuffer;
  679. hdi.cchTextMax = 256;
  681. GetItem(iIndex, &hdi);
  683. NMHEADER nmh;
  684. nmh.hdr.hwndFrom = m_hWnd;
  685. nmh.hdr.idFrom = GetDlgCtrlID();
  686. nmh.hdr.code = HDN_ITEMCLICK;
  687. nmh.iItem = iIndex;
  688. nmh.iButton = 1;
  689. nmh.pitem = &hdi;
  691. // send message to the parent's owner window.
  692. pParentWnd->SendMessage(WM_NOTIFY,
  693. (WPARAM)(int)nmh.hdr.idFrom, (LPARAM)(NMHEADER*)&nmh);
  695. // then forward to the descendants.
  696. pParentWnd->SendMessageToDescendants(WM_NOTIFY,
  697. (WPARAM)(int)nmh.hdr.idFrom, (LPARAM)(NMHEADER*)&nmh);
  698. }
  699. }
  701. void CXTHeaderCtrl::OnSortAsc()
  702. {
  703. int iIndex = HitTest(m_pt);
  704. if (iIndex != -1)
  705. {
  706. if (m_nSortedCol != iIndex || m_bAscending == FALSE)
  707. {
  708. m_bAscending = TRUE;
  709. m_nSortedCol = iIndex;
  710. SendNotify(iIndex);
  711. }
  712. }
  713. }
  715. void CXTHeaderCtrl::OnSortDsc()
  716. {
  717. int iIndex = HitTest(m_pt);
  718. if (iIndex != -1)
  719. {
  720. if (m_nSortedCol != iIndex || m_bAscending == TRUE)
  721. {
  722. m_bAscending = FALSE;
  723. m_nSortedCol = iIndex;
  724. SendNotify(iIndex);
  725. }
  726. }
  727. }
  729. BOOL CXTHeaderCtrl::SetAlingment(int nFlag)
  730. {
  731. int iIndex = HitTest(m_pt);
  733. if (iIndex != -1)
  734. {
  735. CWnd* pParentWnd = GetParent();
  736. if (pParentWnd && (
  737. pParentWnd->IsKindOf(RUNTIME_CLASS(CListCtrl)) ||
  738. pParentWnd->IsKindOf(RUNTIME_CLASS(CListView))))
  739. {
  740. LVCOLUMN lvc;
  741. lvc.mask = LVCF_FMT;
  743. ListView_GetColumn(pParentWnd->m_hWnd, iIndex, &lvc);
  744. lvc.fmt &= ~LVCFMT_JUSTIFYMASK;
  745. lvc.fmt |= nFlag;
  746. ListView_SetColumn(pParentWnd->m_hWnd, iIndex, &lvc);
  747. ListView_SetWorkAreas(pParentWnd->m_hWnd, 0, NULL);
  748. }
  749. }
  751. return FALSE;
  752. }
  754. void CXTHeaderCtrl::OnAlignLeft()
  755. {
  756. SetAlingment(LVCFMT_LEFT);
  757. }
  759. void CXTHeaderCtrl::OnAlignCenter()
  760. {
  761. SetAlingment(LVCFMT_CENTER);
  762. }
  764. void CXTHeaderCtrl::OnAlignRight()
  765. {
  766. SetAlingment(LVCFMT_RIGHT);
  767. }
  769. BOOL CXTHeaderCtrl::HasSortArrow()
  770. {
  771. if (IsThemeValid())
  772. return GetTheme()->HasSortArrow();
  773. return FALSE;
  774. }
  776. void CXTHeaderCtrl::ShowSortArrow(BOOL bSortArrow)
  777. {
  778. if (IsThemeValid())
  779. {
  780. DWORD dwStyle = GetTheme()->GetDrawStyle() & ~XTTHEME_SORTARROW;
  782. if (bSortArrow)
  783. dwStyle |= XTTHEME_SORTARROW;
  785. GetTheme()->SetDrawStyle(dwStyle, this);
  786. }
  787. }
  789. void CXTHeaderCtrl::SetFontBold(BOOL bBoldFont)
  790. {
  791. ASSERT(::IsWindow(m_hWnd));
  792. SetFont(bBoldFont ? &XTAuxData().fontBold : &XTAuxData().font);
  793. }
  795. /////////////////////////////////////////////////////////////////////////////
  796. // CXTFlatHeaderCtrl
  798. IMPLEMENT_DYNAMIC(CXTFlatHeaderCtrl, CXTHeaderCtrl)
  800. CXTFlatHeaderCtrl::CXTFlatHeaderCtrl()
  801. {
  802. SetTheme(new CXTHeaderCtrlThemeOfficeXP());
  803. }
  805. CXTFlatHeaderCtrl::~CXTFlatHeaderCtrl()
  806. {
  808. }