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

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

#ifndef PfibpropsHPP
#define PfibpropsHPP

#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 <Classes.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Db.hpp>	// Pascal unit

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

namespace Pfibprops
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TKindOnOperation { koBefore, koAfter };
#pragma option pop

#pragma option push -b-
enum TpFIBExistObject { eoYes, eoNo, eoUnknown };
#pragma option pop

#pragma option push -b-
enum TpPrepareOption { pfSetRequiredFields, pfSetReadOnlyFields, pfImportDefaultValues, psUseBooleanField, psUseGuidField, psSQLINT64ToBCD, psApplyRepositary, psGetOrderInfo, psAskRecordCount, psCanEditComputedFields, psSetEmptyStrToNull, psSupportUnicodeBlobs, psUseLargeIntField };
#pragma option pop

typedef Set<TpPrepareOption, pfSetRequiredFields, psUseLargeIntField>  TpPrepareOptions;

#pragma option push -b-
enum TpFIBDsOption { poTrimCharFields, poRefreshAfterPost, poRefreshDeletedRecord, poStartTransaction, poAutoFormatFields, poProtectedEdit, poUseSelectForLock, poKeepSorting, poPersistentSorting, poVisibleRecno, poNoForceIsNull, poFetchAll, poFreeHandlesAfterClose, poCacheCalcFields, poRefreshAfterDelete };
#pragma option pop

typedef Set<TpFIBDsOption, poTrimCharFields, poRefreshAfterDelete>  TpFIBDsOptions;

#pragma option push -b-
enum TpFIBQueryOption { qoStartTransaction, qoAutoCommit, qoTrimCharFields, qoNoForceIsNull, qoFreeHandleAfterExecute };
#pragma option pop

typedef Set<TpFIBQueryOption, qoStartTransaction, qoFreeHandleAfterExecute>  TpFIBQueryOptions;

#pragma option push -b-
enum TDetailCondition { dcForceOpen, dcIgnoreMasterClose, dcForceMasterRefresh, dcWaitEndMasterScroll };
#pragma option pop

typedef Set<TDetailCondition, dcForceOpen, dcWaitEndMasterScroll>  TDetailConditions;

#pragma option push -b-
enum TFieldOriginRule { forNoRule, forTableAndFieldName, forClientFieldName, forTableAliasAndFieldName };
#pragma option pop

class DELPHICLASS TSQLs;
class PASCALIMPLEMENTATION TSQLs : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Classes::TComponent* FOwner;
	Classes::TStrings* __fastcall GetSelectSQL(void);
	void __fastcall SetSelectSQL(Classes::TStrings* Value);
	Classes::TStrings* __fastcall GetInsertSQL(void);
	void __fastcall SetInsertSQL(Classes::TStrings* Value);
	Classes::TStrings* __fastcall GetUpdateSQL(void);
	void __fastcall SetUpdateSQL(Classes::TStrings* Value);
	Classes::TStrings* __fastcall GetDeleteSQL(void);
	void __fastcall SetDeleteSQL(Classes::TStrings* Value);
	Classes::TStrings* __fastcall GetRefreshSQL(void);
	void __fastcall SetRefreshSQL(Classes::TStrings* Value);
	
public:
	__fastcall TSQLs(Classes::TComponent* Owner);
	__property Classes::TComponent* Owner = {read=FOwner};
	
__published:
	__property Classes::TStrings* SelectSQL = {read=GetSelectSQL, write=SetSelectSQL};
	__property Classes::TStrings* UpdateSQL = {read=GetUpdateSQL, write=SetUpdateSQL};
	__property Classes::TStrings* DeleteSQL = {read=GetDeleteSQL, write=SetDeleteSQL};
	__property Classes::TStrings* InsertSQL = {read=GetInsertSQL, write=SetInsertSQL};
	__property Classes::TStrings* RefreshSQL = {read=GetRefreshSQL, write=SetRefreshSQL};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TSQLs(void) { }
	#pragma option pop
	
};


