You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
456 lines
18 KiB
C
456 lines
18 KiB
C
2 years ago
|
// XTPReportColumns.h: interface for the CXTPReportColumns class.
|
||
|
//
|
||
|
// This file is a part of the XTREME REPORTCONTROL MFC class library.
|
||
|
// (c)1998-2012 Codejock Software, All Rights Reserved.
|
||
|
//
|
||
|
// THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
|
||
|
// RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
|
||
|
// CONSENT OF CODEJOCK SOFTWARE.
|
||
|
//
|
||
|
// THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
|
||
|
// IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
|
||
|
// YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
|
||
|
// SINGLE COMPUTER.
|
||
|
//
|
||
|
// CONTACT INFORMATION:
|
||
|
// support@codejock.com
|
||
|
// http://www.codejock.com
|
||
|
//
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
//{{AFX_CODEJOCK_PRIVATE
|
||
|
#if !defined(__XTPREPORTCOLUMNS_H__)
|
||
|
#define __XTPREPORTCOLUMNS_H__
|
||
|
//}}AFX_CODEJOCK_PRIVATE
|
||
|
|
||
|
#if _MSC_VER > 1000
|
||
|
#pragma once
|
||
|
#endif // _MSC_VER > 1000
|
||
|
|
||
|
class CXTPReportColumn;
|
||
|
class CXTPReportHeader;
|
||
|
class CXTPReportControl;
|
||
|
class CXTPReportColumnOrder;
|
||
|
class CXTPPropExchange;
|
||
|
|
||
|
//===========================================================================
|
||
|
// Summary:
|
||
|
// This class is a collection of report columns objects,
|
||
|
// each of which can be referred to by its zero-based index.
|
||
|
// Remarks:
|
||
|
// It provides main operations to manipulate with list of columns:
|
||
|
// * Adding/removing columns
|
||
|
// * Showing columns header
|
||
|
// * Working with field chooser
|
||
|
// * Working with "group by" field
|
||
|
// * (Re)Storing column settings
|
||
|
// To create an object of that class simply call it constructor with
|
||
|
// one parameter - pointer to the Report Control object
|
||
|
//===========================================================================
|
||
|
class _XTP_EXT_CLASS CXTPReportColumns : public CXTPCmdTarget
|
||
|
{
|
||
|
friend class CXTPReportColumn;
|
||
|
public:
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Constructs a CXTPReportColumns object
|
||
|
// Parameters:
|
||
|
// pControl - Pointer to the parent Report Control object.
|
||
|
//-----------------------------------------------------------------------
|
||
|
CXTPReportColumns(CXTPReportControl* pControl);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Destroys a CXTPReportColumns object,
|
||
|
// Remarks:
|
||
|
// handles cleanup and deallocation, including all of objects
|
||
|
// presented in list by calling Clear() member function
|
||
|
//-----------------------------------------------------------------------
|
||
|
virtual ~CXTPReportColumns();
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Returns the total number of column items in the collection.
|
||
|
// Returns:
|
||
|
// Total count of column items in the collection.
|
||
|
//-----------------------------------------------------------------------
|
||
|
int GetCount() const;
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Clears columns collection items.
|
||
|
//-----------------------------------------------------------------------
|
||
|
void Clear();
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Returns the number of visible columns in the collection.
|
||
|
// Remarks:
|
||
|
// In opposite to GetCount() member function this one return
|
||
|
// count only those columns that have visibility property set to true
|
||
|
// Returns:
|
||
|
// The number of visible columns in the collection.
|
||
|
//-----------------------------------------------------------------------
|
||
|
int GetVisibleColumnsCount() const;
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Finds all visible columns and places them in the referenced
|
||
|
// CXTPReportColumns array.
|
||
|
// Parameters:
|
||
|
// arrColumns - A reference to a CXTPReportColumns object
|
||
|
// Remarks:
|
||
|
// The referenced CXTPReportColumns array object will get
|
||
|
// filled will all the visible CXTPReportColumn objects.
|
||
|
//-----------------------------------------------------------------------
|
||
|
void GetVisibleColumns(CXTPReportColumns& arrColumns) const;
|
||
|
|
||
|
// ---------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Returns specific column item by its numeric index.
|
||
|
// Parameters:
|
||
|
// nIndex - An integer index that is greater than or equal to 0 and
|
||
|
// less than the value returned by GetCount().
|
||
|
// Remarks:
|
||
|
// Returns the columns list element at the specified index. Passing
|
||
|
// a negative value or a value greater than the value returned by
|
||
|
// GetCount() will return NULL.
|
||
|
// Returns:
|
||
|
// The pointer to column array element currently at this index.
|
||
|
// ---------------------------------------------------------------------
|
||
|
CXTPReportColumn* GetAt(int nIndex) const;
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Returns a column at specified visible position.
|
||
|
// Parameters:
|
||
|
// nIndex - Index of column that is visible on position number nIndex.
|
||
|
// Remarks:
|
||
|
// Returns first visible column before column with given index
|
||
|
// or column with given index.
|
||
|
// Passing a negative value or a value greater than the value returned by
|
||
|
// GetCount() or if visible element not found will return NULL.
|
||
|
// Returns:
|
||
|
// Pointer to column object.
|
||
|
//-----------------------------------------------------------------------
|
||
|
CXTPReportColumn* GetVisibleAt(int nIndex) const;
|
||
|
|
||
|
int GetAtOffset(int nOffset, BOOL bFrozen) const;
|
||
|
|
||
|
int GetOffset(int nIndex) const;
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Gets specific indentation column.
|
||
|
// Remarks:
|
||
|
// Indentation column used for representing it ends in
|
||
|
// grouping mode. Indentation column usually it is the first column
|
||
|
// in list.
|
||
|
// Returns:
|
||
|
// An indentation column.
|
||
|
//-----------------------------------------------------------------------
|
||
|
CXTPReportColumn* GetIndentColumn() const;
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Finds the column by its item index.
|
||
|
// Parameters:
|
||
|
// nItemIndex - Column item index.
|
||
|
// strInternalName - Column internal name.
|
||
|
// Remarks:
|
||
|
// Searches the list sequentially to find the first element matching
|
||
|
// the specified item index column's value. If no matching found
|
||
|
// NULL is returned
|
||
|
// Returns:
|
||
|
// Found column.
|
||
|
//-----------------------------------------------------------------------
|
||
|
CXTPReportColumn* Find(int nItemIndex) const;
|
||
|
CXTPReportColumn* Find(const CString& strInternalName) const; //<COMBINE CXTPReportColumns::Find@int@const>
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Adds one more column item to the collection.
|
||
|
// Parameters:
|
||
|
// pColumn - A column to add to the collection.
|
||
|
// Remarks:
|
||
|
// Adds a new element to the end of a collection, growing the
|
||
|
// collection by 1
|
||
|
//-----------------------------------------------------------------------
|
||
|
void Add(CXTPReportColumn* pColumn);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Removes column from the collection.
|
||
|
// Parameters:
|
||
|
// pColumn - column to be removed.
|
||
|
//-----------------------------------------------------------------------
|
||
|
void Remove(CXTPReportColumn* pColumn);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Clear sort order for each column.
|
||
|
//-----------------------------------------------------------------------
|
||
|
void ResetSortOrder();
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Returns pointer to the associated report header object.
|
||
|
// Returns:
|
||
|
// A pointer to the associated report header.
|
||
|
//-----------------------------------------------------------------------
|
||
|
CXTPReportHeader* GetReportHeader() const;
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Changes column order in the collection.
|
||
|
// Parameters:
|
||
|
// nNewOrder - A new column order index.
|
||
|
// nOldIndex - Index of the changing column.
|
||
|
// Remarks:
|
||
|
// Moves column with index nItemIndex to the new position with
|
||
|
// nNewOrder. If any parameter's value is negative, no changes
|
||
|
// will be done and returns -1
|
||
|
// Returns:
|
||
|
// New column order index.
|
||
|
//-----------------------------------------------------------------------
|
||
|
int ChangeColumnOrder(int nNewOrder, int nOldIndex);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Call this method to get index of the column.
|
||
|
// Parameters:
|
||
|
// pColumn - The column.
|
||
|
// Remarks:
|
||
|
// Searches for the first occurrence of the given Column, beginning
|
||
|
// the search at index, and first position for equality using pointers
|
||
|
// equality. If no matching found return -1
|
||
|
// Returns:
|
||
|
// The index of the column;
|
||
|
//-----------------------------------------------------------------------
|
||
|
int IndexOf(const CXTPReportColumn* pColumn) const;
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Inserts provided column to the sort columns array according to
|
||
|
// the columns order in the group columns array.
|
||
|
// Parameters:
|
||
|
// pColumn - A column to insert.
|
||
|
// Returns:
|
||
|
// The index of the column inserted into the sort columns array.
|
||
|
//-----------------------------------------------------------------------
|
||
|
void InsertSortColumn(CXTPReportColumn* pColumn);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Sets a sort order for the column.
|
||
|
// Parameters:
|
||
|
// pColumn - Pointer to the specified column object.
|
||
|
// bIncreasing - TRUE to sort increasing.
|
||
|
// Remarks:
|
||
|
// Sets given column as the sorted column, reset previous sort order
|
||
|
//-----------------------------------------------------------------------
|
||
|
void SetSortColumn(CXTPReportColumn* pColumn, BOOL bIncreasing);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Provides a user with a columns groups order array.
|
||
|
// Returns:
|
||
|
// A pointer to the columns groups order array.
|
||
|
//-----------------------------------------------------------------------
|
||
|
CXTPReportColumnOrder* GetGroupsOrder() const;
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Provides a user with a columns sort order array.
|
||
|
// Returns:
|
||
|
// A pointer to the columns sort order array.
|
||
|
//-----------------------------------------------------------------------
|
||
|
CXTPReportColumnOrder* GetSortOrder() const;
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Reads or writes configuration to/from the provided archive stream.
|
||
|
// Parameters:
|
||
|
// pPX - A CXTPPropExchange object to serialize to or from.
|
||
|
//----------------------------------------------------------------------
|
||
|
virtual void DoPropExchange(CXTPPropExchange* pPX);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Returns first visible column
|
||
|
// Returns:
|
||
|
// Pointer to first visible column
|
||
|
// See Also: GetLastVisibleColumn
|
||
|
//-----------------------------------------------------------------------
|
||
|
CXTPReportColumn* GetFirstVisibleColumn() const;
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Returns last visible column
|
||
|
// Returns:
|
||
|
// Pointer to last visible column
|
||
|
// See Also: GetFirstVisibleColumn
|
||
|
//-----------------------------------------------------------------------
|
||
|
CXTPReportColumn* GetLastVisibleColumn() const;
|
||
|
protected:
|
||
|
|
||
|
CXTPReportColumnOrder* m_pGroupsOrder; // Container for the columns order in auto grouping mode.
|
||
|
CXTPReportColumnOrder* m_pSortOrder; // Container for the columns sort order.
|
||
|
CArray<CXTPReportColumn*, CXTPReportColumn*> m_arrColumns; // Storage for column items.
|
||
|
CXTPReportControl* m_pControl; // Pointer to the associated report control object.
|
||
|
CXTPReportColumn* m_pTreeColumn; // Column containing tree view images.
|
||
|
|
||
|
};
|
||
|
|
||
|
AFX_INLINE int CXTPReportColumns::GetCount() const
|
||
|
{
|
||
|
return (int) m_arrColumns.GetSize();
|
||
|
}
|
||
|
|
||
|
AFX_INLINE CXTPReportColumn* CXTPReportColumns::GetAt(int nIndex) const
|
||
|
{
|
||
|
return (nIndex >= 0 && nIndex < GetCount()) ? m_arrColumns.GetAt(nIndex) : NULL;
|
||
|
}
|
||
|
|
||
|
AFX_INLINE CXTPReportColumnOrder* CXTPReportColumns::GetGroupsOrder() const
|
||
|
{
|
||
|
return m_pGroupsOrder;
|
||
|
}
|
||
|
|
||
|
AFX_INLINE CXTPReportColumnOrder* CXTPReportColumns::GetSortOrder() const
|
||
|
{
|
||
|
return m_pSortOrder;
|
||
|
}
|
||
|
|
||
|
AFX_INLINE CXTPReportColumn* CXTPReportColumns::GetIndentColumn() const
|
||
|
{
|
||
|
return (GetCount() > 0) ? m_arrColumns.GetAt(0) : NULL;
|
||
|
}
|
||
|
|
||
|
//===========================================================================
|
||
|
// Summary:
|
||
|
// Represents column order, used for sorting and grouping.
|
||
|
// Remarks:
|
||
|
// This class is a collection of sorted columns objects,
|
||
|
// each of which can be referred to by its zero-based index.
|
||
|
// It provides main operations to manipulate with list of columns:
|
||
|
// Adding/removing columns, get at given position, clear collection,
|
||
|
// get index of object by it pointer
|
||
|
// You create object simply by calling constructor with one parameter
|
||
|
// pointer to the columns collection
|
||
|
//===========================================================================
|
||
|
class _XTP_EXT_CLASS CXTPReportColumnOrder : public CXTPCmdTarget
|
||
|
{
|
||
|
public:
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Default column order constructor.
|
||
|
// Parameters:
|
||
|
// pColumns - Parent columns collection.
|
||
|
//-----------------------------------------------------------------------
|
||
|
CXTPReportColumnOrder(CXTPReportColumns* pColumns);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Returns specific column item by its numeric index.
|
||
|
// Parameters:
|
||
|
// nIndex - An integer index that is greater than or equal to 0 and
|
||
|
// less than the value returned by GetCount().
|
||
|
// Remarks:
|
||
|
// Returns the columns list element at the specified index.
|
||
|
// Passing a negative value or a value greater than the value
|
||
|
// returned by GetCount() will return NULL.
|
||
|
// Returns:
|
||
|
// The pointer to column array element currently at this index.
|
||
|
//-----------------------------------------------------------------------
|
||
|
CXTPReportColumn* GetAt(int nIndex);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Inserts specified column at a specified position.
|
||
|
// Parameters:
|
||
|
// nIndex - Order index to insert column to.
|
||
|
// pColumn - A pointer to the inserted column.
|
||
|
// Returns:
|
||
|
// The index of the inserted column.
|
||
|
// -1 in case of an error.
|
||
|
//-----------------------------------------------------------------------
|
||
|
int InsertAt(int nIndex, CXTPReportColumn* pColumn);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Removes specified column at a specified position from the order array.
|
||
|
// Parameters:
|
||
|
// nIndex - Order index of the column to remove.
|
||
|
//-----------------------------------------------------------------------
|
||
|
void RemoveAt(int nIndex);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Removes specified column from order array.
|
||
|
// Parameters:
|
||
|
// pColumn - A column to remove from the order array.
|
||
|
//-----------------------------------------------------------------------
|
||
|
void Remove(CXTPReportColumn* pColumn);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Inserts specified column at the end of the order list.
|
||
|
// Parameters:
|
||
|
// pColumn - An added column pointer.
|
||
|
// bSortIncreasing - TRUE if this column should be sorted in
|
||
|
// increasing order, FALSE for decreasing order.
|
||
|
// Remarks:
|
||
|
// Adds a new element to the end of a collection, growing the
|
||
|
// collection by 1
|
||
|
// Returns:
|
||
|
// The index of the added element.
|
||
|
//-----------------------------------------------------------------------
|
||
|
int Add(CXTPReportColumn* pColumn);
|
||
|
int Add(CXTPReportColumn* pColumn, BOOL bSortIncreasing); // <COMBINE CXTPReportColumnOrder::Add@CXTPReportColumn*>
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Call this method to get index of the column.
|
||
|
// Parameters:
|
||
|
// pColumn - The column.
|
||
|
// Remarks:
|
||
|
// Searches for the first occurrence of the given Column, beginning
|
||
|
// the search at index, and first position for equality using pointers
|
||
|
// If no matching found return -1
|
||
|
// Returns:
|
||
|
// The index of the column;
|
||
|
//-----------------------------------------------------------------------
|
||
|
int IndexOf(const CXTPReportColumn* pColumn);
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Clears all stored order information.
|
||
|
//-----------------------------------------------------------------------
|
||
|
void Clear();
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Returns the number of stored order items.
|
||
|
// Returns:
|
||
|
// The count of items stored in the order array.
|
||
|
//-----------------------------------------------------------------------
|
||
|
int GetCount() const;
|
||
|
|
||
|
//-----------------------------------------------------------------------
|
||
|
// Summary:
|
||
|
// Reads or writes column order settings to/from the provided archive stream.
|
||
|
// Parameters:
|
||
|
// pPX - A CXTPPropExchange object to serialize to or from.
|
||
|
//----------------------------------------------------------------------
|
||
|
virtual void DoPropExchange(CXTPPropExchange* pPX);
|
||
|
|
||
|
protected:
|
||
|
CXTPReportColumns* m_pColumns; // Parent columns array.
|
||
|
|
||
|
CArray<CXTPReportColumn*, CXTPReportColumn*> m_arrColumns; // Storage for column items with the corresponding order.
|
||
|
|
||
|
};
|
||
|
|
||
|
#endif // #if !defined(__XTPREPORTCOLUMNS_H__)
|