sctvar.hpp

suite component ace report

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

// (DO NOT EDIT: machine generated header) 'SctVar.pas' rev: 3.00

#ifndef SctVarHPP
#define SctVarHPP
#include <DBTables.hpp>
#include <DBCtrls.hpp>
#include <Db.hpp>
#include <SctData.hpp>
#include <StdCtrls.hpp>
#include <Dialogs.hpp>
#include <Forms.hpp>
#include <Controls.hpp>
#include <Graphics.hpp>
#include <Classes.hpp>
#include <Messages.hpp>
#include <SysUtils.hpp>
#include <Windows.hpp>
#include <SysInit.hpp>
#include <System.hpp>

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

namespace Sctvar
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TSctVar;
typedef void __fastcall (__closure *TGetDataEvent)(TSctVar* oVar);

enum TSctUpdateMode { umNeedUpdate, umUpdating, umNoUpdate };

enum TSctVarId { vidAbstract, vidDBVar, vidExprVar, vidTotalVar, vidAutoDataVar, vidDateTimeVar, vidPageVar 
	};

class DELPHICLASS TSctLevel;
class PASCALIMPLEMENTATION TSctLevel : public Controls::TControl 
{
	typedef Controls::TControl inherited;
	
private:
	int FLevel;
	bool FIsHeader;
	
protected:
	virtual void __fastcall SetParent(Controls::TWinControl* AParent);
	virtual Classes::TComponent* __fastcall GetPage(void);
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	void __fastcall ReadIsHeader(Classes::TReader* Reader);
	void __fastcall WriteIsHeader(Classes::TWriter* Writer);
	
public:
	__fastcall virtual TSctLevel(Classes::TComponent* AOwner);
	__fastcall virtual ~TSctLevel(void);
	__property int Level = {read=FLevel, write=FLevel, nodefault};
	__property Classes::TComponent* Page = {read=GetPage};
	__property bool IsHeader = {read=FIsHeader, write=FIsHeader, default=0};
};

class PASCALIMPLEMENTATION TSctVar : public Controls::TControl 
{
	typedef Controls::TControl inherited;
	
private:
	Sctdata::TSctData* FDataLast;
	Sctdata::TSctData* FDataNow;
	bool FAutovar;
	TSctDataTypes FDataType;
	TSctUpdateMode FUpdateMode;
	TSctLevel* FUpdateLevel;
	TSctVarId FId;
	bool FActive;
	bool FInitialized;
	bool FRunning;
	
protected:
	virtual void __fastcall SetName(const System::AnsiString NewName);
	virtual void __fastcall SetParent(Controls::TWinControl* AParent);
	virtual void __fastcall Loaded(void);
	void __fastcall SetRunning(bool lRun);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation
		);
	bool __fastcall GetIsNull(void);
	void __fastcall SetIsNull(bool n);
	virtual System::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 Classes::TStream* __fastcall GetAsStream(void);
	virtual Classes::TStrings* __fastcall GetAsStrings(void);
	virtual void __fastcall SetAsString(System::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);
	virtual void __fastcall SetAsStream(Classes::TStream* value);
	virtual void __fastcall SetAsStrings(Classes::TStrings* Value);
	virtual Sctdata::TSctDataTypes __fastcall GetDataType(void);
	virtual Sctdata::TSctData* __fastcall getdatanow(void);
	virtual Sctdata::TSctData* __fastcall getdata(void);
	virtual bool __fastcall getactive(void);
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	void __fastcall ReadAutoVar(Classes::TReader* Reader);
	void __fastcall WriteAutoVar(Classes::TWriter* Writer);
	void __fastcall ReadID(Classes::TReader* Reader);
	void __fastcall WriteID(Classes::TWriter* Writer);
	void __fastcall SetUpdateLevel(TSctLevel* ul);
	void __fastcall SetDataType(Sctdata::TSctDataTypes dt);
	
public:
	__fastcall virtual TSctVar(Classes::TComponent* AOwner);
	__fastcall virtual ~TSctVar(void);
	virtual void __fastcall UpdateData(void);
	virtual void __fastcall UpdateLast(void);
	virtual void __fastcall ReverseUpdate(void);
	virtual void __fastcall Initialize(void);
	__property bool Initialized = {read=FInitialized, write=FInitialized, nodefault};
	__property bool Running = {read=FRunning, write=SetRunning, nodefault};
	__property Sctdata::TSctData* DataNow = {read=getdatanow, write=FDataNow};
	__property Sctdata::TSctData* DataLast = {read=FDataLast, write=FDataLast};
	__property Sctdata::TSctData* Data = {read=getdata};
	__property System::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};
	__property Classes::TStrings* AsStrings = {read=GetAsStrings, write=SetAsStrings};
	__property bool IsNull = {read=GetIsNull, write=SetIsNull, nodefault};
	__property Sctdata::TSctDataTypes DataType = {read=GetDataType, write=SetDataType, nodefault};
	__property TSctUpdateMode UpdateMode = {read=FUpdateMode, write=FUpdateMode, nodefault};
	__property bool Active = {read=getactive, write=FActive, nodefault};
	__property Cursor ;
	__property bool AutoVar = {read=FAutovar, write=FAutovar, nodefault};
	__property TSctVarId Id = {read=FId, write=FId, nodefault};
	__property TSctLevel* UpdateLevel = {read=FUpdateLevel, write=SetUpdateLevel};
	virtual void __fastcall Reset(void);
	virtual void __fastcall ResetData(void);
};