class DELPHICLASS TFormatFields;
class PASCALIMPLEMENTATION TFormatFields : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Classes::TComponent* FOwner;
	AnsiString FDisplayFormatDateTime;
	AnsiString FDisplayFormatDate;
	AnsiString FDisplayFormatTime;
	AnsiString FDisplayFormatNumeric;
	AnsiString FEditFormatNumeric;
	bool __fastcall StoreDfDt(void);
	bool __fastcall StoreDfN(void);
	bool __fastcall StoreEfN(void);
	bool __fastcall StoreDfD(void);
	bool __fastcall StoreDfT(void);
	
protected:
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	
public:
	__fastcall TFormatFields(Classes::TComponent* aOwner);
	
__published:
	__property AnsiString DateTimeDisplayFormat = {read=FDisplayFormatDateTime, write=FDisplayFormatDateTime, stored=StoreDfDt};
	__property AnsiString NumericDisplayFormat = {read=FDisplayFormatNumeric, write=FDisplayFormatNumeric, stored=StoreDfN};
	__property AnsiString NumericEditFormat = {read=FEditFormatNumeric, write=FEditFormatNumeric, stored=StoreEfN};
	__property AnsiString DisplayFormatDate = {read=FDisplayFormatDate, write=FDisplayFormatDate, stored=StoreDfD};
	__property AnsiString DisplayFormatTime = {read=FDisplayFormatTime, write=FDisplayFormatTime, stored=StoreDfT};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TFormatFields(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TWhenGetGenID { wgNever, wgOnNewRecord, wgBeforePost };
#pragma option pop

class DELPHICLASS TAutoUpdateOptions;
class PASCALIMPLEMENTATION TAutoUpdateOptions : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Classes::TComponent* FOwner;
	AnsiString FUpdateTableName;
	Classes::TStrings* FKeyFieldList;
	AnsiString FKeyFields;
	bool FAutoReWriteSqls;
	bool FCanChangeSQLs;
	AnsiString FGeneratorName;
	int FGeneratorStep;
	bool FSelectGenID;
	bool FGenBeforePost;
	bool FUpdateOnlyModifiedFields;
	TWhenGetGenID FWhenGetGenID;
	Classes::TStrings* FParamFieldLinks;
	bool FAutoParamsToFields;
	bool FSeparateBlobUpdate;
	AnsiString FWhereCondition;
	AnsiString FModifiedTable;
	AnsiString FAliasModifiedTable;
	bool FModifiedTableHaveAlias;
	AnsiString FReadySelectSQL;
	void __fastcall SetUpdateTableName(const AnsiString Value);
	void __fastcall SetSelectGenID(bool Value);
	bool __fastcall GetSelectGenID(void);
	bool __fastcall GetGenBeforePost(void);
	void __fastcall SetGenBeforePost(bool Value);
	void __fastcall SetParamFieldLinks(const Classes::TStrings* Value);
	void __fastcall SetUpdateOnlyModifiedFields(const bool Value);
	void __fastcall SetKeyFields(const AnsiString Value);
	AnsiString __fastcall GetAliasModifiedTable();
	AnsiString __fastcall GetModifiedTable();
	void __fastcall PrepareUpdateTableStrings(void);
	
protected:
	void __fastcall ReadSelectGenID(Classes::TReader* Reader);
	void __fastcall ReadGenBeforePost(Classes::TReader* Reader);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	
public:
	__fastcall TAutoUpdateOptions(Classes::TComponent* Owner);
	__fastcall virtual ~TAutoUpdateOptions(void);
	__property Classes::TComponent* Owner = {read=FOwner};
	__property bool SelectGenID = {read=GetSelectGenID, write=SetSelectGenID, nodefault};
	__property bool GenBeforePost = {read=GetGenBeforePost, write=SetGenBeforePost, nodefault};
	__property Classes::TStrings* KeyFieldList = {read=FKeyFieldList};
	__property AnsiString WhereCondition = {read=FWhereCondition, write=FWhereCondition};
	__property AnsiString ModifiedTableName = {read=GetModifiedTable};
	__property AnsiString AliasModifiedTable = {read=GetAliasModifiedTable};
	__property bool ModifiedTableHaveAlias = {read=FModifiedTableHaveAlias, nodefault};
	__property AnsiString ReadySelectSQL = {read=FReadySelectSQL, write=FReadySelectSQL};
	
__published:
	__property AnsiString UpdateTableName = {read=FUpdateTableName, write=SetUpdateTableName};
	__property AnsiString KeyFields = {read=FKeyFields, write=SetKeyFields};
	__property bool AutoReWriteSqls = {read=FAutoReWriteSqls, write=FAutoReWriteSqls, default=0};
	__property bool CanChangeSQLs = {read=FCanChangeSQLs, write=FCanChangeSQLs, default=0};
	__property AnsiString GeneratorName = {read=FGeneratorName, write=FGeneratorName};
	__property bool UpdateOnlyModifiedFields = {read=FUpdateOnlyModifiedFields, write=SetUpdateOnlyModifiedFields, default=0};
	__property TWhenGetGenID WhenGetGenID = {read=FWhenGetGenID, write=FWhenGetGenID, default=0};
	__property int GeneratorStep = {read=FGeneratorStep, write=FGeneratorStep, default=1};
	__property Classes::TStrings* ParamsToFieldsLinks = {read=FParamFieldLinks, write=SetParamFieldLinks};
	__property bool AutoParamsToFields = {read=FAutoParamsToFields, write=FAutoParamsToFields, default=0};
	__property bool SeparateBlobUpdate = {read=FSeparateBlobUpdate, write=FSeparateBlobUpdate, default=0};
};


