home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1997 May / Pcwk0597.iso / borland / cb / setup / cbuilder / data.z / DB.HPP < prev    next >
C/C++ Source or Header  |  1997-02-28  |  60KB  |  1,366 lines
  1. //----------------------------------------------------------------------------
  2. // DB.hpp - bcbdcc32 generated hdr (DO NOT EDIT) rev: 0
  3. // From: DB.pas
  4. //----------------------------------------------------------------------------
  5. #ifndef DBHPP
  6. #define DBHPP
  7. //----------------------------------------------------------------------------
  8. #include <Classes.hpp>
  9. #include <Bde.hpp>
  10. #include <Windows.hpp>
  11. #include <SysUtils.hpp>
  12. #include <System.hpp>
  13. #pragma warn -par
  14. #pragma warn -hid 
  15. #pragma warn -inl
  16.  
  17. namespace Db
  18. {
  19. //-- type declarations -------------------------------------------------------
  20. typedef Bde::FLDDesc TFieldDescList[1024];
  21.  
  22. typedef TFieldDescList *PFieldDescList;
  23.  
  24. typedef Bde::IDXDesc TIndexDescList[64];
  25.  
  26. typedef TIndexDescList *PIndexDescList;
  27.  
  28. class __declspec(delphiclass) EDatabaseError;
  29. class __declspec(pascalimplementation) EDatabaseError : public Sysutils::Exception
  30. {
  31.     typedef Sysutils::Exception inherited;
  32.     
  33. public:
  34.     /* Exception.Create */ __fastcall EDatabaseError(const System::AnsiString Msg) : Sysutils::Exception(
  35.         Msg) { }
  36.     /* Exception.CreateFmt */ __fastcall EDatabaseError(const System::AnsiString Msg, const System::TVarRec 
  37.         * Args, const int Args_Size) : Sysutils::Exception(Msg, Args, Args_Size) { }
  38.     /* Exception.CreateRes */ __fastcall EDatabaseError(int Ident) : Sysutils::Exception(Ident) { }
  39.     /* Exception.CreateResFmt */ __fastcall EDatabaseError(int Ident, const System::TVarRec * Args, const 
  40.         int Args_Size) : Sysutils::Exception(Ident, Args, Args_Size) { }
  41.     /* Exception.CreateHelp */ __fastcall EDatabaseError(const System::AnsiString Msg, int AHelpContext
  42.         ) : Sysutils::Exception(Msg, AHelpContext) { }
  43.     /* Exception.CreateFmtHelp */ __fastcall EDatabaseError(const System::AnsiString Msg, const System::TVarRec 
  44.         * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Msg, Args, Args_Size, AHelpContext
  45.         ) { }
  46.     /* Exception.CreateResHelp */ __fastcall EDatabaseError(int Ident, int AHelpContext) : Sysutils::Exception(
  47.         Ident, AHelpContext) { }
  48.     /* Exception.CreateResFmtHelp */ __fastcall EDatabaseError(int Ident, const System::TVarRec * Args, 
  49.         const int Args_Size, int AHelpContext) : Sysutils::Exception(Ident, Args, Args_Size, AHelpContext)
  50.          { }
  51.     
  52. public:
  53.     /* TObject.Destroy */ __fastcall virtual ~EDatabaseError(void) { }
  54.     
  55. };
  56.  
  57. class __declspec(delphiclass) EDBEngineError;
  58. class __declspec(delphiclass) TDBError;
  59. class __declspec(pascalimplementation) EDBEngineError : public EDatabaseError
  60. {
  61.     typedef EDatabaseError inherited;
  62.     
  63. private:
  64.     Classes::TList* FErrors;
  65.     TDBError* __fastcall GetError(int Index);
  66.     int __fastcall GetErrorCount(void);
  67.     
  68. public:
  69.     __fastcall EDBEngineError(Word ErrorCode);
  70.     __fastcall virtual ~EDBEngineError(void);
  71.     __property int ErrorCount = {read=GetErrorCount, nodefault};
  72.     __property TDBError* Errors[int Index] = {read=GetError};
  73. public:
  74.     /* Exception.CreateFmt */ __fastcall EDBEngineError(const System::AnsiString Msg, const System::TVarRec 
  75.         * Args, const int Args_Size) : Db::EDatabaseError(Msg, Args, Args_Size) { }
  76.     /* Exception.CreateRes */ __fastcall EDBEngineError(int Ident) : Db::EDatabaseError(Ident) { }
  77.     /* Exception.CreateResFmt */ __fastcall EDBEngineError(int Ident, const System::TVarRec * Args, const 
  78.         int Args_Size) : Db::EDatabaseError(Ident, Args, Args_Size) { }
  79.     /* Exception.CreateHelp */ __fastcall EDBEngineError(const System::AnsiString Msg, int AHelpContext
  80.         ) : Db::EDatabaseError(Msg, AHelpContext) { }
  81.     /* Exception.CreateFmtHelp */ __fastcall EDBEngineError(const System::AnsiString Msg, const System::TVarRec 
  82.         * Args, const int Args_Size, int AHelpContext) : Db::EDatabaseError(Msg, Args, Args_Size, AHelpContext
  83.         ) { }
  84.     /* Exception.CreateResHelp */ __fastcall EDBEngineError(int Ident, int AHelpContext) : Db::EDatabaseError(
  85.         Ident, AHelpContext) { }
  86.     /* Exception.CreateResFmtHelp */ __fastcall EDBEngineError(int Ident, const System::TVarRec * Args, 
  87.         const int Args_Size, int AHelpContext) : Db::EDatabaseError(Ident, Args, Args_Size, AHelpContext) { }
  88.         
  89. };
  90.  
  91. class __declspec(pascalimplementation) TDBError : public System::TObject
  92. {
  93.     typedef System::TObject inherited;
  94.     
  95. private:
  96.     Word FErrorCode;
  97.     long FNativeError;
  98.     System::AnsiString FMessage;
  99.     Byte __fastcall GetCategory(void);
  100.     Byte __fastcall GetSubCode(void);
  101.     
  102. public:
  103.     __fastcall TDBError(EDBEngineError* Owner, Word ErrorCode, long NativeError, char * Message);
  104.     __property Byte Category = {read=GetCategory, nodefault};
  105.     __property Word ErrorCode = {read=FErrorCode, nodefault};
  106.     __property Byte SubCode = {read=GetSubCode, nodefault};
  107.     __property System::AnsiString Message = {read=FMessage, nodefault};
  108.     __property long NativeError = {read=FNativeError, nodefault};
  109. public:
  110.     /* TObject.Destroy */ __fastcall virtual ~TDBError(void) { }
  111.     
  112. };
  113.  
  114. typedef void *TLocale;
  115.  
  116. typedef Bde::CBRType __fastcall (__closure *TBDECallbackEvent)(void * CBInfo);
  117.  
  118. class __declspec(delphiclass) TBDECallback;
  119. class __declspec(pascalimplementation) TBDECallback : public System::TObject
  120. {
  121.     typedef System::TObject inherited;
  122.     
  123. private:
  124.     Bde::_hDBIObj *FHandle;
  125.     System::TObject* FOwner;
  126.     CBType FCBType;
  127.     long FOldCBData;
  128.     void *FOldCBBuf;
  129.     Word FOldCBBufLen;
  130.     Bde::pfDBICallBack FOldCBFunc;
  131.     bool FInstalled;
  132.     TBDECallbackEvent FCallbackEvent;
  133.     
  134. protected:
  135.     Bde::CBRType __fastcall Invoke(Bde::CBType CallType, void * CBInfo);
  136.     
  137. public:
  138.     __fastcall TBDECallback(System::TObject* AOwner, Bde::hDBICur Handle, Bde::CBType CBType, void * CBBuf
  139.         , int CBBufSize, TBDECallbackEvent CallbackEvent, bool Chain);
  140.     __fastcall virtual ~TBDECallback(void);
  141. };
  142.  
  143. class __declspec(delphiclass) TSessionList;
  144. class __declspec(delphiclass) TSession;
  145. class __declspec(pascalimplementation) TSessionList : public System::TObject
  146. {
  147.     typedef System::TObject inherited;
  148.     
  149. private:
  150.     Classes::TList* FSessions;
  151.     void __fastcall AddSession(TSession* ASession);
  152.     void __fastcall CloseAll(void);
  153.     int __fastcall GetCount(void);
  154.     TSession* __fastcall GetSession(int Index);
  155.     TSession* __fastcall GetCurrentSession(void);
  156.     TSession* __fastcall GetSessionByName(const System::AnsiString SessionName);
  157.     void __fastcall SetCurrentSession(TSession* Value);
  158.     
  159. public:
  160.     __fastcall TSessionList(void);
  161.     __fastcall virtual ~TSessionList(void);
  162.     __property TSession* CurrentSession = {read=GetCurrentSession, write=SetCurrentSession, nodefault};
  163.         
  164.     TSession* __fastcall FindSession(const System::AnsiString SessionName);
  165.     void __fastcall GetSessionNames(Classes::TStrings* List);
  166.     TSession* __fastcall OpenSession(const System::AnsiString SessionName);
  167.     __property int Count = {read=GetCount, nodefault};
  168.     __property TSession* Sessions[int Index] = {read=GetSession/*, default*/};
  169.     __property TSession* List[System::AnsiString SessionName] = {read=GetSessionByName};
  170. };
  171.  
  172. enum TConfigMode { cmPersistent, cmSession, cmAll };
  173.  
  174. typedef void __fastcall (__closure *TPasswordEvent)(System::TObject* Sender, bool &Continue);
  175.  
  176. enum TDatabaseEvent { dbOpen, dbClose, dbAdd, dbRemove, dbAddAlias, dbDeleteAlias };
  177.  
  178. typedef void __fastcall (__closure *TDatabaseNotifyEvent)(TDatabaseEvent DBEvent, const void *Param)
  179.     ;
  180.  
  181. typedef void __fastcall (*TBDEInitProc)(TSession* Session);
  182.  
  183. enum TTraceFlag { tfQPrepare, tfQExecute, tfError, tfStmt, tfConnect, tfTransact, tfBlob, tfMisc, tfVendor 
  184.     };
  185.  
  186. typedef Set<TTraceFlag, tfQPrepare, tfVendor>  TTraceFlags;
  187.  
  188. typedef DWord __stdcall (*TWriteProc)(System::TObject* Client, char * Data, int Len);
  189.  
  190. typedef System::TObject* __stdcall (*TSMRegProc)(int Handle, char * ClientName, TWriteProc &WriteProc
  191.     , System::TObject* Instance, void * const SignalProc);
  192.  
  193. class __declspec(delphiclass) TDatabase;
  194. class __declspec(pascalimplementation) TSession : public Classes::TComponent
  195. {
  196.     typedef Classes::TComponent inherited;
  197.     
  198. private:
  199.     Bde::_hDBIObj *FHandle;
  200.     bool FDefault;
  201.     Classes::TList* FDatabases;
  202.     Classes::TList* FCallbacks;
  203.     void *FLocale;
  204.     int FClientLib;
  205.     TSMRegProc FSMRegProc;
  206.     TWriteProc FSMWriteProc;
  207.     Bde::TRACEDesc *FSMBuffer;
  208.     System::TObject* FSMClient;
  209.     TTraceFlags FTraceFlags;
  210.     bool FStreamedActive;
  211.     bool FKeepConnections;
  212.     System::AnsiString FSessionName;
  213.     System::AnsiString FNetFileDir;
  214.     System::AnsiString FPrivateDir;
  215.     CBSCType FCBSCType;
  216.     bool FDLLDetach;
  217.     bool FBDEOwnsLoginCbDb;
  218.     int FLockCount;
  219.     Bde::TCBDBLogin FCBDBLogin;
  220.     TPasswordEvent FOnPassword;
  221.     Classes::TNotifyEvent FOnStartup;
  222.     TDatabaseNotifyEvent FOnDBNotify;
  223.     void __fastcall AddDatabase(TDatabase* Value);
  224.     void __fastcall AddConfigRecord(const System::AnsiString Path, const System::AnsiString Node, Classes::TStrings* 
  225.         List);
  226.     void __fastcall CallBDEInitProcs(void);
  227.     void __fastcall CheckInactive(void);
  228.     void __fastcall CheckConfigMode(TConfigMode CfgMode);
  229.     Bde::CBRType __fastcall DBLoginCallback(void * CBInfo);
  230.     void __fastcall DBNotification(TDatabaseEvent DBEvent, const void *Param);
  231.     void __fastcall DeleteConfigPath(const System::AnsiString Path, const System::AnsiString Node);
  232.     bool __fastcall GetActive(void);
  233.     TConfigMode __fastcall GetConfigMode(void);
  234.     TDatabase* __fastcall GetDatabase(int Index);
  235.     int __fastcall GetDatabaseCount(void);
  236.     Bde::hDBISes __fastcall GetHandle(void);
  237.     System::AnsiString __fastcall GetNetFileDir(void);
  238.     System::AnsiString __fastcall GetPrivateDir(void);
  239.     void __fastcall InitializeBDE(void);
  240.     void __fastcall InternalAddAlias(const System::AnsiString Name, const System::AnsiString Driver, Classes::TStrings* 
  241.         List, TConfigMode CfgMode, bool RestoreMode);
  242.     void __fastcall InternalDeleteAlias(const System::AnsiString Name, TConfigMode CfgMode, bool RestoreMode
  243.         );
  244.     void __fastcall LockSession(void);
  245.     void __fastcall MakeCurrent(void);
  246.     void __fastcall ModifyConfigParams(const System::AnsiString Path, const System::AnsiString Node, Classes::TStrings* 
  247.         List);
  248.     void __fastcall RegisterCallbacks(bool Value);
  249.     void __fastcall RemoveDatabase(TDatabase* Value);
  250.     Bde::CBRType __fastcall ServerCallback(void * CBInfo);
  251.     void __fastcall SetActive(bool Value);
  252.     void __fastcall SetConfigMode(TConfigMode Value);
  253.     void __fastcall SetConfigParams(const System::AnsiString Path, const System::AnsiString Node, Classes::TStrings* 
  254.         List);
  255.     void __fastcall SetNetFileDir(const System::AnsiString Value);
  256.     void __fastcall SetPrivateDir(const System::AnsiString Value);
  257.     void __fastcall SetSessionName(const System::AnsiString Value);
  258.     void __fastcall SetTraceFlags(TTraceFlags Value);
  259.     void __fastcall SMClientSignal(System::TObject* Sender, int Data);
  260.     Bde::CBRType __fastcall SqlTraceCallback(void * CBInfo);
  261.     void __fastcall StartSession(bool Value);
  262.     void __fastcall UnlockSession(void);
  263.     
  264. protected:
  265.     virtual void __fastcall Loaded(void);
  266.     __property TDatabaseNotifyEvent OnDBNotify = {read=FOnDBNotify, write=FOnDBNotify};
  267.     __property bool BDEOwnsLoginCbDb = {read=FBDEOwnsLoginCbDb, write=FBDEOwnsLoginCbDb, nodefault};
  268.     
  269. public:
  270.     __fastcall virtual TSession(Classes::TComponent* AOwner);
  271.     __fastcall virtual ~TSession(void);
  272.     void __fastcall AddAlias(const System::AnsiString Name, const System::AnsiString Driver, Classes::TStrings* 
  273.         List);
  274.     void __fastcall AddStandardAlias(const System::AnsiString Name, const System::AnsiString Path, const System::AnsiString 
  275.         DefaultDriver);
  276.     __property TConfigMode ConfigMode = {read=GetConfigMode, write=SetConfigMode, nodefault};
  277.     void __fastcall AddPassword(const System::AnsiString Password);
  278.     void __fastcall Close(void);
  279.     void __fastcall CloseDatabase(TDatabase* Database);
  280.     void __fastcall DeleteAlias(const System::AnsiString Name);
  281.     void __fastcall DropConnections(void);
  282.     TDatabase* __fastcall FindDatabase(const System::AnsiString DatabaseName);
  283.     void __fastcall GetAliasNames(Classes::TStrings* List);
  284.     void __fastcall GetAliasParams(const System::AnsiString AliasName, Classes::TStrings* List);
  285.     System::AnsiString __fastcall GetAliasDriverName(const System::AnsiString AliasName);
  286.     void __fastcall GetConfigParams(const System::AnsiString Path, const System::AnsiString Section, Classes::TStrings* 
  287.         List);
  288.     void __fastcall GetDatabaseNames(Classes::TStrings* List);
  289.     void __fastcall GetDriverNames(Classes::TStrings* List);
  290.     void __fastcall GetDriverParams(const System::AnsiString DriverName, Classes::TStrings* List);
  291.     bool __fastcall GetPassword(void);
  292.     void __fastcall GetTableNames(const System::AnsiString DatabaseName, const System::AnsiString Pattern
  293.         , bool Extensions, bool SystemTables, Classes::TStrings* List);
  294.     void __fastcall GetStoredProcNames(const System::AnsiString DatabaseName, Classes::TStrings* List);
  295.         
  296.     bool __fastcall IsAlias(const System::AnsiString Name);
  297.     void __fastcall ModifyAlias( System::AnsiString Name, Classes::TStrings* List);
  298.     void __fastcall Open(void);
  299.     TDatabase* __fastcall OpenDatabase(const System::AnsiString DatabaseName);
  300.     void __fastcall RemoveAllPasswords(void);
  301.     void __fastcall RemovePassword(const System::AnsiString Password);
  302.     void __fastcall SaveConfigFile(void);
  303.     __property int DatabaseCount = {read=GetDatabaseCount, nodefault};
  304.     __property TDatabase* Databases[int Index] = {read=GetDatabase};
  305.     __property Bde::hDBISes Handle = {read=GetHandle, nodefault};
  306.     __property void * Locale = {read=FLocale, nodefault};
  307.     __property TTraceFlags TraceFlags = {read=FTraceFlags, write=SetTraceFlags, nodefault};
  308.     
  309. __published:
  310.     __property bool Active = {read=GetActive, write=SetActive, default=0};
  311.     __property bool KeepConnections = {read=FKeepConnections, write=FKeepConnections, default=1};
  312.     __property System::AnsiString NetFileDir = {read=GetNetFileDir, write=SetNetFileDir, nodefault};
  313.     __property System::AnsiString PrivateDir = {read=GetPrivateDir, write=SetPrivateDir, nodefault};
  314.     __property System::AnsiString SessionName = {read=FSessionName, write=SetSessionName, nodefault};
  315.     __property TPasswordEvent OnPassword = {read=FOnPassword, write=FOnPassword};
  316.     __property Classes::TNotifyEvent OnStartup = {read=FOnStartup, write=FOnStartup};
  317. };
  318.  
  319. class __declspec(delphiclass) TParamList;
  320. class __declspec(pascalimplementation) TParamList : public System::TObject
  321. {
  322.     typedef System::TObject inherited;
  323.     
  324. private:
  325.     int FFieldCount;
  326.     Word FBufSize;
  327.     TFieldDescList *FFieldDescs;
  328.     char *FBuffer;
  329.     
  330. public:
  331.     __fastcall TParamList(Classes::TStrings* Params);
  332.     __fastcall virtual ~TParamList(void);
  333.     __property char * Buffer = {read=FBuffer, nodefault};
  334.     __property int FieldCount = {read=FFieldCount, nodefault};
  335.     __property PFieldDescList FieldDescs = {read=FFieldDescs, nodefault};
  336. };
  337.  
  338. enum TTransIsolation { tiDirtyRead, tiReadCommitted, tiRepeatableRead };
  339.  
  340. typedef void __fastcall (__closure *TLoginEvent)(TDatabase* Database, Classes::TStrings* LoginParams
  341.     );
  342.  
  343. class __declspec(delphiclass) TDBDataSet;
  344. class __declspec(pascalimplementation) TDatabase : public Classes::TComponent
  345. {
  346.     typedef Classes::TComponent inherited;
  347.     
  348. private:
  349.     Classes::TList* FDataSets;
  350.     TTransIsolation FTransIsolation;
  351.     bool FLoginPrompt;
  352.     bool FKeepConnection;
  353.     bool FTemporary;
  354.     bool FSessionAlias;
  355.     bool FStreamedConnected;
  356.     bool FLocaleLoaded;
  357.     bool FAliased;
  358.     Byte FReserved;
  359.     int FRefCount;
  360.     Bde::_hDBIObj *FHandle;
  361.     bool FSQLBased;
  362.     Bde::_hDBIObj *FTransHandle;
  363.     void *FLocale;
  364.     TSession* FSession;
  365.     System::AnsiString FSessionName;
  366.     Classes::TStrings* FParams;
  367.     System::AnsiString FDatabaseName;
  368.     System::AnsiString FDatabaseType;
  369.     bool FAcquiredHandle;
  370.     TLoginEvent FOnLogin;
  371.     void __fastcall CheckActive(void);
  372.     void __fastcall CheckInactive(void);
  373.     void __fastcall CheckDatabaseName(void);
  374.     void __fastcall CheckDatabaseAlias( System::AnsiString &Password);
  375.     void __fastcall CheckSessionName(bool Required);
  376.     void __fastcall EndTransaction(Bde::eXEnd TransEnd);
  377.     System::AnsiString __fastcall GetAliasName(void);
  378.     bool __fastcall GetConnected(void);
  379.     TDBDataSet* __fastcall GetDataSet(int Index);
  380.     int __fastcall GetDataSetCount(void);
  381.     System::AnsiString __fastcall GetDirectory(void);
  382.     System::AnsiString __fastcall GetDriverName(void);
  383.     bool __fastcall GetIsSQLBased(void);
  384.     bool __fastcall GetInTransaction(void);
  385.     TTraceFlags __fastcall GetTraceFlags(void);
  386.     void __fastcall LoadLocale(void);
  387.     void __fastcall Login(Classes::TStrings* LoginParams);
  388.     void __fastcall ParamsChanging(System::TObject* Sender);
  389.     void __fastcall SetAliasName(const System::AnsiString Value);
  390.     void __fastcall SetConnected(bool Value);
  391.     void __fastcall SetDatabaseName(const System::AnsiString Value);
  392.     void __fastcall SetDatabaseType(const System::AnsiString Value, bool Aliased);
  393.     void __fastcall SetDirectory(const System::AnsiString Value);
  394.     void __fastcall SetDriverName(const System::AnsiString Value);
  395.     void __fastcall SetHandle(Bde::hDBIDb Value);
  396.     void __fastcall SetKeepConnection(bool Value);
  397.     void __fastcall SetParams(Classes::TStrings* Value);
  398.     void __fastcall SetTraceFlags(TTraceFlags Value);
  399.     void __fastcall SetSessionName(const System::AnsiString Value);
  400.     
  401. protected:
  402.     virtual void __fastcall Loaded(void);
  403.     
  404. public:
  405.     __fastcall virtual TDatabase(Classes::TComponent* AOwner);
  406.     __fastcall virtual ~TDatabase(void);
  407.     void __fastcall ApplyUpdates(TDBDataSet* const * DataSets, const int DataSets_Size);
  408.     void __fastcall Close(void);
  409.     void __fastcall CloseDataSets(void);
  410.     void __fastcall Commit(void);
  411.     void __fastcall FlushSchemaCache(const System::AnsiString TableName);
  412.     void __fastcall Open(void);
  413.     void __fastcall Rollback(void);
  414.     void __fastcall StartTransaction(void);
  415.     void __fastcall ValidateName(const System::AnsiString Name);
  416.     __property int DataSetCount = {read=GetDataSetCount, nodefault};
  417.     __property TDBDataSet* DataSets[int Index] = {read=GetDataSet};
  418.     __property System::AnsiString Directory = {read=GetDirectory, write=SetDirectory, nodefault};
  419.     __property Bde::hDBIDb Handle = {read=FHandle, write=SetHandle, nodefault};
  420.     __property bool IsSQLBased = {read=FSQLBased, nodefault};
  421.     __property bool InTransaction = {read=GetInTransaction, nodefault};
  422.     __property void * Locale = {read=FLocale, nodefault};
  423.     __property TSession* Session = {read=FSession, nodefault};
  424.     __property bool Temporary = {read=FTemporary, write=FTemporary, nodefault};
  425.     __property bool SessionAlias = {read=FSessionAlias, nodefault};
  426.     __property TTraceFlags TraceFlags = {read=GetTraceFlags, write=SetTraceFlags, nodefault};
  427.     
  428. __published:
  429.     __property System::AnsiString AliasName = {read=GetAliasName, write=SetAliasName, nodefault};
  430.     __property bool Connected = {read=GetConnected, write=SetConnected, default=0};
  431.     __property System::AnsiString DatabaseName = {read=FDatabaseName, write=SetDatabaseName, nodefault}
  432.         ;
  433.     __property System::AnsiString DriverName = {read=GetDriverName, write=SetDriverName, nodefault};
  434.     __property bool KeepConnection = {read=FKeepConnection, write=SetKeepConnection, default=1};
  435.     __property bool LoginPrompt = {read=FLoginPrompt, write=FLoginPrompt, default=1};
  436.     __property Classes::TStrings* Params = {read=FParams, write=SetParams, nodefault};
  437.     __property System::AnsiString SessionName = {read=FSessionName, write=SetSessionName, nodefault};
  438.     __property TTransIsolation TransIsolation = {read=FTransIsolation, write=FTransIsolation, default=1
  439.         };
  440.     __property TLoginEvent OnLogin = {read=FOnLogin, write=FOnLogin};
  441. };
  442.  
  443. enum TDataEvent { deFieldChange, deRecordChange, deDataSetChange, deDataSetScroll, deLayoutChange, deUpdateRecord, 
  444.     deUpdateState, deCheckBrowseMode, dePropertyChange, deFieldListChange, deFocusControl };
  445.  
  446. class __declspec(delphiclass) TDataSetDesigner;
  447. class __declspec(delphiclass) TDataSet;
  448. class __declspec(delphiclass) TFieldDefs;
  449. class __declspec(delphiclass) TFieldDef;
  450. enum TFieldType { ftUnknown, ftString, ftSmallint, ftInteger, ftWord, ftBoolean, ftFloat, ftCurrency, 
  451.     ftBCD, ftDate, ftTime, ftDateTime, ftBytes, ftVarBytes, ftAutoInc, ftBlob, ftMemo, ftGraphic, ftFmtMemo, 
  452.     ftParadoxOle, ftDBaseOle, ftTypedBinary };
  453.  
  454. class __declspec(pascalimplementation) TFieldDefs : public System::TObject
  455. {
  456.     typedef System::TObject inherited;
  457.     
  458. private:
  459.     TDataSet* FDataSet;
  460.     Classes::TList* FItems;
  461.     bool FUpdated;
  462.     Byte FReserved;
  463.     int __fastcall GetCount(void);
  464.     TFieldDef* __fastcall GetItem(int Index);
  465.     
  466. public:
  467.     __fastcall TFieldDefs(TDataSet* DataSet);
  468.     __fastcall virtual ~TFieldDefs(void);
  469.     void __fastcall Add(const System::AnsiString Name, TFieldType DataType, Word Size, bool Required);
  470.     void __fastcall AddFieldDesc(const Bde::FLDDesc &FieldDesc, bool Required, Word FieldNo);
  471.     void __fastcall Assign(TFieldDefs* FieldDefs);
  472.     void __fastcall Clear(void);
  473.     TFieldDef* __fastcall Find(const System::AnsiString Name);
  474.     int __fastcall IndexOf(const System::AnsiString Name);
  475.     void __fastcall Update(void);
  476.     __property int Count = {read=GetCount, nodefault};
  477.     __property TFieldDef* Items[int Index] = {read=GetItem/*, default*/};
  478. };
  479.  
  480. typedef char *TBufferList[1024];
  481.  
  482. typedef TBufferList *PBufferList;
  483.  
  484. enum TDataSetState { dsInactive, dsBrowse, dsEdit, dsInsert, dsSetKey, dsCalcFields, dsUpdateNew, dsUpdateOld, 
  485.     dsFilter };
  486.  
  487. enum TRecNoStatus { rnDbase, rnParadox, rnNotSupported };
  488.  
  489. class __declspec(delphiclass) TDataLink;
  490. class __declspec(delphiclass) TDataSource;
  491. class __declspec(delphiclass) TField;
  492. typedef void __fastcall (__closure *TDataChangeEvent)(System::TObject* Sender, TField* Field);
  493.  
  494. class __declspec(pascalimplementation) TDataSource : public Classes::TComponent
  495. {
  496.     typedef Classes::TComponent inherited;
  497.     
  498. private:
  499.     TDataSet* FDataSet;
  500.     Classes::TList* FDataLinks;
  501.     bool FEnabled;
  502.     bool FAutoEdit;
  503.     TDataSetState FState;
  504.     Byte FReserved;
  505.     Classes::TNotifyEvent FOnStateChange;
  506.     TDataChangeEvent FOnDataChange;
  507.     Classes::TNotifyEvent FOnUpdateData;
  508.     void __fastcall AddDataLink(TDataLink* DataLink);
  509.     void __fastcall DataEvent(TDataEvent Event, long Info);
  510.     void __fastcall NotifyDataLinks(TDataEvent Event, long Info);
  511.     void __fastcall RemoveDataLink(TDataLink* DataLink);
  512.     void __fastcall SetDataSet(TDataSet* ADataSet);
  513.     void __fastcall SetEnabled(bool Value);
  514.     void __fastcall SetState(TDataSetState Value);
  515.     void __fastcall UpdateState(void);
  516.     
  517. public:
  518.     __fastcall virtual TDataSource(Classes::TComponent* AOwner);
  519.     __fastcall virtual ~TDataSource(void);
  520.     void __fastcall Edit(void);
  521.     bool __fastcall IsLinkedTo(TDataSet* DataSet);
  522.     __property TDataSetState State = {read=FState, nodefault};
  523.     
  524. __published:
  525.     __property bool AutoEdit = {read=FAutoEdit, write=FAutoEdit, default=1};
  526.     __property TDataSet* DataSet = {read=FDataSet, write=SetDataSet, nodefault};
  527.     __property bool Enabled = {read=FEnabled, write=SetEnabled, default=1};
  528.     __property Classes::TNotifyEvent OnStateChange = {read=FOnStateChange, write=FOnStateChange};
  529.     __property TDataChangeEvent OnDataChange = {read=FOnDataChange, write=FOnDataChange};
  530.     __property Classes::TNotifyEvent OnUpdateData = {read=FOnUpdateData, write=FOnUpdateData};
  531. };
  532.  
  533. typedef TField* *TFieldRef;
  534.  
  535. class __declspec(pascalimplementation) TDataLink : public Classes::TPersistent
  536. {
  537.     typedef Classes::TPersistent inherited;
  538.     
  539. private:
  540.     TDataSource* FDataSource;
  541.     TDataLink* FNext;
  542.     int FBufferCount;
  543.     int FFirstRecord;
  544.     bool FReadOnly;
  545.     bool FActive;
  546.     bool FEditing;
  547.     bool FUpdating;
  548.     bool FDataSourceFixed;
  549.     void __fastcall DataEvent(TDataEvent Event, long Info);
  550.     int __fastcall GetActiveRecord(void);
  551.     TDataSet* __fastcall GetDataSet(void);
  552.     int __fastcall GetRecordCount(void);
  553.     void __fastcall SetActive(bool Value);
  554.     void __fastcall SetActiveRecord(int Value);
  555.     void __fastcall SetBufferCount(int Value);
  556.     void __fastcall SetDataSource(TDataSource* ADataSource);
  557.     void __fastcall SetEditing(bool Value);
  558.     void __fastcall SetReadOnly(bool Value);
  559.     void __fastcall UpdateRange(void);
  560.     void __fastcall UpdateState(void);
  561.     
  562. protected:
  563.     virtual void __fastcall ActiveChanged(void);
  564.     virtual void __fastcall CheckBrowseMode(void);
  565.     virtual void __fastcall DataSetChanged(void);
  566.     virtual void __fastcall DataSetScrolled(int Distance);
  567.     virtual void __fastcall FocusControl(TFieldRef Field);
  568.     virtual void __fastcall EditingChanged(void);
  569.     virtual void __fastcall LayoutChanged(void);
  570.     virtual void __fastcall RecordChanged(TField* Field);
  571.     virtual void __fastcall UpdateData(void);
  572.     
  573. public:
  574.     __fastcall TDataLink(void);
  575.     __fastcall virtual ~TDataLink(void);
  576.     bool __fastcall Edit(void);
  577.     void __fastcall UpdateRecord(void);
  578.     __property bool Active = {read=FActive, nodefault};
  579.     __property int ActiveRecord = {read=GetActiveRecord, write=SetActiveRecord, nodefault};
  580.     __property int BufferCount = {read=FBufferCount, write=SetBufferCount, nodefault};
  581.     __property TDataSet* DataSet = {read=GetDataSet, nodefault};
  582.     __property TDataSource* DataSource = {read=FDataSource, write=SetDataSource, nodefault};
  583.     __property bool DataSourceFixed = {read=FDataSourceFixed, write=FDataSourceFixed, nodefault};
  584.     __property bool Editing = {read=FEditing, nodefault};
  585.     __property bool ReadOnly = {read=FReadOnly, write=SetReadOnly, nodefault};
  586.     __property int RecordCount = {read=GetRecordCount, nodefault};
  587. };
  588.  
  589. struct TKeyBuffer;
  590. typedef TKeyBuffer *PKeyBuffer;
  591.  
  592. enum TFilterOption { foCaseInsensitive, foNoPartialCompare };
  593.  
  594. typedef Set<TFilterOption, foCaseInsensitive, foNoPartialCompare>  TFilterOptions;
  595.  
  596. typedef void __fastcall (__closure *TOnServerYieldEvent)(TDataSet* DataSet, bool &AbortQuery);
  597.  
  598. class __declspec(delphiclass) TDataSetUpdateObject;
  599. enum TUpdateKind { ukModify, ukInsert, ukDelete };
  600.  
  601. class __declspec(pascalimplementation) TDataSetUpdateObject : public Classes::TComponent
  602. {
  603.     typedef Classes::TComponent inherited;
  604.     
  605. protected:
  606.     virtual TDataSet* __fastcall GetDataSet(void) = 0;
  607.     virtual void __fastcall SetDataSet(TDataSet* ADataSet) = 0;
  608.     virtual void __fastcall Apply(TUpdateKind UpdateKind) = 0;
  609.     __property TDataSet* DataSet = {read=GetDataSet, write=SetDataSet, nodefault};
  610. public:
  611.     /* TComponent.Create */ __fastcall virtual TDataSetUpdateObject(Classes::TComponent* AOwner) : Classes::
  612.         TComponent(AOwner) { }
  613.     /* TComponent.Destroy */ __fastcall virtual ~TDataSetUpdateObject(void) { }
  614.     
  615. };
  616.  
  617. typedef void __fastcall (__closure *TDataSetNotifyEvent)(TDataSet* DataSet);
  618.  
  619. enum TUpdateAction { uaFail, uaAbort, uaSkip, uaRetry, uaApplied };
  620.  
  621. typedef void __fastcall (__closure *TUpdateErrorEvent)(TDataSet* DataSet, EDatabaseError* E, TUpdateKind 
  622.     UpdateKind, TUpdateAction &UpdateAction);
  623.  
  624. typedef void __fastcall (__closure *TUpdateRecordEvent)(TDataSet* DataSet, TUpdateKind UpdateKind, TUpdateAction 
  625.     &UpdateAction);
  626.  
  627. typedef void __fastcall (__closure *TFilterRecordEvent)(TDataSet* DataSet, bool &Accept);
  628.  
  629. enum TDataAction { daFail, daAbort, daRetry };
  630.  
  631. typedef void __fastcall (__closure *TDataSetErrorEvent)(TDataSet* DataSet, EDatabaseError* E, TDataAction 
  632.     &Action);
  633.  
  634. typedef Word __fastcall (__closure *TDataOperation)(void);
  635.  
  636. enum TLocateOption { loCaseInsensitive, loPartialKey };
  637.  
  638. typedef Set<TLocateOption, loCaseInsensitive, loPartialKey>  TLocateOptions;
  639.  
  640. enum TGetMode { gmCurrent, gmNext, gmPrior };
  641.  
  642. enum TKeyIndex { kiLookup, kiRangeStart, kiRangeEnd, kiCurRangeStart, kiCurRangeEnd, kiSave };
  643.  
  644. enum DB_41 { rtModified, rtInserted, rtDeleted, rtUnmodified };
  645.  
  646. typedef Set<DB_41, rtModified, rtUnmodified>  TUpdateRecordTypes;
  647.  
  648. enum DB_21 { rmExact, rmCenter };
  649.  
  650. typedef Set<DB_21, rmExact, rmCenter>  TResyncMode;
  651.  
  652. enum TUpdateStatus { usUnmodified, usModified, usInserted, usDeleted };
  653.  
  654. class __declspec(pascalimplementation) TDataSet : public Classes::TComponent
  655. {
  656.     typedef Classes::TComponent inherited;
  657.     
  658. private:
  659.     Classes::TList* FFields;
  660.     Classes::TList* FDataSources;
  661.     TFieldDefs* FFieldDefs;
  662.     TBufferList *FBuffers;
  663.     int FBufListSize;
  664.     int FBufferCount;
  665.     int FRecordCount;
  666.     int FActiveRecord;
  667.     int FCurrentRecord;
  668.     Bde::_hDBIObj *FHandle;
  669.     bool FBOF;
  670.     bool FEOF;
  671.     TDataSetState FState;
  672.     bool FAutoCalcFields;
  673.     bool FDefaultFields;
  674.     bool FCanModify;
  675.     bool FModified;
  676.     bool FStreamedActive;
  677.     bool FInfoQueryMode;
  678.     TDataSetState FDisableState;
  679.     TDataEvent FEnableEvent;
  680.     bool FFiltered;
  681.     bool FFound;
  682.     Bde::RECProps FRecProps;
  683.     int FRawFieldCount;
  684.     Word FRecordSize;
  685.     Word FBookmarkSize;
  686.     Word FRecInfoOfs;
  687.     Word FBookmarkOfs;
  688.     TRecNoStatus FRecNoStatus;
  689.     Word FKeySize;
  690.     bool FExpIndex;
  691.     bool FCaseInsIndex;
  692.     Word FCalcFieldsSize;
  693.     Word FRecBufSize;
  694.     int FDisableCount;
  695.     TDataLink* FFirstDataLink;
  696.     void *FLocale;
  697.     TDataSetDesigner* FDesigner;
  698.     TKeyBuffer *FKeyBuffers[6];
  699.     TKeyBuffer *FKeyBuffer;
  700.     char *FCalcBuffer;
  701.     System::AnsiString FFilterText;
  702.     TFilterOptions FFilterOptions;
  703.     Bde::_hDBIObj *FExprFilter;
  704.     Bde::_hDBIObj *FFuncFilter;
  705.     char *FFilterBuffer;
  706.     int FIndexFieldCount;
  707.     Word FIndexFieldMap[16];
  708.     bool FBDECalcFields;
  709.     bool FCachedUpdates;
  710.     Bde::DELAYUPDCbDesc *FUpdateCBBuf;
  711.     TBDECallback* FUpdateCallback;
  712.     bool FInUpdateCallback;
  713.     Word FUpdateErrCode;
  714.     TBDECallback* FAsyncCallback;
  715.     CBYieldStep FCBYieldStep;
  716.     TOnServerYieldEvent FOnServerYield;
  717.     TDataSetUpdateObject* FUpdateObject;
  718.     TDataSetNotifyEvent FBeforeOpen;
  719.     TDataSetNotifyEvent FAfterOpen;
  720.     TDataSetNotifyEvent FBeforeClose;
  721.     TDataSetNotifyEvent FAfterClose;
  722.     TDataSetNotifyEvent FBeforeInsert;
  723.     TDataSetNotifyEvent FAfterInsert;
  724.     TDataSetNotifyEvent FBeforeEdit;
  725.     TDataSetNotifyEvent FAfterEdit;
  726.     TDataSetNotifyEvent FBeforePost;
  727.     TDataSetNotifyEvent FAfterPost;
  728.     TDataSetNotifyEvent FBeforeCancel;
  729.     TDataSetNotifyEvent FAfterCancel;
  730.     TDataSetNotifyEvent FBeforeDelete;
  731.     TDataSetNotifyEvent FAfterDelete;
  732.     TDataSetNotifyEvent FOnNewRecord;
  733.     TDataSetNotifyEvent FOnCalcFields;
  734.     TUpdateErrorEvent FOnUpdateError;
  735.     TUpdateRecordEvent FOnUpdateRecord;
  736.     TFilterRecordEvent FOnFilterRecord;
  737.     TDataSetErrorEvent FOnEditError;
  738.     TDataSetErrorEvent FOnPostError;
  739.     TDataSetErrorEvent FOnDeleteError;
  740.     void __fastcall ActivateBuffers(void);
  741.     void __fastcall ActivateFilters(void);
  742.     void __fastcall AddDataSource(TDataSource* DataSource);
  743.     void __fastcall AddField(TField* Field);
  744.     void __fastcall AddRecord(const System::TVarRec * Values, const int Values_Size, bool Append);
  745.     void __fastcall AllocKeyBuffers(void);
  746.     void __fastcall AllocDelUpdCBBuf(bool Allocate);
  747.     void __fastcall BeginInsertAppend(void);
  748.     void __fastcall BindFields(bool Binding);
  749.     Bde::CBRType __fastcall CachedUpdateCallBack(void * CBInfo);
  750.     void __fastcall CalculateBDEFields(void);
  751.     void __fastcall CalculateFields(void);
  752.     void __fastcall CheckCanModify(void);
  753.     void __fastcall CheckCachedUpdateMode(void);
  754.     void __fastcall CheckFieldName(const System::AnsiString FieldName);
  755.     void __fastcall CheckFieldNames(const System::AnsiString FieldNames);
  756.     void __fastcall CheckOperation(TDataOperation Operation, TDataSetErrorEvent ErrorEvent);
  757.     void __fastcall CheckRequiredFields(void);
  758.     void __fastcall CheckSetKeyMode(void);
  759.     void __fastcall CopyBuffer(int SourceIndex, int DestIndex);
  760.     Bde::hDBIFilter __fastcall CreateExprFilter(const System::AnsiString Expr, TFilterOptions Options, 
  761.         int Priority);
  762.     void __fastcall CreateFields(void);
  763.     Bde::hDBIFilter __fastcall CreateFuncFilter(void * FilterFunc, int Priority);
  764.     Bde::hDBIFilter __fastcall CreateLookupFilter(Classes::TList* Fields, const System::Variant &Values
  765.         , TLocateOptions Options, int Priority);
  766.     void __fastcall DeactivateFilters(void);
  767.     Word __fastcall DeleteRecord(void);
  768.     void __fastcall DestroyFields(void);
  769.     Word __fastcall EditRecord(void);
  770.     void __fastcall EndInsertAppend(void);
  771.     TField* __fastcall FieldByNumber(int FieldNo);
  772.     bool __fastcall FindRecord(bool Restart, bool GoForward);
  773.     void __fastcall FreeFieldBuffers(void);
  774.     void __fastcall FreeKeyBuffers(void);
  775.     bool __fastcall GetActive(void);
  776.     System::AnsiString __fastcall GetBookmarkStr(void);
  777.     void __fastcall GetCalcFields(int Index);
  778.     TField* __fastcall GetField(int Index);
  779.     int __fastcall GetFieldCount(void);
  780.     System::Variant __fastcall GetFieldValue(const System::AnsiString FieldName);
  781.     void __fastcall GetIndexInfo(void);
  782.     bool __fastcall GetNextRecord(void);
  783.     int __fastcall GetNextRecords(void);
  784.     bool __fastcall GetPriorRecord(void);
  785.     int __fastcall GetPriorRecords(void);
  786.     Word __fastcall GetRecord(int Index, TGetMode GetMode);
  787.     long __fastcall GetRecordCount(void);
  788.     bool __fastcall GetUpdatesPending(void);
  789.     PKeyBuffer __fastcall InitKeyBuffer(PKeyBuffer Buffer);
  790.     void __fastcall InitRecord(char * Buffer);
  791.     void __fastcall InternalClose(void);
  792.     void __fastcall InternalOpen(void);
  793.     bool __fastcall LocateRecord(const System::AnsiString KeyFields, const System::Variant &KeyValues, 
  794.         TLocateOptions Options, bool SyncCursor);
  795.     bool __fastcall MapsToIndex(Classes::TList* Fields, bool CaseInsensitive);
  796.     void __fastcall MoveBuffer(int CurIndex, int NewIndex);
  797.     void __fastcall PostKeyBuffer(bool Commit);
  798.     Word __fastcall PostRecord(void);
  799.     short __stdcall RecordFilter(void * RecBuf, int RecNo);
  800.     void __fastcall RemoveDataSource(TDataSource* DataSource);
  801.     void __fastcall RemoveField(TField* Field);
  802.     void __fastcall SetActive(bool Value);
  803.     void __fastcall SetBookmarkStr(const System::AnsiString Value);
  804.     void __fastcall SetBufferCount(int Value);
  805.     void __fastcall SetBufListSize(int Value);
  806.     void __fastcall SetCurrentRecord(int Index);
  807.     void __fastcall SetField(int Index, TField* Value);
  808.     void __fastcall SetFieldDefs(TFieldDefs* Value);
  809.     void __fastcall SetFieldValue(const System::AnsiString FieldName, const System::Variant &Value);
  810.     void __fastcall SetFilterData(const System::AnsiString Text, TFilterOptions Options);
  811.     void __fastcall SetFiltered(bool Value);
  812.     void __fastcall SetFilterHandle(Bde::hDBIFilter &Filter, Bde::hDBIFilter Value);
  813.     void __fastcall SetFilterOptions(TFilterOptions Value);
  814.     void __fastcall SetFilterText(const System::AnsiString Value);
  815.     void __fastcall SetOnFilterRecord(const TFilterRecordEvent Value);
  816.     void __fastcall SetOnUpdateError(TUpdateErrorEvent UpdateEvent);
  817.     void __fastcall SetState(TDataSetState Value);
  818.     void __fastcall UpdateBufferCount(void);
  819.     bool __fastcall UpdateCallbackRequired(void);
  820.     void __fastcall UpdateFieldDefs(void);
  821.     Bde::CBRType __fastcall YieldCallBack(void * CBInfo);
  822.     
  823. protected:
  824.     void __fastcall CheckInactive(void);
  825.     void __fastcall ClearBuffers(void);
  826.     virtual void __fastcall CloseCursor(void);
  827.     virtual Bde::hDBICur __fastcall CreateHandle(void);
  828.     virtual void __fastcall DataEvent(TDataEvent Event, long Info);
  829.     virtual void __fastcall DestroyHandle(void);
  830.     virtual void __fastcall DestroyLookupCursor(void);
  831.     virtual void __fastcall DoAfterCancel(void);
  832.     virtual void __fastcall DoAfterClose(void);
  833.     virtual void __fastcall DoAfterDelete(void);
  834.     virtual void __fastcall DoAfterEdit(void);
  835.     virtual void __fastcall DoAfterInsert(void);
  836.     virtual void __fastcall DoAfterOpen(void);
  837.     virtual void __fastcall DoAfterPost(void);
  838.     virtual void __fastcall DoBeforeCancel(void);
  839.     virtual void __fastcall DoBeforeClose(void);
  840.     virtual void __fastcall DoBeforeDelete(void);
  841.     virtual void __fastcall DoBeforeEdit(void);
  842.     virtual void __fastcall DoBeforeInsert(void);
  843.     virtual void __fastcall DoBeforeOpen(void);
  844.     virtual void __fastcall DoBeforePost(void);
  845.     virtual void __fastcall DoOnCalcFields(void);
  846.     virtual void __fastcall DoOnNewRecord(void);
  847.     virtual bool __fastcall GetCanModify(void);
  848.     virtual TDataSource* __fastcall GetDataSource(void);
  849.     TField* __fastcall GetIndexField(int Index);
  850.     int __fastcall GetIndexFieldCount(void);
  851.     PKeyBuffer __fastcall GetKeyBuffer(TKeyIndex KeyIndex);
  852.     bool __fastcall GetKeyExclusive(void);
  853.     int __fastcall GetKeyFieldCount(void);
  854.     virtual Bde::hDBICur __fastcall GetLookupCursor(const System::AnsiString KeyFields, bool CaseInsensitive
  855.         );
  856.     virtual long __fastcall GetRecordNumber(void);
  857.     virtual void __fastcall InitFieldDefs(void);
  858.     virtual void __fastcall Loaded(void);
  859.     virtual void __fastcall OpenCursor(void);
  860.     virtual void __fastcall PrepareCursor(void);
  861.     bool __fastcall ResetCursorRange(void);
  862.     bool __fastcall SetCursorRange(void);
  863.     void __fastcall SetIndexField(int Index, TField* Value);
  864.     void __fastcall SetKeyBuffer(TKeyIndex KeyIndex, bool Clear);
  865.     void __fastcall SetKeyExclusive(bool Value);
  866.     void __fastcall SetKeyFieldCount(int Value);
  867.     void __fastcall SetKeyFields(TKeyIndex KeyIndex, const System::TVarRec * Values, const int Values_Size
  868.         );
  869.     void __fastcall SetLinkRanges(Classes::TList* MasterFields);
  870.     void __fastcall SetLocale(void * Value);
  871.     virtual void __fastcall SetName(const System::AnsiString Value);
  872.     void __fastcall SwitchToIndex(const System::AnsiString IndexName, const System::AnsiString TagName)
  873.         ;
  874.     virtual void __fastcall GetChildren(Classes::TGetChildProc Proc);
  875.     virtual void __fastcall SetChildOrder(Classes::TComponent* Component, int Order);
  876.     __property bool InfoQueryMode = {read=FInfoQueryMode, nodefault};
  877.     void __fastcall SetCachedUpdates(bool Value);
  878.     void __fastcall SetupCallBack(bool Value);
  879.     Word __fastcall ProcessUpdates(Bde::DBIDelayedUpdCmd UpdCmd);
  880.     TUpdateRecordTypes __fastcall GetUpdateRecordSet(void);
  881.     void __fastcall SetUpdateRecordSet(TUpdateRecordTypes RecordTypes);
  882.     void __fastcall SetUpdateObject(TDataSetUpdateObject* Value);
  883.     bool __fastcall ForceUpdateCallback(void);
  884.     
  885. public:
  886.     __fastcall virtual TDataSet(Classes::TComponent* AOwner);
  887.     __fastcall virtual ~TDataSet(void);
  888.     char * __fastcall ActiveBuffer(void);
  889.     void __fastcall Append(void);
  890.     void __fastcall AppendRecord(const System::TVarRec * Values, const int Values_Size);
  891.     void __fastcall Cancel(void);
  892.     void __fastcall CheckBrowseMode(void);
  893.     void __fastcall ClearFields(void);
  894.     void __fastcall Close(void);
  895.     bool __fastcall ControlsDisabled(void);
  896.     void __fastcall CursorPosChanged(void);
  897.     void __fastcall Delete(void);
  898.     void __fastcall DisableControls(void);
  899.     void __fastcall Edit(void);
  900.     void __fastcall EnableControls(void);
  901.     void __fastcall FetchAll(void);
  902.     TField* __fastcall FieldByName(const System::AnsiString FieldName);
  903.     TField* __fastcall FindField(const System::AnsiString FieldName);
  904.     bool __fastcall FindFirst(void);
  905.     bool __fastcall FindLast(void);
  906.     bool __fastcall FindNext(void);
  907.     bool __fastcall FindPrior(void);
  908.     void __fastcall First(void);
  909.     void __fastcall FreeBookmark(void * Bookmark);
  910.     void * __fastcall GetBookmark(void);
  911.     bool __fastcall GetCurrentRecord(char * Buffer);
  912.     void __fastcall GetFieldList(Classes::TList* List, const System::AnsiString FieldNames);
  913.     void __fastcall GetFieldNames(Classes::TStrings* List);
  914.     void __fastcall GotoBookmark(void * Bookmark);
  915.     HIDESBASE void __fastcall Insert(void);
  916.     void __fastcall InsertRecord(const System::TVarRec * Values, const int Values_Size);
  917.     bool __fastcall IsLinkedTo(TDataSource* DataSource);
  918.     void __fastcall Last(void);
  919.     bool __fastcall Locate(const System::AnsiString KeyFields, const System::Variant &KeyValues, TLocateOptions 
  920.         Options);
  921.     System::Variant __fastcall Lookup(const System::AnsiString KeyFields, const System::Variant &KeyValues
  922.         , const System::AnsiString ResultFields);
  923.     int __fastcall MoveBy(int Distance);
  924.     void __fastcall Next(void);
  925.     void __fastcall Open(void);
  926.     void __fastcall Post(void);
  927.     void __fastcall Prior(void);
  928.     void __fastcall Refresh(void);
  929.     void __fastcall Resync(TResyncMode Mode);
  930.     void __fastcall SetFields(const System::TVarRec * Values, const int Values_Size);
  931.     void __fastcall SetDetailFields(Classes::TList* MasterFields);
  932.     void __fastcall UpdateCursorPos(void);
  933.     void __fastcall UpdateRecord(void);
  934.     void __fastcall ApplyUpdates(void);
  935.     void __fastcall CommitUpdates(void);
  936.     void __fastcall CancelUpdates(void);
  937.     void __fastcall RevertRecord(void);
  938.     TUpdateStatus __fastcall UpdateStatus(void);
  939.     __property bool Bof = {read=FBOF, nodefault};
  940.     __property System::AnsiString Bookmark = {read=GetBookmarkStr, write=SetBookmarkStr, nodefault};
  941.     __property bool CanModify = {read=GetCanModify, nodefault};
  942.     __property TDataSource* DataSource = {read=GetDataSource, nodefault};
  943.     __property bool DefaultFields = {read=FDefaultFields, nodefault};
  944.     __property TDataSetDesigner* Designer = {read=FDesigner, nodefault};
  945.     __property bool Eof = {read=FEOF, nodefault};
  946.     __property bool ExpIndex = {read=FExpIndex, nodefault};
  947.     __property int FieldCount = {read=GetFieldCount, nodefault};
  948.     __property TFieldDefs* FieldDefs = {read=FFieldDefs, write=SetFieldDefs, nodefault};
  949.     __property TField* Fields[int Index] = {read=GetField, write=SetField};
  950.     __property System::Variant FieldValues[System::AnsiString FieldName] = {read=GetFieldValue, write=SetFieldValue
  951.         /*, default*/};
  952.     __property bool Found = {read=FFound, nodefault};
  953.     __property Bde::hDBICur Handle = {read=FHandle, nodefault};
  954.     __property Word KeySize = {read=FKeySize, nodefault};
  955.     __property void * Locale = {read=FLocale, nodefault};
  956.     __property bool Modified = {read=FModified, nodefault};
  957.     __property long RecordCount = {read=GetRecordCount, nodefault};
  958.     __property long RecNo = {read=GetRecordNumber, nodefault};
  959.     __property Word RecordSize = {read=FRecordSize, nodefault};
  960.     __property TDataSetState State = {read=FState, nodefault};
  961.     __property TDataSetUpdateObject* UpdateObject = {read=FUpdateObject, write=SetUpdateObject, nodefault
  962.         };
  963.     __property TUpdateRecordTypes UpdateRecordTypes = {read=GetUpdateRecordSet, write=SetUpdateRecordSet
  964.         , nodefault};
  965.     __property bool UpdatesPending = {read=GetUpdatesPending, nodefault};
  966.     
  967. __published:
  968.     __property bool Active = {read=GetActive, write=SetActive, default=0};
  969.     __property bool AutoCalcFields = {read=FAutoCalcFields, write=FAutoCalcFields, default=1};
  970.     __property bool CachedUpdates = {read=FCachedUpdates, write=SetCachedUpdates, default=0};
  971.     __property System::AnsiString Filter = {read=FFilterText, write=SetFilterText, nodefault};
  972.     __property bool Filtered = {read=FFiltered, write=SetFiltered, default=0};
  973.     __property TFilterOptions FilterOptions = {read=FFilterOptions, write=SetFilterOptions, default=0};
  974.         
  975.     __property TDataSetNotifyEvent BeforeOpen = {read=FBeforeOpen, write=FBeforeOpen};
  976.     __property TDataSetNotifyEvent AfterOpen = {read=FAfterOpen, write=FAfterOpen};
  977.     __property TDataSetNotifyEvent BeforeClose = {read=FBeforeClose, write=FBeforeClose};
  978.     __property TDataSetNotifyEvent AfterClose = {read=FAfterClose, write=FAfterClose};
  979.     __property TDataSetNotifyEvent BeforeInsert = {read=FBeforeInsert, write=FBeforeInsert};
  980.     __property TDataSetNotifyEvent AfterInsert = {read=FAfterInsert, write=FAfterInsert};
  981.     __property TDataSetNotifyEvent BeforeEdit = {read=FBeforeEdit, write=FBeforeEdit};
  982.     __property TDataSetNotifyEvent AfterEdit = {read=FAfterEdit, write=FAfterEdit};
  983.     __property TDataSetNotifyEvent BeforePost = {read=FBeforePost, write=FBeforePost};
  984.     __property TDataSetNotifyEvent AfterPost = {read=FAfterPost, write=FAfterPost};
  985.     __property TDataSetNotifyEvent BeforeCancel = {read=FBeforeCancel, write=FBeforeCancel};
  986.     __property TDataSetNotifyEvent AfterCancel = {read=FAfterCancel, write=FAfterCancel};
  987.     __property TDataSetNotifyEvent BeforeDelete = {read=FBeforeDelete, write=FBeforeDelete};
  988.     __property TDataSetNotifyEvent AfterDelete = {read=FAfterDelete, write=FAfterDelete};
  989.     __property TDataSetNotifyEvent OnNewRecord = {read=FOnNewRecord, write=FOnNewRecord};
  990.     __property TDataSetNotifyEvent OnCalcFields = {read=FOnCalcFields, write=FOnCalcFields};
  991.     __property TFilterRecordEvent OnFilterRecord = {read=FOnFilterRecord, write=SetOnFilterRecord};
  992.     __property TOnServerYieldEvent OnServerYield = {read=FOnServerYield, write=FOnServerYield};
  993.     __property TUpdateErrorEvent OnUpdateError = {read=FOnUpdateError, write=SetOnUpdateError};
  994.     __property TUpdateRecordEvent OnUpdateRecord = {read=FOnUpdateRecord, write=FOnUpdateRecord};
  995.     __property TDataSetErrorEvent OnEditError = {read=FOnEditError, write=FOnEditError};
  996.     __property TDataSetErrorEvent OnPostError = {read=FOnPostError, write=FOnPostError};
  997.     __property TDataSetErrorEvent OnDeleteError = {read=FOnDeleteError, write=FOnDeleteError};
  998. };
  999.  
  1000. class __declspec(pascalimplementation) TDataSetDesigner : public System::TObject
  1001. {
  1002.     typedef System::TObject inherited;
  1003.     
  1004. private:
  1005.     TDataSet* FDataSet;
  1006.     bool FSaveActive;
  1007.     Byte FReserved;
  1008.     
  1009. public:
  1010.     __fastcall TDataSetDesigner(TDataSet* DataSet);
  1011.     __fastcall virtual ~TDataSetDesigner(void);
  1012.     void __fastcall BeginDesign(void);
  1013.     virtual void __fastcall DataEvent(TDataEvent Event, long Info);
  1014.     void __fastcall EndDesign(void);
  1015.     __property TDataSet* DataSet = {read=FDataSet, nodefault};
  1016. };
  1017.  
  1018. typedef System::TMetaClass*TFieldClass;
  1019.  
  1020. class __declspec(pascalimplementation) TFieldDef : public System::TObject
  1021. {
  1022.     typedef System::TObject inherited;
  1023.     
  1024. private:
  1025.     TFieldDefs* FOwner;
  1026.     System::AnsiString FName;
  1027.     TFieldType FDataType;
  1028.     bool FRequired;
  1029.     bool FBDECalcField;
  1030.     Word FSize;
  1031.     int FFieldNo;
  1032.     System::TMetaClass* __fastcall GetFieldClass(void);
  1033.     
  1034. public:
  1035.     __fastcall TFieldDef(TFieldDefs* Owner, const System::AnsiString Name, TFieldType DataType, Word Size
  1036.         , bool Required, int FieldNo);
  1037.     __fastcall virtual ~TFieldDef(void);
  1038.     TField* __fastcall CreateField(Classes::TComponent* Owner);
  1039.     __property bool BDECalcField = {read=FBDECalcField, nodefault};
  1040.     __property TFieldType DataType = {read=FDataType, nodefault};
  1041.     __property System::TMetaClass* FieldClass = {read=GetFieldClass, nodefault};
  1042.     __property int FieldNo = {read=FFieldNo, nodefault};
  1043.     __property System::AnsiString Name = {read=FName, nodefault};
  1044.     __property bool Required = {read=FRequired, nodefault};
  1045.     __property Word Size = {read=FSize, nodefault};
  1046. };
  1047.  
  1048. typedef void *TBookmark;
  1049.  
  1050. typedef System::AnsiString TBookmarkStr;
  1051.  
  1052. #pragma pack(push, 1)
  1053. struct DB_31
  1054. {
  1055.     
  1056. } ;
  1057. #pragma pack(pop)
  1058.  
  1059. struct TKeyBuffer
  1060. {
  1061.     bool Modified;
  1062.     bool Exclusive;
  1063.     int FieldCount;
  1064.     DB_31 Data;
  1065. } ;
  1066.  
  1067. struct TRecInfo;
  1068. typedef TRecInfo *PRecInfo;
  1069.  
  1070. struct TRecInfo
  1071. {
  1072.     TUpdateStatus UpdateStatus;
  1073.     long RecordNumber;
  1074. } ;
  1075.  
  1076. enum TUpdateMode { upWhereAll, upWhereChanged, upWhereKeyOnly };
  1077.  
  1078. typedef Set<Shortint, 0, 15>  TDBFlags;
  1079.  
  1080. class __declspec(pascalimplementation) TDBDataSet : public TDataSet
  1081. {
  1082.     typedef TDataSet inherited;
  1083.     
  1084. private:
  1085.     TDBFlags FDBFlags;
  1086.     TUpdateMode FUpdateMode;
  1087.     Byte FReserved;
  1088.     TDatabase* FDatabase;
  1089.     System::AnsiString FDatabaseName;
  1090.     System::AnsiString FSessionName;
  1091.     void __fastcall CheckDBSessionName(void);
  1092.     bool __fastcall GetDBFlag(int Flag);
  1093.     Bde::hDBIDb __fastcall GetDBHandle(void);
  1094.     void * __fastcall GetDBLocale(void);
  1095.     TSession* __fastcall GetDBSession(void);
  1096.     void __fastcall SetDatabaseName(const System::AnsiString Value);
  1097.     void __fastcall SetSessionName(const System::AnsiString Value);
  1098.     void __fastcall SetUpdateMode(const TUpdateMode Value);
  1099.     
  1100. protected:
  1101.     virtual void __fastcall CloseCursor(void);
  1102.     virtual void __fastcall Disconnect(void);
  1103.     virtual void __fastcall OpenCursor(void);
  1104.     virtual void __fastcall SetDBFlag(int Flag, bool Value);
  1105.     __property TDBFlags DBFlags = {read=FDBFlags, nodefault};
  1106.     __property TUpdateMode UpdateMode = {read=FUpdateMode, write=SetUpdateMode, default=0};
  1107.     
  1108. public:
  1109.     bool __fastcall CheckOpen(Word Status);
  1110.     __property TDatabase* Database = {read=FDatabase, nodefault};
  1111.     __property Bde::hDBIDb DBHandle = {read=GetDBHandle, nodefault};
  1112.     __property void * DBLocale = {read=GetDBLocale, nodefault};
  1113.     __property TSession* DBSession = {read=GetDBSession, nodefault};
  1114.     
  1115. __published:
  1116.     __property System::AnsiString DatabaseName = {read=FDatabaseName, write=SetDatabaseName, nodefault}
  1117.         ;
  1118.     __property System::AnsiString SessionName = {read=FSessionName, write=SetSessionName, nodefault};
  1119. public:
  1120.         
  1121.     /* TDataSet.Create */ __fastcall virtual TDBDataSet(Classes::TComponent* AOwner) : Db::TDataSet(AOwner
  1122.         ) { }
  1123.     /* TDataSet.Destroy */ __fastcall virtual ~TDBDataSet(void) { }
  1124.     
  1125. };
  1126.  
  1127. enum TFieldKind { fkData, fkCalculated, fkLookup };
  1128.  
  1129. typedef void __fastcall (__closure *TFieldNotifyEvent)(TField* Sender);
  1130.  
  1131. typedef void __fastcall (__closure *TFieldGetTextEvent)(TField* Sender,  System::AnsiString &Text, bool 
  1132.     DisplayText);
  1133.  
  1134. typedef void __fastcall (__closure *TFieldSetTextEvent)(TField* Sender, const System::AnsiString Text
  1135.     );
  1136.  
  1137. class __declspec(pascalimplementation) TField : public Classes::TComponent
  1138. {
  1139.     typedef Classes::TComponent inherited;
  1140.     
  1141. private:
  1142.     TDataSet* FDataSet;
  1143.     System::AnsiString FFieldName;
  1144.     TFieldType FDataType;
  1145.     bool FReadOnly;
  1146.     TFieldKind FFieldKind;
  1147.     TAlignment FAlignment;
  1148.     bool FVisible;
  1149.     bool FRequired;
  1150.     bool FValidating;
  1151.     Word FSize;
  1152.     Word FDataSize;
  1153.     int FFieldNo;
  1154.     Word FOffset;
  1155.     int FDisplayWidth;
  1156.     System::AnsiString FDisplayLabel;
  1157.     System::AnsiString FEditMask;
  1158.     void *FValueBuffer;
  1159.     TDataSet* FLookupDataSet;
  1160.     System::AnsiString FKeyFields;
  1161.     System::AnsiString FLookupKeyFields;
  1162.     System::AnsiString FLookupResultField;
  1163.     System::AnsiString FAttributeSet;
  1164.     TFieldNotifyEvent FOnChange;
  1165.     TFieldNotifyEvent FOnValidate;
  1166.     TFieldGetTextEvent FOnGetText;
  1167.     TFieldSetTextEvent FOnSetText;
  1168.     void __fastcall Bind(bool Binding);
  1169.     void __fastcall CalcLookupValue(void);
  1170.     bool __fastcall GetBDECalcField(void);
  1171.     bool __fastcall GetCalculated(void);
  1172.     System::AnsiString __fastcall GetDisplayLabel(void);
  1173.     System::AnsiString __fastcall GetDisplayName(void);
  1174.     System::AnsiString __fastcall GetDisplayText(void);
  1175.     int __fastcall GetDisplayWidth(void);
  1176.     System::AnsiString __fastcall GetEditText(void);
  1177.     int __fastcall GetIndex(void);
  1178.     bool __fastcall GetIsIndexField(void);
  1179.     bool __fastcall GetIsNull(void);
  1180.     bool __fastcall GetLookup(void);
  1181.     System::Variant __fastcall GetNewValue(void);
  1182.     System::Variant __fastcall GetOldValue(void);
  1183.     System::Variant __fastcall GetUpdateValue(TDataSetState ValueState);
  1184.     bool __fastcall IsDisplayLabelStored(void);
  1185.     bool __fastcall IsDisplayWidthStored(void);
  1186.     void __fastcall ReadAttributeSet(Classes::TReader* Reader);
  1187.     void __fastcall SetAlignment(Classes::TAlignment Value);
  1188.     void __fastcall SetCalculated(bool Value);
  1189.     void __fastcall SetDataSet(TDataSet* ADataSet);
  1190.     void __fastcall SetDisplayLabel( System::AnsiString Value);
  1191.     void __fastcall SetDisplayWidth(int Value);
  1192.     void __fastcall SetEditMask(const System::AnsiString Value);
  1193.     void __fastcall SetEditText(const System::AnsiString Value);
  1194.     void __fastcall SetFieldKind(TFieldKind Value);
  1195.     void __fastcall SetFieldName(const System::AnsiString Value);
  1196.     void __fastcall SetIndex(int Value);
  1197.     void __fastcall SetLookup(bool Value);
  1198.     void __fastcall SetLookupDataSet(TDataSet* Value);
  1199.     void __fastcall SetLookupKeyFields(const System::AnsiString Value);
  1200.     void __fastcall SetLookupResultField(const System::AnsiString Value);
  1201.     void __fastcall SetKeyFields(const System::AnsiString Value);
  1202.     void __fastcall SetNewValue(const System::Variant &Value);
  1203.     void __fastcall SetVisible(bool Value);
  1204.     void __fastcall UpdateDataSize(void);
  1205.     void __fastcall WriteAttributeSet(Classes::TWriter* Writer);
  1206.     
  1207. protected:
  1208.     void __fastcall AccessError(const System::AnsiString TypeName);
  1209.     void __fastcall CheckInactive(void);
  1210.     virtual void __fastcall Change(void);
  1211.     void __fastcall DataChanged(void);
  1212.     virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
  1213.     virtual void __fastcall FreeBuffers(void);
  1214.     virtual bool __fastcall GetAsBoolean(void);
  1215.     virtual System::Currency __fastcall GetAsCurrency(void);
  1216.     virtual System::TDateTime __fastcall GetAsDateTime(void);
  1217.     virtual double __fastcall GetAsFloat(void);
  1218.     virtual long __fastcall GetAsInteger(void);
  1219.     virtual System::AnsiString __fastcall GetAsString(void);
  1220.     virtual System::Variant __fastcall GetAsVariant(void);
  1221.     bool __fastcall GetCanModify(void);
  1222.     virtual int __fastcall GetDefaultWidth(void);
  1223.     virtual Classes::TComponent* __fastcall GetParentComponent(void);
  1224.     virtual void __fastcall GetText( System::AnsiString &Text, bool DisplayText);
  1225.     virtual bool __fastcall HasParent(void);
  1226.     virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation
  1227.         );
  1228.     void __fastcall PropertyChanged(bool LayoutAffected);
  1229.     virtual void __fastcall ReadState(Classes::TReader* Reader);
  1230.     virtual void __fastcall SetAsBoolean(bool Value);
  1231.     virtual void __fastcall SetAsCurrency(System::Currency Value);
  1232.     virtual void __fastcall SetAsDateTime(System::TDateTime Value);
  1233.     virtual void __fastcall SetAsFloat(double Value);
  1234.     virtual void __fastcall SetAsInteger(long Value);
  1235.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  1236.     virtual void __fastcall SetAsVariant(const System::Variant &Value);
  1237.     void __fastcall SetDataType(TFieldType Value);
  1238.     void __fastcall SetSize(Word Value);
  1239.     virtual void __fastcall SetParentComponent(Classes::TComponent* AParent);
  1240.     virtual void __fastcall SetText(const System::AnsiString Value);
  1241.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  1242.     
  1243. public:
  1244.     __fastcall virtual TField(Classes::TComponent* AOwner);
  1245.     __fastcall virtual ~TField(void);
  1246.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  1247.     void __fastcall AssignValue(const System::TVarRec &Value);
  1248.     virtual void __fastcall Clear(void);
  1249.     void __fastcall FocusControl(void);
  1250.     bool __fastcall GetData(void * Buffer);
  1251.     virtual bool __fastcall IsValidChar(char InputChar);
  1252.     void __fastcall SetData(void * Buffer);
  1253.     virtual void __fastcall SetFieldType(TFieldType Value);
  1254.     __property bool AsBoolean = {read=GetAsBoolean, write=SetAsBoolean, nodefault};
  1255.     __property System::Currency AsCurrency = {read=GetAsCurrency, write=SetAsCurrency};
  1256.     __property System::TDateTime AsDateTime = {read=GetAsDateTime, write=SetAsDateTime};
  1257.     __property double AsFloat = {read=GetAsFloat, write=SetAsFloat};
  1258.     __property long AsInteger = {read=GetAsInteger, write=SetAsInteger, nodefault};
  1259.     __property System::AnsiString AsString = {read=GetAsString, write=SetAsString, nodefault};
  1260.     __property System::Variant AsVariant = {read=GetAsVariant, write=SetAsVariant};
  1261.     __property System::AnsiString AttributeSet = {read=FAttributeSet, write=FAttributeSet, nodefault};
  1262.     __property bool BDECalcField = {read=GetBDECalcField, nodefault};
  1263.     __property bool CanModify = {read=GetCanModify, nodefault};
  1264.     __property TDataSet* DataSet = {read=FDataSet, write=SetDataSet, stored=false, nodefault};
  1265.     __property Word DataSize = {read=FDataSize, nodefault};
  1266.     __property TFieldType DataType = {read=FDataType, nodefault};
  1267.     __property System::AnsiString DisplayName = {read=GetDisplayName, nodefault};
  1268.     __property System::AnsiString DisplayText = {read=GetDisplayText, nodefault};
  1269.     __property System::AnsiString EditMask = {read=FEditMask, write=SetEditMask, nodefault};
  1270.     __property System::AnsiString EditMaskPtr = {read=FEditMask, nodefault};
  1271.     __property TFieldKind FieldKind = {read=FFieldKind, write=SetFieldKind, nodefault};
  1272.     __property int FieldNo = {read=FFieldNo, nodefault};
  1273.     __property bool IsIndexField = {read=GetIsIndexField, nodefault};
  1274.     __property bool IsNull = {read=GetIsNull, nodefault};
  1275.     __property Word Size = {read=FSize, write=SetSize, nodefault};
  1276.     __property System::AnsiString Text = {read=GetEditText, write=SetEditText, nodefault};
  1277.     __property System::Variant Value = {read=GetAsVariant, write=SetAsVariant};
  1278.     __property System::Variant NewValue = {read=GetNewValue, write=SetNewValue};
  1279.     __property System::Variant OldValue = {read=GetOldValue};
  1280.     
  1281. __published:
  1282.     __property Classes::TAlignment Alignment = {read=FAlignment, write=SetAlignment, default=0};
  1283.     __property bool Calculated = {read=GetCalculated, write=SetCalculated, default=0};
  1284.     __property System::AnsiString DisplayLabel = {read=GetDisplayLabel, write=SetDisplayLabel, stored=IsDisplayLabelStored
  1285.         , nodefault};
  1286.     __property int DisplayWidth = {read=GetDisplayWidth, write=SetDisplayWidth, stored=IsDisplayWidthStored
  1287.         , nodefault};
  1288.     __property System::AnsiString FieldName = {read=FFieldName, write=SetFieldName, nodefault};
  1289.     __property int Index = {read=GetIndex, write=SetIndex, stored=false, nodefault};
  1290.     __property bool Lookup = {read=GetLookup, write=SetLookup, default=0};
  1291.     __property TDataSet* LookupDataSet = {read=FLookupDataSet, write=SetLookupDataSet, nodefault};
  1292.     __property System::AnsiString LookupKeyFields = {read=FLookupKeyFields, write=SetLookupKeyFields, nodefault
  1293.         };
  1294.     __property System::AnsiString LookupResultField = {read=FLookupResultField, write=SetLookupResultField
  1295.         , nodefault};
  1296.     __property System::AnsiString KeyFields = {read=FKeyFields, write=SetKeyFields, nodefault};
  1297.     __property bool ReadOnly = {read=FReadOnly, write=FReadOnly, default=0};
  1298.     __property bool Required = {read=FRequired, write=FRequired, default=0};
  1299.     __property bool Visible = {read=FVisible, write=SetVisible, default=1};
  1300.     __property TFieldNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
  1301.     __property TFieldGetTextEvent OnGetText = {read=FOnGetText, write=FOnGetText};
  1302.     __property TFieldSetTextEvent OnSetText = {read=FOnSetText, write=FOnSetText};
  1303.     __property TFieldNotifyEvent OnValidate = {read=FOnValidate, write=FOnValidate};
  1304. };
  1305.  
  1306. //-- var, const, procedure ---------------------------------------------------
  1307. #define dsMaxBufferCount (Word)(1024)
  1308. #define dsMaxStringSize (Word)(8192)
  1309. #define smTraceBufSize (Word)(8199)
  1310. #define dbfOpened (Byte)(0)
  1311. #define dbfPrepared (Byte)(1)
  1312. #define dbfExecSQL (Byte)(2)
  1313. #define dbfTable (Byte)(3)
  1314. #define dbfFieldList (Byte)(4)
  1315. #define dbfIndexList (Byte)(5)
  1316. #define dbfStoredProc (Byte)(6)
  1317. #define dbfExecProc (Byte)(7)
  1318. #define dbfProcDesc (Byte)(8)
  1319. #define dsEditModes 0x1C
  1320. extern TSession* Session;
  1321. extern TSessionList* Sessions;
  1322. extern void __fastcall (*RegisterFieldsProc)(System::TMetaClass* const * FieldClassess, const int FieldClassess_Size
  1323.     );
  1324. extern void __fastcall RegisterBDEInitProc(const TBDEInitProc InitProc);
  1325. extern char * __fastcall AnsiToNative(void * Locale, const System::AnsiString AnsiStr, char * NativeStr
  1326.     , int MaxLen);
  1327. extern void __fastcall NativeToAnsi(void * Locale, char * NativeStr,  System::AnsiString &AnsiStr);
  1328. extern void __fastcall AnsiToNativeBuf(void * Locale, char * Source, char * Dest, int Len);
  1329. extern void __fastcall NativeToAnsiBuf(void * Locale, char * Source, char * Dest, int Len);
  1330. extern int __fastcall NativeCompareStr(void * Locale, const System::AnsiString S1, const System::AnsiString 
  1331.     S2, int Len);
  1332. extern int __fastcall NativeCompareStrBuf(void * Locale, char * const S1, char * const S2, int Len);
  1333.     
  1334. extern int __fastcall NativeCompareText(void * Locale, const System::AnsiString S1, const System::AnsiString 
  1335.     S2, int Len);
  1336. extern int __fastcall NativeCompareTextBuf(void * Locale, char * const S1, char * const S2, int Len)
  1337.     ;
  1338. extern System::AnsiString __fastcall ExtractFieldName(const System::AnsiString Fields, int &Pos);
  1339. extern void __fastcall RegisterFields(System::TMetaClass* const * FieldClasses, const int FieldClasses_Size
  1340.     );
  1341. extern void __fastcall DatabaseError(const System::AnsiString Message);
  1342. extern void __fastcall DBError(Word Ident);
  1343. extern void __fastcall DBErrorFmt(Word Ident, const System::TVarRec * Args, const int Args_Size);
  1344. extern void __fastcall DbiError(Word ErrorCode);
  1345. extern void __fastcall Check(Word Status);
  1346. extern void __fastcall finalization(void);
  1347. //-- template instantiations -------------------------------------------------
  1348. template class TDBFlags ;
  1349. template class TResyncMode ;
  1350. template class TUpdateRecordTypes ;
  1351. template class TLocateOptions ;
  1352. template class TFilterOptions ;
  1353. template class TTraceFlags ;
  1354.  
  1355. }    /* namespace Db */
  1356.  
  1357. #pragma warn .par
  1358. #pragma warn .hid 
  1359. #pragma warn .inl
  1360.  
  1361. #if !defined(NO_IMPLICIT_NAMESPACE_USE)
  1362. using namespace Db;
  1363. #endif
  1364. //-- end unit ----------------------------------------------------------------
  1365. #endif    // DB
  1366.