frxcross.hpp

这个是功能强大的报表软件

// Borland C++ Builder
// Copyright (c) 1995, 2005 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Frxcross.pas' rev: 10.00

#ifndef FrxcrossHPP
#define FrxcrossHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <Sysinit.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Frxclass.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

namespace Frxcross
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TfrxCrossObject;
class PASCALIMPLEMENTATION TfrxCrossObject : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
public:
	#pragma option push -w-inl
	/* TComponent.Create */ inline __fastcall virtual TfrxCrossObject(Classes::TComponent* AOwner) : Classes::TComponent(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TComponent.Destroy */ inline __fastcall virtual ~TfrxCrossObject(void) { }
	#pragma option pop
	
};


typedef AnsiString TfrxPrintCellEvent;

typedef AnsiString TfrxPrintHeaderEvent;

typedef AnsiString TfrxCalcWidthEvent;

typedef AnsiString TfrxCalcHeightEvent;

typedef void __fastcall (__closure *TfrxOnPrintCellEvent)(Frxclass::TfrxCustomMemoView* Memo, int RowIndex, int ColumnIndex, int CellIndex, const Variant &RowValues, const Variant &ColumnValues, const Variant &Value);

typedef void __fastcall (__closure *TfrxOnPrintHeaderEvent)(Frxclass::TfrxCustomMemoView* Memo, const Variant &HeaderIndexes, const Variant &HeaderValues, const Variant &Value);

typedef void __fastcall (__closure *TfrxOnCalcWidthEvent)(int ColumnIndex, const Variant &ColumnValues, Extended &Width);

typedef void __fastcall (__closure *TfrxOnCalcHeightEvent)(int RowIndex, const Variant &RowValues, Extended &Height);

struct TfrxCrossCell;
typedef TfrxCrossCell *PfrCrossCell;

#pragma pack(push,1)
struct TfrxCrossCell
{
	
public:
	Variant Value;
	int Count;
	TfrxCrossCell *Next;
} ;
#pragma pack(pop)

#pragma option push -b-
enum TfrxCrossSortOrder { soAscending, soDescending, soNone };
#pragma option pop

#pragma option push -b-
enum TfrxCrossFunction { cfNone, cfSum, cfMin, cfMax, cfAvg, cfCount };
#pragma option pop

typedef DynamicArray<Variant >  TfrxVariantArray;

typedef TfrxCrossSortOrder TfrxSortArray[32];

class DELPHICLASS TfrxIndexItem;
class PASCALIMPLEMENTATION TfrxIndexItem : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	DynamicArray<Variant >  FIndexes;
	
public:
	__fastcall virtual ~TfrxIndexItem(void);
	__property TfrxVariantArray Indexes = {read=FIndexes, write=FIndexes};
public:
	#pragma option push -w-inl
	/* TCollectionItem.Create */ inline __fastcall virtual TfrxIndexItem(Classes::TCollection* Collection) : Classes::TCollectionItem(Collection) { }
	#pragma option pop
	
};


class DELPHICLASS TfrxIndexCollection;
class PASCALIMPLEMENTATION TfrxIndexCollection : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TfrxIndexItem* operator[](int Index) { return Items[Index]; }
	
private:
	int FIndexesCount;
	TfrxCrossSortOrder FSortOrder[32];
	TfrxIndexItem* __fastcall GetItems(int Index);
	
public:
	bool __fastcall Find(Variant const * Indexes, const int Indexes_Size, int &Index);
	HIDESBASE virtual TfrxIndexItem* __fastcall InsertItem(int Index, Variant const * Indexes, const int Indexes_Size);
	__property TfrxIndexItem* Items[int Index] = {read=GetItems/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Create */ inline __fastcall TfrxIndexCollection(TMetaClass* ItemClass) : Classes::TCollection(ItemClass) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TfrxIndexCollection(void) { }
	#pragma option pop
	
};


class DELPHICLASS TfrxCrossRow;
class PASCALIMPLEMENTATION TfrxCrossRow : public TfrxIndexItem 
{
	typedef TfrxIndexItem inherited;
	
private:
	int FCellLevels;
	Classes::TList* FCells;
	void __fastcall CreateCell(int Index);
	
public:
	__fastcall virtual TfrxCrossRow(Classes::TCollection* Collection);
	__fastcall virtual ~TfrxCrossRow(void);
	PfrCrossCell __fastcall GetCell(int Index);
	Variant __fastcall GetCellValue(int Index1, int Index2);
	void __fastcall SetCellValue(int Index1, int Index2, const Variant &Value);
};


