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

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

对话框与窗口

开发平台：

Visual C++

XTPReportColumns.cpp：源码内容
  1. // XTPReportColumns.cpp : implementation of the CXTPReportColumns 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/XTPPropExchange.h"
  24. #include "XTPReportControl.h"
  25. #include "XTPReportHeader.h"
  26. #include "XTPReportColumn.h"
  27. #include "XTPReportColumns.h"
  29. #ifdef _DEBUG
  30. #define new DEBUG_NEW
  31. #undef THIS_FILE
  32. static char THIS_FILE[] = __FILE__;
  33. #endif
  36. /////////////////////////////////////////////////////////////////////////////
  37. // CXTPReportColumns
  39. CXTPReportColumns::CXTPReportColumns(CXTPReportControl* pControl)
  40. : m_pControl(pControl)
  41. {
  42. m_pGroupsOrder = new CXTPReportColumnOrder(this);
  43. m_pSortOrder = new CXTPReportColumnOrder(this);
  45. m_pTreeColumn = NULL;
  47. }
  49. CXTPReportColumns::~CXTPReportColumns()
  50. {
  51. Clear();
  53. if (m_pGroupsOrder)
  54. m_pGroupsOrder->InternalRelease();
  55. if (m_pSortOrder)
  56. m_pSortOrder->InternalRelease();
  58. }
  60. void CXTPReportColumns::Clear()
  61. {
  62. // array cleanup
  63. for (int nColumn = GetCount() - 1; nColumn >= 0; nColumn--)
  64. {
  65. CXTPReportColumn* pColumn = m_arrColumns.GetAt(nColumn);
  66. pColumn->InternalRelease();
  67. }
  68. m_arrColumns.RemoveAll();
  70. m_pSortOrder->Clear();
  71. m_pGroupsOrder->Clear();
  73. // clear variables which could be references to those values
  74. if (m_pControl && (m_pControl->GetColumns() == this))
  75. {
  76. m_pControl->SetFocusedColumn(NULL);
  77. }
  78. }
  80. int CXTPReportColumnOrder::GetCount() const
  81. {
  82. return (int)m_arrColumns.GetSize();
  83. }
  86. void CXTPReportColumns::Add(CXTPReportColumn* pColumn)
  87. {
  88. pColumn->m_pColumns = this;
  89. m_arrColumns.Add(pColumn);
  91. GetReportHeader()->OnColumnsChanged();
  92. }
  94. CXTPReportHeader* CXTPReportColumns::GetReportHeader() const
  95. {
  96. return m_pControl->GetReportHeader();
  97. }
  100. void CXTPReportColumns::Remove(CXTPReportColumn* pColumn)
  101. {
  102. m_pGroupsOrder->Remove(pColumn);
  103. m_pSortOrder->Remove(pColumn);
  105. int nIndex = IndexOf(pColumn);
  106. if (nIndex != -1)
  107. {
  108. m_arrColumns.RemoveAt(nIndex);
  109. pColumn->InternalRelease();
  111. GetReportHeader()->OnColumnsChanged();
  112. }
  113. }
  115. int CXTPReportColumns::IndexOf(const CXTPReportColumn* pColumn) const
  116. {
  117. // array cleanup
  118. for (int nColumn = GetCount() - 1; nColumn >= 0; nColumn--)
  119. {
  120. if (m_arrColumns.GetAt(nColumn) == pColumn)
  121. return nColumn;
  122. }
  123. return -1;
  124. }
  126. void CXTPReportColumns::ResetSortOrder()
  127. {
  128. m_pSortOrder->Clear();
  129. }
  131. void CXTPReportColumns::SetSortColumn(CXTPReportColumn* pColumn, BOOL bIncreasing)
  132. {
  133. ResetSortOrder();
  134. m_pSortOrder->Add(pColumn, bIncreasing);
  135. }
  137. int CXTPReportColumns::ChangeColumnOrder(int nNewOrder, int nItemIndex)
  138. {
  139. if (nNewOrder < 0 || nItemIndex < 0)
  140. return -1;
  142. CXTPReportColumn* pColumn = GetAt(nItemIndex);
  144. if (pColumn)
  145. {
  146. if (nNewOrder == nItemIndex)
  147. return nNewOrder;
  149. if (nNewOrder > nItemIndex)
  150. nNewOrder--;
  152. m_arrColumns.RemoveAt(nItemIndex);
  153. m_arrColumns.InsertAt(nNewOrder, pColumn);
  154. }
  156. return nNewOrder;
  157. }
  159. int CXTPReportColumns::GetVisibleColumnsCount() const
  160. {
  161. int nVisibleCount = 0;
  162. int nCount = GetCount();
  163. for (int nColumn = 0; nColumn < nCount; nColumn++)
  164. {
  165. CXTPReportColumn* pColumn = GetAt(nColumn);
  166. if (pColumn && pColumn->IsVisible())
  167. nVisibleCount++;
  168. }
  169. return nVisibleCount;
  170. }
  172. void CXTPReportColumns::GetVisibleColumns(CXTPReportColumns& arrColumns) const
  173. {
  174. int nCount = GetCount();
  175. for (int nColumn = 0; nColumn < nCount; nColumn++)
  176. {
  177. CXTPReportColumn* pColumn = GetAt(nColumn);
  178. if (pColumn && pColumn->IsVisible())
  179. {
  180. arrColumns.m_arrColumns.Add(pColumn);
  181. pColumn->InternalAddRef();
  182. }
  183. }
  184. }
  186. CXTPReportColumn* CXTPReportColumns::Find(int nItemIndex) const
  187. {
  188. for (int nColumn = 0; nColumn < GetCount(); nColumn++)
  189. {
  190. CXTPReportColumn* pColumn = GetAt(nColumn);
  191. if (pColumn->GetItemIndex() == nItemIndex)
  192. return pColumn;
  193. }
  194. return NULL;
  195. }
  197. CXTPReportColumn* CXTPReportColumns::Find(const CString& strInternalName) const
  198. {
  199. for (int nColumn = 0; nColumn < GetCount(); nColumn++)
  200. {
  201. CXTPReportColumn* pColumn = GetAt(nColumn);
  202. if (pColumn->GetInternalName() == strInternalName)
  203. return pColumn;
  204. }
  205. return NULL;
  206. }
  208. void CXTPReportColumns::InsertSortColumn(CXTPReportColumn* pColumn)
  209. {
  210. if (m_pSortOrder->IndexOf(pColumn) == -1)
  211. m_pSortOrder->Add(pColumn);
  212. }
  214. CXTPReportColumn* CXTPReportColumns::GetVisibleAt(int nIndex) const
  215. {
  216. for (int nColumn = 0; nColumn < GetCount(); nColumn++)
  217. {
  218. CXTPReportColumn* pColumn = GetAt(nColumn);
  219. if (!pColumn->IsVisible())
  220. continue;
  222. if (nIndex == 0)
  223. return pColumn;
  225. nIndex--;
  226. }
  227. return NULL;
  228. }
  230. CXTPReportColumn* CXTPReportColumns::GetFirstVisibleColumn() const
  231. {
  232. for (int nColumn = 0; nColumn < GetCount(); nColumn++)
  233. {
  234. CXTPReportColumn* pColumn = GetAt(nColumn);
  235. if (pColumn->IsVisible())
  236. return pColumn;
  237. }
  238. return NULL;
  239. }
  241. CXTPReportColumn* CXTPReportColumns::GetLastVisibleColumn() const
  242. {
  243. for (int nColumn = GetCount() - 1; nColumn >= 0; nColumn--)
  244. {
  245. CXTPReportColumn* pColumn = GetAt(nColumn);
  246. if (pColumn->IsVisible())
  247. return pColumn;
  248. }
  249. return NULL;
  250. }
  253. void CXTPReportColumns::DoPropExchange(CXTPPropExchange* pPX)
  254. {
  255. int nItemIndex;
  256. CString strInternalName;
  257. if (pPX->IsStoring())
  258. {
  259. int nCount = GetCount();
  261. CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Column")));
  262. POSITION pos = pEnumerator->GetPosition(nCount, FALSE);
  264. for (int nColumn = 0; nColumn < nCount; nColumn++)
  265. {
  266. CXTPReportColumn* pColumn = GetAt(nColumn);
  267. CXTPPropExchangeSection secColumn(pEnumerator->GetNext(pos));
  269. nItemIndex = pColumn->GetItemIndex();
  270. strInternalName = pColumn->GetInternalName();
  272. PX_Int(&secColumn, _T("ItemIndex"), nItemIndex);
  273. PX_String(&secColumn, _T("InternalName"), strInternalName);
  275. pColumn->DoPropExchange(&secColumn);
  276. }
  277. }
  278. else
  279. {
  280. CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Column")));
  281. POSITION pos = pEnumerator->GetPosition(0, FALSE);
  283. CXTPReportColumn tmpColumn(0, _T(""), 0);
  284. int i = 0;
  285. while (pos)
  286. {
  287. CXTPPropExchangeSection secColumn(pEnumerator->GetNext(pos));
  289. CXTPReportColumn* pColumn = NULL;
  290. PX_Int(&secColumn, _T("ItemIndex"), nItemIndex, -1);
  292. if (pPX->GetSchema() > _XTP_SCHEMA_110)
  293. {
  294. PX_String(&secColumn, _T("InternalName"), strInternalName);
  296. if (!strInternalName.IsEmpty())
  297. {
  298. pColumn = Find(strInternalName);
  300. // column data is exists but column is not in the collection.
  301. if (!pColumn)
  302. {
  303. // just read data to skeep (to be safe for array serialization)
  304. tmpColumn.DoPropExchange(&secColumn);
  305. continue;
  306. }
  307. }
  308. }
  310. if (!pColumn)
  311. pColumn = Find(nItemIndex);
  313. if (!pColumn)
  314. AfxThrowArchiveException(CArchiveException::badIndex);
  316. pColumn->DoPropExchange(&secColumn);
  317. ChangeColumnOrder(i, IndexOf(pColumn));
  318. i++;
  319. }
  320. }
  322. CXTPPropExchangeSection secGroupsOrder(pPX->GetSection(_T("GroupsOrder")));
  323. m_pGroupsOrder->DoPropExchange(&secGroupsOrder);
  325. CXTPPropExchangeSection secSortOrder(pPX->GetSection(_T("SortOrder")));
  326. m_pSortOrder->DoPropExchange(&secSortOrder);
  327. }
  329. /////////////////////////////////////////////////////////////////////////////
  330. // CXTPReportColumnOrder
  332. CXTPReportColumnOrder::CXTPReportColumnOrder(CXTPReportColumns* pColumns) :
  333. m_pColumns(pColumns)
  334. {
  335. }
  338. CXTPReportColumn* CXTPReportColumnOrder::GetAt(int nIndex)
  339. {
  340. if (nIndex >= 0 && nIndex < GetCount())
  341. return m_arrColumns.GetAt(nIndex);
  342. else
  343. return NULL;
  344. }
  346. int CXTPReportColumnOrder::InsertAt(int nIndex, CXTPReportColumn* pColumn)
  347. {
  348. if (nIndex < 0)
  349. return -1;
  351. if (nIndex >= GetCount())
  352. nIndex = GetCount();
  354. int nPrevIndex = IndexOf(pColumn);
  356. if (nPrevIndex != -1)
  357. {
  358. if (nPrevIndex == nIndex)
  359. return nIndex;
  361. if (nIndex > nPrevIndex)
  362. nIndex--;
  364. if (nIndex == nPrevIndex)
  365. return nIndex;
  367. // change order
  368. m_arrColumns.RemoveAt(nPrevIndex);
  370. }
  371. m_arrColumns.InsertAt(nIndex, pColumn);
  372. return nIndex;
  373. }
  375. int CXTPReportColumnOrder::Add(CXTPReportColumn* pColumn, BOOL bSortIncreasing)
  376. {
  377. pColumn->m_bSortIncreasing = bSortIncreasing;
  378. return (int)m_arrColumns.Add(pColumn);
  379. }
  381. int CXTPReportColumnOrder::Add(CXTPReportColumn* pColumn)
  382. {
  383. return (int)m_arrColumns.Add(pColumn);
  384. }
  386. void CXTPReportColumnOrder::Clear()
  387. {
  388. m_arrColumns.RemoveAll();
  389. }
  391. int CXTPReportColumnOrder::IndexOf(const CXTPReportColumn* pColumn)
  392. {
  393. int nCount = GetCount();
  394. for (int i = 0; i < nCount; i++)
  395. {
  396. if (GetAt(i) == pColumn)
  397. return i;
  398. }
  399. return -1;
  400. }
  402. void CXTPReportColumnOrder::RemoveAt(int nIndex)
  403. {
  404. if (nIndex >= 0 && nIndex < GetCount())
  405. {
  406. m_arrColumns.RemoveAt(nIndex);
  407. }
  408. }
  410. void CXTPReportColumnOrder::Remove(CXTPReportColumn* pColumn)
  411. {
  412. int nCount = GetCount();
  413. for (int i = 0; i < nCount; i++)
  414. {
  415. if (GetAt(i) == pColumn)
  416. {
  417. m_arrColumns.RemoveAt(i);
  418. break;
  419. }
  420. }
  421. }
  423. void CXTPReportColumnOrder::DoPropExchange(CXTPPropExchange* pPX)
  424. {
  425. if (pPX->IsStoring())
  426. {
  427. int nCount = GetCount();
  428. PX_Int(pPX, _T("Count"), nCount, 0);
  430. for (int i = 0; i < nCount; i++)
  431. {
  432. CXTPReportColumn* pColumn = GetAt(i);
  433. if (pColumn)
  434. {
  435. int nItemIndex = pColumn->GetItemIndex();
  436. CString strInternalName = pColumn->GetInternalName();
  437. CString strParamName;
  439. strParamName.Format(_T("Column%i"), i);
  440. PX_Int(pPX, strParamName, nItemIndex, 0);
  442. strParamName.Format(_T("InternalName%i"), i);
  443. PX_String(pPX, strParamName, strInternalName);
  444. }
  445. }
  446. }
  447. else
  448. {
  449. Clear();
  451. int nCount = 0;
  452. PX_Int(pPX, _T("Count"), nCount, 0);
  454. for (int i = 0; i < nCount; i++)
  455. {
  456. int nItemIndex = 0;
  457. CString strParamName;
  458. strParamName.Format(_T("Column%i"), i);
  459. PX_Int(pPX, strParamName, nItemIndex, 0);
  461. CXTPReportColumn* pColumn = NULL;
  462. if (pPX->GetSchema() > _XTP_SCHEMA_110)
  463. {
  464. strParamName.Format(_T("InternalName%i"), i);
  465. CString strInternalName;
  466. PX_String(pPX, strParamName, strInternalName);
  468. if (!strInternalName.IsEmpty())
  469. pColumn = m_pColumns->Find(strInternalName);
  470. }
  471. if (!pColumn)
  472. pColumn = m_pColumns->Find(nItemIndex);
  474. if (pColumn)
  475. Add(pColumn);
  476. }
  477. }
  478. }