class DELPHICLASS TSctDBVar;
class PASCALIMPLEMENTATION TSctDBVar : public Sctvar::TSctVar 
{
	typedef Sctvar::TSctVar inherited;
	
private:
	int FFieldNo;
	System::AnsiString FDataField;
	Dbctrls::TFieldDataLink* FDataLink;
	void __fastcall ActiveChange(System::TObject* Sender);
	System::AnsiString __fastcall GetDataField();
	Db::TDataSource* __fastcall GetDataSource(void);
	Db::TField* __fastcall GetField(void);
	void __fastcall SetDataField(const System::AnsiString Value);
	void __fastcall SetDataSource(Db::TDataSource* Value);
	
protected:
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation
		);
	virtual Sctdata::TSctDataTypes __fastcall GetDataType(void);
	virtual Db::TFieldType __fastcall GetFieldDataType(void);
	
public:
	__fastcall virtual TSctDBVar(Classes::TComponent* AOwner);
	__fastcall virtual ~TSctDBVar(void);
	virtual void __fastcall UpdateData(void);
	__property Db::TField* Field = {read=GetField};
	virtual void __fastcall Initialize(void);
	__property Db::TFieldType FieldDataType = {read=GetFieldDataType, nodefault};
	
__published:
	__property System::AnsiString DataField = {read=GetDataField, write=SetDataField};
	__property Db::TDataSource* DataSource = {read=GetDataSource, write=SetDataSource};
	__property UpdateLevel ;
};

class DELPHICLASS TSctExprVar;
class PASCALIMPLEMENTATION TSctExprVar : public Sctvar::TSctVar 
{
	typedef Sctvar::TSctVar inherited;
	
private:
	TGetDataEvent FOnGetData;
	
public:
	__fastcall virtual TSctExprVar(Classes::TComponent* AOwner);
	__fastcall virtual ~TSctExprVar(void);
	virtual void __fastcall UpdateData(void);
	
__published:
	__property DataType ;
	__property TGetDataEvent OnGetData = {read=FOnGetData, write=FOnGetData};
	__property UpdateLevel ;
};

class DELPHICLASS TSctDateTimeVar;
class PASCALIMPLEMENTATION TSctDateTimeVar : public Sctvar::TSctVar 
{
	typedef Sctvar::TSctVar inherited;
	
protected:
	virtual void __fastcall Loaded(void);
	
public:
	__fastcall virtual TSctDateTimeVar(Classes::TComponent* AOwner);
	virtual void __fastcall Initialize(void);
	
__published:
	__property UpdateLevel ;
public:
	/* TSctVar.Destroy */ __fastcall virtual ~TSctDateTimeVar(void) { }
	
};

class DELPHICLASS TSctPageVar;
class PASCALIMPLEMENTATION TSctPageVar : public Sctvar::TSctVar 
{
	typedef Sctvar::TSctVar inherited;
	
protected:
	virtual void __fastcall Loaded(void);
	
public:
	__fastcall virtual TSctPageVar(Classes::TComponent* AOwner);
	virtual void __fastcall UpdateData(void);
	
__published:
	__property UpdateLevel ;
public:
	/* TSctVar.Destroy */ __fastcall virtual ~TSctPageVar(void) { }
	
};

class DELPHICLASS TSctTotalvar;
class PASCALIMPLEMENTATION TSctTotalvar : public Sctvar::TSctVar 
{
	typedef Sctvar::TSctVar inherited;
	
private:
	TSctVar* FVariable;
	Classes::TList* FDataNowList;
	Classes::TList* FDataLastList;
	Classes::TList* FResetNowList;
	Classes::TList* FResetLastList;
	bool FIgnoreNulls;
	
protected:
	virtual Sctdata::TSctData* __fastcall GetDataNow(void);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation
		);
	virtual bool __fastcall GetActive(void);
	void __fastcall SetVariable(TSctVar* V);
	
public:
	__fastcall virtual TSctTotalvar(Classes::TComponent* AOwner);
	__fastcall virtual ~TSctTotalvar(void);
	virtual void __fastcall UpdateData(void);
	virtual Sctdata::TSctDataTypes __fastcall GetDataType(void);
	virtual void __fastcall Initialize(void);
	void __fastcall ResetLevel(TSctLevel* Level);
	virtual void __fastcall UpdateLast(void);
	virtual void __fastcall ReverseUpdate(void);
	void __fastcall UpdateAtlevel(TSctLevel* Level);
	Sctdata::TSctFloat* __fastcall Getlevel(TSctLevel* level, Sctdata::TSctTotalType TotalType);
	Sctdata::TSctFloat* __fastcall GetLevelNow(TSctLevel* Level, Sctdata::TSctTotalType TotalType);
	Sctdata::TSctFloat* __fastcall GetLevelLast(TSctLevel* Level, Sctdata::TSctTotalType TotalType);
	void __fastcall AddLevels(void);
	void __fastcall DeleteLevels(void);
	__property Classes::TList* DataNowList = {read=FDataNowList, write=FDataNowList};
	__property Classes::TList* DataLastList = {read=FDataLastList, write=FDataLastList};
	__property Classes::TList* ResetNowList = {read=FResetNowList, write=FResetNowList};
	__property Classes::TList* ResetLastList = {read=FResetLastList, write=FResetLastList};
	virtual void __fastcall Reset(void);
	void __fastcall ResetAtlevel(TSctLevel* Level);
	virtual void __fastcall ResetData(void);
	void __fastcall ResetMarkedLevel(TSctLevel* Level);
	
__published:
	__property TSctVar* Variable = {read=FVariable, write=SetVariable};
	__property UpdateLevel ;
	__property bool IgnoreNulls = {read=FIgnoreNulls, write=FIgnoreNulls, default=0};
};

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

}	/* namespace Sctvar */
#if !defined(NO_IMPLICIT_NAMESPACE_USE)
using namespace Sctvar;
#endif
//-- end unit ----------------------------------------------------------------
#endif	// SctVar