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.
508 lines
20 KiB
C++
508 lines
20 KiB
C++
// XTPReportRows.h: interface for the CXTPReportRows 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(__XTPREPORTROWS_H__)
|
|
#define __XTPREPORTROWS_H__
|
|
//}}AFX_CODEJOCK_PRIVATE
|
|
|
|
#if _MSC_VER > 1000
|
|
#pragma once
|
|
#endif // _MSC_VER > 1000
|
|
|
|
class CXTPReportRow;
|
|
class CXTPReportRecord;
|
|
class CXTPReportRecordItem;
|
|
class CXTPReportControl;
|
|
class CXTPReportColumns;
|
|
|
|
//===========================================================================
|
|
// Summary:
|
|
// This enum defines selection change action.
|
|
// See Also: XTP_NM_REPORT_SELCHANGING, XTP_NM_SELECTION_CHANGING
|
|
//===========================================================================
|
|
enum XTPReportSelectionChangeType
|
|
{
|
|
xtpReportSelectionAdd, // Row will be added to selected rows collection.
|
|
xtpReportSelectionRemove, // Row will be removed from selected rows collection.
|
|
xtpReportSelectionClear // The selected rows collection will be cleared.
|
|
};
|
|
|
|
//===========================================================================
|
|
// Summary:
|
|
// This struct defines data for XTP_NM_REPORT_SELCHANGING notification.
|
|
// See Also: XTP_NM_REPORT_SELCHANGING, XTP_NM_SELECTION_CHANGING
|
|
//===========================================================================
|
|
struct XTP_NM_SELECTION_CHANGING
|
|
{
|
|
NMHDR hdr; // Standard structure, containing information
|
|
// about a notification message.
|
|
CXTPReportRow* pRow; // Pointer to the row associated with the
|
|
// notification. It is NULL for xtpReportSelectionClear action.
|
|
XTPReportSelectionChangeType nType; // Selection change action.
|
|
};
|
|
|
|
//===========================================================================
|
|
// Summary:
|
|
// This structure that contains information for use in processing the
|
|
// XTP_NM_REPORT_STATECHANGED message.
|
|
//===========================================================================
|
|
struct XTP_NM_REPORTSTATECHANGED
|
|
{
|
|
NMHDR hdr; // Standard structure, containing information
|
|
int nBegin; // Zero-based index of the first item in the range of items.
|
|
int nEnd; // Zero-based index of the last item in the range of items.
|
|
};
|
|
|
|
class _XTP_EXT_CLASS CXTPReportScreenRows : public CArray<CXTPReportRow*, CXTPReportRow*>
|
|
{
|
|
public:
|
|
|
|
CXTPReportScreenRows();
|
|
~CXTPReportScreenRows();
|
|
|
|
public:
|
|
CXTPReportRow* HitTest(CPoint pt) const;
|
|
void Clear();
|
|
};
|
|
|
|
//===========================================================================
|
|
// Summary:
|
|
// This class represents a rows collection class.
|
|
// It supports an array of CXTPReportRow pointers.
|
|
// Example:
|
|
// See CXTPReportRows::Add for an example of how to work with this class.
|
|
// See Also: CXTPReportRow, CXTPReportSelectedRows
|
|
//===========================================================================
|
|
class _XTP_EXT_CLASS CXTPReportRows : public CXTPHeapObjectT<CXTPCmdTarget, CXTPReportDataAllocator>
|
|
{
|
|
public:
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Constructs an empty CXTPReportRow pointer array.
|
|
// Example:
|
|
// <code>
|
|
// // Declare a local CXTPReportRows object.
|
|
// CXTPReportRows myList;
|
|
//
|
|
// // Declare a dynamic CXTPReportRows object.
|
|
// CXTPReportRows* pTree = new CXTPReportRows();
|
|
// </code>
|
|
//-----------------------------------------------------------------------
|
|
CXTPReportRows();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Destroys CXTPReportRows object. Performs cleanup operations.
|
|
//-----------------------------------------------------------------------
|
|
virtual ~CXTPReportRows();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Returns whether this row collection contains a specific row.
|
|
//-----------------------------------------------------------------------
|
|
virtual BOOL Contains(const CXTPReportRow *pRow) const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Removes all the elements from this array.
|
|
// Parameters:
|
|
// bResetRow - TRUE to remove visible flag of child rows.
|
|
// Remarks:
|
|
// Removes all the pointers from this array and releases instances
|
|
// of all stored CXTPReportRow objects.
|
|
// Example:
|
|
// See example for CXTPReportRows::Add method.
|
|
// See Also: CXTPReportRows overview
|
|
//-----------------------------------------------------------------------
|
|
virtual void Clear(BOOL bResetRow = TRUE);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Gets the number of CXTPReportRow elements in this collection.
|
|
// Remarks:
|
|
// Call this method to retrieve the number of elements in the array.
|
|
// Because indexes are zero-based, the size is 1 greater than
|
|
// the largest index.
|
|
// Example:
|
|
// See example for CXTPReportRows::Add method.
|
|
// Returns:
|
|
// The number of items in the collection.
|
|
// See Also: CXTPReportRows overview
|
|
//-----------------------------------------------------------------------
|
|
int GetCount() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Returns a row at the specified 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 array element at the specified index.
|
|
// Example:
|
|
// See example for CXTPReportRows::Add method.
|
|
// Returns:
|
|
// The row element currently at this index.
|
|
//-----------------------------------------------------------------------
|
|
virtual CXTPReportRow* GetAt(int nIndex) const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Returns the currently displayed rows of this rows collection.
|
|
//-----------------------------------------------------------------------
|
|
virtual CXTPReportScreenRows *GetScreenRows();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Returns the currently focused row index.
|
|
//-----------------------------------------------------------------------
|
|
virtual int GetFocusedRowIndex() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Returns whether a row of the collection currently has the focus.
|
|
//-----------------------------------------------------------------------
|
|
virtual BOOL HasFocus() const;
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Sets the currently focused row index.
|
|
//-----------------------------------------------------------------------
|
|
virtual void SetFocusedRowIndex(int nRow);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Returns the currently focused row index.
|
|
//-----------------------------------------------------------------------
|
|
virtual CXTPReportRow *GetFocusedRow();
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Adds a new Row element to the end of an array.
|
|
// Parameters:
|
|
// pRow - The row element to be added to this array.
|
|
// Remarks:
|
|
// Use this method to add the specified CXTPReportRow pointer
|
|
// to the end of the CXTPReportRows collection.
|
|
// Returns:
|
|
// The index of the added row.
|
|
// Example:
|
|
// <code>
|
|
// CXTPReportRows* pTree = new CXTPReportRows();
|
|
// pTree->Add(new CXTPReportRow(pControl, pRecord1));
|
|
// pTree->Add(new CXTPReportRow(pControl, pRecord2));
|
|
// CXTPReportRow* pRow0 = pTree->GetAt(0);
|
|
// CXTPReportRow* pRow1 = pTree->GetAt(1);
|
|
// ASSERT(pRow0 == pTree->GetPrev(pRow1));
|
|
// ASSERT(pRow1 == pTree->GetNext(pRow0));
|
|
// pTree->RemoveAt(0);
|
|
// ASSERT(1 == pTree->GetCount());
|
|
// pTree->InsertAt(0, pRow0);
|
|
// ASSERT(2 == pTree->GetCount());
|
|
// pTree->Clear();
|
|
// ASSERT(0 == pTree->GetCount());
|
|
// </code>
|
|
// See Also:
|
|
// CXTPReportRows overview, GetAt, InsertAt, Clear, GetNext, GetPrev, GetCount
|
|
//-----------------------------------------------------------------------
|
|
virtual int Add(CXTPReportRow* pRow);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Removes an item from the collection on specified position.
|
|
// Parameters:
|
|
// nIndex - An integer index that is greater than or equal to 0
|
|
// and less than the value returned by GetCount.
|
|
// Remarks:
|
|
// In the process, it shifts down all the elements above the
|
|
// removed element. It decrements the upper bound of the array
|
|
// but does not free memory.
|
|
// It also releases an instance of the removed element.
|
|
// Example:
|
|
// See example for CXTPReportRows::Add method.
|
|
//-----------------------------------------------------------------------
|
|
virtual void RemoveAt(int nIndex);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Removes specified row from the collection.
|
|
// Parameters:
|
|
// pRow - The row element to be removed.
|
|
// Returns:
|
|
// An integer value specifying the index of the removed item, -1 if item
|
|
// is not removed.
|
|
//-----------------------------------------------------------------------
|
|
virtual int RemoveRow(CXTPReportRow* pRow);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Adds one more Row object to the collection at the specified position.
|
|
// Parameters:
|
|
// nIndex - An integer index that is greater than or equal to 0
|
|
// and less than the value returned by GetCount.
|
|
// pRow - The row element to be placed in this array.
|
|
// Remarks:
|
|
// InsertAt inserts one element at a specified index in an array.
|
|
// In the process, it shifts up (by incrementing the index) the
|
|
// existing element at this index, and it shifts up all the elements
|
|
// above it.
|
|
// Example:
|
|
// See example for CXTPReportRows::Add method.
|
|
//-----------------------------------------------------------------------
|
|
virtual void InsertAt(int nIndex, CXTPReportRow* pRow);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Returns next row in the list.
|
|
// Parameters:
|
|
// pRow - A reference to the current element of the list.
|
|
// bSkipGroupFocus - TRUE to skip all groups.
|
|
// Remarks:
|
|
// This function finds a pointer to the provided row element
|
|
// in the list, and returns a pointer to the elements following
|
|
// the found one.
|
|
// Returns:
|
|
// A pointer to a next element of the list.
|
|
// Example:
|
|
// See example for CXTPReportRows::Add method.
|
|
// See Also: GetPrev, CXTPReportControl::SkipGroupsFocus
|
|
//-----------------------------------------------------------------------
|
|
virtual CXTPReportRow* GetNext(CXTPReportRow* pRow, BOOL bSkipGroupFocus);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Returns previous row in the list.
|
|
// Parameters:
|
|
// pRow - A reference to the current element of the list.
|
|
// bSkipGroupFocus - TRUE to skip all groups.
|
|
// Remarks:
|
|
// This function finds a pointer to the provided row element
|
|
// in the list, and returns a pointer to the elements before
|
|
// the found one.
|
|
// Returns:
|
|
// A pointer to a previous element of the list.
|
|
// Example:
|
|
// See example for CXTPReportRows::Add method.
|
|
// See Also: GetNext, CXTPReportControl::SkipGroupsFocus
|
|
//-----------------------------------------------------------------------
|
|
virtual CXTPReportRow* GetPrev(CXTPReportRow* pRow, BOOL bSkipGroupFocus);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to set virtual mode with nCount rows.
|
|
// Parameters:
|
|
// pRow - Virtual row
|
|
// nCount - Count of virtual rows
|
|
//-----------------------------------------------------------------------
|
|
virtual void SetVirtualMode(CXTPReportRow* pRow, int nCount);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to find row corresponded with specified record
|
|
// Parameters:
|
|
// pRecord - Record need to find.
|
|
// Returns:
|
|
// A pointer to associated row object or NULL.
|
|
//-----------------------------------------------------------------------
|
|
virtual CXTPReportRow* Find(CXTPReportRecord *pRecord);
|
|
virtual CXTPReportRow* Find(CXTPReportRecord *pRecord, BOOL bRecursive);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to find row corresponded with specified record.
|
|
// This function performs search in children too.
|
|
// Parameters:
|
|
// pRecord - Record need to find.
|
|
// Returns:
|
|
// A pointer to associated row object or NULL.
|
|
//-----------------------------------------------------------------------
|
|
virtual CXTPReportRow* FindInTree(CXTPReportRecord* pRecord);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this method to find a position to insert a new row at.
|
|
// This function performs search in children too.
|
|
// Parameters:
|
|
// pRow - A row to insert.
|
|
// bInsertAfter - the function sets it to TRUE if a row has to be inserted after the row found.
|
|
// Returns:
|
|
// A pointer to the found row object or NULL.
|
|
//-----------------------------------------------------------------------
|
|
virtual CXTPReportRow* FindInsertionPos(CXTPReportRow* pRow, BOOL& bInsertAfter);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Recalculates child indices of all rows in the collection.
|
|
// Parameters:
|
|
// bRunInChildren - if TRUE, indices are refreshed in children also.
|
|
//-----------------------------------------------------------------------
|
|
virtual void RefreshChildIndices(BOOL bRunInChildren = TRUE);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Sorts collection elements.
|
|
// Parameters:
|
|
// pCompareFunc - A T_CompareFunc function pointer that is used
|
|
// to compare rows.
|
|
// Remarks:
|
|
// This method uses Visual C++ run-time library (MSVCRT)
|
|
// implementation of the quick-sort function, qsort, for sorting
|
|
// stored CXTPReportRow objects.
|
|
//
|
|
// Sort() internally uses CompareRows method for comparing 2 rows.
|
|
// See Also: CompareRows
|
|
//-----------------------------------------------------------------------
|
|
virtual void SortEx(XTPReportRowsCompareFunc pCompareFunc);
|
|
virtual void Sort(); // <COMBINE SortEx>
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Compares 2 rows using groups and sort orders of the report control.
|
|
// Parameters:
|
|
// pRow1 - First row for comparison.
|
|
// pRow2 - Second row for comparison.
|
|
// Remarks:
|
|
// This function is called directly by Sort method.
|
|
//
|
|
// The default implementation returns the result of the comparison
|
|
// of *pRow1 and *pRow2.
|
|
//
|
|
// This implementation uses CXTPReportRecordItem::Compare for comparing
|
|
// two corresponding items from the row records. First it compares
|
|
// record items in the group order, then by sort order. It returns
|
|
// the first comparison result differ from equality. If no differences was
|
|
// found, it returns 0.
|
|
//
|
|
// Returns:
|
|
// Zero if pRow1 is equal to pRow2;
|
|
// Less than zero if pRow1 is less than pRow2;
|
|
// Greater than zero if pRow1 is greater than pRow2.
|
|
// See Also: Sort, CXTPReportRecordItem::Compare
|
|
//-----------------------------------------------------------------------
|
|
static int _cdecl CompareRows(const CXTPReportRow** pRow1, const CXTPReportRow** pRow2);
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Compares 2 rows using groups and sort orders of the report control.
|
|
// Parameters:
|
|
// pRow1 - First row for comparison.
|
|
// pRow2 - Second row for comparison.
|
|
// Remarks:
|
|
// This function is called directly by Sort method.
|
|
//
|
|
// The default implementation returns the result of the comparison
|
|
// of *pRow1 and *pRow2.
|
|
//
|
|
// This implementation uses CXTPReportRecordItem::Compare for comparing
|
|
// two corresponding items from the row records. First it compares
|
|
// record items in the group order, then by sort order. It returns
|
|
// the first comparison result differ from equality. If no differences was
|
|
// found, it returns 0.
|
|
//
|
|
// Returns:
|
|
// Zero if pRow1 is equal to pRow2;
|
|
// Less than zero if pRow1 is less than pRow2;
|
|
// Greater than zero if pRow1 is greater than pRow2.
|
|
// See Also: Sort, CXTPReportRecordItem::Compare
|
|
//-----------------------------------------------------------------------
|
|
static int _cdecl CompareRows2(const CXTPReportRow** pRow1, const CXTPReportRow** pRow2); //<COMBINE CompareRows>
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Summary:
|
|
// Call this function to search for a record item by rows.
|
|
// Parameters:
|
|
// nStartIndex - The starting index.
|
|
// nEndIndex - The end index.
|
|
// nStartColumn- The start column.
|
|
// nEndColumn - The end column.
|
|
// nItem - Record item index to start search from.
|
|
// nRecordIndex- Record index to start search from.
|
|
// pcszText - The search text.
|
|
// nFlags - The search flags.
|
|
// Remarks:
|
|
// The various values for nFlags are,
|
|
// xtpReportTextSearchExactPhrase - Search exact phrase.
|
|
// xtpReportTextSearchMatchCase - Match case during search.
|
|
// xtpReportTextSearchBackward - Search backwards.
|
|
// xtpReportTextSearchExactStart - Search phrase where the start of the phrase matches exactly.
|
|
// For those familiar with grep this is just like using the
|
|
// "^" to state that the text must start with the specified search.
|
|
// Returns:
|
|
// Report record item found or NULL otherwise.
|
|
//-----------------------------------------------------------------------
|
|
virtual CXTPReportRecordItem* FindRecordItemByRows(
|
|
int nStartIndex, int nEndIndex,
|
|
int nStartColumn, int nEndColumn,
|
|
int nRecordIndex, int nItem,
|
|
LPCTSTR pcszText, int nFlags);
|
|
|
|
//{{AFX_CODEJOCK_PRIVATE
|
|
virtual void ReserveSize(INT_PTR nNewSize, INT_PTR nGrowBy = -1);
|
|
virtual void SetSize(INT_PTR nNewSize, INT_PTR nGrowBy = -1);
|
|
virtual void SetAt(INT_PTR nIndex, CXTPReportRow* pRow);
|
|
//}}AFX_CODEJOCK_PRIVATE
|
|
protected:
|
|
|
|
//{{AFX_CODEJOCK_PRIVATE
|
|
class CXTPReportRowsArray : public CArray<CXTPReportRow*, CXTPReportRow*>
|
|
{
|
|
public:
|
|
void ReserveSize(INT_PTR nNewSize, INT_PTR nGrowBy = -1)
|
|
{
|
|
if (GetSize() != 0)
|
|
{
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
SetSize(1, nNewSize);
|
|
Add(NULL);
|
|
SetSize(1, nGrowBy < 0 ? 0 : nGrowBy);
|
|
|
|
m_nSize = 0;
|
|
|
|
//ASSERT(m_pData == NULL);
|
|
//if (m_pData)
|
|
// delete m_pData;
|
|
//m_pData = (CXTPReportRow**) new CXTPReportRow*[nNewSize];
|
|
//m_nSize = 0;
|
|
//m_nMaxSize = nNewSize;
|
|
//m_nGrowBy = nGrowBy < 0 ? 0 : nGrowBy;
|
|
}
|
|
};
|
|
CXTPReportRowsArray m_arrRows; // Internal storage for CXTPReportRow objects.
|
|
//}}AFX_CODEJOCK_PRIVATE
|
|
|
|
CXTPReportRow *m_pVirtualRow; // Virtual row.
|
|
CXTPReportScreenRows *m_pScreenRows; // Rows currently presented on screen.
|
|
int m_nVirtualRowsCount; // Count of virtual rows.
|
|
|
|
int m_nFocusedRow; // Current focused row index
|
|
|
|
|
|
friend class CXTPReportControl;
|
|
friend class CXTPTrackControl;
|
|
friend class CXTPReportNavigator;
|
|
friend class CXTPReportSection;
|
|
};
|
|
|
|
#endif //#if !defined(__XTPREPORTROWS_H__)
|