class DELPHICLASS TfrxCrossRows;
class PASCALIMPLEMENTATION TfrxCrossRows : public TfrxIndexCollection 
{
	typedef TfrxIndexCollection inherited;
	
public:
	TfrxCrossRow* operator[](int Index) { return Items[Index]; }
	
private:
	int FCellLevels;
	HIDESBASE TfrxCrossRow* __fastcall GetItems(int Index);
	
public:
	__fastcall TfrxCrossRows(void);
	virtual TfrxIndexItem* __fastcall InsertItem(int Index, Variant const * Indexes, const int Indexes_Size);
	TfrxCrossRow* __fastcall Row(Variant const * Indexes, const int Indexes_Size);
	__property TfrxCrossRow* Items[int Index] = {read=GetItems/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TfrxCrossRows(void) { }
	#pragma option pop
	
};


class DELPHICLASS TfrxCrossColumn;
class PASCALIMPLEMENTATION TfrxCrossColumn : public TfrxIndexItem 
{
	typedef TfrxIndexItem inherited;
	
private:
	int FCellIndex;
	
public:
	__property int CellIndex = {read=FCellIndex, write=FCellIndex, nodefault};
public:
	#pragma option push -w-inl
	/* TfrxIndexItem.Destroy */ inline __fastcall virtual ~TfrxCrossColumn(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TCollectionItem.Create */ inline __fastcall virtual TfrxCrossColumn(Classes::TCollection* Collection) : TfrxIndexItem(Collection) { }
	#pragma option pop
	
};


class DELPHICLASS TfrxCrossColumns;
class PASCALIMPLEMENTATION TfrxCrossColumns : public TfrxIndexCollection 
{
	typedef TfrxIndexCollection inherited;
	
public:
	TfrxCrossColumn* operator[](int Index) { return Items[Index]; }
	
private:
	HIDESBASE TfrxCrossColumn* __fastcall GetItems(int Index);
	
public:
	__fastcall TfrxCrossColumns(void);
	TfrxCrossColumn* __fastcall Column(Variant const * Indexes, const int Indexes_Size);
	virtual TfrxIndexItem* __fastcall InsertItem(int Index, Variant const * Indexes, const int Indexes_Size);
	__property TfrxCrossColumn* Items[int Index] = {read=GetItems/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TfrxCrossColumns(void) { }
	#pragma option pop
	
};


class DELPHICLASS TfrxCrossHeader;
class PASCALIMPLEMENTATION TfrxCrossHeader : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	TfrxCrossHeader* operator[](int Index) { return Items[Index]; }
	
private:
	#pragma pack(push,1)
	Frxclass::TfrxRect FBounds;
	#pragma pack(pop)
	Classes::TList* FMemos;
	Classes::TList* FTotalMemos;
	DynamicArray<Variant >  FCounts;
	int FCellIndex;
	int FCellLevels;
	DynamicArray<Variant >  FFuncValues;
	bool FHasCellHeaders;
	int FIndex;
	bool FIsCellHeader;
	bool FIsIndex;
	bool FIsTotal;
	Classes::TList* FItems;
	int FLevelsCount;
	Frxclass::TfrxCustomMemoView* FMemo;
	bool FNoLevels;
	TfrxCrossHeader* FParent;
	#pragma pack(push,1)
	Frxclass::TfrxPoint FSize;
	#pragma pack(pop)
	int FTotalIndex;
	Variant FValue;
	bool FVisible;
	TfrxCrossHeader* __fastcall AddCellHeader(Classes::TList* Memos, int Index, int CellIndex);
	TfrxCrossHeader* __fastcall AddChild(Frxclass::TfrxCustomMemoView* Memo);
	void __fastcall AddFuncValues(Variant const * Values, const int Values_Size, Variant const * Counts, const int Counts_Size, TfrxCrossFunction const * CellFunctions, const int CellFunctions_Size);
	void __fastcall AddValues(Variant const * Values, const int Values_Size);
	void __fastcall Reset(TfrxCrossFunction const * CellFunctions, const int CellFunctions_Size);
	int __fastcall GetCount(void);
	TfrxCrossHeader* __fastcall GetItems(int Index);
	int __fastcall GetLevel(void);
	Extended __fastcall GetHeight(void);
	Extended __fastcall GetWidth(void);
	
public:
	__fastcall TfrxCrossHeader(int CellLevels);
	__fastcall virtual ~TfrxCrossHeader(void);
	virtual void __fastcall CalcBounds(void) = 0 ;
	virtual void __fastcall CalcSizes(int MaxWidth, int MinWidth, bool AutoSize) = 0 ;
	Classes::TList* __fastcall AllItems(void);
	int __fastcall Find(const Variant &Value);
	Variant __fastcall GetIndexes();
	Variant __fastcall GetValues();
	Classes::TList* __fastcall TerminalItems(void);
	Classes::TList* __fastcall IndexItems(void);
	__property Frxclass::TfrxRect Bounds = {read=FBounds, write=FBounds};
	__property int Count = {read=GetCount, nodefault};
	__property bool HasCellHeaders = {read=FHasCellHeaders, write=FHasCellHeaders, nodefault};
	__property Extended Height = {read=GetHeight};
	__property bool IsTotal = {read=FIsTotal, nodefault};
	__property TfrxCrossHeader* Items[int Index] = {read=GetItems/*, default*/};
	__property int Level = {read=GetLevel, nodefault};
	__property Frxclass::TfrxCustomMemoView* Memo = {read=FMemo};
	__property TfrxCrossHeader* Parent = {read=FParent};
	__property Variant Value = {read=FValue, write=FValue};
	__property bool Visible = {read=FVisible, write=FVisible, nodefault};
	__property Extended Width = {read=GetWidth};
};


class DELPHICLASS TfrxCrossColumnHeader;
class PASCALIMPLEMENTATION TfrxCrossColumnHeader : public TfrxCrossHeader 
{
	typedef TfrxCrossHeader inherited;
	
private:
	TfrxCrossHeader* FCorner;
	
public:
	virtual void __fastcall CalcBounds(void);
	virtual void __fastcall CalcSizes(int MaxWidth, int MinWidth, bool AutoSize);
public:
	#pragma option push -w-inl
	/* TfrxCrossHeader.Create */ inline __fastcall TfrxCrossColumnHeader(int CellLevels) : TfrxCrossHeader(CellLevels) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TfrxCrossHeader.Destroy */ inline __fastcall virtual ~TfrxCrossColumnHeader(void) { }
	#pragma option pop
	
};


class DELPHICLASS TfrxCrossRowHeader;
class PASCALIMPLEMENTATION TfrxCrossRowHeader : public TfrxCrossHeader 
{
	typedef TfrxCrossHeader inherited;
	
private:
	TfrxCrossHeader* FCorner;
	
public:
	virtual void __fastcall CalcBounds(void);
	virtual void __fastcall CalcSizes(int MaxWidth, int MinWidth, bool AutoSize);
public:
	#pragma option push -w-inl
	/* TfrxCrossHeader.Create */ inline __fastcall TfrxCrossRowHeader(int CellLevels) : TfrxCrossHeader(CellLevels) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TfrxCrossHeader.Destroy */ inline __fastcall virtual ~TfrxCrossRowHeader(void) { }
	#pragma option pop
	
};


class DELPHICLASS TfrxCrossCorner;
class PASCALIMPLEMENTATION TfrxCrossCorner : public TfrxCrossColumnHeader 
{
	typedef TfrxCrossColumnHeader inherited;
	
public:
	#pragma option push -w-inl
	/* TfrxCrossHeader.Create */ inline __fastcall TfrxCrossCorner(int CellLevels) : TfrxCrossColumnHeader(CellLevels) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TfrxCrossHeader.Destroy */ inline __fastcall virtual ~TfrxCrossCorner(void) { }
	#pragma option pop
	
};


class DELPHICLASS TfrxCutBandItem;
class PASCALIMPLEMENTATION TfrxCutBandItem : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
public:
	Frxclass::TfrxBand* Band;
	int FromIndex;
	int ToIndex;
	__fastcall virtual ~TfrxCutBandItem(void);
public:
	#pragma option push -w-inl
	/* TCollectionItem.Create */ inline __fastcall virtual TfrxCutBandItem(Classes::TCollection* Collection) : Classes::TCollectionItem(Collection) { }
	#pragma option pop