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

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

对话框与窗口

开发平台：

Visual C++

XTPReportNavigator.cpp：源码内容
  1. // XTPReportNavigator.cpp : implementation of the CXTPReportNavigator 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"
  24. #include "Common/XTPResourceManager.h"
  25. #include "Common/XTPDrawHelpers.h"
  26. #include "Common/XTPImageManager.h"
  27. #include "Common/XTPVC80Helpers.h"
  29. #include "XTPReportNavigator.h"
  30. #include "XTPReportControl.h"
  31. #include "XTPReportRecord.h"
  32. #include "XTPReportRecordItem.h"
  33. #include "XTPReportColumn.h"
  34. #include "XTPReportColumns.h"
  35. #include "XTPReportInplaceControls.h"
  38. #ifdef _DEBUG
  39. #undef THIS_FILE
  40. static char THIS_FILE[] = __FILE__;
  41. #define new DEBUG_NEW
  42. #endif
  45. //////////////////////////////////////////////////////////////////////
  46. // CXTPReportNavigator
  48. CXTPReportNavigator::CXTPReportNavigator(CXTPReportControl* pReportControl)
  49. : m_pReportControl(pReportControl), m_bCurrentFocusInHeadersRows(FALSE), m_bCurrentFocusInFootersRows(FALSE)
  50. {
  52. }
  54. CXTPReportNavigator::~CXTPReportNavigator()
  55. {
  56. }
  58. void CXTPReportNavigator::MoveDown(BOOL bSelectBlock, BOOL bIgnoreSelection)
  59. {
  60. if  (!m_pReportControl)
  61. return;
  63. CXTPReportRow* pNextRow = NULL;
  64. CXTPReportRow* pFocusedRow = m_pReportControl->GetFocusedRow();
  66. if (m_bCurrentFocusInHeadersRows)
  67. {
  68. pNextRow = m_pReportControl->m_pHeaderRows->GetNext(pFocusedRow, m_pReportControl->m_bSkipGroupsFocus);
  70. // from the last header row jump to the first visible body row
  71. if (pFocusedRow == pNextRow)
  72. {
  73. MoveFirstVisibleRow(xtpRowTypeBody);
  74. }
  75. else
  76. {
  77. m_pReportControl->SetFocusedRow(pNextRow, bSelectBlock, bIgnoreSelection);
  78. }
  79. }
  80. else if (m_bCurrentFocusInFootersRows)
  81. {
  82. m_pReportControl->SetFocusedRow(
  83. m_pReportControl->m_pFooterRows->GetNext(pFocusedRow, m_pReportControl->m_bSkipGroupsFocus),
  84. bSelectBlock,
  85. bIgnoreSelection);
  86. }
  87. else
  88. {
  89. // body rows
  90. pNextRow = m_pReportControl->m_pRows->GetNext(pFocusedRow, m_pReportControl->m_bSkipGroupsFocus);
  92. if (pNextRow)
  93. {
  94. // from the last body row jump to the first header row
  95. if (m_pReportControl->m_nFocusedRow == pNextRow->GetIndex())
  96. {
  97. if (m_pReportControl->IsFooterRowsVisible() && m_pReportControl->IsFooterRowsAllowAccess())
  98. MoveFirstVisibleRow(xtpRowTypeFooter);
  99. }
  100. else
  101. {
  102. m_pReportControl->SetFocusedRow(pNextRow, bSelectBlock, bIgnoreSelection);
  103. }
  104. }
  105. }
  106. }
  108. void CXTPReportNavigator::MoveUp(BOOL bSelectBlock, BOOL bIgnoreSelection)
  109. {
  110. if  (!m_pReportControl)
  111. return;
  113. CXTPReportRow* pPrevRow = NULL;
  114. CXTPReportRow* pFocusedRow = m_pReportControl->GetFocusedRow();
  116. if (m_bCurrentFocusInHeadersRows)
  117. {
  118. m_pReportControl->SetFocusedRow(
  119. m_pReportControl->m_pHeaderRows->GetPrev(pFocusedRow, m_pReportControl->m_bSkipGroupsFocus),
  120. bSelectBlock,
  121. bIgnoreSelection);
  122. }
  123. else if (m_bCurrentFocusInFootersRows)
  124. {
  125. pPrevRow = m_pReportControl->m_pFooterRows->GetPrev(pFocusedRow, m_pReportControl->m_bSkipGroupsFocus);
  127. // from the first footer row jump to the last visible body row
  128. if (pFocusedRow == pPrevRow)
  129. {
  130. MoveLastVisibleRow(xtpRowTypeBody);
  131. }
  132. else
  133. {
  134. m_pReportControl->SetFocusedRow(pPrevRow, bSelectBlock, bIgnoreSelection);
  135. }
  136. }
  137. else
  138. {
  139. // body rows
  140. pPrevRow = m_pReportControl->m_pRows->GetPrev(pFocusedRow, m_pReportControl->m_bSkipGroupsFocus);
  142. if (pPrevRow)
  143. {
  144. // from the first body row jump to the last header row
  145. if (m_pReportControl->m_nFocusedRow == pPrevRow->GetIndex())
  146. {
  147. if (m_pReportControl->IsHeaderRowsVisible() && m_pReportControl->IsHeaderRowsAllowAccess())
  148. MoveLastVisibleRow(xtpRowTypeHeader);
  149. }
  150. else
  151. {
  152. m_pReportControl->SetFocusedRow(pPrevRow, bSelectBlock, bIgnoreSelection);
  153. }
  154. }
  155. }
  156. }
  158. void CXTPReportNavigator::MovePageDown(BOOL bSelectBlock, BOOL bIgnoreSelection)
  159. {
  160. if  (!m_pReportControl)
  161. return;
  163. int nCurrentRowIndex = m_pReportControl->m_nFocusedRow != -1 ? m_pReportControl->m_nFocusedRow : 0;
  164. nCurrentRowIndex = min(
  165. m_pReportControl->m_pRows->GetCount() - 1,
  166. nCurrentRowIndex + m_pReportControl->GetReportAreaRows(nCurrentRowIndex, true));
  168. m_pReportControl->SetFocusedRow(
  169. m_pReportControl->m_pRows->GetAt(nCurrentRowIndex),
  170. bSelectBlock,
  171. bIgnoreSelection);
  172. }
  174. void CXTPReportNavigator::MovePageUp(BOOL bSelectBlock, BOOL bIgnoreSelection)
  175. {
  176. if  (!m_pReportControl)
  177. return;
  179. int nCurrentRowIndex = m_pReportControl->m_nFocusedRow != -1 ? m_pReportControl->m_nFocusedRow : 0;
  180. nCurrentRowIndex = max(0, nCurrentRowIndex - m_pReportControl->GetReportAreaRows(nCurrentRowIndex, false));
  182. m_pReportControl->SetFocusedRow(
  183. m_pReportControl->m_pRows->GetAt(nCurrentRowIndex),
  184. bSelectBlock,
  185. bIgnoreSelection);
  186. }
  188. void CXTPReportNavigator::MoveFirstRow(BOOL bSelectBlock, BOOL bIgnoreSelection)
  189. {
  190. if  (!m_pReportControl)
  191. return;
  193. m_pReportControl->SetFocusedRow(
  194. m_pReportControl->m_pRows->GetAt(0),
  195. bSelectBlock,
  196. bIgnoreSelection);
  197. }
  199. void CXTPReportNavigator::MoveLastRow(BOOL bSelectBlock, BOOL bIgnoreSelection)
  200. {
  201. if  (!m_pReportControl)
  202. return;
  204. m_pReportControl->SetFocusedRow(
  205. m_pReportControl->m_pRows->GetAt(m_pReportControl->m_pRows->GetCount() - 1),
  206. bSelectBlock,
  207. bIgnoreSelection);
  208. }
  210. void CXTPReportNavigator::MoveToRow(int nRowIndex, BOOL bSelectBlock, BOOL bIgnoreSelection)
  211. {
  212. if  (!m_pReportControl)
  213. return;
  215. int nCurrentRowIndex = max(0, nRowIndex);
  216. nCurrentRowIndex = min(nCurrentRowIndex, m_pReportControl->m_pRows->GetCount() - 1);
  217. if (nCurrentRowIndex < 0)
  218. {
  219. return;
  220. }
  222. m_pReportControl->SetFocusedRow(
  223. m_pReportControl->m_pRows->GetAt(nCurrentRowIndex),
  224. bSelectBlock,
  225. bIgnoreSelection);
  226. }
  229. void CXTPReportNavigator::BeginEdit()
  230. {
  231. if  (!m_pReportControl)
  232. return;
  234. m_pReportControl->AdjustScrollBars();
  235. m_pReportControl->RedrawControl();
  236. m_pReportControl->UpdateWindow();
  238. CXTPReportRow* pFocusedRow = m_pReportControl->GetFocusedRow();
  240. if (m_pReportControl->m_pFocusedColumn &&
  241. pFocusedRow && pFocusedRow->GetRecord())
  242. {
  243. XTP_REPORTRECORDITEM_ARGS itemArgs(m_pReportControl, pFocusedRow, m_pReportControl->m_pFocusedColumn);
  245. if (itemArgs.pItem && itemArgs.pItem->IsAllowEdit(&itemArgs))
  246. {
  247. if (!m_pReportControl->IsVirtualMode())
  248. {
  249. m_pReportControl->EnsureVisible(pFocusedRow);
  250. }
  252. m_pReportControl->EditItem(&itemArgs);
  254. if (m_pReportControl->GetInplaceEdit()->GetSafeHwnd() &&
  255. m_pReportControl->GetInplaceEdit()->GetItem() == itemArgs.pItem)
  256. {
  257. CXTPReportRecordItemEditOptions* pEditOptions = itemArgs.pItem->GetEditOptions(itemArgs.pColumn);
  258. if (pEditOptions && pEditOptions->m_bSelectTextOnEdit)
  259. {
  260. m_pReportControl->GetInplaceEdit()->SetSel(0, -1);
  261. }
  262. else
  263. {
  264. CString str;
  265. m_pReportControl->GetInplaceEdit()->GetWindowText(str);
  266. m_pReportControl->GetInplaceEdit()->SetSel(str.GetLength(), str.GetLength());
  267. }
  268. }
  269. }
  270. }
  271. }
  273. void CXTPReportNavigator::MoveLeftRight(BOOL bBack, BOOL bSelectBlock, BOOL bIgnoreSelection)
  274. {
  275. if  (!m_pReportControl)
  276. return;
  278. CXTPReportControl::CUpdateContext updateContext(m_pReportControl);
  280. CXTPReportRow* pFocusedRow = m_pReportControl->GetFocusedRow();
  281. CXTPReportColumn* pFocusedColumn = m_pReportControl->GetNextFocusableColumn(pFocusedRow,
  282. m_pReportControl->m_pFocusedColumn ? m_pReportControl->m_pFocusedColumn->GetIndex() : -1,
  283. bBack ? -1 : 1);
  285. if (pFocusedColumn)
  286. {
  287. m_pReportControl->SetFocusedColumn(pFocusedColumn);
  288. }
  289. else
  290. {
  291. CXTPReportRows* pRows;
  292. int nFocusedRow = m_pReportControl->GetFocusedRow() ? m_pReportControl->GetFocusedRow()->GetIndex() : -1;
  293. switch(pFocusedRow->GetType())
  294. {
  295. case xtpRowTypeHeader : pRows = m_pReportControl->GetHeaderRows(); break;
  296. case xtpRowTypeFooter : pRows = m_pReportControl->GetFooterRows(); break;
  297. default : pRows = m_pReportControl->GetRows(); break;
  298. }
  299. CXTPReportRow* pRow = bBack ? pRows->GetPrev(pFocusedRow, FALSE) : pRows->GetNext(pFocusedRow, FALSE);
  300. if (pRow && pRow->GetIndex() != nFocusedRow)
  301. {
  302. m_pReportControl->SetFocusedRow(pRow, bSelectBlock, bIgnoreSelection);
  303. m_pReportControl->SetFocusedColumn(
  304. m_pReportControl->GetNextFocusableColumn(
  305. m_pReportControl->GetFocusedRow(),
  306. bBack ? m_pReportControl->m_pColumns->GetCount() : -1,
  307. bBack ? -1 : +1)
  308. );
  309. }
  310. }
  311. }
  313. void CXTPReportNavigator::MoveLeft(BOOL bSelectBlock, BOOL bIgnoreSelection)
  314. {
  315. MoveLeftRight(TRUE, bSelectBlock, bIgnoreSelection);
  316. }
  318. void CXTPReportNavigator::MoveRight(BOOL bSelectBlock, BOOL bIgnoreSelection)
  319. {
  320. MoveLeftRight(FALSE, bSelectBlock, bIgnoreSelection);
  321. }
  323. void CXTPReportNavigator::MoveFirstColumn()
  324. {
  325. if  (!m_pReportControl)
  326. return;
  328. CXTPReportControl::CUpdateContext updateContext(m_pReportControl);
  329. CXTPReportRow* pFocusedRow = m_pReportControl->GetFocusedRow();
  330. CXTPReportColumn* pFocusedColumn = m_pReportControl->GetNextFocusableColumn(pFocusedRow, -1, +1);
  331. if (pFocusedColumn)
  332. {
  333. m_pReportControl->SetFocusedColumn(pFocusedColumn);
  334. }
  335. }
  337. void CXTPReportNavigator::MoveLastColumn()
  338. {
  339. if  (!m_pReportControl)
  340. return;
  342. CXTPReportControl::CUpdateContext updateContext(m_pReportControl);
  343. CXTPReportRow* pFocusedRow = m_pReportControl->GetFocusedRow();
  344. CXTPReportColumn* pFocusedColumn = m_pReportControl->GetNextFocusableColumn(pFocusedRow, m_pReportControl->GetColumns()->GetCount(), -1);
  345. if (pFocusedColumn)
  346. {
  347. m_pReportControl->SetFocusedColumn(pFocusedColumn);
  348. }
  349. }
  351. void CXTPReportNavigator::MoveToColumn(int nColumnIndex, BOOL bClearIfNonFocusable)
  352. {
  353. if (!m_pReportControl)
  354. {
  355. return;
  356. }
  358. nColumnIndex = max(0, nColumnIndex);
  359. nColumnIndex = min(nColumnIndex, m_pReportControl->GetColumns()->GetCount()-1);
  360. if (nColumnIndex < 0)
  361. {
  362. return;
  363. }
  365. CXTPReportControl::CUpdateContext updateContext(m_pReportControl);
  367. CXTPReportRow* pFocusedRow = m_pReportControl->GetFocusedRow();
  368. CXTPReportColumn* pColumn = m_pReportControl->GetColumns()->GetAt(nColumnIndex);
  369. if (!pColumn)
  370. {
  371. return;
  372. }
  374. CXTPReportRecordItem* pItem = pFocusedRow->GetRecord()->GetItem(pColumn);
  376. if (!pItem || !pItem->IsFocusable())
  377. {
  378. if (bClearIfNonFocusable)
  379. {
  380. pColumn = NULL;
  381. }
  382. else
  383. {
  384. return;
  385. }
  386. }
  388. m_pReportControl->SetFocusedColumn(pColumn);
  389. }
  391. void CXTPReportNavigator::SetCurrentFocusInHeadersRows(BOOL bCurrentFocusInHeadersRows)
  392. {
  393. if(m_pReportControl->m_bHeaderRecordsVisible && m_pReportControl->m_bHeaderRowsAllowAccess)
  394. {
  395. m_bCurrentFocusInHeadersRows = bCurrentFocusInHeadersRows;
  396. }
  397. else
  398. {
  399. m_bCurrentFocusInHeadersRows = FALSE;
  400. }
  403. if (m_bCurrentFocusInHeadersRows)
  404. {
  405. MoveFirstVisibleRow(xtpRowTypeHeader);
  406. }
  407. else if (!m_bCurrentFocusInFootersRows && m_pReportControl->m_bHeaderRowsAllowAccess)
  408. {
  409. MoveFirstVisibleRow(xtpRowTypeBody);    // neither header nor footer is active
  410. }
  411. }
  413. void CXTPReportNavigator::SetCurrentFocusInFootersRows(BOOL bCurrentFocusInFootersRows)
  414. {
  415. if(m_pReportControl->m_bFooterRecordsVisible && m_pReportControl->m_bFooterRowsAllowAccess)
  416. {
  417. m_bCurrentFocusInFootersRows = bCurrentFocusInFootersRows;
  418. }
  419. else
  420. {
  421. m_bCurrentFocusInFootersRows = FALSE;
  422. }
  424. if (m_bCurrentFocusInFootersRows)
  425. {
  426. MoveFirstVisibleRow(xtpRowTypeFooter);
  427. }
  428. else if (!m_bCurrentFocusInHeadersRows && m_pReportControl->m_bFooterRowsAllowAccess)
  429. {
  430. MoveFirstVisibleRow(xtpRowTypeBody);    // neither header nor footer is active
  431. }
  432. }
  434. BOOL CXTPReportNavigator::GetCurrentFocusInHeadersRows()
  435. {
  436. return m_bCurrentFocusInHeadersRows;
  437. }
  439. BOOL CXTPReportNavigator::GetCurrentFocusInFootersRows()
  440. {
  441. return m_bCurrentFocusInFootersRows;
  442. }
  444. void CXTPReportNavigator::SetMovePosition(XTPReportRowType RowType)
  445. {
  446. switch(RowType)
  447. {
  448. case xtpRowTypeBody:    m_bCurrentFocusInHeadersRows = FALSE;   m_bCurrentFocusInFootersRows = FALSE; break;
  449. case xtpRowTypeHeader:  m_bCurrentFocusInHeadersRows = TRUE;    m_bCurrentFocusInFootersRows = FALSE; break;
  450. case xtpRowTypeFooter:  m_bCurrentFocusInHeadersRows = FALSE;   m_bCurrentFocusInFootersRows = TRUE; break;
  451. }
  452. }
  454. void CXTPReportNavigator::MoveFirstVisibleRow(XTPReportRowType TargetType)
  455. {
  456. switch(TargetType)
  457. {
  458. case xtpRowTypeBody:    m_pReportControl->SetFocusedRow(m_pReportControl->m_pRows->GetAt(m_pReportControl->m_nTopRow));
  460. break;
  462. case xtpRowTypeHeader:  if (m_pReportControl->m_pHeaderRows)
  463. {
  464. if (m_pReportControl->m_pHeaderRows->GetCount()>0)
  465. m_pReportControl->SetFocusedRow(m_pReportControl->m_pHeaderRows->GetAt(0));
  466. }
  467. break;
  469. case xtpRowTypeFooter:  if (m_pReportControl->m_pFooterRows)
  470. {
  471. if (m_pReportControl->m_pFooterRows->GetCount()>0)
  472. m_pReportControl->SetFocusedRow(m_pReportControl->m_pFooterRows->GetAt(0));
  473. }
  474. break;
  475. }
  476. }
  478. void CXTPReportNavigator::MoveLastVisibleRow(XTPReportRowType TargetType)
  479. {
  480. switch(TargetType)
  481. {
  482. case xtpRowTypeBody:    {
  483. int nRows = m_pReportControl->GetReportAreaRows(m_pReportControl->m_nTopRow, TRUE);
  485. if (nRows > -1 && m_pReportControl->m_pRows->GetCount()>0)
  486. {
  487. int nIdx = min(m_pReportControl->m_nTopRow + nRows, m_pReportControl->m_pRows->GetCount()-1);
  489. m_pReportControl->SetFocusedRow(m_pReportControl->m_pRows->GetAt(nIdx));
  490. }
  491. }
  492. break;
  494. case xtpRowTypeHeader:  if (m_pReportControl->m_pHeaderRows && m_pReportControl->m_pHeaderRows->GetCount()>0)
  495. {
  496. m_pReportControl->SetFocusedRow(
  497. m_pReportControl->m_pHeaderRows->GetAt(m_pReportControl->m_pHeaderRows->GetCount()-1));
  499. }
  500. break;
  502. case xtpRowTypeFooter:  if (m_pReportControl->m_pFooterRows && m_pReportControl->m_pFooterRows->GetCount()>0)
  503. {
  504. m_pReportControl->SetFocusedRow(
  505. m_pReportControl->m_pFooterRows->GetAt(m_pReportControl->m_pFooterRows->GetCount()-1));
  506. }
  507. break;
  508. }
  509. }
  511. //////////////////////////////////////////////////////////////////////////