sctdata.hpp

suite component ace report

// Borland C++ Builder
// Copyright (c) 1995, 1999 by Borland International
// All rights reserved

// (DO NOT EDIT: machine generated header) 'SctData.pas' rev: 4.00

#ifndef SctDataHPP
#define SctDataHPP

#pragma delphiheader begin
#pragma option push -w-
#include <SysUtils.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.hpp>	// Pascal unit

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

namespace Sctdata
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TSctDataTypes { dtypeUnknown, dtypeString, dtypeFloat, dtypeInteger, dtypeBoolean, dtypeDateTime, 
	dtypeBlob, dtypeMemo, dtypeGraphic };
#pragma option pop

#pragma option push -b-
enum TSctTextCase { tcNone, tcUpper, tcLower };
#pragma option pop

#pragma option push -b-
enum TSctTotalType { ttSum, ttCount, ttMax, ttMin, ttAverage, ttValue };
#pragma option pop

class DELPHICLASS TSctCalc;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctCalc : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	double FValue;
	double FSum;
	double FMin;
	double FMax;
	int FCount;
	
protected:
	double __fastcall GetAverage(void);
	void __fastcall NewVal(double Val);
	
public:
	__fastcall virtual TSctCalc(void);
	__fastcall virtual ~TSctCalc(void);
	virtual void __fastcall Update(void);
	__property double Value = {read=FValue, write=NewVal};
	__property double Sum = {read=FSum, write=FSum};
	__property int Count = {read=FCount, write=FCount, nodefault};
	__property double Min = {read=FMin, write=FMin};
	__property double Max = {read=FMax, write=FMax};
	__property double Average = {read=GetAverage};
	void __fastcall Reset(void);
};

#pragma pack(pop)

class DELPHICLASS TSctRootFormat;
class DELPHICLASS TSctData;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctRootFormat : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	AnsiString FDisplayFormat;
	TSctTextCase FTextCase;
	Sysutils::TFloatFormat FFloatFormat;
	int FWidth;
	int FDigits;
	Classes::TComponent* FSctLabel;
	Classes::TStream* FReturnStream;
	bool FSuppressNulls;
	bool FUseCurrencyDecimals;
	
protected:
	void __fastcall SetDisplayFormat(AnsiString DF);
	void __fastcall SetTextCase(TSctTextCase TC);
	void __fastcall SetFloatFormat(Sysutils::TFloatFormat FF);
	void __fastcall SetWidth(int W);
	void __fastcall SetDigits(int D);
	void __fastcall SetCurrencyDecimals(bool C);
	Classes::TStream* __fastcall GetReturnStream(void);
	__property Classes::TStream* ReturnStream = {read=GetReturnStream, write=FReturnStream};
	void __fastcall SetSuppressNulls(bool sn);
	
public:
	__fastcall virtual TSctRootFormat(void);
	__fastcall virtual ~TSctRootFormat(void);
	AnsiString __fastcall FormatAsString(TSctData* Data);
	Classes::TStream* __fastcall FormatAsStream(TSctData* Data);
	__property Classes::TComponent* SctLabel = {read=FSctLabel, write=FSctLabel};
	__property Sysutils::TFloatFormat FloatFormat = {read=FFloatFormat, write=SetFloatFormat, default=0
		};
	__property int Digits = {read=FDigits, write=SetDigits, default=0};
	
__published:
	__property AnsiString DisplayFormat = {read=FDisplayFormat, write=SetDisplayFormat};
	__property int Width = {read=FWidth, write=SetWidth, default=15};
	__property TSctTextCase TextCase = {read=FTextCase, write=SetTextCase, default=0};
	__property bool SuppressNulls = {read=FSuppressNulls, write=SetSuppressNulls, default=0};
	__property bool UseCurrencyDecimals = {read=FUseCurrencyDecimals, write=SetCurrencyDecimals, default=0
		};
};

#pragma pack(pop)