class DELPHICLASS TIBConnectParams;
class PASCALIMPLEMENTATION TIBConnectParams : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Classes::TComponent* FOwner;
	AnsiString __fastcall GetInstanceName();
	void __fastcall SetInstanceName(const AnsiString Value);
	
public:
	__fastcall TIBConnectParams(Classes::TComponent* Owner);
	
__published:
	__property AnsiString InstanceName = {read=GetInstanceName, write=SetInstanceName, stored=false};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TIBConnectParams(void) { }
	#pragma option pop
	
};


class DELPHICLASS TConnectParams;
class PASCALIMPLEMENTATION TConnectParams : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Classes::TComponent* FOwner;
	TIBConnectParams* FIBParams;
	void __fastcall SetIBParams(const TIBConnectParams* Value);
	AnsiString __fastcall GetUserNameA();
	void __fastcall SetUserName(const AnsiString Value);
	AnsiString __fastcall GetRoleName();
	void __fastcall SetRoleName(const AnsiString Value);
	AnsiString __fastcall GetPassword();
	void __fastcall SetPassword(const AnsiString Value);
	AnsiString __fastcall GetCharSet();
	void __fastcall SetCharSet(const AnsiString Value);
	
public:
	__fastcall TConnectParams(Classes::TComponent* Owner);
	__fastcall virtual ~TConnectParams(void);
	
__published:
	__property AnsiString UserName = {read=GetUserNameA, write=SetUserName, stored=false};
	__property AnsiString RoleName = {read=GetRoleName, write=SetRoleName, stored=false};
	__property AnsiString Password = {read=GetPassword, write=SetPassword, stored=false};
	__property AnsiString CharSet = {read=GetCharSet, write=SetCharSet, stored=false};
	__property TIBConnectParams* IB2007 = {read=FIBParams, write=SetIBParams};
};


class DELPHICLASS TCacheSchemaOptions;
class PASCALIMPLEMENTATION TCacheSchemaOptions : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	AnsiString FLocalCacheFile;
	bool FAutoSaveToFile;
	bool FAutoLoadFromFile;
	bool FValidateAfterLoad;
	
public:
	__fastcall TCacheSchemaOptions(void);
	
__published:
	__property AnsiString LocalCacheFile = {read=FLocalCacheFile, write=FLocalCacheFile};
	__property bool AutoSaveToFile = {read=FAutoSaveToFile, write=FAutoSaveToFile, default=0};
	__property bool AutoLoadFromFile = {read=FAutoLoadFromFile, write=FAutoLoadFromFile, default=0};
	__property bool ValidateAfterLoad = {read=FValidateAfterLoad, write=FValidateAfterLoad, default=1};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TCacheSchemaOptions(void) { }
	#pragma option pop
	
};


