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

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

对话框与窗口

开发平台：

Visual C++

XTPReportHeader.cpp：源码内容
  1. // XTPReportHeader.cpp : implementation of the CXTPReportHeader class.
  2. //
  3. // This file is a part of the XTREME REPORTCONTROL 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 "Resource.h"
  23. #include "Common/Resource.h"
  25. #include "Common/XTPDrawHelpers.h"
  26. #include "Common/XTPPropExchange.h"
  27. #include "Common/XTPToolTipContext.h"
  28. #include "Common/XTPResourceManager.h"
  30. #include "XTPReportColumn.h"
  31. #include "XTPReportColumns.h"
  32. #include "XTPReportRecordItem.h"
  33. #include "XTPReportControl.h"
  34. #include "XTPReportPaintManager.h"
  35. #include "XTPReportSubListControl.h"
  36. #include "XTPReportFilterEditControl.h"
  37. #include "XTPReportDragDrop.h"
  38. #include "XTPReportInplaceControls.h"
  39. #include "XTPReportHeader.h"
  41. #ifdef _DEBUG
  42. #define new DEBUG_NEW
  43. #undef THIS_FILE
  44. static char THIS_FILE[] = __FILE__;
  45. #endif
  47. /////////////////////////////////////////////////////////////////////////////
  48. // CXTPReportHeader
  49. int CXTPReportHeader::s_nMinAutoScrollStep = 3;
  50. BOOL CXTPReportHeader::s_bShowItemsInGroupsPXDefault = TRUE;
  51. BOOL CXTPReportHeader::s_bSendContextMenuForWholeHeaderArea = FALSE;
  53. CXTPReportHeader::CXTPReportHeader(CXTPReportControl* pControl, CXTPReportColumns* pColumns)
  54. : m_pColumns(pColumns), m_pControl(pControl)
  55. {
  56. m_nResizeCaptureRange = 3;
  57. m_pSubList = NULL;
  58. m_pFilterEdit = NULL;
  59. m_dragMode = dragNothing;
  60. m_nDropIndex = -1;
  61. m_rcHeader.SetRect(0, 0, 0, 0);
  62. m_pDropWnd = NULL;
  63. m_pDragWnd = NULL;
  64. m_pHotTrackingColumn = NULL;
  66. m_bAllowColumnResize = TRUE;
  67. m_bAllowColumnRemove = TRUE;
  68. m_bAllowColumnReorder = TRUE;
  69. m_bAllowColumnSort = TRUE;
  72. m_pDragColumn = NULL;
  74. m_hResizeCursor = XTPResourceManager()->LoadCursor(XTP_IDC_VRESIZE);
  75. m_hDontDropCursor = XTPResourceManager()->LoadCursor(XTP_IDC_REPORT_NODROP);
  77. m_bShowItemsInGroups = FALSE;
  80. m_bDragHeader = m_bDragGroupBox = FALSE;
  82. m_nIndentLevel = 0;
  83. m_bAutoColumnSizing = TRUE;
  84. m_nHeaderWidth = 0;
  85. }
  87. CXTPReportHeader::~CXTPReportHeader()
  88. {
  89. DestroyDropWnd();
  91. if (m_pDragWnd)
  92. m_pDragWnd->DestroyWindow();
  93. }
  95. CXTPReportPaintManager* CXTPReportHeader::GetPaintManager() const
  96. {
  97. return m_pControl->GetPaintManager();
  98. }
  100. void CXTPReportHeader::Draw(CDC* pDC, CRect rcHeader, int nLeftOffset)
  101. {
  102. int nFreezeCols = GetControl()->m_nFreezeColumnsCount;
  104. rcHeader.OffsetRect(-nLeftOffset, 0);
  105. m_rcHeader = rcHeader;
  107. // draw background
  108. CXTPClientRect rcHeaderClientArea(m_pControl);
  109. rcHeaderClientArea.top = rcHeader.top;
  110. rcHeaderClientArea.bottom = rcHeader.bottom;
  112. GetPaintManager()->FillHeaderControl(pDC, rcHeaderClientArea);
  114. int x = rcHeader.left;
  116. // draw items
  117. int nColumnsCount = m_pColumns->GetCount(), nColumn;
  118. for (nColumn = 0; nColumn < nColumnsCount; nColumn++)
  119. {
  120. CXTPReportColumn* pColumn = m_pColumns->GetAt(nColumn);
  122. if (pColumn && pColumn->IsVisible())
  123. {
  124. CRect rcItem(x, rcHeader.top, x + pColumn->GetWidth(), rcHeader.bottom);
  125. pColumn->m_rcColumn = rcItem;
  127. if (rcItem.Height() > 0 && CRect().IntersectRect(rcHeaderClientArea, rcItem))
  128. {
  129. GetPaintManager()->DrawColumn(pDC, pColumn, this, rcItem);
  130. }
  132. x += rcItem.Width();
  133. pColumn->m_nMaxItemWidth = 0;
  134. }
  135. }
  137. int xFreeze = 0;
  139. // draw freeze items
  140. for (nColumn = 0; nFreezeCols > 0 && nColumn < nColumnsCount; nColumn++)
  141. {
  142. CXTPReportColumn* pColumn = m_pColumns->GetAt(nColumn);
  144. if (pColumn && pColumn->IsVisible())
  145. {
  146. CRect rcItem(xFreeze, rcHeader.top, xFreeze + pColumn->GetWidth(), rcHeader.bottom);
  147. pColumn->m_rcColumn = rcItem;
  149. if (rcItem.Height() > 0 && CRect().IntersectRect(rcHeaderClientArea, rcItem))
  150. {
  151. GetPaintManager()->FillHeaderControl(pDC, pColumn->m_rcColumn);
  152. GetPaintManager()->DrawColumn(pDC, pColumn, this, rcItem);
  154. if (nFreezeCols == 1 &&
  155. (GetPaintManager()->GetFreezeColsDividerStyle() & xtpReportFreezeColsDividerHeader))
  156. GetPaintManager()->DrawFreezeColsDivider(pDC, rcItem, GetControl());
  157. }
  159. xFreeze += rcItem.Width();
  161. nFreezeCols--;
  162. }
  163. }
  165. // draw empty column to fill free header area
  166. if (x < rcHeaderClientArea.right)
  167. {
  168. CRect rcEmptyColumn = rcHeaderClientArea;
  169. rcEmptyColumn.left = x;
  170. rcEmptyColumn.right += 10;
  172. CXTPReportColumn colEmpty(0, _T(""), rcEmptyColumn.Width(), FALSE,
  173. XTP_REPORT_NOICON, FALSE, TRUE);
  174. ASSERT(m_pColumns);
  175. colEmpty.m_pColumns = m_pColumns;
  177. GetPaintManager()->DrawColumn(pDC, &colEmpty, this, rcEmptyColumn);
  178. }
  179. }
  183. void CXTPReportHeader::CancelMouseMode()
  184. {
  185. if (m_pControl->GetMouseMode() != xtpReportMouseNothing)
  186. {
  187. m_pControl->SetMouseMode(xtpReportMouseNothing);
  189. m_pDragColumn = NULL;
  191. SetHotDivider(-1);
  193. // Drag wnd cleanup
  194. if (m_pDragWnd != NULL)
  195. {
  196. m_pDragWnd->DestroyWindow();
  197. m_pDragWnd = NULL;
  198. }
  200. if (CWnd::GetCapture() == m_pControl)
  201. ReleaseCapture();
  203. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  205. m_bDragGroupBox = FALSE;
  206. m_bDragHeader = FALSE;
  208. m_pControl->RedrawControl();
  209. }
  210. }
  213. void CXTPReportHeader::SetAutoColumnSizing(BOOL bAutoColumnSizing)
  214. {
  215. m_bAutoColumnSizing = bAutoColumnSizing;
  216. m_pControl->m_nLeftOffset = 0;
  218. if (m_bAutoColumnSizing && m_pControl->m_hWnd)
  219. {
  220. m_pControl->EnableScrollBarCtrl(SB_HORZ, FALSE);
  221. }
  222. AdjustColumnsWidth(m_pControl->m_rcHeaderArea.Width());
  223. m_pControl->RedrawControl();
  224. }
  226. void CXTPReportHeader::OnColumnsChanged(BOOL bGroupOrderChanged)
  227. {
  228. AdjustColumnsWidth(m_pControl->m_rcHeaderArea.Width());
  230. if (!GetPaintManager()->IsFixedRowHeight())
  231. m_pControl->AdjustScrollBars();
  233. m_pControl->UpdateSubList();
  234. m_pControl->RedrawControl();
  236. m_pControl->SendNotifyMessage(XTP_NM_REPORT_COLUMNORDERCHANGED);
  237. if(bGroupOrderChanged)
  238. m_pControl->SendNotifyMessage(XTP_NM_REPORT_GROUPORDERCHANGED);
  239. }
  241. void CXTPReportHeader::TrackColumn(CXTPReportColumn* pColumn, CPoint point)
  242. {
  243. CXTPClientRect rcControl(m_pControl);
  244. m_pControl->ClientToScreen(&point);
  246. CRect rcColumn(pColumn->GetRect());
  247. rcColumn.bottom = rcControl.bottom;
  248. m_pControl->ClientToScreen(&rcColumn);
  250. int nBottomMax = rcColumn.bottom;
  252. CDC* pDC = m_pControl->GetDC();
  253. if (pDC)
  254. {
  255. CRect rcVisible;
  256. UINT uRes = pDC->GetBoundsRect(&rcVisible, 0);
  258. m_pControl->ReleaseDC(pDC);
  259. pDC = NULL;
  261. if ((uRes & DCB_SET) == DCB_SET)
  262. {
  263. m_pControl->ClientToScreen(&rcVisible);
  264. nBottomMax = min(rcVisible.bottom, nBottomMax);
  265. }
  266. }
  268. int nMaxAvailWidth = GetMaxAvailWidth(pColumn);
  269. int nMinWidth = pColumn->GetMinWidth();
  271. CRect rcAvail(rcColumn.left + nMinWidth, rcColumn.top,
  272. rcColumn.left + nMaxAvailWidth, nBottomMax);
  274. CRect rcTracker(rcColumn.right, rcColumn.top, rcColumn.right + 1, nBottomMax);
  275. CRect rcBound(rcColumn.left - 1, rcColumn.top, rcColumn.left, nBottomMax);
  277. BOOL bLayoutRTL = m_pControl->GetExStyle() & WS_EX_LAYOUTRTL;
  279. if (bLayoutRTL)
  280. {
  281. rcAvail.SetRect(rcColumn.left - nMaxAvailWidth, rcColumn.top,
  282. rcColumn.right - nMinWidth, nBottomMax);
  283. }
  285. CXTPSplitterTracker tracker(TRUE);
  286. tracker.SetBoundRect(bLayoutRTL ? rcTracker : rcBound);
  288. if (tracker.Track(m_pControl, rcAvail, bLayoutRTL ? rcBound : rcTracker, point, TRUE))
  289. {
  290. ResizeColumn(pColumn, rcTracker.left - rcBound.right);
  292. m_pControl->RedrawControl();
  293. }
  294. }
  296. void CXTPReportHeader::OnLButtonDblClk(CPoint ptClick)
  297. {
  298. if (m_pControl->GetMouseMode() == xtpReportMouseOverColumnDivide)
  299. {
  300. CPoint ptLeftColumn(ptClick);
  301. ptLeftColumn.x -= m_nResizeCaptureRange + 1;
  302. CXTPReportColumn* pColumn = HitTest(ptLeftColumn);
  303. if (pColumn != NULL)
  304. {
  305. BestFit(pColumn);
  306. }
  307. }
  309. }
  312. void CXTPReportHeader::OnLButtonDown(CPoint ptClick)
  313. {
  314. m_pControl->SetCapture();
  316. if (m_pControl->GetMouseMode() == xtpReportMouseOverColumnDivide)
  317. {
  318. CXTPReportColumn* pColumn = MouseOverColumnResizeArea(ptClick);
  320. if (pColumn != NULL && pColumn->IsResizable() && m_bAllowColumnResize)
  321. {
  322. if (!m_bAutoColumnSizing || (!IsLastResizebleColumn(pColumn) && !IsLastVisibleColumn(pColumn)))
  323. {
  324. m_pControl->SetMouseMode(xtpReportMouseNothing);
  325. TrackColumn(pColumn, ptClick);
  326. return;
  327. }
  328. }
  329. }
  331. if (m_pControl->GetMouseMode() == xtpReportMouseNothing)
  332. {
  333. BOOL bDragHeader = FALSE;
  334. CXTPReportColumn* pColumn = NULL;
  335. if (m_rcHeader.PtInRect(ptClick))
  336. {
  337. int nColumn = HitTestHeaderColumnIndex(ptClick);
  338. pColumn = m_pColumns->GetAt(nColumn);
  340. bDragHeader = TRUE;
  341. }
  342. else if (m_rcGroupBy.PtInRect(ptClick))
  343. {
  344. int nColumn = FindGroupByColumn(ptClick, TRUE);
  345. pColumn = m_pColumns->GetGroupsOrder()->GetAt(nColumn);
  347. }
  348. if (pColumn != NULL)
  349. {
  350. StartDragging(pColumn, bDragHeader);
  352. m_ptMouse = ptClick;
  353. m_pControl->SetMouseMode(xtpReportMousePrepareDragColumn);
  354. m_pControl->RedrawControl();
  355. }
  356. }
  357. }
  359. void CXTPReportHeader::AdjustColumnsWidth(int nTotalWidth, int nFirstIndex)
  360. {
  361. if (m_bAutoColumnSizing)
  362. {
  363. int nColumnsWidth = 0;
  364. CXTPReportColumn* pLastAutoColumn = NULL;
  365. int nColumn;
  367. for (nColumn = nFirstIndex; nColumn < m_pColumns->GetCount(); nColumn++)
  368. {
  369. CXTPReportColumn* pColumn = m_pColumns->GetAt(nColumn);
  370. if (!pColumn->IsVisible())
  371. continue;
  373. if (pColumn->m_bAutoSize)
  374. {
  375. pLastAutoColumn = pColumn;
  376. nColumnsWidth += pColumn->m_nColumnAutoWidth;
  377. }
  378. else
  379. {
  380. nTotalWidth -= pColumn->GetWidth();
  381. }
  382. }
  384. if (pLastAutoColumn && nTotalWidth > 0)
  385. {
  387. for (nColumn = nFirstIndex; nColumn < m_pColumns->GetCount(); nColumn++)
  388. {
  389. CXTPReportColumn* pColumn = m_pColumns->GetAt(nColumn);
  390. if (!pColumn->IsVisible())
  391. continue;
  393. if (pColumn->m_bAutoSize)
  394. {
  395. if (pColumn == pLastAutoColumn)
  396. {
  397. pColumn->m_nColumnStaticWidth = max(nTotalWidth, pColumn->GetMinWidth());
  398. if(pColumn->m_nColumnStaticWidth != pColumn->m_nColumnAutoWidth)
  399. {
  400. XTP_NM_REPORTCOLUMNRESIZE nmData;
  401. nmData.pColumn = pColumn;
  402. nmData.nPrevWidth = pColumn->m_nColumnAutoWidth;
  403. nmData.nNewWidth = pColumn->m_nColumnStaticWidth;
  404. m_pControl->SendNotifyMessage(XTP_NM_REPORT_COLUMNWIDTHCHANGED, (NMHDR*)&nmData);
  405. }
  406. }
  407. else
  408. {
  409. nColumnsWidth = max(1, nColumnsWidth);
  411. pColumn->m_nColumnStaticWidth =
  412. max(int(pColumn->m_nColumnAutoWidth * nTotalWidth / nColumnsWidth), pColumn->GetMinWidth());
  413. if(pColumn->m_nColumnStaticWidth != pColumn->m_nColumnAutoWidth)
  414. {
  415. XTP_NM_REPORTCOLUMNRESIZE nmData;
  416. nmData.pColumn = pColumn;
  417. nmData.nPrevWidth = pColumn->m_nColumnAutoWidth;
  418. nmData.nNewWidth = pColumn->m_nColumnStaticWidth;
  419. m_pControl->SendNotifyMessage(XTP_NM_REPORT_COLUMNWIDTHCHANGED, (NMHDR*)&nmData);
  420. }
  422. nTotalWidth -= pColumn->m_nColumnStaticWidth;
  423. nColumnsWidth -= pColumn->m_nColumnAutoWidth;
  424. }
  425. }
  426. }
  427. }
  429. m_nHeaderWidth = m_pControl->m_rcHeaderArea.Width();
  430. }
  431. else
  432. {
  433. m_nHeaderWidth = 0;
  435. for (int nColumn = 0; nColumn < m_pColumns->GetCount(); nColumn++)
  436. {
  437. CXTPReportColumn* pColumn = m_pColumns->GetAt(nColumn);
  439. if (pColumn && pColumn->IsVisible())
  440. m_nHeaderWidth += pColumn->GetWidth();
  441. }
  443. if (m_nHeaderWidth == 0)
  444. {
  445. m_nHeaderWidth = nTotalWidth;
  446. }
  448. m_pControl->AdjustScrollBars();
  449. }
  451. XTP_NM_REPORTCOLUMNRESIZE nmData;
  452. ZeroMemory(&nmData, sizeof(nmData));
  453. m_pControl->SendNotifyMessage(XTP_NM_REPORT_COLUMNWIDTHCHANGED, (NMHDR*)&nmData);
  454. }
  456. void CXTPReportHeader::ResizeColumn(CXTPReportColumn* pColumnResize, int nWidth)
  457. {
  458. int nResizeIndex = 0;
  459. int nColumn;
  460. int nTotalWidth = 0;
  462. ASSERT(pColumnResize->IsResizable());
  464. for (nColumn = 0; nColumn < m_pColumns->GetCount(); nColumn++)
  465. {
  466. CXTPReportColumn* pColumn = m_pColumns->GetAt(nColumn);
  467. if (!pColumn->IsVisible())
  468. continue;
  470. if (nResizeIndex > 0)
  471. nTotalWidth += pColumn->m_nColumnStaticWidth;
  473. if (pColumnResize == pColumn)
  474. {
  475. int nDelta = pColumn->GetWidth() - nWidth;
  477. nResizeIndex = nColumn + 1;
  478. nTotalWidth = - nWidth + pColumn->GetWidth();
  479. pColumn->m_nColumnStaticWidth = nWidth;
  481. if (m_bAutoColumnSizing)
  482. {
  483. // if next column is "last resizeble" but not "auto size" column - resize it too.
  485. CXTPReportColumn* pColNext = CXTPReportHeader::GetNextVisibleColumn(nColumn, 1);
  487. if (pColNext && !pColNext->IsAutoSize() && pColNext->IsResizable() &&
  488. IsLastResizebleColumn(pColNext))
  489. {
  490. pColNext->m_nColumnStaticWidth += nDelta;
  491. if(pColNext->m_nColumnStaticWidth != pColNext->m_nColumnAutoWidth)
  492. {
  493. XTP_NM_REPORTCOLUMNRESIZE nmData;
  494. nmData.pColumn = pColNext;
  495. nmData.nPrevWidth = pColNext->m_nColumnAutoWidth;
  496. nmData.nNewWidth = pColNext->m_nColumnStaticWidth;
  497. m_pControl->SendNotifyMessage(XTP_NM_REPORT_COLUMNWIDTHCHANGED, (NMHDR*)&nmData);
  498. }
  499. }
  500. }
  501. }
  502. if(pColumn->m_nColumnStaticWidth != pColumn->m_nColumnAutoWidth)
  503. {
  504. XTP_NM_REPORTCOLUMNRESIZE nmData;
  505. nmData.pColumn = pColumn;
  506. nmData.nPrevWidth = pColumn->m_nColumnAutoWidth;
  507. nmData.nNewWidth = pColumn->m_nColumnStaticWidth;
  508. m_pControl->SendNotifyMessage(XTP_NM_REPORT_COLUMNWIDTHCHANGED, (NMHDR*)&nmData);
  509. }
  510. pColumn->m_nColumnAutoWidth = pColumn->m_nColumnStaticWidth;
  511. }
  512. AdjustColumnsWidth(nTotalWidth, nResizeIndex);
  514. for (nColumn = 0; nColumn < m_pColumns->GetCount(); nColumn++)
  515. {
  516. CXTPReportColumn* pColumn = m_pColumns->GetAt(nColumn);
  517. pColumn->m_nColumnAutoWidth = pColumn->m_nColumnStaticWidth;
  518. }
  519. AdjustColumnsWidth(m_rcHeader.Width());
  521. if (!GetPaintManager()->IsFixedRowHeight())
  522. m_pControl->AdjustScrollBars();
  523. }
  525. void CXTPReportHeader::OnLButtonUp(UINT nFlags, CPoint ptClick)
  526. {
  527. XTPReportMouseMode mouseMode = m_pControl->GetMouseMode();
  528. m_pControl->SetMouseMode(xtpReportMouseNothing);
  530. ReleaseCapture();
  532. if (mouseMode == xtpReportMouseDraggingColumn)
  533. {
  534. // End dragging column
  535. CXTPReportColumn* pDragColumn = m_pDragColumn;
  536. ASSERT(pDragColumn);
  537. if (!pDragColumn)
  538. return;
  539. BOOL bGroupOrderChanged = FALSE;
  541. // Drop column - change position
  542. if (m_dragMode == dragOutTarget || m_dragMode == dragFieldChooser)
  543. {
  544. if (m_bAllowColumnRemove && pDragColumn->m_bAllowRemove)
  545. {
  546. if (m_bDragHeader)
  547. {
  548. XTP_TRACE(_T("Removing columnn"));
  549. pDragColumn->SetVisible(FALSE);
  550. }
  551. else if (m_bDragGroupBox)
  552. {
  553. m_pColumns->GetGroupsOrder()->Remove(pDragColumn);
  554. bGroupOrderChanged = TRUE;
  555. m_pControl->Populate();
  556. }
  557. }
  558. }
  559. else if (((m_dragMode & dragInTarget) != 0) && m_nDropIndex >= 0)
  560. {
  561. XTP_TRACE(_T("Changing column position to %dn"), m_nDropIndex);
  563. CXTPClientRect rcClient(m_pControl);
  564. CRect rcHeaderFull = m_rcHeader;
  565. rcHeaderFull.right = rcClient.right;
  566. if (rcHeaderFull.PtInRect(ptClick))
  567. {
  568. int nDragIndex = m_pColumns->IndexOf(pDragColumn);
  570. pDragColumn->SetVisible();
  571. m_pColumns->ChangeColumnOrder(m_nDropIndex, nDragIndex);
  573. if (m_bDragGroupBox && ((nFlags & MK_CONTROL) == 0))
  574. {
  575. m_pColumns->GetGroupsOrder()->Remove(pDragColumn);
  576. bGroupOrderChanged = TRUE;
  577. m_pControl->Populate();
  578. }
  579. }
  580. else if (m_rcGroupBy.PtInRect(ptClick))
  581. {
  582. // set grouping by
  583. m_pColumns->GetGroupsOrder()->InsertAt(m_nDropIndex, pDragColumn);
  584. bGroupOrderChanged = TRUE;
  586. if (m_bDragHeader && ((nFlags & MK_CONTROL) == 0))
  587. {
  588. pDragColumn->SetVisible(FALSE);
  589. }
  590. m_pControl->Populate();
  591. }
  592. }
  593. m_dragMode = dragNothing;
  594. OnColumnsChanged(bGroupOrderChanged);
  596. SetHotDivider(-1);
  597. m_pDragColumn = NULL;
  599. // Drag wnd cleanup
  600. if (m_pDragWnd != NULL)
  601. {
  602. m_pDragWnd->DestroyWindow();
  603. m_pDragWnd = NULL;
  604. }
  606. m_bDragHeader = m_bDragGroupBox = FALSE;
  608. return; // Stop message processing
  609. }
  611. if (m_pDragColumn && m_pDragColumn == HitTest(ptClick))
  612. {
  613. m_pControl->SendMessageToParent(NULL, NULL, m_pDragColumn, NM_CLICK, &ptClick);
  614. }
  616. // End holding left mouse button - change sort order for the column
  617. if (mouseMode == xtpReportMousePrepareDragColumn)
  618. {
  619. if (!m_pDragColumn)
  620. return;
  622. CXTPReportColumn* pColumn = m_pDragColumn;
  624. m_pDragColumn = NULL;
  626. // change sort order
  627. if (pColumn->IsSortable() && m_bAllowColumnSort)
  628. {
  629. BOOL bGroupOrderChanged = FALSE;
  630. // do not reset sort order if clicked on the column header from the Group By area
  631. if (m_bDragHeader)
  632. {
  633. CXTPReportColumnOrder* pColumnOrder = m_bShowItemsInGroups && pColumn->IsGroupable() ?
  634. m_pColumns->GetGroupsOrder(): m_pColumns->GetSortOrder();
  636. BOOL bColumnFound = pColumnOrder->IndexOf(pColumn) >= 0;
  638. if (GetKeyState(VK_SHIFT) >= 0)
  639. {
  640. if (m_bShowItemsInGroups && !IsAllowColumnRemove())
  641. {
  642. for (int i = 0; i < pColumnOrder->GetCount(); i++)
  643. {
  644. pColumnOrder->GetAt(i)->SetVisible();
  645. }
  646. }
  647. pColumnOrder->Clear();
  648. pColumnOrder->Add(pColumn);
  649. bGroupOrderChanged = m_bShowItemsInGroups;
  650. }
  651. else if (!bColumnFound)
  652. {
  653. pColumnOrder->Add(pColumn);
  654. bGroupOrderChanged = m_bShowItemsInGroups;
  655. }
  657. if (bColumnFound)
  658. {
  659. pColumn->m_bSortIncreasing = !pColumn->m_bSortIncreasing;
  660. }
  661. }
  662. else
  663. {
  664. pColumn->m_bSortIncreasing = !pColumn->m_bSortIncreasing;
  665. }
  667. m_pControl->SendNotifyMessage(XTP_NM_REPORT_PRESORTORDERCHANGED);
  669. if (bGroupOrderChanged)
  670. m_pControl->Populate();
  671. else
  672. m_pControl->ReSortRows();
  674. m_pControl->SendNotifyMessage(XTP_NM_REPORT_SORTORDERCHANGED);
  676. if (bGroupOrderChanged)
  677. {
  678. OnColumnsChanged(bGroupOrderChanged);
  679. }
  680. }
  681. else
  682. {
  683. // redraw
  684. m_pControl->RedrawControl();
  685. }
  687. m_bDragHeader = m_bDragGroupBox = FALSE;
  688. }
  689. }
  692. CXTPReportColumn* CXTPReportHeader::HitTest(CPoint ptPoint) const
  693. {
  694. int nIndex = HitTestHeaderColumnIndex(ptPoint);
  695. if (nIndex < 0 || m_pColumns == NULL)
  696. return NULL;
  698. return m_pColumns->GetAt(nIndex);
  699. }
  701. int CXTPReportHeader::HitTestHeaderColumnIndex(CPoint ptPoint) const
  702. {
  703. if (!m_pControl->m_rcHeaderArea.PtInRect(ptPoint))
  704. return -1;
  706. int x = m_rcHeader.left;
  708. int nFreezeCols = GetControl()->m_nFreezeColumnsCount;
  710. // enumerate items
  711. int nColumnCount = m_pColumns->GetCount();
  712. for (int nColumn = 0; nColumn < nColumnCount; nColumn++)
  713. {
  714. CXTPReportColumn* pColumn = m_pColumns->GetAt(nColumn);
  715. if (pColumn && pColumn->IsVisible())
  716. {
  717. x += pColumn->GetWidth();
  719. if (ptPoint.x < x - (nFreezeCols > 0 ? m_rcHeader.left : 0))
  720. {
  721. return nColumn;
  722. }
  723. nFreezeCols--;
  724. }
  725. }
  726. return -1;
  727. }
  729. int CXTPReportHeader::GetFulColScrollInfo(CXTPReportColumn*& rpPrev, CXTPReportColumn*& rpCurr, CXTPReportColumn*& rpNext,
  730.   int& rnScrollPos, int& rnScrollMax) const
  731. {
  732. int x = m_rcHeader.left;
  733. int nLBorderX = 0;
  735. rnScrollPos = -1;
  736. rnScrollMax = 0;
  737. rpPrev = rpCurr = rpNext = NULL;
  738. BOOL bFind = FALSE;
  739. int nFreezeCols = GetControl()->m_nFreezeColumnsCount;
  741. // enumerate items
  742. int nColumnCount = m_pColumns->GetCount();
  743. for (int nColumn = 0; nColumn < nColumnCount; nColumn++)
  744. {
  745. CXTPReportColumn* pColumn = m_pColumns->GetAt(nColumn);
  746. if (pColumn && pColumn->IsVisible())
  747. {
  748. if (nFreezeCols <= 0)
  749. rnScrollMax++;
  751. if (!bFind)
  752. {
  753. if (nFreezeCols <= 0)
  754. rnScrollPos++;
  756. rpPrev = rpCurr;
  757. rpCurr = pColumn;
  759. x += pColumn->GetWidth();
  761. if (nFreezeCols > 0)
  762. {
  763. nLBorderX += pColumn->GetWidth();
  764. nFreezeCols--;
  765. }
  766. else
  767. {
  768. if (nLBorderX + 1 < x)
  769. {
  770. bFind = TRUE;
  771. }
  772. }
  773. }
  774. else if (!rpNext)
  775. {
  776. rpNext = pColumn;
  777. }
  778. }
  779. }
  780. return nLBorderX;
  781. }
  783. CXTPReportColumn* CXTPReportHeader::MouseOverColumnResizeArea(CPoint ptPoint)
  784. {
  785. if (ptPoint.y >= m_rcHeader.bottom ||
  786. ptPoint.y <= m_rcHeader.top)
  787. {
  788. return NULL;
  789. }
  791. // enumerate columns
  792. int nVisColCount = m_pColumns->GetVisibleColumnsCount() - (m_bAutoColumnSizing ? 1 : 0);
  793. int nFreezeCols = min(GetControl()->m_nFreezeColumnsCount, nVisColCount);
  794. int xMaxFreezeR = 0;
  796. for (int nColumn = 0; nColumn < nVisColCount; nColumn++)
  797. {
  798. BOOL bFreezeCol = nColumn < nFreezeCols;
  799. int nColIdx = bFreezeCol ? nColumn : nVisColCount + nFreezeCols - 1 - nColumn;
  801. CXTPReportColumn* pColumn = m_pColumns->GetVisibleAt(nColIdx);
  802. ASSERT(pColumn->IsVisible());
  804. if (!pColumn->IsResizable())
  805. continue;
  807. int xBorderR = pColumn->GetRect().right;
  809. if (bFreezeCol)
  810. {
  811. xMaxFreezeR = max(xMaxFreezeR, xBorderR);
  812. }
  813. else if (xBorderR <= xMaxFreezeR)
  814. {
  815. return NULL;
  816. }
  818. if (abs(ptPoint.x - xBorderR) <= m_nResizeCaptureRange)
  819. {
  820. if (!m_bAutoColumnSizing ||
  821. (!IsLastResizebleColumn(pColumn) && !IsLastVisibleColumn(pColumn)))
  822. {
  823. return pColumn;
  824. }
  825. }
  826. }
  828. return NULL;
  829. }
  831. int CXTPReportHeader::FindHeaderColumn(CPoint ptPoint) const
  832. {
  833. // Find column in header
  835. CXTPClientRect rcClient(m_pControl);
  836. CRect rcLastEmptyCol = m_rcHeader;
  837. rcLastEmptyCol.left = m_rcHeader.right;
  838. rcLastEmptyCol.right = rcClient.right;
  840. int nCount = m_pColumns->GetCount();
  841. int nVisColCount = m_pColumns->GetVisibleColumnsCount();
  843. if (rcLastEmptyCol.PtInRect(ptPoint))
  844. {
  845. return nCount;
  846. }
  848. if (!m_pControl->m_rcHeaderArea.PtInRect(ptPoint))
  849. return -1;
  851. int nFreezeCols = min(GetControl()->m_nFreezeColumnsCount, nVisColCount);
  852. int xMaxFreezeR = 0;
  854. for (int nColumn = 0; nColumn < nVisColCount; nColumn++)
  855. {
  856. BOOL bFreezeCol = nColumn < nFreezeCols;
  857. int nColIdx = bFreezeCol ? nColumn : nVisColCount + nFreezeCols - 1 - nColumn;
  858. BOOL bLastFreezeCol = nColumn + 1 == nFreezeCols;
  860. CXTPReportColumn* pColumn = m_pColumns->GetVisibleAt(nColIdx);
  861. ASSERT(pColumn->IsVisible());
  863. int xBorderR = pColumn->GetRect().right;
  865. if (bFreezeCol)
  866. {
  867. xMaxFreezeR = max(xMaxFreezeR, xBorderR);
  868. }
  869. else if (xBorderR <= xMaxFreezeR)
  870. {
  871. return -1;
  872. }
  874. CRect rcTest0 = pColumn->GetRect();
  875. if (!bFreezeCol)
  876. {
  877. rcTest0.left = max(xMaxFreezeR, rcTest0.left);
  878. }
  879. CRect rcTest1 = rcTest0;
  881. if (rcTest0.left != pColumn->GetRect().left)
  882. {
  883. rcTest0.SetRect(0, 0, 0, 0);
  884. }
  885. else if (rcTest0.right > rcClient.right)
  886. {
  887. rcTest1.SetRect(0, 0, 0, 0);
  888. }
  889. else
  890. {
  891. rcTest0.right -= rcTest0.Width()/2;
  892. rcTest1.left += rcTest0.Width()/2;
  893. }
  895. if (rcTest0.PtInRect(ptPoint))
  896. {
  897. return pColumn->GetIndex();
  898. }
  899. if (rcTest1.PtInRect(ptPoint))
  900. {
  901. if (bLastFreezeCol && GetControl()->m_nLeftOffset != 0)
  902. {
  903. return pColumn->GetIndex();
  904. }
  905. else
  906. {
  907. return pColumn->GetIndex() + 1;
  908. }
  909. }
  910. }
  911. return 0;
  912. }
  914. int CXTPReportHeader::FindGroupByColumn(CPoint ptPoint, BOOL bExactSearch) const
  915. {
  916. // Find column in Group By area
  917. if (m_rcGroupBy.PtInRect(ptPoint))
  918. {
  919. CXTPReportPaintManager* pPaintManager = GetPaintManager();
  920. int nHeaderHeight = pPaintManager->GetHeaderHeight();
  922. if (bExactSearch)
  923. {
  924. int x = m_rcGroupBy.left + 9;
  925. int y = m_rcGroupBy.top + 7;
  926. //int nTargetColumn = -1;
  927. CXTPReportColumn* pColumn = NULL;
  929. // draw items
  930. int nColumnsCount = m_pColumns->GetGroupsOrder()->GetCount();
  931. for (int nColumn = 0; nColumn < nColumnsCount; nColumn++)
  932. {
  933. pColumn = m_pColumns->GetGroupsOrder()->GetAt(nColumn);
  934. if (pColumn)
  935. {
  936. CRect rcItem(x, y, x + pColumn->m_rcGroupBy.Width(), y + nHeaderHeight - 3);
  938. if (rcItem.PtInRect(ptPoint))
  939. return nColumn;
  941. // next column
  942. x = rcItem.right + 5;
  943. y = rcItem.top + rcItem.Height() / 2;
  944. }
  945. }
  946. return nColumnsCount;
  947. }
  948. else
  949. {
  950. int xLeft = m_rcGroupBy.left + 9;
  951. int xRight;
  952. //int nTargetColumn = -1;
  953. CXTPReportColumn* pColumn = NULL;
  955. // draw items
  956. int nColumnsCount = m_pColumns->GetGroupsOrder()->GetCount();
  957. for (int nColumn = 0; nColumn < nColumnsCount; nColumn++)
  958. {
  959. pColumn = m_pColumns->GetGroupsOrder()->GetAt(nColumn);
  961. if (pColumn)
  962. {
  963. xRight = xLeft + pColumn->m_rcGroupBy.Width();
  965. if (ptPoint.x <= xRight)
  966. {
  967. if (ptPoint.x <= (xLeft + xRight) / 2)
  968. return nColumn;
  969. return nColumn + 1;
  970. }
  971. // next column
  972. xLeft = xRight + 5;
  973. }
  974. }
  975. return nColumnsCount;
  976. }
  977. }
  978. return -1;
  979. }
  981. void CXTPReportHeader::DestroyDropWnd()
  982. {
  983. if (m_pDropWnd != NULL)
  984. {
  985. m_pDropWnd->DestroyWindow();
  986. m_pDropWnd = NULL;
  987. }
  988. }
  990. int CXTPReportHeader::SetHotDivider(int nIndex, BOOL bHeader)
  991. {
  992. m_nDropIndex = nIndex;
  994. if (nIndex < 0)
  995. {
  996. DestroyDropWnd();
  997. return nIndex;
  998. }
  1000. CXTPReportPaintManager* pPaintManager = GetPaintManager();
  1001. int nHeaderHeight = pPaintManager->GetHeaderHeight();
  1004. // compare hot divider left and right columns with dragging column
  1005. //  and do not show hot divider near dragging column
  1006. CXTPReportColumn* pDraggingColumn = GetDraggingColumn();
  1008. CPoint pt;
  1009. if (bHeader)
  1010. {
  1011. if (pDraggingColumn)
  1012. {
  1013. // find column following hot divider column
  1014. CXTPReportColumn* pLeftColumn = NULL;
  1015. CXTPReportColumn* pRightColumn = NULL;
  1016. int nTotalColumnCount = m_pColumns->GetCount();
  1017. // find left visible column
  1018. for (int nLeftColumnIndex = nIndex - 1; nLeftColumnIndex >= 0; nLeftColumnIndex--)
  1019. {
  1020. if (nLeftColumnIndex < nTotalColumnCount)
  1021. {
  1022. pLeftColumn = m_pColumns->GetAt(nLeftColumnIndex);
  1023. if (pLeftColumn->IsVisible())
  1024. break;
  1026. pLeftColumn = NULL;
  1027. }
  1028. }
  1029. // find right visible column
  1030. for (int nRightColumnIndex = nIndex; nRightColumnIndex < nTotalColumnCount; nRightColumnIndex++)
  1031. {
  1032. pRightColumn = m_pColumns->GetAt(nRightColumnIndex);
  1033. if (pRightColumn->IsVisible())
  1034. break;
  1036. pRightColumn = NULL;
  1037. }
  1038. // compare
  1039. if ((pDraggingColumn == pLeftColumn) || (pDraggingColumn == pRightColumn))
  1040. {
  1041. DestroyDropWnd();
  1042. return -1;
  1043. }
  1044. }
  1046. pt.y = m_rcHeader.CenterPoint().y;
  1047. pt.x = m_rcHeader.left;
  1049. if (nIndex < m_pColumns->GetCount())
  1050. {
  1051. CXTPReportColumn* pColumnL = m_pColumns->GetAt(nIndex);
  1053. if (pColumnL->IsVisible())
  1054. {
  1055. pt.x = pColumnL->GetRect().left;
  1056. }
  1057. else
  1058. {
  1059. if (nIndex > 0 && m_pColumns->GetAt(nIndex-1))
  1060. {
  1061. CXTPReportColumn* pColumnR = m_pColumns->GetAt(nIndex-1);
  1062. ASSERT(pColumnR->IsVisible());
  1063. pt.x = pColumnR->GetRect().right;
  1064. }
  1065. }
  1066. }
  1067. else
  1068. {
  1069. pt.x = m_rcHeader.right;
  1070. }
  1072. if (pt.x < 0)
  1073. {
  1074. DestroyDropWnd();
  1075. return -1;
  1076. }
  1077. }
  1078. else
  1079. {
  1081. int nDraggingIndex = m_pColumns->GetGroupsOrder()->IndexOf(pDraggingColumn);
  1082. if (nDraggingIndex != -1 && (nDraggingIndex == nIndex || nDraggingIndex == nIndex - 1))
  1083. {
  1084. DestroyDropWnd();
  1085. return -1;
  1086. }
  1088. pt.x = m_rcGroupBy.left + 9;
  1089. pt.y = m_rcGroupBy.top + 6 + nHeaderHeight / 2;
  1091. int nColumnCount = m_pColumns->GetGroupsOrder()->GetCount();
  1092. int nLastColumn = min(nColumnCount, nIndex);
  1093. for (int nColumn = 0; nColumn < nLastColumn; nColumn++)
  1094. {
  1095. CXTPReportColumn* pColumn = m_pColumns->GetGroupsOrder()->GetAt(nColumn);
  1096. if (pColumn)
  1097. {
  1098. pt.x += pColumn->m_rcGroupBy.Width();
  1099. if (nColumn < nColumnCount - 1)
  1100. {
  1101. pt.x += 5;
  1102. pt.y += (nHeaderHeight - 3) / 2 ;
  1103. }
  1104. }
  1105. }
  1106. }
  1108. if (m_pDropWnd == NULL)
  1109. {
  1110. m_pDropWnd = new CXTPReportHeaderDropWnd(pPaintManager->m_clrHotDivider);
  1111. if (m_pDropWnd)
  1112. m_pDropWnd->Create(nHeaderHeight);
  1113. }
  1115. if (m_pDropWnd)
  1116. {
  1117. m_pControl->ClientToScreen(&pt);
  1118. m_pDropWnd->SetWindowPos(pt.x, pt.y);
  1119. }
  1121. return nIndex;
  1122. }
  1124. int CXTPReportHeader::GetMaxAvailWidth(CXTPReportColumn* pColumnCheck)
  1125. {
  1126. int nTotalWidth = m_pControl->m_rcHeaderArea.Width();
  1128. if (!m_bAutoColumnSizing)
  1129. return 32000;
  1131. int nWidth = 0;
  1133. for (int i = 0; i < m_pColumns->GetCount(); i++)
  1134. {
  1135. CXTPReportColumn* pColumn = m_pColumns->GetAt(i);
  1136. if (!pColumn->IsVisible())
  1137. continue;
  1139. if (nWidth > 0)
  1140. {
  1141. nWidth -= pColumn->GetMinWidth();
  1142. }
  1144. if (pColumn == pColumnCheck)
  1145. {
  1146. nWidth = nTotalWidth - pColumnCheck->GetRect().left;
  1147. }
  1148. }
  1150. return nWidth;
  1151. }
  1154. CXTPReportColumn* CXTPReportHeader::GetHotTrackingColumn() const
  1155. {
  1156. return m_pDragColumn && IsDragHeader() ? m_pDragColumn : m_pHotTrackingColumn;
  1157. }
  1159. void CXTPReportHeader::SetHotTrackingColumn(CXTPReportColumn* pColumn)
  1160. {
  1161. if (!GetPaintManager()->IsColumHotTrackingEnabled())
  1162. pColumn = NULL;
  1164. if (m_pHotTrackingColumn != pColumn)
  1165. {
  1166. m_pHotTrackingColumn = pColumn;
  1167. m_pControl->RedrawControl();
  1169. if (!CWnd::GetCapture())
  1170. {
  1171. TRACKMOUSEEVENT tme =
  1172. {
  1173. sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_pControl->GetSafeHwnd(), 0
  1174. };
  1175. _TrackMouseEvent (&tme);
  1176. }
  1177. }
  1178. }
  1180. void CXTPReportHeader::OnMouseMove(UINT /*nFlags*/, CPoint point)
  1181. {
  1182. XTPReportMouseMode mouseMode = m_pControl->GetMouseMode();
  1184. SetHotTrackingColumn(HitTest(point));
  1186. if (m_bAllowColumnResize && (mouseMode == xtpReportMouseNothing || mouseMode == xtpReportMouseOverColumnDivide)
  1187. && MouseOverColumnResizeArea(point))
  1188. {
  1189. if (mouseMode == xtpReportMouseNothing)
  1190. SetCursor(m_hResizeCursor);
  1192. m_pControl->SetMouseMode(xtpReportMouseOverColumnDivide);
  1193. return;
  1194. }
  1196. if (mouseMode == xtpReportMousePrepareDragColumn)
  1197. {
  1198. CXTPReportColumn* pColumn = GetDraggingColumn();
  1199. if (!pColumn)
  1200. return;
  1202. if (!m_bAllowColumnReorder && (!m_bAllowColumnRemove || !pColumn->m_bAllowRemove) && !m_pControl->IsGroupByVisible())
  1203. return;
  1205. if (abs (point.x - m_ptMouse.x) + abs (point.y - m_ptMouse.y) < 4)
  1206. return;
  1208. if (!(pColumn->IsAllowDragging() && pColumn->GetIndex() >= m_pControl->GetDisableReorderColumnsCount()))
  1209. {
  1210. m_pDragColumn = NULL;
  1211. m_pControl->SetMouseMode(xtpReportMouseNothing);
  1212. m_pControl->RedrawControl();
  1213. }
  1214. else
  1215. {
  1216. m_pControl->SetMouseMode(xtpReportMouseDraggingColumn);
  1217. m_dragMode = m_bDragHeader ? dragInHeader : dragInGroupBox;
  1218. // set dragging cursor
  1219. ASSERT(m_pDragWnd == NULL);
  1220. m_pDragWnd = new CXTPReportHeaderDragWnd();
  1222. CRect rcItem(pColumn->GetRect());
  1223. if (!m_bDragHeader)
  1224. {
  1225. // set sizes as drawing external
  1226. rcItem.right = rcItem.left + pColumn->m_rcGroupBy.Width();
  1227. }
  1228. m_pControl->ClientToScreen(&rcItem);
  1229. m_pDragWnd->Create(rcItem, this, GetPaintManager(), pColumn);
  1231. return;
  1232. }
  1233. }
  1235. if (mouseMode == xtpReportMouseDraggingColumn)
  1236. {
  1237. if (!m_pDragColumn)
  1238. return;
  1240. CPoint ptScreen = point;
  1241. m_pControl->ClientToScreen(&ptScreen);
  1243. if (m_pDragWnd)
  1244. {
  1245. CRect rcWnd;
  1246. m_pDragWnd->GetWindowRect(&rcWnd);
  1248. CPoint pt(ptScreen);
  1249. pt.Offset(-(rcWnd.Width() >> 1), -(rcWnd.Height() >> 1));
  1251. m_pDragWnd->SetWindowPos(&CWnd::wndTop,
  1252. pt.x, pt.y, 0, 0,
  1253. SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOACTIVATE);
  1254. }
  1256. if (m_pSubList && m_pSubList->GetSafeHwnd() && m_pSubList->IsWindowVisible() &&
  1257. CXTPWindowRect(m_pSubList).PtInRect(ptScreen))
  1258. {
  1259. if (m_dragMode == dragFieldChooser)
  1260. return;
  1261. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  1262. SetHotDivider(-1);
  1263. m_dragMode = dragFieldChooser;
  1264. return;
  1265. }
  1267. CXTPClientRect rcClient(m_pControl);
  1268. CRect rcDropTarget(m_rcHeader);
  1269. if (m_pDragColumn->IsGroupable())
  1270. rcDropTarget.UnionRect(m_rcHeader, m_rcGroupBy);
  1271. rcDropTarget.right = rcClient.right;
  1273. if (rcDropTarget.PtInRect(point))
  1274. {
  1275. CRect rcHeaderFull = m_rcHeader;
  1276. rcHeaderFull.right = rcClient.right;
  1277. BOOL bHeaderPoint = rcHeaderFull.PtInRect(point);
  1278. // change dropping place
  1279. int nDropPos = bHeaderPoint ? FindHeaderColumn(point) : FindGroupByColumn(point);
  1281. if (bHeaderPoint && !(m_bAllowColumnReorder && nDropPos > (m_pControl->GetDisableReorderColumnsCount() - 1)) && m_bDragHeader)
  1282. nDropPos = -1;
  1284. XTP_TRACE(_T("nDropPos = %i, m_nDropIndex = %in"), nDropPos, m_nDropIndex);
  1286. ReportDraggingMode dragMode = bHeaderPoint ? dragInHeader : dragInGroupBox;
  1288. // dropping will change order
  1289. if ((m_dragMode & dragInTarget) == 0)
  1290. {
  1291. // Change drag mode
  1292. XTP_TRACE(_T("Switch INn"));
  1293. XTP_TRACE(_T("point = %d %dt"), point.x, point.y);
  1295. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  1296. }
  1298. // redraw control with new arrows if dropping place changed
  1299. //if (nDropPos != m_nDropIndex || m_dragMode != dragMode)
  1300. {
  1301. SetHotDivider(nDropPos, bHeaderPoint);
  1302. }
  1303. m_dragMode = dragMode;
  1304. }
  1305. else
  1306. {
  1307. // dropping will remove the column
  1308. if (m_dragMode != dragOutTarget)
  1309. {
  1310. // change drag mode
  1311. XTP_TRACE(_T("Switch OUTn"));
  1312. XTP_TRACE(_T("point = %d %dt"), point.x, point.y);
  1314. if (m_bAllowColumnRemove && m_pDragColumn->m_bAllowRemove)
  1315. {
  1316. SetCursor(m_hDontDropCursor);
  1317. }
  1319. SetHotDivider(-1);
  1321. m_dragMode = dragOutTarget;
  1322. }
  1323. }
  1325. return;
  1326. }
  1328. if (mouseMode != xtpReportMouseNothing)
  1329. {
  1330. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  1331. m_pControl->SetMouseMode(xtpReportMouseNothing);
  1333. return;
  1334. }
  1336. }
  1338. void CXTPReportHeader::StartDragging(CXTPReportColumn* pColumn, BOOL bHeader)
  1339. {
  1340. ASSERT(pColumn);
  1341. m_pDragColumn = pColumn;
  1342. m_bDragHeader = bHeader;
  1343. m_bDragGroupBox = !bHeader;
  1344. m_nDropIndex = -1;
  1345. }
  1347. CXTPReportColumn* CXTPReportHeader::GetDraggingColumn() const
  1348. {
  1349. return m_pDragColumn;
  1350. }
  1353. BOOL CXTPReportHeader::SetSubListCtrl(CXTPReportSubListControl* pSubList)
  1354. {
  1355. m_pSubList = pSubList;
  1357. if (!pSubList)
  1358. return FALSE;
  1360. m_pSubList->SetReportCtrl(m_pControl);
  1362. return TRUE;
  1363. }
  1365. BOOL CXTPReportHeader::SetFilterEditCtrl(CXTPReportFilterEditControl* pFilterEdit)
  1366. {
  1367. if (!pFilterEdit)
  1368. return FALSE;
  1370. m_pFilterEdit = pFilterEdit;
  1371. m_pFilterEdit->SetReportCtrl(m_pControl);
  1373. return TRUE;
  1374. }
  1376. void CXTPReportHeader::OnContextMenu(CPoint ptClick)
  1377. {
  1378. CPoint ptClient(ptClick);
  1379. if (!m_pControl || !m_pControl->m_rcHeaderArea.PtInRect(ptClient))
  1380. return;
  1382. if (m_pControl->GetMouseMode() == xtpReportMouseNothing)
  1383. {
  1384. // mark the column as clicked at by the dragging
  1385. CXTPReportColumn* pColumn = HitTest(ptClient);
  1386. if (pColumn || s_bSendContextMenuForWholeHeaderArea)
  1387. {
  1388. m_pControl->ClientToScreen(&ptClick);
  1389. // send process notification to the user and wait for the reaction
  1390. m_pControl->SendMessageToParent(NULL, NULL, pColumn, XTP_NM_REPORT_HEADER_RCLICK, &ptClick);
  1392. m_pControl->RedrawControl();
  1393. }
  1394. }
  1395. }
  1397. void CXTPReportHeader::DrawFooter(CDC* pDC, CRect& rcFooter, int nLeftOffset)
  1398. {
  1399. UNREFERENCED_PARAMETER(nLeftOffset);
  1400. // draw background
  1401. GetPaintManager()->FillFooter(pDC, rcFooter);
  1403. // draw items
  1404. int nVisColCount = m_pColumns->GetVisibleColumnsCount();
  1405. int nFreezeCols = min(GetControl()->m_nFreezeColumnsCount, nVisColCount);
  1407. for (int nColumn = nVisColCount-1; nColumn >= 0; nColumn--)
  1408. {
  1409. BOOL bFreezeCol = nColumn < nFreezeCols;
  1410. int nColIdx = bFreezeCol ? nFreezeCols - 1 - nColumn : nColumn;
  1412. CXTPReportColumn* pColumn = m_pColumns->GetVisibleAt(nColIdx);
  1413. ASSERT(pColumn && pColumn->IsVisible());
  1414. if (pColumn)
  1415. {
  1416. CRect rcItem = pColumn->GetRect();
  1417. rcItem.top = rcFooter.top;
  1418. rcItem.bottom = rcFooter.bottom;
  1420. if (rcItem.Height() > 0)
  1421. {
  1422. if (bFreezeCol)
  1423. {
  1424. GetPaintManager()->FillFooter(pDC, rcItem);
  1425. }
  1426. GetPaintManager()->DrawColumnFooter(pDC, pColumn, this, rcItem);
  1427. }
  1428. }
  1429. }
  1430. }
  1432. void CXTPReportHeader::DrawGroupByControl(CDC* pDC, CRect& rcGroupBy)
  1433. {
  1434. m_rcGroupBy = rcGroupBy;
  1436. if (rcGroupBy.Height() <= 0)
  1437. return;
  1439. CXTPReportPaintManager* pPaintManager = GetPaintManager();
  1441. pPaintManager->FillGroupByControl(pDC, rcGroupBy);
  1443. CXTPFontDC font(pDC, &pPaintManager->m_fontCaption);
  1445. int x = m_rcGroupBy.left + 9;
  1446. int y = m_rcGroupBy.top + 7;
  1448. int nHeaderHeight = pPaintManager->GetHeaderHeight();
  1450. // draw items
  1451. int nColumnsCount = m_pColumns->GetGroupsOrder()->GetCount();
  1452. for (int nColumn = 0; nColumn < nColumnsCount; nColumn++)
  1453. {
  1454. CXTPReportColumn* pColumn = m_pColumns->GetGroupsOrder()->GetAt(nColumn);
  1456. if (pColumn /*&& pColumn->IsVisible()*/)
  1457. {
  1458. CRect rcItem(x, y, x + pColumn->GetCaptionWidth(pDC) + 50, y + nHeaderHeight - 3);
  1459. pColumn->m_rcGroupBy = rcItem;
  1461. // draw background
  1462. GetPaintManager()->FillHeaderControl(pDC, rcItem);
  1463. // draw column
  1464. GetPaintManager()->DrawColumn(pDC, pColumn, this, rcItem, TRUE);
  1465. // next column
  1466. x = rcItem.right + 5;
  1467. y = rcItem.top + rcItem.Height() / 2;
  1468. // draw connector
  1469. if (nColumn < nColumnsCount - 1)
  1470. GetPaintManager()->DrawConnector(pDC, CPoint(rcItem.right - 5, rcItem.bottom), CPoint(x, rcItem.bottom + 4));
  1471. }
  1472. }
  1474. // draw default dragging text if no items there
  1475. if (nColumnsCount == 0)
  1476. {
  1477. CRect rcItem(x, y, x, y + nHeaderHeight - 3);
  1478. GetPaintManager()->DrawNoGroupByText(pDC, rcItem);
  1479. }
  1480. }
  1482. int CXTPReportHeader::GetGroupByHeight() const
  1483. {
  1484. CXTPReportPaintManager* pPaintManager = GetPaintManager();
  1486. int nColumnsCount = m_pColumns->GetGroupsOrder()->GetCount();
  1487. int nHeaderHeight = pPaintManager->GetHeaderHeight();
  1488. int nHeight = 8 + ((nHeaderHeight - 3) / 2) * (nColumnsCount + 1) + 7;
  1489. if (!nColumnsCount)
  1490. nHeight += (nHeaderHeight - 3) / 2;
  1491. return nHeight;
  1492. }
  1494. void CXTPReportHeader::BestFit(CXTPReportColumn* pColumn)
  1495. {
  1496. if (pColumn->IsResizable() && m_bAllowColumnResize)
  1497. if (!m_bAutoColumnSizing || (!IsLastResizebleColumn(pColumn) && !IsLastVisibleColumn(pColumn)))
  1498. {
  1499. int nMaxAvailWidth = GetMaxAvailWidth(pColumn);
  1500. int nMinWidth = pColumn->GetMinWidth();
  1502. int nMaxItemWidth = min(pColumn->GetBestFitWidth(), nMaxAvailWidth);
  1504. if (nMaxItemWidth > nMinWidth)
  1505. {
  1506. ResizeColumn(pColumn, nMaxItemWidth);
  1507. m_pControl->RedrawControl();
  1508. }
  1509. }
  1510. }
  1513. BOOL CXTPReportHeader::IsLastVisibleColumn(CXTPReportColumn* pColumn) const
  1514. {
  1515. int nColumnCount = m_pColumns->GetCount();
  1517. for (int nColumn = m_pColumns->IndexOf(pColumn) + 1; nColumn < nColumnCount; nColumn++)
  1518. {
  1519. CXTPReportColumn* pCol = m_pColumns->GetAt(nColumn);
  1520. if (pCol && pCol->IsVisible())
  1521. return FALSE;
  1522. }
  1524. return TRUE;
  1525. }
  1527. BOOL CXTPReportHeader::IsLastResizebleColumn(CXTPReportColumn* pColumn) const
  1528. {
  1529. int nColumnCount = m_pColumns->GetCount();
  1531. for (int nColumn = m_pColumns->IndexOf(pColumn) + 1; nColumn < nColumnCount; nColumn++)
  1532. {
  1533. CXTPReportColumn* pCol = m_pColumns->GetAt(nColumn);
  1535. if (pCol && pCol->IsVisible() && pCol->IsResizable())
  1536. return FALSE;
  1537. }
  1539. return TRUE;
  1540. }
  1542. void CXTPReportHeader::ShowItemsInGroups(BOOL bShowInGroups)
  1543. {
  1544. m_bShowItemsInGroups = bShowInGroups;
  1546. if (m_bShowItemsInGroups)
  1547. {
  1548. m_pColumns->GetGroupsOrder()->Clear();
  1549. if (m_pColumns->GetSortOrder()->GetCount() > 0)
  1550. {
  1551. m_pColumns->GetGroupsOrder()->Add(m_pColumns->GetSortOrder()->GetAt(0));
  1552. m_pColumns->GetSortOrder()->Clear();
  1553. }
  1554. m_pControl->Populate();
  1555. OnColumnsChanged(TRUE);
  1556. }
  1557. }
  1559. CXTPReportColumn* CXTPReportHeader::GetNextVisibleColumn(int nIndex, int nDirection)
  1560. {
  1561. if (nDirection == 1)
  1562. {
  1563. int nColumnCount = m_pColumns->GetCount();
  1565. for (int nColumn = nIndex + 1; nColumn < nColumnCount; nColumn++)
  1566. {
  1567. CXTPReportColumn* pCol = m_pColumns->GetAt(nColumn);
  1569. if (pCol && pCol->IsVisible())
  1570. return pCol;
  1571. }
  1572. }
  1573. if (nDirection == -1)
  1574. {
  1575. for (int nColumn = nIndex - 1; nColumn >= 0; nColumn--)
  1576. {
  1577. CXTPReportColumn* pCol = m_pColumns->GetAt(nColumn);
  1579. if (pCol && pCol->IsVisible())
  1580. return pCol;
  1581. }
  1582. }
  1584. return NULL;
  1586. }
  1588. INT_PTR CXTPReportHeader::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  1589. {
  1590. CXTPReportColumn* pColumn = HitTest(point);
  1591. if (!pColumn)
  1592. return -1;
  1594. INT_PTR nHit = (INT_PTR)pColumn;
  1596. CString strTip = pColumn->GetTooltip();
  1598. if (strTip.IsEmpty())
  1599. {
  1600. CXTPReportPaintManager* pPaintManager = GetPaintManager();
  1602. strTip = pColumn->GetCaption();
  1604. if (pColumn->IsSortable() && m_bAllowColumnSort)
  1605. {
  1606. strTip = pPaintManager->m_strSortBy + strTip;
  1607. }
  1608. }
  1609. if (strTip.GetLength() == 0)
  1610. return -1;
  1612. CXTPToolTipContext::FillInToolInfo(pTI, m_pControl->m_hWnd, pColumn->GetRect(),
  1613. nHit, strTip);
  1615. return nHit;
  1616. }
  1618. void CXTPReportHeader::DoPropExchange(CXTPPropExchange* pPX)
  1619. {
  1620. PX_Bool(pPX, _T("AllowColumnRemove"), m_bAllowColumnRemove, TRUE);
  1621. PX_Bool(pPX, _T("AllowColumnResize"), m_bAllowColumnResize, TRUE);
  1622. PX_Bool(pPX, _T("AllowColumnReorder"), m_bAllowColumnReorder, TRUE);
  1623. PX_Bool(pPX, _T("AllowColumnSort"), m_bAllowColumnSort, TRUE);
  1625. PX_Bool(pPX, _T("AutoColumnSizing"), m_bAutoColumnSizing, TRUE);
  1626. PX_Bool(pPX, _T("ShowItemsInGroups"), m_bShowItemsInGroups, s_bShowItemsInGroupsPXDefault);
  1627. }