class DELPHICLASS TSctFormat;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctFormat : public TSctRootFormat 
{
	typedef TSctRootFormat inherited;
	
__published:
	__property FloatFormat ;
	__property Digits ;
public:
	#pragma option push -w-inl
	/* TSctRootFormat.Create */ inline __fastcall virtual TSctFormat(void) : TSctRootFormat() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TSctRootFormat.Destroy */ inline __fastcall virtual ~TSctFormat(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

class DELPHICLASS TSctFloatFormat;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctFloatFormat : public TSctRootFormat 
{
	typedef TSctRootFormat inherited;
	
public:
	__fastcall virtual TSctFloatFormat(void);
	
__published:
	__property FloatFormat ;
	__property Digits ;
public:
	#pragma option push -w-inl
	/* TSctRootFormat.Destroy */ inline __fastcall virtual ~TSctFloatFormat(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctData : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	TSctDataTypes FDataType;
	Classes::TStream* FReturnStream;
	bool FIsNull;
	Classes::TStrings* FStrings;
	
protected:
	Classes::TStream* __fastcall GetReturnStream(void);
	virtual AnsiString __fastcall GetAsString(void) = 0 ;
	virtual int __fastcall GetAsInteger(void) = 0 ;
	virtual double __fastcall GetAsFloat(void);
	virtual System::TDateTime __fastcall GetAsDateTime(void) = 0 ;
	virtual bool __fastcall GetAsBoolean(void);
	virtual Classes::TStream* __fastcall GetAsStream(void);
	virtual Classes::TStrings* __fastcall GetAsStrings(void);
	virtual void __fastcall SetAsString(AnsiString Value) = 0 ;
	virtual void __fastcall SetAsInteger(int Value) = 0 ;
	virtual void __fastcall SetAsFloat(double Value) = 0 ;
	virtual void __fastcall SetAsDateTime(System::TDateTime Value) = 0 ;
	virtual void __fastcall SetAsBoolean(bool Value) = 0 ;
	virtual void __fastcall SetAsStream(Classes::TStream* Stream) = 0 ;
	virtual void __fastcall SetAsStrings(Classes::TStrings* Strings) = 0 ;
	__property Classes::TStream* ReturnStream = {read=GetReturnStream, write=FReturnStream};
	
public:
	__fastcall virtual TSctData(void);
	__fastcall virtual ~TSctData(void);
	virtual void __fastcall SetValue(void *Value);
	virtual void __fastcall SetData(TSctData* Data);
	virtual void __fastcall Reset(void);
	__property TSctDataTypes DataType = {read=FDataType, write=FDataType, nodefault};
	__property AnsiString AsString = {read=GetAsString, write=SetAsString};
	__property int AsInteger = {read=GetAsInteger, write=SetAsInteger, nodefault};
	__property double AsFloat = {read=GetAsFloat, write=SetAsFloat};
	__property System::TDateTime AsDateTime = {read=GetAsDateTime, write=SetAsDateTime};
	__property bool AsBoolean = {read=GetAsBoolean, write=SetAsBoolean, nodefault};
	__property Classes::TStream* AsStream = {read=GetAsStream, write=SetAsStream};
	virtual AnsiString __fastcall AsFormat(TSctFormat* format);
	__property bool IsNull = {read=FIsNull, write=FIsNull, nodefault};
	__property Classes::TStrings* AsStrings = {read=GetAsStrings, write=SetAsStrings};
};

#pragma pack(pop)

class DELPHICLASS TSctString;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctString : public TSctData 
{
	typedef TSctData inherited;
	
private:
	AnsiString FValueString;
	
protected:
	virtual AnsiString __fastcall GetAsString();
	virtual int __fastcall GetAsInteger(void);
	virtual double __fastcall GetAsFloat(void);
	virtual System::TDateTime __fastcall GetAsDateTime(void);
	virtual bool __fastcall GetAsBoolean(void);
	virtual void __fastcall SetAsString(AnsiString Value);
	virtual void __fastcall SetAsInteger(int Value);
	virtual void __fastcall SetAsFloat(double Value);
	virtual void __fastcall SetAsDateTime(System::TDateTime Value);
	virtual void __fastcall SetAsBoolean(bool Value);
	
public:
	__fastcall virtual TSctString(void);
	virtual void __fastcall Reset(void);
	virtual void __fastcall SetValue(void *Value);
	virtual void __fastcall SetData(TSctData* Data);
	__property AnsiString ValueString = {read=FValueString, write=FValueString};
public:
	#pragma option push -w-inl
	/* TSctData.Destroy */ inline __fastcall virtual ~TSctString(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

class DELPHICLASS TSctInteger;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctInteger : public TSctData 
{
	typedef TSctData inherited;
	
private:
	int FValueInteger;
	
protected:
	virtual AnsiString __fastcall GetAsString();
	virtual int __fastcall GetAsInteger(void);
	virtual double __fastcall GetAsFloat(void);
	virtual bool __fastcall GetAsBoolean(void);
	virtual void __fastcall SetAsString(AnsiString Value);
	virtual void __fastcall SetAsInteger(int Value);
	virtual void __fastcall SetAsFloat(double Value);
	virtual void __fastcall SetAsBoolean(bool Value);
	
public:
	__fastcall virtual TSctInteger(void);
	virtual void __fastcall Reset(void);
	virtual void __fastcall SetValue(void *Value);
	virtual void __fastcall SetData(TSctData* data);
	__property int ValueInteger = {read=FValueInteger, write=FValueInteger, nodefault};
public:
	#pragma option push -w-inl
	/* TSctData.Destroy */ inline __fastcall virtual ~TSctInteger(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

class DELPHICLASS TSctFloat;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctFloat : public TSctData 
{
	typedef TSctData inherited;
	
private:
	TSctCalc* FCalc;
	TSctTotalType FTotalType;
	
protected:
	virtual double __fastcall GetValueFloat(void);
	virtual void __fastcall SetValueFloat(double Value);
	virtual AnsiString __fastcall GetAsString();
	virtual int __fastcall GetAsInteger(void);
	virtual double __fastcall GetAsFloat(void);
	virtual bool __fastcall GetAsBoolean(void);
	virtual void __fastcall SetAsString(AnsiString Value);
	virtual void __fastcall SetAsInteger(int Value);
	virtual void __fastcall SetAsFloat(double Value);
	virtual void __fastcall SetAsBoolean(bool Value);
	
public:
	__fastcall virtual TSctFloat(void);
	__fastcall virtual ~TSctFloat(void);
	virtual void __fastcall Reset(void);
	virtual void __fastcall SetValue(void *Value);
	virtual void __fastcall SetData(TSctData* data);
	__property double ValueFloat = {read=GetValueFloat, write=SetValueFloat};
	__property TSctCalc* Calc = {read=FCalc, write=FCalc};
	__property TSctTotalType TotalType = {read=FTotalType, write=FTotalType, nodefault};
};

#pragma pack(pop)

class DELPHICLASS TSctDateTime;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctDateTime : public TSctData 
{
	typedef TSctData inherited;
	
private:
	System::TDateTime FValueDateTime;
	
protected:
	virtual AnsiString __fastcall GetAsString();
	virtual System::TDateTime __fastcall GetAsDateTime(void);
	virtual double __fastcall GetAsFloat(void);
	virtual void __fastcall SetAsString(AnsiString Value);
	virtual void __fastcall SetAsDateTime(System::TDateTime Value);
	virtual void __fastcall SetAsFloat(double Value);
	
public:
	__fastcall virtual TSctDateTime(void);
	virtual void __fastcall Reset(void);
	virtual void __fastcall SetValue(void *Value);
	virtual void __fastcall SetData(TSctData* Data);
	__property System::TDateTime ValueDateTime = {read=FValueDateTime, write=FValueDateTime};
public:
	#pragma option push -w-inl
	/* TSctData.Destroy */ inline __fastcall virtual ~TSctDateTime(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

class DELPHICLASS TSctBoolean;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctBoolean : public TSctData 
{
	typedef TSctData inherited;
	
private:
	bool FValueBoolean;
	
protected:
	virtual AnsiString __fastcall GetAsString();
	virtual int __fastcall GetAsInteger(void);
	virtual double __fastcall GetAsFloat(void);
	virtual bool __fastcall GetAsBoolean(void);
	virtual void __fastcall SetAsString(AnsiString Value);
	virtual void __fastcall SetAsInteger(int Value);
	virtual void __fastcall SetAsFloat(double Value);
	virtual void __fastcall SetAsBoolean(bool Value);
	
public:
	__fastcall virtual TSctBoolean(void);
	virtual void __fastcall Reset(void);
	virtual void __fastcall SetValue(void *Value);
	virtual void __fastcall SetData(TSctData* Data);
	__property bool ValueBoolean = {read=FValueBoolean, write=FValueBoolean, nodefault};
public:
	#pragma option push -w-inl
	/* TSctData.Destroy */ inline __fastcall virtual ~TSctBoolean(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

class DELPHICLASS TSctBlob;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctBlob : public TSctData 
{
	typedef TSctData inherited;
	
private:
	Classes::TMemoryStream* FValueStream;
	
protected:
	virtual AnsiString __fastcall GetAsString();
	virtual Classes::TStream* __fastcall GetAsStream(void);
	virtual void __fastcall SetAsStream(Classes::TStream* Stream);
	virtual void __fastcall SetAsString(AnsiString Value);
	
public:
	__fastcall virtual TSctBlob(void);
	__fastcall virtual ~TSctBlob(void);
	virtual void __fastcall Reset(void);
	virtual void __fastcall SetValue(void *Value);
	virtual void __fastcall SetData(TSctData* Data);
	__property Classes::TMemoryStream* ValueStream = {read=FValueStream, write=FValueStream};
};

#pragma pack(pop)

class DELPHICLASS TSctMemo;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctMemo : public TSctBlob 
{
	typedef TSctBlob inherited;
	
protected:
	virtual AnsiString __fastcall GetAsString();
	virtual Classes::TStrings* __fastcall GetAsStrings(void);
	virtual void __fastcall SetAsStrings(Classes::TStrings* Strings);
	
public:
	__fastcall virtual TSctMemo(void);
public:
	#pragma option push -w-inl
	/* TSctBlob.Destroy */ inline __fastcall virtual ~TSctMemo(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

class DELPHICLASS TSctGraphic;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctGraphic : public TSctBlob 
{
	typedef TSctBlob inherited;
	
public:
	__fastcall virtual TSctGraphic(void);
public:
	#pragma option push -w-inl
	/* TSctBlob.Destroy */ inline __fastcall virtual ~TSctGraphic(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

class DELPHICLASS TSctUnknown;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSctUnknown : public TSctBlob 
{
	typedef TSctBlob inherited;
	
protected:
	virtual AnsiString __fastcall GetAsString();
	
public:
	__fastcall virtual TSctUnknown(void);
public:
	#pragma option push -w-inl
	/* TSctBlob.Destroy */ inline __fastcall virtual ~TSctUnknown(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

//-- var, const, procedure ---------------------------------------------------

}	/* namespace Sctdata */
#if !defined(NO_IMPLICIT_NAMESPACE_USE)
using namespace Sctdata;
#endif
#pragma option pop	// -w-

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// SctData