XTPReportColumns.h
上传用户:szled88
上传日期:2015-04-09
资源大小:43957k
文件大小:18k
源码类别:

对话框与窗口

开发平台:

Visual C++

  1. // XTPReportColumns.h: interface for 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. /////////////////////////////////////////////////////////////////////////////
  20. //{{AFX_CODEJOCK_PRIVATE
  21. #if !defined(__XTPREPORTCOLUMNS_H__)
  22. #define __XTPREPORTCOLUMNS_H__
  23. //}}AFX_CODEJOCK_PRIVATE
  24. #if _MSC_VER > 1000
  25. #pragma once
  26. #endif // _MSC_VER > 1000
  27. class CXTPReportColumn;
  28. class CXTPReportHeader;
  29. class CXTPReportControl;
  30. class CXTPReportColumnOrder;
  31. class CXTPPropExchange;
  32. //===========================================================================
  33. // Summary:
  34. //     This class is a collection of report columns objects,
  35. //     each of which can be referred to by its zero-based index.
  36. // Remarks:
  37. //     It provides main operations to manipulate with list of columns:
  38. //          * Adding/removing columns
  39. //          * Showing columns header
  40. //          * Working with field chooser
  41. //          * Working with "group by" field
  42. //          * (Re)Storing column settings
  43. //     To create an object of that class simply call it constructor with
  44. //     one parameter - pointer to the Report Control object
  45. //===========================================================================
  46. class _XTP_EXT_CLASS CXTPReportColumns : public CXTPCmdTarget
  47. {
  48. friend class CXTPReportColumn;
  49. public:
  50. //-----------------------------------------------------------------------
  51. // Summary:
  52. //     Constructs a CXTPReportColumns object
  53. // Parameters:
  54. //     pControl - Pointer to the parent Report Control object.
  55. //-----------------------------------------------------------------------
  56. CXTPReportColumns(CXTPReportControl* pControl);
  57. //-----------------------------------------------------------------------
  58. // Summary:
  59. //     Destroys a CXTPReportColumns object,
  60. // Remarks:
  61. //     handles cleanup and deallocation, including all of objects
  62. //     presented in list by calling Clear() member function
  63. //-----------------------------------------------------------------------
  64. virtual ~CXTPReportColumns();
  65. //-----------------------------------------------------------------------
  66. // Summary:
  67. //     Returns the total number of column items in the collection.
  68. // Returns:
  69. //     Total count of column items in the collection.
  70. //-----------------------------------------------------------------------
  71. int GetCount() const;
  72. //-----------------------------------------------------------------------
  73. // Summary:
  74. //     Clears columns collection items.
  75. //-----------------------------------------------------------------------
  76. void Clear();
  77. //-----------------------------------------------------------------------
  78. // Summary:
  79. //     Returns the number of visible columns in the collection.
  80. // Remarks:
  81. //     In opposite to GetCount() member function this one return
  82. //     count only those columns that have visibility property set to true
  83. // Returns:
  84. //     The number of visible columns in the collection.
  85. //-----------------------------------------------------------------------
  86. int GetVisibleColumnsCount() const;
  87. //-----------------------------------------------------------------------
  88. // Summary:
  89. //     Finds all visible columns and places them in the referenced
  90. //      CXTPReportColumns array.
  91. // Parameters:
  92. //     arrColumns - A reference to a CXTPReportColumns object
  93. // Remarks:
  94. //      The referenced CXTPReportColumns array object will get
  95. //      filled will all the visible CXTPReportColumn objects.
  96. //-----------------------------------------------------------------------
  97. void GetVisibleColumns(CXTPReportColumns& arrColumns) const;
  98. // ---------------------------------------------------------------------
  99. // Summary:
  100. //     Returns specific column item by its numeric index.
  101. // Parameters:
  102. //     nIndex - An integer index that is greater than or equal to 0 and
  103. //              less than the value returned by GetCount().
  104. // Remarks:
  105. //     Returns the columns list element at the specified index. Passing
  106. //     a negative value or a value greater than the value returned by
  107. //     GetCount() will return NULL.
  108. // Returns:
  109. //     The pointer to column array element currently at this index.
  110. // ---------------------------------------------------------------------
  111. CXTPReportColumn* GetAt(int nIndex) const;
  112. //-----------------------------------------------------------------------
  113. // Summary:
  114. //     Returns a column at specified visible position.
  115. // Parameters:
  116. //     nIndex - Index of column that is visible on position number nIndex.
  117. // Remarks:
  118. //     Returns first visible column before column with given index
  119. //     or column with given index.
  120. //     Passing a negative value or a value greater than the value returned by
  121. //     GetCount() or if visible element not found will return NULL.
  122. // Returns:
  123. //     Pointer to column object.
  124. //-----------------------------------------------------------------------
  125. CXTPReportColumn* GetVisibleAt(int nIndex) const;
  126. //-----------------------------------------------------------------------
  127. // Summary:
  128. //     Gets specific indentation column.
  129. // Remarks:
  130. //     Indentation column used for representing it ends in
  131. //     grouping mode. Indentation column usually it is the first column
  132. //     in list.
  133. // Returns:
  134. //     An indentation column.
  135. //-----------------------------------------------------------------------
  136. CXTPReportColumn* GetIndentColumn() const;
  137. //-----------------------------------------------------------------------
  138. // Summary:
  139. //     Finds the column by its item index.
  140. // Parameters:
  141. //     nItemIndex - Column item index.
  142. //     strInternalName  - Column internal name.
  143. // Remarks:
  144. //     Searches the list sequentially to find the first element matching
  145. //     the specified item index column's value. If no matching found
  146. //     NULL is returned
  147. // Returns:
  148. //     Found column.
  149. //-----------------------------------------------------------------------
  150. CXTPReportColumn* Find(int nItemIndex) const;
  151. CXTPReportColumn* Find(const CString& strInternalName) const; //<COMBINE CXTPReportColumns::Find@int@const>
  152. //-----------------------------------------------------------------------
  153. // Summary:
  154. //     Adds one more column item to the collection.
  155. // Parameters:
  156. //     pColumn - A column to add to the collection.
  157. // Remarks:
  158. //     Adds a new element to the end of a collection, growing the
  159. //     collection by 1
  160. //-----------------------------------------------------------------------
  161. void Add(CXTPReportColumn* pColumn);
  162. //-----------------------------------------------------------------------
  163. // Summary:
  164. //     Removes column from the collection.
  165. // Parameters:
  166. //     pColumn - column to be removed.
  167. //-----------------------------------------------------------------------
  168. void Remove(CXTPReportColumn* pColumn);
  169. //-----------------------------------------------------------------------
  170. // Summary:
  171. //     Clear sort order for each column.
  172. //-----------------------------------------------------------------------
  173. void ResetSortOrder();
  174. //-----------------------------------------------------------------------
  175. // Summary:
  176. //     Returns pointer to the associated report header object.
  177. // Returns:
  178. //     A pointer to the associated report header.
  179. //-----------------------------------------------------------------------
  180. CXTPReportHeader* GetReportHeader() const;
  181. //-----------------------------------------------------------------------
  182. // Summary:
  183. //     Changes column order in the collection.
  184. // Parameters:
  185. //     nNewOrder - A new column order index.
  186. //     nOldIndex - Index of the changing column.
  187. // Remarks:
  188. //     Moves column with index nItemIndex to the new position with
  189. //     nNewOrder. If any parameter's value is negative, no changes
  190. //     will be done and returns -1
  191. // Returns:
  192. //     New column order index.
  193. //-----------------------------------------------------------------------
  194. int ChangeColumnOrder(int nNewOrder, int nOldIndex);
  195. //-----------------------------------------------------------------------
  196. // Summary:
  197. //     Call this method to get index of the column.
  198. // Parameters:
  199. //     pColumn - The column.
  200. // Remarks:
  201. //     Searches for the first occurrence of the given Column, beginning
  202. //     the search at index, and first position for equality using pointers
  203. //     equality. If no matching found return -1
  204. // Returns:
  205. //     The index of the column;
  206. //-----------------------------------------------------------------------
  207. int IndexOf(const CXTPReportColumn* pColumn) const;
  208. //-----------------------------------------------------------------------
  209. // Summary:
  210. //     Inserts provided column to the sort columns array according to
  211. //     the columns order in the group columns array.
  212. // Parameters:
  213. //     pColumn - A column to insert.
  214. // Returns:
  215. //     The index of the column inserted into the sort columns array.
  216. //-----------------------------------------------------------------------
  217. void InsertSortColumn(CXTPReportColumn* pColumn);
  218. //-----------------------------------------------------------------------
  219. // Summary:
  220. //     Sets a sort order for the column.
  221. // Parameters:
  222. //     pColumn - Pointer to the specified column object.
  223. //     bIncreasing - TRUE to sort increasing.
  224. // Remarks:
  225. //     Sets given column as the sorted column, reset previous sort order
  226. //-----------------------------------------------------------------------
  227. void SetSortColumn(CXTPReportColumn* pColumn, BOOL bIncreasing);
  228. //-----------------------------------------------------------------------
  229. // Summary:
  230. //     Provides a user with a columns groups order array.
  231. // Returns:
  232. //     A pointer to the columns groups order array.
  233. //-----------------------------------------------------------------------
  234. CXTPReportColumnOrder* GetGroupsOrder() const;
  235. //-----------------------------------------------------------------------
  236. // Summary:
  237. //     Provides a user with a columns sort order array.
  238. // Returns:
  239. //     A pointer to the columns sort order array.
  240. //-----------------------------------------------------------------------
  241. CXTPReportColumnOrder* GetSortOrder() const;
  242. //-----------------------------------------------------------------------
  243. // Summary:
  244. //     Reads or writes configuration to/from the provided archive stream.
  245. // Parameters:
  246. //     pPX - A CXTPPropExchange object to serialize to or from.
  247. //----------------------------------------------------------------------
  248. virtual void DoPropExchange(CXTPPropExchange* pPX);
  249. //-----------------------------------------------------------------------
  250. // Summary:
  251. //     Returns first visible column
  252. // Returns:
  253. //     Pointer to first visible column
  254. // See Also: GetLastVisibleColumn
  255. //-----------------------------------------------------------------------
  256. CXTPReportColumn* GetFirstVisibleColumn() const;
  257. //-----------------------------------------------------------------------
  258. // Summary:
  259. //     Returns last visible column
  260. // Returns:
  261. //     Pointer to last visible column
  262. // See Also: GetFirstVisibleColumn
  263. //-----------------------------------------------------------------------
  264. CXTPReportColumn* GetLastVisibleColumn() const;
  265. protected:
  266. CXTPReportColumnOrder* m_pGroupsOrder;  // Container for the columns order in auto grouping mode.
  267. CXTPReportColumnOrder* m_pSortOrder;    // Container for the columns sort order.
  268. CArray<CXTPReportColumn*, CXTPReportColumn*> m_arrColumns;  // Storage for column items.
  269. CXTPReportControl* m_pControl;          // Pointer to the associated report control object.
  270. CXTPReportColumn* m_pTreeColumn;       // Column containing tree view images.
  271. };
  272. AFX_INLINE int CXTPReportColumns::GetCount() const {
  273. return (int)m_arrColumns.GetSize();
  274. }
  275. AFX_INLINE CXTPReportColumn* CXTPReportColumns::GetAt(int nIndex) const{
  276. return (nIndex >= 0 && nIndex < GetCount()) ? m_arrColumns.GetAt(nIndex) : NULL;
  277. }
  278. AFX_INLINE CXTPReportColumnOrder* CXTPReportColumns::GetGroupsOrder() const {
  279. return m_pGroupsOrder;
  280. }
  281. AFX_INLINE CXTPReportColumnOrder* CXTPReportColumns::GetSortOrder() const{
  282. return m_pSortOrder;
  283. }
  284. AFX_INLINE CXTPReportColumn* CXTPReportColumns::GetIndentColumn() const{
  285. return (GetCount() > 0) ? m_arrColumns.GetAt(0) : NULL;
  286. }
  287. //===========================================================================
  288. // Summary:
  289. //     Represents column order, used for sorting and grouping.
  290. // Remarks:
  291. //     This class is a collection of sorted columns objects,
  292. //     each of which can be referred to by its zero-based index.
  293. //     It provides main operations to manipulate with list of columns:
  294. //     Adding/removing columns, get at given position, clear collection,
  295. //     get index of object by it pointer
  296. //     You create object simply by calling constructor with one parameter
  297. //     pointer to the columns collection
  298. //===========================================================================
  299. class _XTP_EXT_CLASS CXTPReportColumnOrder : public CXTPCmdTarget
  300. {
  301. public:
  302. //-----------------------------------------------------------------------
  303. // Summary:
  304. //     Default column order constructor.
  305. // Parameters:
  306. //     pColumns - Parent columns collection.
  307. //-----------------------------------------------------------------------
  308. CXTPReportColumnOrder(CXTPReportColumns* pColumns);
  309. //-----------------------------------------------------------------------
  310. // Summary:
  311. //     Returns specific column item by its numeric index.
  312. // Parameters:
  313. //     nIndex - An integer index that is greater than or equal to 0 and
  314. //              less than the value returned by GetCount().
  315. // Remarks:
  316. //     Returns the columns list element at the specified index.
  317. //     Passing a negative value or a value greater than the value
  318. //     returned by GetCount() will return NULL.
  319. // Returns:
  320. //     The pointer to column array element currently at this index.
  321. //-----------------------------------------------------------------------
  322. CXTPReportColumn* GetAt(int nIndex);
  323. //-----------------------------------------------------------------------
  324. // Summary:
  325. //     Inserts specified column at a specified position.
  326. // Parameters:
  327. //     nIndex - Order index to insert column to.
  328. //     pColumn - A pointer to the inserted column.
  329. // Returns:
  330. //     The index of the inserted column.
  331. //     -1 in case of an error.
  332. //-----------------------------------------------------------------------
  333. int InsertAt(int nIndex, CXTPReportColumn* pColumn);
  334. //-----------------------------------------------------------------------
  335. // Summary:
  336. //     Removes specified column at a specified position from the order array.
  337. // Parameters:
  338. //     nIndex - Order index of the column to remove.
  339. //-----------------------------------------------------------------------
  340. void RemoveAt(int nIndex);
  341. //-----------------------------------------------------------------------
  342. // Summary:
  343. //     Removes specified column from order array.
  344. // Parameters:
  345. //     pColumn - A column to remove from the order array.
  346. //-----------------------------------------------------------------------
  347. void Remove(CXTPReportColumn* pColumn);
  348. //-----------------------------------------------------------------------
  349. // Summary:
  350. //     Inserts specified column at the end of the order list.
  351. // Parameters:
  352. //     pColumn         - An added column pointer.
  353. //     bSortIncreasing - TRUE if this column should be sorted in
  354. //                            increasing order, FALSE for decreasing order.
  355. // Remarks:
  356. //     Adds a new element to the end of a collection, growing the
  357. //     collection by 1
  358. // Returns:
  359. //     The index of the added element.
  360. //-----------------------------------------------------------------------
  361. int Add(CXTPReportColumn* pColumn);
  362. int Add(CXTPReportColumn* pColumn, BOOL bSortIncreasing); // <COMBINE CXTPReportColumnOrder::Add@CXTPReportColumn*>
  363. //-----------------------------------------------------------------------
  364. // Summary:
  365. //     Call this method to get index of the column.
  366. // Parameters:
  367. //     pColumn - The column.
  368. // Remarks:
  369. //     Searches for the first occurrence of the given Column, beginning
  370. //     the search at index, and first position for equality using pointers
  371. //     If no matching found return -1
  372. // Returns:
  373. //     The index of the column;
  374. //-----------------------------------------------------------------------
  375. int IndexOf(const CXTPReportColumn* pColumn);
  376. //-----------------------------------------------------------------------
  377. // Summary:
  378. //     Clears all stored order information.
  379. //-----------------------------------------------------------------------
  380. void Clear();
  381. //-----------------------------------------------------------------------
  382. // Summary:
  383. //     Returns the number of stored order items.
  384. // Returns:
  385. //     The count of items stored in the order array.
  386. //-----------------------------------------------------------------------
  387. int GetCount() const;
  388. //-----------------------------------------------------------------------
  389. // Summary:
  390. //     Reads or writes column order settings to/from the provided archive stream.
  391. // Parameters:
  392. //     pPX - A CXTPPropExchange object to serialize to or from.
  393. //----------------------------------------------------------------------
  394. virtual void DoPropExchange(CXTPPropExchange* pPX);
  395. protected:
  396. CXTPReportColumns* m_pColumns;  // Parent columns array.
  397. CArray<CXTPReportColumn*, CXTPReportColumn*> m_arrColumns;  // Storage for column items with the corresponding order.
  398. };
  399. #endif // #if !defined(__XTPREPORTCOLUMNS_H__)