class DELPHICLASS TDBParams;
class PASCALIMPLEMENTATION TDBParams : public Classes::TStringList 
{
	typedef Classes::TStringList inherited;
	
private:
	Classes::TComponent* FOwner;
	HIDESBASE void __fastcall ReadData(Classes::TReader* Reader);
	HIDESBASE void __fastcall WriteData(Classes::TWriter* Writer);
	
protected:
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	
public:
	__fastcall TDBParams(Classes::TComponent* AOwner);
public:
	#pragma option push -w-inl
	/* TStringList.Destroy */ inline __fastcall virtual ~TDBParams(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TTransactionAction1 { TARollback1, TARollbackRetaining1, TACommit1, TACommitRetaining1 };
#pragma option pop

#pragma option push -b-
enum TTPBMode { tpbDefault, tpbReadCommitted, tpbRepeatableRead };
#pragma option pop

class DELPHICLASS TBlobSwapSupport;
class PASCALIMPLEMENTATION TBlobSwapSupport : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FActive;
	AnsiString FSwapDirectory;
	int FMinBlobSizeToSwap;
	AnsiString __fastcall GetSwapDirectory();
	bool __fastcall StoreSwapDir(void);
	
public:
	__fastcall TBlobSwapSupport(void);
	__property AnsiString SwapDirectory = {read=GetSwapDirectory};
	
__published:
	__property bool Active = {read=FActive, write=FActive, default=0};
	__property AnsiString SwapDir = {read=FSwapDirectory, write=FSwapDirectory, stored=StoreSwapDir};
	__property int MinBlobSizeToSwap = {read=FMinBlobSizeToSwap, write=FMinBlobSizeToSwap, default=0};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TBlobSwapSupport(void) { }
	#pragma option pop
	
};


class DELPHICLASS TCondition;
class DELPHICLASS TConditions;
#pragma option push -b-
enum TConditionsStateFlag { csInApply, csInCancel, csInRestorePrimarySQL };
#pragma option pop

typedef Set<TConditionsStateFlag, csInApply, csInRestorePrimarySQL>  TConditionsState;

class PASCALIMPLEMENTATION TConditions : public Classes::TStringList 
{
	typedef Classes::TStringList inherited;
	
public:
	TCondition* operator[](int Index) { return Condition[Index]; }
	
private:
	Classes::TComponent* FFIBQuery;
	bool FApplied;
	AnsiString FPrimarySQL;
	TConditionsState FState;
	AnsiString __fastcall GetEnabledText();
	TCondition* __fastcall GetCondition(int Index);
	
protected:
	virtual void __fastcall Put(int Index, const AnsiString S);
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	void __fastcall ReadEnabled(Classes::TReader* Reader);
	void __fastcall ReadStrings(Classes::TReader* Reader);
	HIDESBASE void __fastcall ReadData(Classes::TReader* Reader);
	HIDESBASE void __fastcall WriteData(Classes::TWriter* Writer);
	
public:
	void __fastcall WriteToExchangeStrings(Classes::TStrings* Dest);
	AnsiString __fastcall ExchangeString();
	void __fastcall ReadFromExchangeStrings(Classes::TStrings* Source);
	void __fastcall ReadFromExchangeString(const AnsiString Source);
	__fastcall TConditions(Classes::TComponent* AOwner);
	__fastcall virtual ~TConditions(void);
	virtual int __fastcall Add(const AnsiString S);
	virtual int __fastcall AddObject(const AnsiString S, System::TObject* AObject);
	virtual void __fastcall Clear(void);
	virtual void __fastcall Delete(int Index);
	TCondition* __fastcall AddCondition(const AnsiString Name, const AnsiString Condition, bool Enabled);
	TCondition* __fastcall FindCondition(const AnsiString Name);
	TCondition* __fastcall ByName(const AnsiString Name);
	void __fastcall Remove(const AnsiString Name);
	void __fastcall Apply(void);
	void __fastcall CancelApply(void);
	void __fastcall RestorePrimarySQL(void);
	__property AnsiString EnabledText = {read=GetEnabledText};
	__property bool Applied = {read=FApplied, nodefault};
	__property TCondition* Condition[int Index] = {read=GetCondition/*, default*/};
	__property AnsiString PrimarySQL = {read=FPrimarySQL, write=FPrimarySQL};
	__property TConditionsState State = {read=FState, nodefault};
};


class PASCALIMPLEMENTATION TCondition : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	TConditions* FOwner;
	bool FEnabled;
	bool FInDestroy;
	bool FEnabledFromStream;
	bool FValueFromStream;
	AnsiString __fastcall GetName();
	AnsiString __fastcall GetValue();
	void __fastcall SetValue(const AnsiString Value);
	void __fastcall SetValueFromStream(const AnsiString Value);
	void __fastcall SetName(const AnsiString Name);
	void __fastcall SetEnabled(const bool Value);
	void __fastcall SetEnabledFromStream(const bool Value);
	
public:
	__fastcall TCondition(TConditions* AOwner);
	__fastcall virtual ~TCondition(void);
	__property bool Enabled = {read=FEnabled, write=SetEnabled, nodefault};
	__property AnsiString Name = {read=GetName, write=SetName};
	__property AnsiString Value = {read=GetValue, write=SetValue};
};


