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

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

对话框与窗口

开发平台：

Visual C++

XTPReportRecordItem.cpp：源码内容
  1. // XTPReportRecordItem.cpp : implementation of the CXTPReportRecordItem 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 "Common/XTPDrawHelpers.h"
  23. #include "Common/XTPMarkupRender.h"
  25. #include "XTPReportRow.h"
  26. #include "XTPReportRecords.h"
  27. #include "XTPReportColumns.h"
  28. #include "XTPReportColumn.h"
  29. #include "XTPReportControl.h"
  30. #include "XTPReportPaintManager.h"
  31. #include "XTPReportHyperlink.h"
  32. #include "XTPReportRecord.h"
  33. #include "XTPReportRecordItem.h"
  34. #include "XTPReportInplaceControls.h"
  35. #include "XTPReportRecordItemControls.h"
  37. #include "Common/XTPPropExchange.h"
  39. #ifdef _DEBUG
  40. #define new DEBUG_NEW
  41. #undef THIS_FILE
  42. static char THIS_FILE[] = __FILE__;
  43. #endif
  45. #ifndef IDC_HAND
  46. #define IDC_HAND MAKEINTRESOURCE(32649)
  47. #endif
  49. //////////////////////////////////////////////////////////////////////////
  50. // XTP_REPORTRECORDITEM_ARGS
  52. XTP_REPORTRECORDITEM_ARGS::XTP_REPORTRECORDITEM_ARGS()
  53. {
  54. pControl = NULL;
  55. pRow = NULL;
  56. pColumn = NULL;
  57. pItem = NULL;
  58. rcItem.SetRectEmpty();
  59. }
  61. XTP_REPORTRECORDITEM_ARGS::XTP_REPORTRECORDITEM_ARGS(CXTPReportControl* pControl, CXTPReportRow* pRow, CXTPReportColumn* pColumn)
  62. {
  63. ASSERT(pControl && pRow && pColumn);
  65. this->pControl = pControl;
  66. this->pRow = pRow;
  67. this->pColumn = pColumn;
  68. this->pItem = pRow->GetRecord()->GetItem(pColumn);
  69. this->rcItem = pRow->GetItemRect(pItem);
  70. }
  71. XTP_REPORTRECORDITEM_ARGS::~XTP_REPORTRECORDITEM_ARGS()
  72. {
  74. }
  76. void XTP_REPORTRECORDITEM_ARGS::AddRef()
  77. {
  78. CMDTARGET_ADDREF(pRow);
  79. CMDTARGET_ADDREF(pColumn);
  80. CMDTARGET_ADDREF(pItem);
  82. }
  84. void XTP_REPORTRECORDITEM_ARGS::Release()
  85. {
  86. if (pRow)
  87. pRow->InternalRelease();
  89. if (pColumn)
  90. pColumn->InternalRelease();
  92. if (pItem)
  93. pItem->InternalRelease();
  94. }
  96. const XTP_REPORTRECORDITEM_ARGS& XTP_REPORTRECORDITEM_ARGS::operator=(const XTP_REPORTRECORDITEM_ARGS& src)
  97. {
  98. pControl = src.pControl;
  99. pRow     = src.pRow;
  100. pColumn  = src.pColumn;
  101. pItem    = src.pItem;
  102. rcItem   = src.rcItem;
  104. return *this;
  105. }
  107. CXTPReportInplaceButtons::CXTPReportInplaceButtons()
  108. {
  110. }
  112. //////////////////////////////////////////////////////////////////////////
  113. // CXTPReportRecordItemConstraint
  115. CXTPReportRecordItemConstraint::CXTPReportRecordItemConstraint()
  116. {
  118. m_dwData = 0;
  119. m_nIndex = 0;
  120. }
  122. int CXTPReportRecordItemConstraint::GetIndex() const
  123. {
  124. return m_nIndex;
  125. }
  127. //////////////////////////////////////////////////////////////////////////
  128. // CXTPReportRecordItemConstraints
  130. CXTPReportRecordItemConstraints::CXTPReportRecordItemConstraints()
  131. {
  132. }
  133. CXTPReportRecordItemConstraints::~CXTPReportRecordItemConstraints()
  134. {
  135. RemoveAll();
  136. }
  139. int CXTPReportRecordItemConstraints::GetCount() const
  140. {
  141. return (int)m_arrConstraints.GetSize();
  142. }
  144. CXTPReportRecordItemConstraint* CXTPReportRecordItemConstraints::GetAt(int nIndex) const
  145. {
  146. return m_arrConstraints.GetAt(nIndex);
  147. }
  149. void CXTPReportRecordItemConstraints::RemoveAll()
  150. {
  151. for (int i = 0; i < GetCount(); i++)
  152. m_arrConstraints[i]->InternalRelease();
  153. m_arrConstraints.RemoveAll();
  154. }
  156. //////////////////////////////////////////////////////////////////////////
  157. // CXTPReportRecordItemEditOptions
  159. CXTPReportRecordItemEditOptions::CXTPReportRecordItemEditOptions()
  160. {
  161. m_bAllowEdit = TRUE;
  162. m_bConstraintEdit = FALSE;
  163. m_pConstraints = new CXTPReportRecordItemConstraints();
  164. m_bSelectTextOnEdit = FALSE;
  165. m_dwEditStyle = ES_AUTOHSCROLL;
  166. m_nMaxLength = 0;
  169. }
  171. CXTPReportRecordItemEditOptions::~CXTPReportRecordItemEditOptions()
  172. {
  173. RemoveButtons();
  175. CMDTARGET_RELEASE(m_pConstraints);
  176. }
  178. void CXTPReportRecordItemEditOptions::RemoveButtons()
  179. {
  180. for (int j = 0; j < arrInplaceButtons.GetSize(); j++)
  181. arrInplaceButtons[j]->InternalRelease();
  183. arrInplaceButtons.RemoveAll();
  184. }
  186. void CXTPReportRecordItemEditOptions::AddComboButton()
  187. {
  188. arrInplaceButtons.Add(new CXTPReportInplaceButton(XTP_ID_REPORT_COMBOBUTTON));
  189. }
  191. void CXTPReportRecordItemEditOptions::AddExpandButton()
  192. {
  193. arrInplaceButtons.Add(new CXTPReportInplaceButton(XTP_ID_REPORT_EXPANDBUTTON));
  194. }
  196. void CXTPReportRecordItemEditOptions::AddSpinButton()
  197. {
  198. arrInplaceButtons.Add(new CXTPReportInplaceButton(XTP_ID_REPORT_SPINBUTTON));
  199. }
  201. CXTPReportInplaceButton* CXTPReportRecordItemEditOptions::GetButton(int nIndex)
  202. {
  203. if(nIndex >= arrInplaceButtons.GetSize())
  204. return NULL;
  205. return arrInplaceButtons.GetAt(nIndex);
  206. }
  208. CXTPReportRecordItemConstraint* CXTPReportRecordItemEditOptions::FindConstraint(DWORD_PTR dwData)
  209. {
  210. for (int i = 0; i < m_pConstraints->GetCount(); i++)
  211. {
  212. CXTPReportRecordItemConstraint* pConstaint = m_pConstraints->GetAt(i);
  213. if (pConstaint->m_dwData == dwData)
  214. return pConstaint;
  215. }
  216. return NULL;
  217. }
  219. CXTPReportRecordItemConstraint* CXTPReportRecordItemEditOptions::FindConstraint(LPCTSTR lpszConstraint)
  220. {
  221. for (int i = 0; i < m_pConstraints->GetCount(); i++)
  222. {
  223. CXTPReportRecordItemConstraint* pConstaint = m_pConstraints->GetAt(i);
  224. if (pConstaint->m_strConstraint == lpszConstraint)
  225. return pConstaint;
  226. }
  227. return NULL;
  228. }
  230. CXTPReportRecordItemConstraint* CXTPReportRecordItemEditOptions::AddConstraint(LPCTSTR lpszConstraint, DWORD_PTR dwData /*= 0*/)
  231. {
  232. CXTPReportRecordItemConstraint* pConstaint = new CXTPReportRecordItemConstraint();
  234. pConstaint->m_strConstraint = lpszConstraint;
  235. pConstaint->m_dwData = dwData;
  236. pConstaint->m_nIndex = (int)m_pConstraints->m_arrConstraints.Add(pConstaint);
  238. return pConstaint;
  239. }
  241. //////////////////////////////////////////////////////////////////////////
  242. // CXTPReportRecordItem
  245. IMPLEMENT_SERIAL(CXTPReportRecordItem, CCmdTarget, VERSIONABLE_SCHEMA | _XTP_SCHEMA_CURRENT)
  247. CXTPReportRecordItem::CXTPReportRecordItem()
  248. {
  249. static const CString g_strFormatStringDef = _T("%s");
  251. m_strFormatString = g_strFormatStringDef;
  252. m_bEditable = TRUE;
  253. m_pFontCaption = NULL;
  254. m_bBoldText = FALSE;
  255. m_clrText = XTP_REPORT_COLOR_DEFAULT;
  256. m_clrBackground = XTP_REPORT_COLOR_DEFAULT;
  258. m_nIconIndex = XTP_REPORT_NOICON;
  260. m_pRecord = 0;
  261. m_dwData = 0;
  263. m_nSortPriority = -1;
  264. m_nGroupPriority = -1;
  266. m_Alignment = (XTPReportColumnIconAlignment)(-1);
  268. m_bChecked = FALSE;
  269. m_bHasCheckbox = FALSE;
  270. m_pEditOptions = NULL;
  271. m_pItemControls = NULL;
  272. m_pFocusedItemControl = NULL;
  273. m_bItemControlUnderMouse = FALSE;
  274. m_pItemControlHookWnd = NULL;
  276. m_bFocusable = TRUE;
  278. m_pHyperlinks = NULL;
  280. m_pMarkupUIElement = NULL;
  281. m_pControl = NULL;
  284. }
  286. CXTPReportRecordItem::~CXTPReportRecordItem()
  287. {
  288. CMDTARGET_RELEASE(m_pEditOptions);
  289. CMDTARGET_RELEASE(m_pItemControls);
  290. CMDTARGET_RELEASE(m_pHyperlinks);
  292. XTPMarkupReleaseElement(m_pMarkupUIElement);
  293. }
  295. void CXTPReportRecordItem::SetCaption(LPCTSTR strCaption)
  296. {
  297. m_strCaption = strCaption;
  299. XTPMarkupReleaseElement(m_pMarkupUIElement);
  301. if (m_pRecord && m_pRecord->m_pRecords && m_pRecord->m_pRecords->GetMarkupContext())
  302. {
  303. m_pMarkupUIElement = XTPMarkupParseText(m_pRecord->m_pRecords->GetMarkupContext(), strCaption);
  304. }
  305. }
  308. void CXTPReportRecordItem::DoMouseButtonClick()
  309. {
  310. mouse_event(GetSystemMetrics(SM_SWAPBUTTON) ? MOUSEEVENTF_RIGHTDOWN : MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
  311. mouse_event(GetSystemMetrics(SM_SWAPBUTTON) ? MOUSEEVENTF_RIGHTUP : MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
  312. }
  314. void CXTPReportRecordItem::GetCaptionRect(XTP_REPORTRECORDITEM_ARGS* pDrawArgs, CRect& rcItem)
  315. {
  316. ASSERT(pDrawArgs->pControl);
  317. if (!pDrawArgs->pControl)
  318. return;
  319. else
  320. m_pControl = pDrawArgs->pControl;
  322. if (GetIconIndex() != XTP_REPORT_NOICON)
  323. rcItem.left += pDrawArgs->pControl->GetPaintManager()->DrawBitmap(NULL, pDrawArgs->pControl, rcItem, GetIconIndex());
  325. if (m_bHasCheckbox)
  326. rcItem.left += 15;
  328. if(m_pItemControls && m_pItemControls->GetSize())
  329. {
  330. for(int i = 0; i < m_pItemControls->GetSize() && rcItem.Width() > 0; i++)
  331. {
  332. int nWidth = m_pItemControls->GetAt(i)->GetSize().cx;
  333. nWidth = nWidth < 0 ? rcItem.Width() : nWidth;
  334. if(m_pItemControls->GetAt(i)->GetAlignment() == xtpItemControlRight)
  335. rcItem.right -= nWidth;
  336. else
  337. rcItem.left += nWidth;
  338. }
  339. }
  340. }
  342. void CXTPReportRecordItem::DrawCheckBox(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, CRect& rcItem)
  343. {
  344. BOOL bEditable = IsEditable() && (pDrawArgs->pColumn == NULL || pDrawArgs->pColumn->IsEditable());
  346. CDC* pDC = pDrawArgs->pDC;
  347. int eState = (bEditable ? 0: 2) + (IsChecked() ? 1 : 0);
  349. CXTPReportPaintManager* pPaintManager = pDrawArgs->pControl->GetPaintManager();
  351. int nIconAlign = pDrawArgs->nTextAlign & xtpColumnIconMask;
  353. m_rcGlyph = rcItem;
  354. CSize sizeGlyph = pPaintManager->DrawGlyph(NULL, m_rcGlyph, eState + 2);
  356. CRect rcGlyph(m_rcGlyph);
  357. // horizontal alignment
  358. switch(nIconAlign)
  359. {
  360. case xtpColumnIconRight:
  361. rcGlyph.left = rcItem.right - sizeGlyph.cx - 2;
  362. // shift text box to the left
  363. rcItem.right -= (2 + sizeGlyph.cx);
  364. break;
  365. case xtpColumnIconCenter:
  366. rcGlyph.left = rcItem.CenterPoint().x - sizeGlyph.cx / 2 - 1;
  367. rcGlyph.right = rcGlyph.left + sizeGlyph.cx;
  368. break; // left text box as is - draw on image...
  369. case xtpColumnIconLeft:
  370. default:
  371. rcGlyph.left += 2;
  372. // shift text box to the right
  373. rcItem.left += 2 + sizeGlyph.cx;
  374. rcGlyph.right = rcItem.left - 1;
  375. break;
  376. }
  377. // vertical alignment
  378. switch(nIconAlign)
  379. {
  380. case xtpColumnIconTop:
  381. rcGlyph.bottom = rcItem.top + sizeGlyph.cy + 2;
  382. break;
  383. case xtpColumnIconBottom:
  384. rcGlyph.top = rcItem.bottom - sizeGlyph.cy - 2;
  385. break;
  386. }
  387. // draw the glyph
  388. pPaintManager->DrawGlyph(pDC, rcGlyph, eState + 2);
  389. }
  391. void CXTPReportRecordItem::OnDrawCaption(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, XTP_REPORTRECORDITEM_METRICS* pMetrics)
  392. {
  393. ASSERT(pDrawArgs->pItem == this);
  395. if (m_pMarkupUIElement)
  396. {
  397. CRect rcItem = pDrawArgs->rcItem;
  398. rcItem.DeflateRect(2, 1, 2, 0);
  400. XTPMarkupMeasureElement(m_pMarkupUIElement, rcItem.Width(), INT_MAX);
  402. XTPMarkupSetDefaultFont(m_pRecord->GetRecords()->GetMarkupContext(), (HFONT)pMetrics->pFont->GetSafeHandle(), pMetrics->clrForeground);
  403. XTPMarkupRenderElement(m_pMarkupUIElement, pDrawArgs->pDC->GetSafeHdc(), &rcItem);
  404. }
  405. else
  406. {
  407. pDrawArgs->pControl->GetPaintManager()->DrawItemCaption(pDrawArgs, pMetrics);
  408. }
  409. }
  411. void CXTPReportRecordItem::OnDrawControls(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, CRect& rcItem)
  412. {
  413. ASSERT(pDrawArgs->pItem == this);
  414. if(!m_pItemControls)
  415. return;
  416. for (int i = 0; i < m_pItemControls->GetSize() && rcItem.Width(); i++)
  417. {
  418. pDrawArgs->pControl->GetPaintManager()->DrawItemControl(pDrawArgs, m_pItemControls->GetAt(i), rcItem);
  419. }
  420. }
  423. int CXTPReportRecordItem::Draw(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs)
  424. {
  425. ASSERT(pDrawArgs->pControl);
  426. if (!pDrawArgs->pControl)
  427. return 0;
  428. else
  429. m_pControl = pDrawArgs->pControl;
  431. CDC* pDC = pDrawArgs->pDC;
  432. CRect& rcItem = pDrawArgs->rcItem;
  433. CXTPReportPaintManager* pPaintManager = pDrawArgs->pControl->GetPaintManager();
  435. CRgn rgn;
  436. rgn.CreateRectRgn(rcItem.left, rcItem.top - 1, rcItem.right, rcItem.bottom);
  438. if (!pDC->IsPrinting())
  439. pDC->SelectClipRgn(&rgn);
  441. XTP_REPORTRECORDITEM_METRICS* pMetrics = new XTP_REPORTRECORDITEM_METRICS();
  442. pMetrics->strText = GetCaption(pDrawArgs->pColumn);
  443. pDrawArgs->pRow->GetItemMetrics(pDrawArgs, pMetrics);
  445. ASSERT(pMetrics->pFont);
  446. ASSERT(pMetrics->clrForeground != XTP_REPORT_COLOR_DEFAULT);
  448. if (pMetrics->clrBackground != XTP_REPORT_COLOR_DEFAULT)
  449. pDC->FillSolidRect(rcItem, pMetrics->clrBackground);
  451. int nItemGlyphs = rcItem.left;
  453. // draw tree inside item rect (see also HitTest function)
  454. if (pDrawArgs->pColumn && pDrawArgs->pColumn->IsTreeColumn())
  455. {
  456. if(pDrawArgs->pControl->IsVirtualMode())
  457. {
  458. pDrawArgs->pRow->m_nRowLevel = pMetrics->nVirtRowLevel ? 1 : 0; // only 1 level of children is supported at the moment
  459. if(pDrawArgs->pRow->m_nRowLevel)
  460. pDrawArgs->pRow->m_rcCollapse = CRect(0);
  461. }
  462. int nTreeDepth = pDrawArgs->pRow->GetTreeDepth() - pDrawArgs->pRow->GetGroupLevel();
  463. if (nTreeDepth > 0)
  464. nTreeDepth++;
  465. rcItem.left += pDrawArgs->pControl->GetIndent(nTreeDepth);
  467. BOOL bHasChildren = pDrawArgs->pControl->IsVirtualMode() ?
  468. pDrawArgs->pRow->m_nRowLevel == 0 && (pMetrics->nVirtRowFlags & xtpVirtRowHasChildren) :
  469. pDrawArgs->pRow->HasChildren();
  471. CRect rcBitmap(rcItem);
  472. CSize sizeBitmap = pPaintManager->DrawCollapsedBitmap(NULL, pDrawArgs->pRow, rcBitmap);
  474. pPaintManager->DrawTreeStructure(pDrawArgs, pMetrics, rcItem, sizeBitmap);
  476. int nIconAlign = pDrawArgs->nTextAlign & xtpColumnIconMask;
  477. // horizontal alignment
  478. switch(nIconAlign)
  479. {
  480. case xtpColumnIconRight:
  481. rcBitmap.left = rcBitmap.right - sizeBitmap.cx - 2;
  482. break;
  483. case xtpColumnIconLeft:
  484. rcBitmap.right = rcBitmap.left + sizeBitmap.cx + 2;
  485. break;
  486. }
  487. // vertical alignment
  488. switch(nIconAlign)
  489. {
  490. case xtpColumnIconTop:
  491. rcBitmap.bottom = rcBitmap.top + sizeBitmap.cy + 2;
  492. break;
  493. case xtpColumnIconBottom:
  494. rcBitmap.top = rcBitmap.bottom - sizeBitmap.cy - 2;
  495. break;
  496. }
  497. sizeBitmap = pPaintManager->DrawCollapsedBitmap(bHasChildren ? pDC : NULL, pDrawArgs->pRow, rcBitmap);
  499. if (!pDC->IsPrinting() && bHasChildren)
  500. pDrawArgs->pRow->SetCollapseRect(rcBitmap);
  502. rcItem.left += sizeBitmap.cx + 2;
  503. }
  505. pDC->SetTextColor(pMetrics->clrForeground);
  507. CFont* pOldFont = (CFont*)pDC->SelectObject(pMetrics->pFont);
  509. if (pMetrics->clrBackground != XTP_REPORT_COLOR_DEFAULT)
  510. pDC->SetBkColor(pMetrics->clrBackground);
  511. else
  512. pDC->SetBkColor(pPaintManager->m_clrControlBack);
  514. if (m_bHasCheckbox)
  515. DrawCheckBox(pDrawArgs, rcItem);
  517. // Do the draw bitmap pDC, rcItem, GetIconIndex()
  518. if (pMetrics->nItemIcon != XTP_REPORT_NOICON || GetIconIndex() != XTP_REPORT_NOICON)
  519. {
  520. pPaintManager->DrawItemBitmap(pDrawArgs, rcItem, pMetrics->nItemIcon != XTP_REPORT_NOICON ? pMetrics->nItemIcon : GetIconIndex());
  521. }
  523. nItemGlyphs = (rcItem.left - nItemGlyphs);
  525. OnDrawControls(pDrawArgs, rcItem);
  526. if(rcItem.Width())
  527. OnDrawCaption(pDrawArgs, pMetrics);
  529. int nItemTextWidth = nItemGlyphs + pDC->GetTextExtent(pMetrics->strText).cx + 4;
  531. pDC->SelectObject(pOldFont);
  533. pMetrics->InternalRelease();
  535. if (!pDC->IsPrinting())
  536. pDC->SelectClipRgn(NULL);
  538. return nItemTextWidth;
  539. }
  541. CXTPReportRecordItemControl* CXTPReportRecordItem::HitTest(CPoint ptPoint)
  542. {
  543. if(!(m_pItemControls && m_pItemControls->GetSize()))
  544. return NULL;
  546. for(int i = 0; i < m_pItemControls->GetSize(); i++)
  547. {
  548. CRect rcControl = m_pItemControls->GetAt(i)->GetRect();
  549. if(rcControl.PtInRect(ptPoint))
  550. return m_pItemControls->GetAt(i);
  551. }
  553. return NULL;
  554. }
  556. BOOL CXTPReportRecordItem::OnLButtonDown(XTP_REPORTRECORDITEM_CLICKARGS* pClickArgs)
  557. {
  558. CXTPReportRecordItemControl* pItemControl = HitTest(pClickArgs->ptClient);
  559. if(!pItemControl)
  560. return FALSE;
  561. pItemControl->OnLButtonDown(pClickArgs);
  562. // create item control window
  563. m_pItemControlHookWnd = new CXTPReportRecordItemControlHookWnd(pClickArgs);
  564. m_pItemControlHookWnd->Create(AfxRegisterWndClass(0), _T(""), WS_CHILD, pItemControl->GetRect(), pClickArgs->pControl, 0);
  565. m_pItemControlHookWnd->SetCapture();
  566. // redraw control
  567. pClickArgs->pControl->RedrawControl();
  568. return TRUE;
  569. }
  571. BOOL CXTPReportRecordItem::OnLButtonUp(XTP_REPORTRECORDITEM_CLICKARGS* pClickArgs)
  572. {
  573. if(m_pItemControlHookWnd && m_pFocusedItemControl)
  574. {
  575. pClickArgs->pControl->ScreenToClient(&pClickArgs->ptClient);
  576. m_pFocusedItemControl->OnLButtonUp(pClickArgs);
  577. pClickArgs->pControl->RedrawControl();
  578. // destroy item control window
  579. ReleaseCapture();
  580. m_pItemControlHookWnd->DestroyWindow();
  581. delete m_pItemControlHookWnd;
  582. m_pItemControlHookWnd = NULL;
  583. return TRUE;
  584. }
  585. CXTPReportRecordItemControl* pItemControl = HitTest(pClickArgs->ptClient);
  586. if(!pItemControl)
  587. return FALSE;
  588. pItemControl->OnLButtonUp(pClickArgs);
  589. pClickArgs->pControl->RedrawControl();
  590. return TRUE;
  591. }
  593. void CXTPReportRecordItem::OnClick(XTP_REPORTRECORDITEM_CLICKARGS* pClickArgs)
  594. {
  595. if (!pClickArgs || !pClickArgs->pControl)
  596. return;
  598. if(OnLButtonUp(pClickArgs))
  599. return;
  601. InternalAddRef();
  602. CMDTARGET_ADDREF(pClickArgs->pColumn);
  603. CMDTARGET_ADDREF(pClickArgs->pControl);
  605. CXTPReportRow* pRow = pClickArgs->pRow;
  606. CMDTARGET_ADDREF(pRow);
  608. BOOL bCheckBoxClicked = FALSE;
  609. CXTPReportControl* pControl = pClickArgs->pControl;
  611. if (IsEditable() && m_bHasCheckbox && (pClickArgs->pColumn == NULL || pClickArgs->pColumn->IsEditable())
  612. && OnRequestEdit(pClickArgs))
  613. {
  614. // adjust vertical coordinates if virtual mode
  615. if (pControl->IsVirtualMode())
  616. {
  617. m_rcGlyph.top = pClickArgs->rcItem.top;
  618. m_rcGlyph.bottom = pClickArgs->rcItem.bottom;
  619. }
  620. // check whether we're clicking glyph area
  621. if (m_rcGlyph.PtInRect(pClickArgs->ptClient))
  622. {
  623. if (pControl->IsAutoCheckItems()) SetChecked(!IsChecked());
  624. pControl->RedrawControl();
  626. pControl->SendMessageToParent(pClickArgs->pRow, this, pClickArgs->pColumn, XTP_NM_REPORT_CHECKED, &pClickArgs->ptClient);
  627. bCheckBoxClicked = TRUE;
  628. }
  629. }
  631. if (!bCheckBoxClicked && IsAllowEdit(pClickArgs) && pControl->IsEditOnClick())
  632. {
  633. pControl->EditItem(pClickArgs);
  635. CPoint pt(pClickArgs->ptClient);
  636. pControl->ClientToScreen(&pt);
  638. CXTPReportInplaceEdit* pEdit = DYNAMIC_DOWNCAST(CXTPReportInplaceEdit, CWnd::FromHandle(WindowFromPoint(pt)));
  639. if (pEdit && pEdit->GetItem() == this)
  640. {
  641. CXTPReportRecordItemEditOptions* pEditOptions = GetEditOptions(pClickArgs->pColumn);
  643. if (pEditOptions->m_bSelectTextOnEdit)
  644. {
  645. pEdit->SetSel(0, -1);
  646. }
  647. else
  648. {
  649. DoMouseButtonClick();
  650. }
  651. }
  652. }
  654. pClickArgs->pControl->SendMessageToParent(pClickArgs->pRow, this, pClickArgs->pColumn, NM_CLICK, &pClickArgs->ptClient);
  656. // Determine Hyperlink Click
  657. int nHyperlink = HitTestHyperlink(pClickArgs->ptClient);
  658. if (nHyperlink >= 0)
  659. {
  660. pClickArgs->pControl->SendMessageToParent(pClickArgs->pRow, this, pClickArgs->pColumn, XTP_NM_REPORT_HYPERLINK, &pClickArgs->ptClient, nHyperlink);
  661. }
  663. CMDTARGET_RELEASE(pRow);
  664. CMDTARGET_RELEASE(pClickArgs->pColumn);
  665. CMDTARGET_RELEASE(pClickArgs->pControl);
  666. InternalRelease();
  667. }
  669. int CXTPReportRecordItem::HitTestHyperlink(CPoint ptClick)
  670. {
  671. int nHyperlinks = GetHyperlinksCount();
  672. CXTPReportHyperlink* pHyperlink;
  673. for (int nHyperlink = 0; nHyperlink < nHyperlinks; nHyperlink++)
  674. {
  675. pHyperlink = GetHyperlinkAt(nHyperlink);
  676. ASSERT(pHyperlink);
  677. if (pHyperlink && pHyperlink->m_rcHyperSpot.PtInRect(ptClick))
  678. return nHyperlink;
  679. }
  680. return -1;
  681. }
  683. void CXTPReportRecordItem::OnDblClick(XTP_REPORTRECORDITEM_CLICKARGS* pClickArgs)
  684. {
  685. if(OnLButtonDown(pClickArgs))
  686. return;
  688. CXTPReportControl* pControl = pClickArgs->pControl;
  690. if (IsAllowEdit(pClickArgs) && !pControl->IsEditOnClick() && pControl->GetInplaceEdit()->GetItem() != this)
  691. {
  692. pControl->EditItem(pClickArgs);
  694. CPoint pt(pClickArgs->ptClient);
  695. pControl->ClientToScreen(&pt);
  697. CXTPReportInplaceEdit* pEdit = DYNAMIC_DOWNCAST(CXTPReportInplaceEdit, CWnd::FromHandle(WindowFromPoint(pt)));
  698. if (pEdit && pEdit->GetItem() == this)
  699. {
  700. CXTPReportRecordItemEditOptions* pEditOptions = GetEditOptions(pClickArgs->pColumn);
  702. if (pEditOptions->m_bSelectTextOnEdit)
  703. {
  704. pEdit->SetSel(0, -1);
  705. }
  706. else
  707. {
  708. DoMouseButtonClick();
  709. }
  710. }
  711. }
  713. pControl->SendMessageToParent(pClickArgs->pRow, this, pClickArgs->pColumn, NM_DBLCLK, &pClickArgs->ptClient, -1);
  714. }
  716. void CXTPReportRecordItem::OnMouseMove(UINT nFlags, CPoint point, CXTPReportControl* pControl)
  717. {
  718. int nHyperlink = HitTestHyperlink(point);
  719. if (nHyperlink >= 0)
  720. {
  721. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_HAND));
  722. return;
  723. }
  725. CXTPReportRecordItemControl* pItemControl = HitTest(point);
  727. if(m_pItemControlHookWnd && m_pFocusedItemControl && (nFlags & MK_LBUTTON))
  728. {
  729. pControl->ScreenToClient(&point);
  730. if(m_bItemControlUnderMouse && !m_pFocusedItemControl->GetRect().PtInRect(point))
  731. {
  732. m_pFocusedItemControl->OnMouseLeave(nFlags, point);
  733. m_bItemControlUnderMouse = FALSE;
  734. }
  735. else if(!m_bItemControlUnderMouse && m_pFocusedItemControl->GetRect().PtInRect(point))
  736. {
  737. m_pFocusedItemControl->OnMouseEnter(nFlags, point);
  738. m_bItemControlUnderMouse = TRUE;
  739. }
  740. else
  741. m_pFocusedItemControl->OnMouseMove(nFlags, point);
  742. pControl->RedrawControl();
  743. return;
  744. }
  746. if(pItemControl)
  747. {
  748. if(pItemControl != m_pFocusedItemControl)
  749. {
  750. if(m_pFocusedItemControl)
  751. {
  752. m_pFocusedItemControl->OnMouseLeave(nFlags, point);
  753. m_bItemControlUnderMouse = FALSE;
  754. }
  755. pItemControl->OnMouseEnter(nFlags, point);
  756. m_bItemControlUnderMouse = TRUE;
  757. }
  758. pItemControl->OnMouseMove(nFlags, point);
  759. if(pControl)
  760. pControl->RedrawControl();
  761. }
  762. else
  763. {
  764. if(m_pFocusedItemControl)
  765. {
  766. m_pFocusedItemControl->OnMouseLeave(nFlags, point);
  767. m_bItemControlUnderMouse = FALSE;
  768. if(pControl)
  769. pControl->RedrawControl();
  770. }
  771. }
  772. m_pFocusedItemControl = pItemControl;
  773. }
  775. void CXTPReportRecordItem::SetFont(CFont* pFont)
  776. {
  777. m_pFontCaption = pFont;
  778. }
  780. void CXTPReportRecordItem::SetBold(BOOL bBold)
  781. {
  782. m_bBoldText = bBold;
  783. }
  785. void CXTPReportRecordItem::SetTextColor(COLORREF clrText)
  786. {
  787. m_clrText = clrText;
  788. }
  790. void CXTPReportRecordItem::SetBackgroundColor(COLORREF clrBackground)
  791. {
  792. m_clrBackground = clrBackground;
  793. }
  795. int CXTPReportRecordItem::Compare(CXTPReportColumn* pColumn, CXTPReportRecordItem* pItem)
  796. {
  797. if (!pItem)
  798. return 0;
  800. if (m_nSortPriority != -1 || pItem->m_nSortPriority != -1)
  801. return m_nSortPriority - pItem->m_nSortPriority;
  803. return m_pRecord->GetRecords()->Compare(GetCaption(pColumn), pItem->GetCaption(pColumn));
  804. }
  806. CFont* CXTPReportRecordItem::GetFont()
  807. {
  808. return m_pFontCaption;
  809. }
  811. CString CXTPReportRecordItem::GetGroupCaption(CXTPReportColumn* pColumn)
  812. {
  813. if (!m_strGroupCaption.IsEmpty())
  814. return m_strGroupCaption;
  816. int nID = GetGroupCaptionID(pColumn);
  818. if (nID > 0)
  819. {
  820. CString str;
  821. if (str.LoadString(nID))
  822. {
  823. return str;
  824. }
  825. }
  827. return pColumn->GetCaption() + _T(": ") + GetCaption(pColumn);
  828. }
  830. int CXTPReportRecordItem::CompareGroupCaption(CXTPReportColumn* pColumn, CXTPReportRecordItem* pItem)
  831. {
  832. if (m_nGroupPriority != -1)
  833. return m_nGroupPriority - pItem->m_nGroupPriority;
  835. if (!m_strGroupCaption.IsEmpty())
  836. return m_pRecord->GetRecords()->Compare(m_strGroupCaption, pItem->m_strGroupCaption);
  838. int nID = GetGroupCaptionID(pColumn);
  840. if (nID > 0)
  841. return nID - pItem->GetGroupCaptionID(pColumn);
  843. return Compare(pColumn, pItem);
  844. }
  846. int CXTPReportRecordItem::GetGroupCaptionID(CXTPReportColumn* /*pColumn*/)
  847. {
  848. return m_nGroupPriority;
  849. }
  852. void CXTPReportRecordItem::GetItemMetrics(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, XTP_REPORTRECORDITEM_METRICS* pItemMetrics)
  853. {
  854. if (m_clrBackground != XTP_REPORT_COLOR_DEFAULT)
  855. pItemMetrics->clrBackground = m_clrBackground;
  857. if (m_clrText != XTP_REPORT_COLOR_DEFAULT)
  858. pItemMetrics->clrForeground = m_clrText;
  860. if (m_pFontCaption != NULL)
  861. pItemMetrics->pFont = m_pFontCaption;
  862. else if (m_bBoldText)
  863. pItemMetrics->pFont = &pDrawArgs->pControl->GetPaintManager()->m_fontBoldText;
  865. if(m_Alignment != (XTPReportColumnIconAlignment)(-1))
  866. pItemMetrics->nColumnAlignment = m_Alignment;
  867. }
  869. int CXTPReportRecordItem::GetIndex() const
  870. {
  871. return m_pRecord ? m_pRecord->IndexOf(this) : -1;
  872. }
  874. CXTPReportColumn* CXTPReportRecordItem::GetColumn()
  875. {
  876. if (m_pControl)
  877. {
  878. int nItemIndex = GetIndex();
  879. CXTPReportColumns* pCols = m_pControl->GetColumns();
  880. if (pCols)
  881. {
  882. return pCols->GetAt(nItemIndex);
  883. }
  884. }
  886. return NULL;
  887. }
  889. BOOL CXTPReportRecordItem::IsEditable() const
  890. {
  891. if (this == NULL)
  892. return FALSE;
  894. ASSERT(m_pRecord);
  895. return m_pRecord ? m_pRecord->m_bEditable && m_bEditable && IsFocusable() : FALSE;
  896. }
  899. BOOL CXTPReportRecordItem::IsFocusable() const
  900. {
  901. if (this == NULL)
  902. return FALSE;
  904. return m_bFocusable;
  905. }
  907. void CXTPReportRecordItem::OnBeginEdit(XTP_REPORTRECORDITEM_ARGS* pItemArgs)
  908. {
  909. ASSERT(pItemArgs);
  910. if (!pItemArgs)
  911. return;
  913. CXTPReportControl* pControl = pItemArgs->pControl;
  914. CXTPReportInplaceEdit* pEdit = pControl->GetInplaceEdit();
  915. CRect rcCaption(pItemArgs->rcItem);
  916. GetCaptionRect(pItemArgs, rcCaption);
  918. if (IsEditable() && OnRequestEdit(pItemArgs))
  919. {
  920. CXTPReportRecordItemEditOptions* pEditOptions = GetEditOptions(pItemArgs->pColumn);
  921. ASSERT(pEditOptions);
  923. CXTPReportInplaceButtons* pInpaceButtons = &pEditOptions->arrInplaceButtons;
  925. CRect rcButtons(pItemArgs->rcItem);
  926. CXTPClientRect rcControl(pItemArgs->pControl);
  928. int i;
  929. // calculate right-aligned item controls width
  930. int nControlsWidthRight = 0;
  931. for(i = 0; m_pItemControls && i < m_pItemControls->GetSize(); i++)
  932. {
  933. if(m_pItemControls->GetAt(i)->GetAlignment() == xtpItemControlRight)
  934. nControlsWidthRight += m_pItemControls->GetAt(i)->GetRect().Width();
  935. }
  937. // calculate inplace buttons widths
  938. int nButtonsWidthIn = 0, nButtonsWidthOut = 0;
  939. for (i = 0; i < pInpaceButtons->GetSize(); i++)
  940. {
  941. CXTPReportInplaceButton* pButton = pInpaceButtons->GetAt(i);
  942. if (pButton->IsInsideCellButton())
  943. nButtonsWidthIn += pButton->GetWidth();
  944. else
  945. nButtonsWidthOut += pButton->GetWidth();
  946. }
  948. // adjust buttons rect
  949. if (rcButtons.right + nButtonsWidthOut > rcControl.right)
  950. rcButtons.right = rcControl.right - nButtonsWidthOut;
  952. rcButtons.left = min(rcButtons.right, pItemArgs->rcItem.right - nControlsWidthRight);
  954. // create buttons
  955. for (i = 0; i < pInpaceButtons->GetSize(); i++)
  956. {
  957. CXTPReportInplaceButton* pButton = pInpaceButtons->GetAt(i);
  958. pButton->Create(pItemArgs, rcButtons);
  960. pControl->GetInplaceButtons()->Add(pButton);
  961. }
  963. // adjust item rect
  964. pItemArgs->rcItem.right = rcButtons.left + 1 + nControlsWidthRight;
  966. if (pEditOptions->m_bAllowEdit)
  967. {
  968. pEdit->Create(pItemArgs);
  969. }
  970. else if (pInpaceButtons->GetSize() > 0)
  971. {
  972. OnInplaceButtonDown(pInpaceButtons->GetAt(0));
  973. }
  975. //----------------------------------------------------
  976. XTP_NM_REPORTRECORDITEM nm;
  977. ::ZeroMemory(&nm, sizeof(nm));
  979. nm.pItem = this;
  980. nm.pRow = pItemArgs->pRow;
  981. nm.pColumn = pItemArgs->pColumn;
  983. pControl->SendNotifyMessage(XTP_NM_REPORT_BEGINEDIT, (NMHDR*)&nm);
  984. }
  985. }
  987. void CXTPReportRecordItem::OnCancelEdit(CXTPReportControl* pControl, BOOL bApply)
  988. {
  989. CXTPReportInplaceButtons* pInpaceButtons = pControl->GetInplaceButtons();
  991. for (int i = 0; i < pInpaceButtons->GetSize(); i++)
  992. {
  993. CXTPReportInplaceButton* pButton = pInpaceButtons->GetAt(i);
  994. pButton->DestroyWindow();
  995. pButton->SetItemArgs(0);
  996. }
  997. pInpaceButtons->RemoveAll();
  999. CXTPReportInplaceList* pInpaceList = pControl->GetInplaceList();
  1000. if (pInpaceList->GetSafeHwnd())
  1001. {
  1002. pInpaceList->DestroyWindow();
  1003. }
  1006. CXTPReportInplaceEdit* pEdit = pControl->GetInplaceEdit();
  1008. if (bApply && pEdit->GetSafeHwnd() && pEdit->GetItem() == this)
  1009. {
  1010. OnValidateEdit((XTP_REPORTRECORDITEM_ARGS*)pEdit);
  1011. }
  1013. pEdit->HideWindow();
  1014. pEdit->SetItemArgs(0);
  1015. pEdit->DestroyWindow(); // pControl->SetFocus();
  1018. }
  1020. void CXTPReportRecordItem::OnConstraintChanged(XTP_REPORTRECORDITEM_ARGS* pItemArgs, CXTPReportRecordItemConstraint* pConstraint)
  1021. {
  1022. OnEditChanged(pItemArgs, pConstraint->m_strConstraint);
  1023. }
  1025. void CXTPReportRecordItem::OnValidateEdit(XTP_REPORTRECORDITEM_ARGS* pItemArgs)
  1026. {
  1027. ASSERT(pItemArgs);
  1028. if (!pItemArgs)
  1029. return;
  1031. CXTPReportControl* pControl = pItemArgs->pControl;
  1032. CXTPReportInplaceEdit* pEdit = pControl->GetInplaceEdit();
  1033. XTP_REPORTRECORDITEM_ARGS args = *pItemArgs;
  1035. if (pEdit->GetSafeHwnd() && pEdit->GetItem() == this)
  1036. {
  1037. args.AddRef();
  1039. BOOL bRedraw = FALSE;
  1040. CMDTARGET_RELEASE(pEdit->pItem); //pEdit->pItem = NULL;
  1042. if (GetEditOptions(args.pColumn)->m_bConstraintEdit)
  1043. {
  1044. if (pEdit->m_pSelectedConstraint)
  1045. {
  1046. OnConstraintChanged(&args, pEdit->m_pSelectedConstraint);
  1047. bRedraw = TRUE;
  1048. }
  1049. }
  1050. else
  1051. {
  1052. CString strValue;
  1053. pEdit->GetWindowText(strValue);
  1055. if (GetCaption(args.pColumn) != strValue)
  1056. {
  1057. OnEditChanged(&args, strValue);
  1058. bRedraw = TRUE;
  1059. }
  1060. }
  1061. if (bRedraw)
  1062. {
  1063. pControl->RedrawControl();
  1064. pControl->SendMessageToParent(args.pRow, this, args.pColumn, XTP_NM_REPORT_VALUECHANGED, 0);
  1065. }
  1066. else
  1067. {
  1068. OnEditCanceled(pItemArgs);
  1069. pControl->SendMessageToParent(args.pRow, this, args.pColumn, XTP_NM_REPORT_EDIT_CANCELED, 0);
  1070. }
  1072. pEdit->SetItemArgs(0);
  1074. args.Release();
  1075. }
  1076. }
  1078. BOOL CXTPReportRecordItem::IsAllowEdit(XTP_REPORTRECORDITEM_ARGS* pItemArgs)
  1079. {
  1080. BOOL bIsAllowEdit = pItemArgs->pControl->IsAllowEdit();
  1082. if (m_pRecord)
  1083. {
  1084. // is header record
  1085. if (m_pRecord->m_pRecords == pItemArgs->pControl->GetHeaderRecords())
  1086. {
  1087. bIsAllowEdit = pItemArgs->pControl->IsHeaderRowsAllowEdit();
  1088. }
  1089. else
  1090. // is footer record
  1091. if (m_pRecord->m_pRecords == pItemArgs->pControl->GetFooterRecords())
  1092. {
  1093. bIsAllowEdit = pItemArgs->pControl->IsFooterRowsAllowEdit();
  1094. }
  1095. }
  1097. return bIsAllowEdit && IsEditable() &&
  1098. ((pItemArgs->pColumn && pItemArgs->pColumn->IsEditable()) || (!pItemArgs->pColumn && m_pEditOptions &&
  1099. m_pEditOptions->m_bAllowEdit));
  1101. /*  return pItemArgs->pControl->IsAllowEdit() && IsEditable() &&
  1102. ((pItemArgs->pColumn && pItemArgs->pColumn->IsEditable()) || (!pItemArgs->pColumn && m_pEditOptions &&
  1103. m_pEditOptions->m_bAllowEdit));*/
  1104. }
  1106. BOOL CXTPReportRecordItem::OnRequestEdit(XTP_REPORTRECORDITEM_ARGS* pItemArgs)
  1107. {
  1108. CXTPReportControl* pControl = pItemArgs->pControl;
  1110. XTP_NM_REPORTREQUESTEDIT nm;
  1111. ::ZeroMemory(&nm, sizeof(nm));
  1113. nm.bCancel = FALSE;
  1114. nm.pItem = this;
  1115. nm.pRow = pItemArgs->pRow;
  1116. nm.pColumn = pItemArgs->pColumn;
  1118. pControl->SendNotifyMessage(XTP_NM_REPORT_REQUESTEDIT, (NMHDR*)&nm);
  1120. return !nm.bCancel;
  1121. }
  1123. BOOL CXTPReportRecordItem::OnChar(XTP_REPORTRECORDITEM_ARGS* pItemArgs, UINT nChar)
  1124. {
  1125. CXTPReportControl* pControl = pItemArgs->pControl;
  1127. if ((nChar == VK_SPACE) && IsEditable() && m_bHasCheckbox && (pItemArgs->pColumn == NULL || pItemArgs->pColumn->IsEditable())
  1128. && OnRequestEdit(pItemArgs))
  1129. {
  1130. if (pControl->IsAutoCheckItems()) SetChecked(!IsChecked());
  1131. pControl->RedrawControl();
  1133. pControl->SendMessageToParent(pItemArgs->pRow, this, pItemArgs->pColumn, XTP_NM_REPORT_CHECKED, NULL);
  1134. return TRUE;
  1135. }
  1137. if (IsAllowEdit(pItemArgs))
  1138. {
  1139. pControl->EditItem(pItemArgs);
  1141. CXTPReportInplaceEdit* pEdit = pControl->GetInplaceEdit();
  1143. if (pEdit->GetSafeHwnd() && pEdit->GetItem() == this)
  1144. {
  1145. pEdit->SetFocus();
  1146. pEdit->SetSel(0, -1);
  1147. if (nChar != VK_TAB) pEdit->SendMessage(WM_CHAR, nChar);
  1148. }
  1149. return TRUE;
  1151. }
  1152. return FALSE;
  1153. }
  1155. CXTPReportRecordItemEditOptions* CXTPReportRecordItem::GetEditOptions(CXTPReportColumn* pColumn)
  1156. {
  1157. if (m_pEditOptions)
  1158. return m_pEditOptions;
  1160. if (pColumn)
  1161. return pColumn->GetEditOptions();
  1163. return m_pEditOptions = new CXTPReportRecordItemEditOptions();
  1164. }
  1166. CXTPReportRecordItemControls* CXTPReportRecordItem::GetItemControls()
  1167. {
  1168. if (!m_pItemControls)
  1169. m_pItemControls = new CXTPReportRecordItemControls(this);
  1170. return m_pItemControls;
  1171. }
  1173. void CXTPReportRecordItem::OnInplaceButtonDown(CXTPReportInplaceButton* pButton)
  1174. {
  1175. CXTPReportControl* pControl = pButton->pControl;
  1177. XTP_NM_REPORTINPLACEBUTTON nm;
  1178. ::ZeroMemory(&nm, sizeof(nm));
  1180. nm.pButton = pButton;
  1181. nm.pItem = this;
  1183. if (pControl->SendNotifyMessage(XTP_NM_REPORT_INPLACEBUTTONDOWN, (NMHDR*)&nm) == TRUE)
  1184. return;
  1186. if (pButton->GetID() == XTP_ID_REPORT_COMBOBUTTON)
  1187. {
  1188. CXTPReportInplaceList* pList = pControl->GetInplaceList();
  1190. XTP_REPORTRECORDITEM_ARGS itemArgs = *pButton;
  1191. if (!itemArgs.pColumn && !itemArgs.pControl && !itemArgs.pItem && !itemArgs.pRow)
  1192. {
  1193. return;
  1194. }
  1195. ASSERT(itemArgs.pItem == this);
  1197. CXTPWindowRect rcButton(pButton);
  1198. pControl->ScreenToClient(&rcButton);
  1199. itemArgs.rcItem.right = rcButton.right;
  1200. itemArgs.rcItem.bottom  = rcButton.bottom;
  1202. CXTPReportRecordItemEditOptions* pEditOptions = GetEditOptions(itemArgs.pColumn);
  1204. if (pEditOptions->GetConstraints()->GetCount() > 0)
  1205. {
  1206. pList->Create(&itemArgs, pEditOptions->GetConstraints());
  1207. }
  1208. }
  1209. else if (pButton->GetID() == XTP_ID_REPORT_SPINBUTTON)
  1210. {
  1211. XTP_REPORTRECORDITEM_ARGS itemArgs = *pButton;
  1212. ASSERT(itemArgs.pItem == this);
  1213. CXTPReportInplaceEdit* pEdit = pControl->GetInplaceEdit();
  1214. if (itemArgs.pRow && itemArgs.pColumn && pEdit->GetSafeHwnd() && pEdit->GetItem() == this)
  1215. {
  1216. CString strValue;
  1217. pEdit->GetWindowText(strValue);
  1218. int nValue = _ttoi(strValue);
  1219. nValue += pButton->m_nSpinIncrement;
  1220. strValue.Format(_T("%d"), nValue);
  1221. pEdit->SetWindowText(strValue);
  1222. pControl->RedrawControl();
  1223. pControl->SendMessageToParent(itemArgs.pRow, this, itemArgs.pColumn, XTP_NM_REPORT_VALUECHANGED, 0);
  1224. }
  1225. }
  1226. }
  1228. CXTPReportHyperlinks* CXTPReportRecordItem::GetHyperlinks()
  1229. {
  1230. if (!m_pHyperlinks)
  1231. m_pHyperlinks = new CXTPReportHyperlinks();
  1233. return m_pHyperlinks;
  1234. }
  1236. void CXTPReportRecordItem::DoPropExchange(CXTPPropExchange* pPX)
  1237. {
  1238. PX_DWord(pPX, _T("TextColor"), (DWORD&)m_clrText, XTP_REPORT_COLOR_DEFAULT);
  1239. PX_DWord(pPX, _T("BackgroundColor"), (DWORD&)m_clrBackground, XTP_REPORT_COLOR_DEFAULT);
  1241. PX_Bool(pPX, _T("BoldText"), m_bBoldText, FALSE);
  1243. PX_String(pPX, _T("Format"), m_strFormatString, _T("%s"));
  1245. PX_Bool(pPX, _T("Editable"), m_bEditable, TRUE);
  1247. PX_Int(pPX, _T("IconIndex"), m_nIconIndex, XTP_REPORT_NOICON);
  1249. PX_Int(pPX, _T("SortPriority"), m_nSortPriority, -1);
  1250. PX_Int(pPX, _T("GroupPriority"), m_nGroupPriority, -1);
  1252. PX_String(pPX, _T("GroupCaption"), m_strGroupCaption, _T(""));
  1254. PX_Bool(pPX, _T("Focusable"), m_bFocusable, TRUE);
  1256. PX_Bool(pPX, _T("Checked"), m_bChecked, FALSE);
  1257. PX_Bool(pPX, _T("HasCheckbox"), m_bHasCheckbox, FALSE);
  1259. ULONGLONG ullData = m_dwData;
  1260. PX_UI8(pPX, _T("Data"), ullData, 0);
  1261. m_dwData = (DWORD_PTR)ullData;
  1263. PX_String(pPX, _T("Tooltip"), m_strTooltip, _T(""));
  1265. if (pPX->GetSchema() > _XTP_SCHEMA_98)
  1266. {
  1267. PX_String(pPX, _T("Caption"), m_strCaption, _T(""));
  1268. }
  1271. // Hyperlinks
  1272. CXTPPropExchangeSection secHyperlinks(pPX->GetSection(_T("Hyperlinks")));
  1274. CXTPReportHyperlinks arHyperlinks;
  1276. if (pPX->IsStoring() && m_pHyperlinks)
  1277. {
  1278. arHyperlinks.CopyFrom(m_pHyperlinks);
  1279. }
  1281. arHyperlinks.DoPropExchange(&secHyperlinks);
  1283. if (pPX->IsLoading())
  1284. {
  1285. if (arHyperlinks.GetSize())
  1286. {
  1287. if (GetHyperlinks())
  1288. GetHyperlinks()->CopyFrom(&arHyperlinks);
  1289. }
  1290. else if (m_pHyperlinks)
  1291. {
  1292. m_pHyperlinks->RemoveAll();
  1293. }
  1294. }
  1296. // Item controls
  1297. CXTPReportRecordItemControls arItemControls;
  1298. if (pPX->IsStoring() && m_pItemControls)
  1299. arItemControls.CopyFrom(m_pItemControls);
  1301. if (pPX->GetSchema() >= _XTP_SCHEMA_1200)
  1302. {
  1303. CXTPPropExchangeSection secItemControls(pPX->GetSection(_T("ItemControls")));
  1304. arItemControls.DoPropExchange(&secItemControls);
  1305. }
  1306. if (pPX->IsLoading())
  1307. {
  1308. if (arItemControls.GetSize())
  1309. {
  1310. if (GetItemControls())
  1311. GetItemControls()->CopyFrom(&arItemControls);
  1312. }
  1313. else if (m_pItemControls)
  1314. {
  1315. m_pItemControls->RemoveAll();
  1316. }
  1317. }
  1319. // Update Markup data
  1320. if (pPX->IsLoading())
  1321. {
  1322. XTPMarkupReleaseElement(m_pMarkupUIElement);
  1324. if (m_pRecord && m_pRecord->GetRecords() && m_pRecord->GetRecords()->GetMarkupContext())
  1325. {
  1326. m_pMarkupUIElement = XTPMarkupParseText(m_pRecord->GetRecords()->GetMarkupContext(), m_strCaption);
  1327. }
  1328. }
  1330. }