//-- var, const, procedure ---------------------------------------------------
#define StatDefPrepareOptions (Set<TpPrepareOption, pfSetRequiredFields, psUseLargeIntField> () << TpPrepareOption(2) << TpPrepareOption(3) << TpPrepareOption(7) << TpPrepareOption(10) )
extern PACKAGE TpPrepareOptions DefaultPrepareOptions;
#define StatDefDataSetOptions (Set<TpFIBDsOption, poTrimCharFields, poRefreshAfterDelete> () << TpFIBDsOption(0) << TpFIBDsOption(1) << TpFIBDsOption(3) << TpFIBDsOption(4) )
extern PACKAGE TpFIBDsOptions DefaultOptions;
extern PACKAGE TDetailConditions DefaultDetailConditions;
extern PACKAGE bool DefStoreConnected;
extern PACKAGE bool DefSynchronizeTime;
extern PACKAGE bool DefUpperOldNames;
extern PACKAGE bool DefUseLoginPrompt;
extern PACKAGE AnsiString DefCharSet;
extern PACKAGE int DefSQLDialect;
extern PACKAGE TTransactionAction1 DefTimeOutAction;
extern PACKAGE int DefTimeOut;
extern PACKAGE TTPBMode DefTPBMode;
extern PACKAGE bool DefParamCheck;
extern PACKAGE bool DefGoToFirstRecordOnExecute;
extern PACKAGE TpFIBQueryOptions DefQueryOptions;
#define RegFIBRoot "FIBC_Software"
#define RegFIBTrKinds "Transation Kinds"
#define RegPreferences "Preferences"
#define RegRepository "Repository"
extern PACKAGE AnsiString DefPrefixGenName;
extern PACKAGE AnsiString DefSufixGenName;
extern PACKAGE bool DefEmptyStrToNull;
extern PACKAGE bool FF_UseRuntimeDefaults;
extern PACKAGE AnsiString RDefDateFormat;
extern PACKAGE AnsiString RDefTimeFormat;
extern PACKAGE AnsiString RDefDisplayFormatNum;
extern PACKAGE AnsiString RDefEditFormatNum;
extern PACKAGE AnsiString dDefDateFormat;
extern PACKAGE AnsiString dDefTimeFormat;
extern PACKAGE AnsiString dDefDateTimeFormat;
extern PACKAGE AnsiString dDefDisplayFormatNum;
extern PACKAGE AnsiString dDefEditFormatNum;

}	/* namespace Pfibprops */
using namespace Pfibprops;
#pragma pack(pop)
#pragma option pop

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