ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/public/ibx/branches/journaling/design/IBDBReg.pas
(Generate patch)

Comparing ibx/trunk/design/IBDBReg.pas (file contents):
Revision 1 by tony, Mon Jul 31 16:43:00 2000 UTC vs.
Revision 107 by tony, Thu Jan 18 14:37:40 2018 UTC

# Line 24 | Line 24
24   {       Corporation. All Rights Reserved.                                }
25   {    Contributor(s): Jeff Overcash                                       }
26   {                                                                        }
27 + {    IBX For Lazarus (Firebird Express)                                  }
28 + {    Contributor: Tony Whyman, MWA Software http://www.mwasoftware.co.uk }
29 + {    Portions created by MWA Software are copyright McCallum Whyman      }
30 + {    Associates Ltd 2011                                                 }
31   {************************************************************************}
32  
33   unit IBDBReg;
34  
35 + {$MODE Delphi}
36 +
37   (*
38   * Compiler defines
39   *)
40   {$A+}                           (* Aligned records: On *)
41   {$B-}                           (* Short circuit boolean expressions: Off *)
36 – {$G+}                           (* Imported data: On *)
42   {$H+}                           (* Huge Strings: On *)
43   {$J-}                           (* Modification of Typed Constants: Off *)
44   {$M+}                           (* Generate run-time type information: On *)
# Line 41 | Line 46 | unit IBDBReg;
46   {$Q-}                           (* Overflow checks: Off *)
47   {$R-}                           (* Range checks: Off *)
48   {$T+}                           (* Typed address: On *)
44 – {$U+}                           (* Pentim-safe FDIVs: On *)
49   {$W-}                           (* Always generate stack frames: Off *)
50   {$X+}                           (* Extended syntax: On *)
51   {$Z1}                           (* Minimum Enumeration Size: 1 Byte *)
52  
53   interface
54  
55 < uses Windows, SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
56 <     DsgnIntf, DB, ParentageSupport, dsndb, DBReg, ColnEdit, FldLinks, SQLEdit,
57 <     DataModelSupport, IBTable, IBDatabase, IBUpdateSQLEditor,  IBEventsEditor,
58 <     IBXConst;
55 > uses SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
56 >     DB, IBTable, IBDatabase,  IBEventsEditor,  LazarusPackageIntf,
57 >      IBUpdateSQL, IBUpdate, ComponentEditors, PropEdits, DBPropEdits, FieldsEditor,
58 >     dbFieldLinkPropEditor, dbFieldListPropEditor, IBDialogs;
59  
60   type
61  
# Line 79 | Line 83 | type
83      procedure GetValues(Proc: TGetStrProc); override;
84    end;
85  
86 +  { TIBPackageNameProperty
87 +    Editor for the TIBStoredProc.PackageName property.  Displays a drop-down list of all
88 +    the StoredProcedures in the Database.}
89 +  TIBPackageNameProperty = class(TIBNameProperty)
90 +  public
91 +    procedure GetValues(Proc: TGetStrProc); override;
92 +  end;
93 +
94    { TIBTableNameProperty
95      Editor for the TIBTable.TableName property.  Displays a drop-down list of all
96      the Tables in the Database.}
# Line 87 | Line 99 | type
99      procedure GetValues(Proc: TGetStrProc); override;
100    end;
101  
102 +  { TDBStringProperty }
103 +
104    TDBStringProperty = class(TStringProperty)
105 +  private
106 +    function ConnecttoDB: boolean;
107    public
108      function GetAttributes: TPropertyAttributes; override;
109      procedure GetValueList(List: TStrings); virtual;
110      procedure GetValues(Proc: TGetStrProc); override;
111 +    procedure Edit; override;
112    end;
113  
114 +  { TIBIndexFieldNamesProperty }
115 +
116    TIBIndexFieldNamesProperty = class(TDBStringProperty)
117    public
118      procedure GetValueList(List: TStrings); override;
# Line 121 | Line 140 | type
140      function GetVerbCount: Integer; override;
141    end;
142  
143 +  { TIBArrayGridEditor }
144 +
145 +  TIBArrayGridEditor = class(TComponentEditor)
146 +  public
147 +    procedure ExecuteVerb(Index: Integer); override;
148 +    function GetVerb(Index: Integer): string; override;
149 +    function GetVerbCount: Integer; override;
150 +  end;
151 +
152   { TIBQueryEditor }
153  
154 <  TIBQueryEditor = class(TDataSetEditor)
127 <  protected
128 <    FGetTableNamesProc: TGetTableNamesProc;
129 <    FGetFieldnamesProc: TGetFieldNamesProc;
154 >  TIBQueryEditor = class(TFieldsComponentEditor)
155    public
131 –    procedure EditSQL;
156      procedure ExecuteVerb(Index: Integer); override;
157      function GetVerb(Index: Integer): string; override;
158      function GetVerbCount: Integer; override;
# Line 136 | Line 160 | type
160  
161   { TIBStoredProcEditor }
162  
163 <  TIBStoredProcEditor = class(TDataSetEditor)
163 >  TIBStoredProcEditor = class(TFieldsComponentEditor)
164    public
165      procedure ExecuteVerb(Index: Integer); override;
166      function GetVerb(Index: Integer): string; override;
# Line 145 | Line 169 | type
169  
170   { TIBDataSetEditor }
171  
172 <  TIBDataSetEditor = class(TDataSetEditor)
149 <  protected
150 <    FGetTableNamesProc: TGetTableNamesProc;
151 <    FGetFieldnamesProc: TGetFieldNamesProc;
172 >  TIBDataSetEditor = class(TFieldsComponentEditor)
173    public
153 –    procedure EditSQL;
174      procedure ExecuteVerb(Index: Integer); override;
175      function GetVerb(Index: Integer): string; override;
176      function GetVerbCount: Integer; override;
# Line 165 | Line 185 | type
185     function GetVerbCount: Integer; override;
186    end;
187  
188 <  TIBStoredProcParamsProperty = class(TCollectionProperty)
188 > { TIBSQLEditor }
189 >
190 >  TIBSQLEditor  = class(TComponentEditor)
191    public
192 <    procedure Edit; override;
192 >    procedure ExecuteVerb(Index: Integer); override;
193 >    function GetVerb(Index: Integer): string; override;
194 >   function GetVerbCount: Integer; override;
195    end;
196  
197 + { TIBServiceEditor}
198 +
199 +  TIBServiceEditor = class(TComponentEditor)
200 +  public
201 +    procedure ExecuteVerb(Index: Integer); override;
202 +    function GetVerb(Index: Integer): string; override;
203 +   function GetVerbCount: Integer; override;
204 +  end;
205 +
206 +  TIBStoredProcParamsProperty = class(TCollectionPropertyEditor)
207 +  end;
208 +
209 +  { TIBTableFieldLinkProperty }
210 +
211    TIBTableFieldLinkProperty = class(TFieldLinkProperty)
212    private
213      FTable: TIBTable;
214    protected
215 +    function GetIndexDefs: TIndexDefs; override;
216      function GetIndexFieldNames: string; override;
217      function GetMasterFields: string; override;
218      procedure SetIndexFieldNames(const Value: string); override;
# Line 184 | Line 223 | type
223  
224   { TSQLPropertyEditor }
225  
226 <  TSQLPropertyEditor = class(TClassProperty)
188 <  protected
189 <    FGetTableNamesProc: TGetTableNamesProc;
190 <    FGetFieldnamesProc: TGetFieldNamesProc;
226 >  TSQLPropertyEditor = class(TStringsPropertyEditor)
227    public
192 –    procedure EditSQL;
228      function GetAttributes: TPropertyAttributes; override;
229    end;
230  
# Line 200 | Line 235 | type
235      procedure Edit; override;
236    end;
237  
238 + {TIBSQLSQLPropertyEditor }
239 +
240 +  TIBSQLSQLPropertyEditor = class(TSQLPropertyEditor)
241 +  public
242 +    procedure Edit; override;
243 +  end;
244 +
245   { TIBDatasetSQLProperty }
246  
247    TIBDatasetSQLProperty = class(TSQLPropertyEditor)
# Line 214 | Line 256 | type
256      procedure Edit; override;
257    end;
258  
259 <  TIBEventListProperty = class(TClassProperty)
259 > { TUpdateSQLPropertyEditor }
260 >
261 >   TUpdateSQLPropertyEditor = class(TSQLPropertyEditor)
262 >   protected
263 >     FIBUpdateSQL: TIBUpdateSQL;
264 >     FDatabase: TIBDatabase;
265 >     function GetObjects: boolean;
266 >   end;
267 >
268 > { TIBUpdateSQLProperty }
269 >
270 >  TIBUpdateSQLProperty = class(TSQLPropertyEditor)
271    public
219 –    function GetAttributes: TPropertyAttributes; override;
272      procedure Edit; override;
273    end;
274  
275 < { DataModel Designer stuff }
275 > { TIBRefreshSQLProperty }
276  
277 <  TIBSQLSprig = class(TSprig)
277 >  TIBRefreshSQLProperty = class(TSQLPropertyEditor)
278    public
279 <    procedure FigureParent; override;
228 <    function AnyProblems: Boolean; override;
229 <    function DragDropTo(AItem: TSprig): Boolean; override;
230 <    function DragOverTo(AItem: TSprig): Boolean; override;
231 <    class function PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean; override;
279 >    procedure Edit; override;
280    end;
281  
282 <  TIBCustomDataSetSprig = class(TDataSetSprig)
235 <  public
236 <    procedure FigureParent; override;
237 <    function AnyProblems: Boolean; override;
238 <    function DragDropTo(AItem: TSprig): Boolean; override;
239 <    function DragOverTo(AItem: TSprig): Boolean; override;
240 <    class function PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean; override;
241 <  end;
282 > { TIBInsertSQLProperty }
283  
284 <  TIBQuerySprig = class(TIBCustomDataSetSprig)
284 >  TIBInsertSQLProperty = class(TSQLPropertyEditor)
285    public
286 <    function AnyProblems: Boolean; override;
286 >    procedure Edit; override;
287    end;
288  
289 <  TIBTableSprig = class(TIBCustomDataSetSprig)
289 > { TIBDeleteSQLProperty }
290 >
291 >  TIBDeleteSQLProperty = class(TSQLPropertyEditor)
292    public
293 <    function AnyProblems: Boolean; override;
251 <    function Caption: string; override;
293 >    procedure Edit; override;
294    end;
295  
296 <  TIBStoredProcSprig = class(TIBCustomDataSetSprig)
296 >  { TIBUpdateSQLUpdateProperty }
297 >
298 >  TIBUpdateSQLUpdateProperty = class(TUpdateSQLPropertyEditor)
299    public
300 <    function AnyProblems: Boolean; override;
257 <    function Caption: string; override;
300 >    procedure Edit; override;
301    end;
302  
303 <  TIBUpdateSQLSprig = class(TSprigAtRoot)
303 > { TIBUpdateSQLRefreshSQLProperty }
304 >
305 >  TIBUpdateSQLRefreshSQLProperty = class(TUpdateSQLPropertyEditor)
306    public
307 <    function AnyProblems: Boolean; override;
307 >    procedure Edit; override;
308    end;
309  
310 <  TIBDatabaseSprig = class(TSprigAtRoot)
310 > { TIBUpdateSQLInsertSQLProperty }
311 >
312 >  TIBUpdateSQLInsertSQLProperty = class(TUpdateSQLPropertyEditor)
313    public
314 <    function AnyProblems: Boolean; override;
268 <    function Caption: string; override;
314 >    procedure Edit; override;
315    end;
316  
317 <  TIBTransactionSprig = class(TSprig)
317 >  { TIBUpdateSQLDeleteProperty }
318 >
319 >  TIBUpdateSQLDeleteProperty = class(TUpdateSQLPropertyEditor)
320    public
321 <    function Caption: string; override;
322 <    procedure FigureParent; override;
275 <    function AnyProblems: Boolean; override;
276 <    function DragDropTo(AItem: TSprig): Boolean; override;
277 <    function DragOverTo(AItem: TSprig): Boolean; override;
278 <    class function PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean; override;
321 >    function GetAttributes: TPropertyAttributes; override;
322 >    procedure Edit; override;
323    end;
324  
325 <  TIBDatabaseInfoSprig = class(TSprig)
325 > { TIBEventListProperty }
326 >
327 >  TIBEventListProperty = class(TClassProperty)
328    public
329 <    class function ParentProperty: string; override;
329 >    function GetAttributes: TPropertyAttributes; override;
330 >    procedure Edit; override;
331    end;
332  
333 <  TIBEventsSprig = class(TSprig)
333 > {TIBGeneratorProperty}
334 >
335 >  TIBGeneratorProperty = class(TPersistentPropertyEditor)
336    public
337 <    class function ParentProperty: string; override;
338 <    function AnyProblems: Boolean; override;
337 >    function GetAttributes: TPropertyAttributes; override;
338 >    procedure Edit; override;
339    end;
340  
341 <  TIBTransactionIsland = class(TIsland)
341 >  { TDBDynamicGridFieldProperty }
342 >
343 >  TDBDynamicGridFieldProperty = class(TFieldProperty)
344    public
345 <    function VisibleTreeParent: Boolean; override;
345 >    procedure FillValues(const Values: TStringList); override;
346    end;
347  
348 <  TIBSQLIsland = class(TIsland)
348 >  { TDBLookupPropertiesGridFieldProperty }
349 >
350 >  TDBLookupPropertiesGridFieldProperty = class(TFieldProperty)
351    public
352 <    function VisibleTreeParent: Boolean; override;
352 >    procedure FillValues(const Values: TStringList); override;
353    end;
354  
355 <  TIBCustomDataSetIsland = class(TDataSetIsland)
355 >  { TIBTreeViewFieldProperty }
356 >
357 >  TIBTreeViewFieldProperty = class(TFieldProperty)
358    public
359 <    function VisibleTreeParent: Boolean; override;
359 >    procedure FillValues(const Values: TStringList); override;
360    end;
361  
362 <  TIBTableIsland = class(TIBCustomDataSetIsland)
362 >  { TIBDynamicGridIndexNamesProperty }
363 >
364 >  TIBDynamicGridIndexNamesProperty = class(TIndexFieldNamesProperty)
365 >  protected
366 >    function GetFieldDefs: TFieldDefs; override;
367 >    function GetIndexFieldNames: string; override;
368 >    procedure SetIndexFieldNames(const Value: string); override;
369    end;
370  
371 <  TIBTableMasterDetailBridge = class(TMasterDetailBridge)
371 >  { TIBFieldDefsProperty }
372 >
373 >  TIBFieldDefsProperty = class(TCollectionPropertyEditor)
374    public
375 <    function CanEdit: Boolean; override;
313 <    class function OmegaIslandClass: TIslandClass; override;
314 <    class function GetOmegaSource(AItem: TPersistent): TDataSource; override;
315 <    class procedure SetOmegaSource(AItem: TPersistent; ADataSource: TDataSource); override;
316 <    function Caption: string; override;
317 <    function Edit: Boolean; override;
375 >    procedure Edit; override;
376    end;
377  
378 <  TIBQueryIsland = class(TIBCustomDataSetIsland)
321 <  end;
378 >  { TIBIndexDefsProperty }
379  
380 <  TIBQueryMasterDetailBridge = class(TMasterDetailBridge)
380 >  TIBIndexDefsProperty = class(TCollectionPropertyEditor)
381    public
382 <    class function RemoveMasterFieldsAsWell: Boolean; override;
326 <    class function OmegaIslandClass: TIslandClass; override;
327 <    class function GetOmegaSource(AItem: TPersistent): TDataSource; override;
328 <    class procedure SetOmegaSource(AItem: TPersistent; ADataSource: TDataSource); override;
329 <    function Caption: string; override;
382 >    procedure Edit; override;
383    end;
384  
385 +
386   procedure Register;
387  
388   implementation
389  
390 < uses IB, IBQuery, IBStoredProc, IBUpdateSQL, IBCustomDataSet,
391 <     IBIntf, IBSQL, IBSQLMonitor, IBDatabaseInfo, IBEvents,
392 <     IBServices, IBInstall, IBDatabaseEdit, IBTransactionEdit,
393 <     IBBatchMove, DBLogDlg;
390 > uses IB, IBQuery, IBStoredProc, IBCustomDataSet, FBMessages,
391 >     IBSQL, IBSQLMonitor, IBDatabaseInfo, IBEvents, IBTypes,
392 >     IBServices, IBDatabaseEdit, IBTransactionEdit,
393 >     IBBatchMove, IBExtract,LResources, IBSelectSQLEditor,
394 >     IBModifySQLEditor,IBDeleteSQLEditor,IBRefreshSQLEditor,
395 >     IBInsertSQLEditor, IBGeneratorEditor, IBUpdateSQLEditor, IBDataSetEditor,
396 >     IBSQLEditor, ibserviceeditor, LCLVersion, IBDynamicGrid, IBLookupComboEditBox,
397 >     IBTreeView, DBControlGrid, ibxscript, IBLocalDBSupport, IBDSDialogs,
398 >     IBArrayGrid, IBVersion, IBDataOutput;
399 >
400 > const
401 >  IBPalette1 = 'Firebird'; {do not localize}
402 >  IBPalette2 = 'Firebird Admin'; {do not localize}
403 >  IBPalette3 = 'Firebird Data Controls';   {do not localize}
404 >  
405 > resourcestring
406 >   SInterbaseExpressVersion = 'Firebird Express for Lazarus ' + IBX_VERSION;
407 >   SEditSQL = 'Edit SQL';
408 >   SIBSQLEditor = 'IBSQL Editor';
409 >   SIBServiceEditor = 'Edit IB Service';
410 >   SIBUpdateSQLEditor = '&UpdateSQL Editor...';
411 >   SIBDataSetEditor = '&Dataset Editor...';
412 >   SExecute = 'E&xecute';
413 >   SIBDatabaseEditor = 'Da&tabase Editor...';
414 >   SIBTransactionEditor = '&Transaction Editor...';
415 >   SIBUpdateLayout = 'Update Layout';
416  
417   procedure Register;
418   begin
419 <  RegisterComponents(IBPalette1, [TIBTable, TIBQuery,
420 <    TIBStoredProc, TIBDatabase, TIBTransaction, TIBUpdateSQL,
421 <    TIBDataSet, TIBSQL, TIBDatabaseInfo, TIBSQLMonitor, TIBEvents]);
422 < {$IFDEF IB6_ONLY}
423 <  if (TryIBLoad) and (GetIBClientVersion >= 6) then
419 >  if not TryIBLoad then
420 >  begin
421 >    MessageDlg('IBX is unable to locate the Firebird Library - have you remembered to install it?',mtError,[mbOK],0);
422 >    Exit;
423 >  end;
424 >
425 >  RegisterNoIcon([TIBStringField, TIBBCDField, TIBMemoField, TIBArrayField,
426 >    TIBSmallintField, TIBIntegerField, TIBLargeIntField]);
427 >  {$if lcl_fullversion < 01010000}
428 >  {see http://bugs.freepascal.org/view.php?id=19035 }
429 >  RegisterNoIcon([TIntegerField]);
430 >  {$endif}
431 >  RegisterComponents(IBPalette1, [ TIBQuery, TIBDataSet,
432 >   TIBDatabase, TIBTransaction, TIBUpdateSQL, TIBUpdate, TIBEvents,
433 >     TIBSQL, TIBDatabaseInfo, TIBSQLMonitor,
434 >       TIBStoredProc,TIBBatchMove,  TIBTable,TIBExtract, TIBXScript, TIBLocalDBSupport,
435 >       TIBBlockFormatOut,TIBCSVDataOut,TIBInsertStmtsOut]);
436 >  if FirebirdAPI.HasServiceAPI  then
437      RegisterComponents(IBPalette2, [TIBConfigService, TIBBackupService,
438        TIBRestoreService, TIBValidationService, TIBStatisticalService,
439 <      TIBLogService, TIBSecurityService, TIBServerProperties,
440 <      TIBInstall, TIBUninstall]);
441 < {$ENDIF}
442 <  RegisterClasses([TIBStringField, TIBBCDField]);
354 <  RegisterFields([TIBStringField, TIBBCDField]);
439 >      TIBLogService, TIBSecurityService, TIBServerProperties]);
440 >
441 >
442 >  RegisterComponents(IBPalette3,[TIBLookupComboEditBox,TIBDynamicGrid,TIBTreeView,TDBControlGrid, TIBArrayGrid]);
443    RegisterPropertyEditor(TypeInfo(TIBFileName), TIBDatabase, 'DatabaseName', TIBFileNameProperty); {do not localize}
444    RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'StoredProcName', TIBStoredProcNameProperty); {do not localize}
445 +  RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'PackageName', TIBPackageNameProperty); {do not localize}
446    RegisterPropertyEditor(TypeInfo(TParams), TIBStoredProc, 'Params', TIBStoredProcParamsProperty);
447    RegisterPropertyEditor(TypeInfo(string), TIBTable, 'TableName', TIBTableNameProperty); {do not localize}
448    RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexName', TIBIndexNameProperty); {do not localize}
449    RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexFieldNames', TIBIndexFieldNamesProperty); {do not localize}
450    RegisterPropertyEditor(TypeInfo(string), TIBTable, 'MasterFields', TIBTableFieldLinkProperty); {do not localize}
451 +  RegisterPropertyEditor(TypeInfo(TFieldDefs), TIBTable, 'FieldDefs', TIBFieldDefsProperty); {do not localize}
452 +  RegisterPropertyEditor(TypeInfo(TIndexDefs), TIBTable, 'IndexDefs', TIBIndexDefsProperty); {do not localize}
453    RegisterPropertyEditor(TypeInfo(TStrings), TIBQuery, 'SQL', TIBQuerySQLProperty); {do not localize}
454    RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'SelectSQL', TIBDatasetSQLProperty); {do not localize}
455 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLProperty); {do not localize}
455 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'ModifySQL', TIBUpdateSQLProperty); {do not localize}
456 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'InsertSQL', TIBInsertSQLProperty); {do not localize}
457 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'RefreshSQL', TIBRefreshSQLProperty); {do not localize}
458 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'DeleteSQL', TIBDeleteSQLProperty); {do not localize}
459 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLSQLPropertyEditor); {do not localize}
460 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'RefreshSQL', TIBUpdateSQLRefreshSQLProperty); {do not localize}
461 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'ModifySQL', TIBUpdateSQLUpdateProperty); {do not localize}
462 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'InsertSQL', TIBUpdateSQLInsertSQLProperty); {do not localize}
463 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'DeleteSQL', TIBUpdateSQLDeleteProperty); {do not localize}
464    RegisterPropertyEditor(TypeInfo(TStrings), TIBEvents, 'Events', TIBEventListProperty); {do not localize}
465 +  RegisterPropertyEditor(TypeInfo(TPersistent), TIBDataSet, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
466 +  RegisterPropertyEditor(TypeInfo(TPersistent), TIBQuery, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
467 +  RegisterPropertyEditor(TypeInfo(TPersistent), TIBTable, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
468  
469    RegisterComponentEditor(TIBDatabase, TIBDatabaseEditor);
470    RegisterComponentEditor(TIBTransaction, TIBTransactionEditor);
# Line 370 | Line 472 | begin
472    RegisterComponentEditor(TIBDataSet, TIBDataSetEditor);
473    RegisterComponentEditor(TIBQuery, TIBQueryEditor);
474    RegisterComponentEditor(TIBStoredProc, TIBStoredProcEditor);
475 +  RegisterComponentEditor(TIBSQL, TIBSQLEditor);
476 +  RegisterComponentEditor(TIBCustomService, TIBServiceEditor);
477 +  RegisterComponentEditor(TIBArrayGrid, TIBArrayGridEditor);
478 +
479  
480 <  RegisterSprigType(TIBDatabase, TIBDatabaseSprig);
481 <  RegisterSprigType(TIBTransaction, TIBTransactionSprig);
480 >  {Firebird Data Access Controls}
481 >  RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'KeyField', TDBDynamicGridFieldProperty);
482 >  RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'ListField', TDBDynamicGridFieldProperty);
483 >  RegisterPropertyEditor(TypeInfo(string), TIBDynamicGrid, 'IndexFieldNames', TIBDynamicGridIndexNamesProperty);
484 >  RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'DataFieldName', TDBLookupPropertiesGridFieldProperty);
485 >  RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'KeyField', TIBTreeViewFieldProperty);
486 >  RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'TextField', TIBTreeViewFieldProperty);
487 >  RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'ParentField', TIBTreeViewFieldProperty);
488 >  RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'HasChildField', TIBTreeViewFieldProperty);
489  
490 <  RegisterSprigType(TIBDatabaseInfo, TIBDatabaseInfoSprig);
491 <  RegisterSprigType(TIBEvents, TIBEventsSprig);
379 <  RegisterSprigType(TIBSQL, TIBSQLSprig);
380 <
381 <  RegisterSprigType(TIBUpdateSQL, TIBUpdateSQLSprig);
382 <
383 <  RegisterSprigType(TIBCustomDataSet, TIBCustomDataSetSprig);
384 <  RegisterSprigType(TIBQuery, TIBQuerySprig);
385 <  RegisterSprigType(TIBTable, TIBTableSprig);
386 <  RegisterSprigType(TIBStoredProc, TIBStoredProcSprig);
387 <
388 <  RegisterIslandType(TIBTransactionSprig, TIBTransactionIsland);
389 <  RegisterIslandType(TIBSQLSprig, TIBSQLIsland);
390 <  RegisterIslandType(TIBCustomDataSetSprig, TIBCustomDataSetIsland);
391 <  RegisterIslandType(TIBTableSprig, TIBTableIsland);
392 <  RegisterIslandType(TIBQuerySprig, TIBQueryIsland);
490 >  IBGUIInterface :=  TIBDSLCLInterface.Create;
491 > end;
492  
493 <  RegisterBridgeType(TDataSetIsland, TIBTableIsland, TIBTableMasterDetailBridge);
494 <  RegisterBridgeType(TDataSetIsland, TIBQueryIsland, TIBQueryMasterDetailBridge);
493 > procedure LoadDataSourceFields(DataSource: TDataSource; List: TStrings);
494 > var
495 >  DataSet: TDataSet;
496 >  i: Integer;
497 > begin
498 >  if Assigned(DataSource) then
499 >  begin
500 >    DataSet := DataSource.DataSet;
501 >    if Assigned(DataSet) then
502 >    begin
503 >      if DataSet.Fields.Count > 0 then
504 >        DataSet.GetFieldNames(List)
505 >      else
506 >      begin
507 >        DataSet.FieldDefs.Update;
508 >        for i := 0 to DataSet.FieldDefs.Count - 1 do
509 >          List.Add(DataSet.FieldDefs[i].Name);
510 >      end;
511 >    end;
512 >  end;
513 > end;
514 >
515 > { TIBPackageNameProperty }
516 >
517 > procedure TIBPackageNameProperty.GetValues(Proc: TGetStrProc);
518 > var
519 >   StoredProc : TIBStoredProc;
520 >   i : integer;
521 > begin
522 >    StoredProc := GetComponent(0) as TIBStoredProc;
523 >    if StoredProc.Database = nil then
524 >      Exit;
525 >
526 >    with StoredProc do
527 >    try
528 >      for I := 0 to PackageNames.Count - 1 do
529 >        Proc (PackageNames[i]);
530 >    except on E: Exception do
531 >      MessageDlg(E.Message,mtError,[mbOK],0)
532 >    end;
533 > end;
534 >
535 > { TIBIndexDefsProperty }
536 >
537 > procedure TIBIndexDefsProperty.Edit;
538 > var IndexDefs: TIndexDefs;
539 > begin
540 >  IndexDefs := TIndexDefs(GetObjectValue);
541 >  if IndexDefs <> nil then
542 >    IndexDefs.Update;
543 >  inherited Edit;
544 > end;
545 >
546 > { TIBFieldDefsProperty }
547 >
548 > procedure TIBFieldDefsProperty.Edit;
549 > var FieldDefs: TFieldDefs;
550 > begin
551 >  FieldDefs := TFieldDefs(GetObjectValue);
552 >  if FieldDefs <> nil then
553 >    FieldDefs.Update;
554 >  inherited Edit;
555 > end;
556 >
557 > { TIBArrayGridEditor }
558 >
559 > procedure TIBArrayGridEditor.ExecuteVerb(Index: Integer);
560 > begin
561 >  if Index < inherited GetVerbCount then
562 >    inherited ExecuteVerb(Index)
563 >  else
564 >  case Index of
565 >    0: TIBArrayGrid(Component).UpdateLayout;
566 >  end;
567 > end;
568 >
569 > function TIBArrayGridEditor.GetVerb(Index: Integer): string;
570 > begin
571 >  if Index < inherited GetVerbCount then
572 >    Result := inherited GetVerb(Index) else
573 >  begin
574 >    Dec(Index, inherited GetVerbCount);
575 >    case Index of
576 >      0: Result := SIBUpdateLayout;
577 >      1 : Result := SInterbaseExpressVersion ;
578 >    end;
579 >  end;
580 > end;
581 >
582 > function TIBArrayGridEditor.GetVerbCount: Integer;
583 > begin
584 >  Result := 2;
585 > end;
586 >
587 > { TDBLookupPropertiesGridFieldProperty }
588 >
589 > procedure TDBLookupPropertiesGridFieldProperty.FillValues(
590 >  const Values: TStringList);
591 > var
592 >  P: TDBLookupProperties;
593 > begin
594 >  P :=TDBLookupProperties(GetComponent(0));
595 >  if not (P is TDBLookupProperties) then exit;
596 >  LoadDataSourceFields(TIBDynamicGrid(P.Owner.Grid).DataSource, Values);
597 > end;
598 >
599 > { TIBTreeViewFieldProperty }
600 >
601 > procedure TIBTreeViewFieldProperty.FillValues(const Values: TStringList);
602 > var ListSource: TDataSource;
603 > begin
604 >  ListSource :=  TIBTreeView(GetComponent(0)).DataSource;
605 >  LoadDataSourceFields(ListSource, Values);
606 > end;
607 >
608 > { TIBDynamicGridIndexNamesProperty }
609 >
610 > function TIBDynamicGridIndexNamesProperty.GetFieldDefs: TFieldDefs;
611 > var Grid: TIBDynamicGrid;
612 > begin
613 >  Result := nil;
614 >  Grid := TIBDynamicGrid(GetComponent(0));
615 >  if assigned(Grid.DataSource) and assigned(Grid.DataSource.DataSet) then
616 >     Result := Grid.DataSource.DataSet.FieldDefs
617 > end;
618 >
619 > function TIBDynamicGridIndexNamesProperty.GetIndexFieldNames: string;
620 > var Grid: TIBDynamicGrid;
621 > begin
622 >  Grid := TIBDynamicGrid(GetComponent(0));
623 >  Result := Grid.IndexFieldNames
624 > end;
625 >
626 > procedure TIBDynamicGridIndexNamesProperty.SetIndexFieldNames(
627 >  const Value: string);
628 > var Grid: TIBDynamicGrid;
629 > begin
630 >  Grid := TIBDynamicGrid(GetComponent(0));
631 >  Grid.IndexFieldNames := Value
632 > end;
633 >
634 > { TDBDynamicGridFieldProperty }
635 >
636 > procedure TDBDynamicGridFieldProperty.FillValues(const Values: TStringList);
637 > var
638 >  P: TDBLookupProperties;
639 > begin
640 >  P :=TDBLookupProperties(GetComponent(0));
641 >  if not (P is TDBLookupProperties) then exit;
642 >  LoadDataSourceFields(P.ListSource, Values);
643 > end;
644 >
645 > { TIBServiceEditor }
646 >
647 > procedure TIBServiceEditor.ExecuteVerb(Index: Integer);
648 > begin
649 >  if Index < inherited GetVerbCount then
650 >    inherited ExecuteVerb(Index) else
651 >  begin
652 >    Dec(Index, inherited GetVerbCount);
653 >    case Index of
654 >      0 : if ibserviceeditor.EditIBService(TIBCustomService(Component)) then Designer.Modified;
655 >    end;
656 >  end;
657 > end;
658 >
659 > function TIBServiceEditor.GetVerb(Index: Integer): string;
660 > begin
661 >  if Index < inherited GetVerbCount then
662 >    Result := inherited GetVerb(Index) else
663 >  begin
664 >    Dec(Index, inherited GetVerbCount);
665 >    case Index of
666 >      0: Result := SIBServiceEditor;
667 >      1 : Result := SInterbaseExpressVersion;
668 >    end;
669 >  end;
670 > end;
671 >
672 > function TIBServiceEditor.GetVerbCount: Integer;
673 > begin
674 >  Result := inherited GetVerbCount + 2;
675   end;
676  
677   { TIBFileNameProperty }
# Line 401 | Line 680 | begin
680    with TOpenDialog.Create(Application) do
681      try
682        InitialDir := ExtractFilePath(GetStrValue);
683 <      Filter := 'Database Files|*.gdb'; {do not localize}
683 >      Filter := SDatabaseFilter; {do not localize}
684        if Execute then
685          SetStrValue(FileName);
686      finally
# Line 429 | Line 708 | var
708     i : integer;
709   begin
710      StoredProc := GetComponent(0) as TIBStoredProc;
711 +    if StoredProc.Database = nil then
712 +      Exit;
713 +
714      with StoredProc do
715 +    try
716        for I := 0 to StoredProcedureNames.Count - 1 do
717          Proc (StoredProcedureNames[i]);
718 +    except on E: Exception do
719 +      MessageDlg(E.Message,mtError,[mbOK],0)
720 +    end;
721   end;
722  
723   { TIBTableNameProperty }
724  
725   procedure TIBTableNameProperty.GetValues(Proc: TGetStrProc);
726   var
727 <   TableName : TIBTable;
727 >   Table : TIBTable;
728     i : integer;
729   begin
730 <  TableName := GetComponent(0) as TIBTable;
731 <  with TableName do
730 >  Table := GetComponent(0) as TIBTable;
731 >   if Table.Database = nil then
732 >      Exit;
733 >  with Table do
734      for I := 0 to TableNames.Count - 1 do
735        Proc (TableNames[i]);
736   end;
737  
738   { TDBStringProperty }
739  
740 + function TDBStringProperty.ConnecttoDB: boolean;
741 + var DataSet: TIBCustomDataSet;
742 + begin
743 +  Result := false;
744 +  DataSet := (GetComponent(0) as TIBCustomDataSet);
745 +  if assigned(Dataset.Database) then
746 +  begin
747 +    try
748 +      DataSet.Database.Connected := true;
749 +    except on E: Exception do
750 +      ShowMessage(E.Message)
751 +    end;
752 +    Result := DataSet.Database.Connected
753 +  end;
754 + end;
755 +
756   function TDBStringProperty.GetAttributes: TPropertyAttributes;
757   begin
758    Result := [paValueList, paSortList, paMultiSelect];
# Line 463 | Line 767 | var
767    I: Integer;
768    Values: TStringList;
769   begin
770 +  if not ConnecttoDB then Exit;
771    Values := TStringList.Create;
772    try
773      GetValueList(Values);
# Line 472 | Line 777 | begin
777    end;
778   end;
779  
780 + procedure TDBStringProperty.Edit;
781 + begin
782 +  if ConnecttoDB then
783 +    inherited Edit;
784 + end;
785 +
786   { Utility Functions }
787  
788   function GetPropertyValue(Instance: TPersistent; const PropName: string): TPersistent;
# Line 521 | Line 832 | end;
832  
833   { TSQLPropertyEditor }
834  
524 – procedure TSQLPropertyEditor.EditSQL;
525 – var
526 –  SQLText: string;
527 –  SQL: TStrings;
528 – begin
529 –  SQL := TStringList.Create;
530 –  try
531 –    SQL.Assign(TStrings(GetOrdValue));
532 –    SQLText := SQL.Text;
533 –    if (SQLEdit.EditSQL(SQLText, FGetTableNamesProc, FGetFieldNamesProc)) and
534 –      (SQL.Text <> SQLText) then
535 –    begin
536 –      SQL.Text := SQLText;
537 –      SetOrdValue(LongInt(SQL));
538 –    end;
539 –  finally
540 –    SQL.free;
541 –  end;
542 – end;
543 –
835   function TSQLPropertyEditor.GetAttributes: TPropertyAttributes;
836   begin
837 <  Result := inherited GetAttributes + [paDialog] - [paSubProperties];
837 >  Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
838   end;
839  
840   { TIBQuerySQLProperty }
# Line 552 | Line 843 | procedure TIBQuerySQLProperty.Edit;
843   var
844    Query: TIBQuery;
845   begin
846 <  Query := TIBQuery(GetComponent(0));
847 <  if Assigned(Query.Database) then
557 <  begin
558 <    FGetTableNamesProc := Query.Database.GetTableNames;
559 <    FGetFieldNamesProc := Query.Database.GetFieldNames;
560 <  end
561 <  else
562 <  begin
563 <    FGetTableNamesProc := nil;
564 <    FGetFieldNamesProc := nil;
565 <  end;
566 <  EditSQL;
846 >  Query := GetComponent(0) as TIBQuery;
847 >  if IBSelectSQLEditor.EditSQL(Query,Query.SQL) then Modified;
848   end;
849  
850   { TIBDatasetSQLProperty }
# Line 572 | Line 853 | procedure TIBDatasetSQLProperty.Edit;
853   var
854    IBDataset: TIBDataset;
855   begin
856 <  IBDataset := TIBDataset(GetComponent(0));
857 <  if Assigned(IBDataSet.Database) then
577 <  begin
578 <    FGetTableNamesProc := IBDataset.Database.GetTableNames;
579 <    FGetFieldNamesProc := IBDataset.Database.GetFieldNames;
580 <  end
581 <  else
582 <  begin
583 <    FGetTableNamesProc := nil;
584 <    FGetFieldNamesProc := nil;
585 <  end;
586 <  EditSQL;
856 >  IBDataset := GetComponent(0) as TIBDataset;
857 >  if IBSelectSQLEditor.EditSQL(IBDataSet,IBDataSet.SelectSQL) then Modified;
858   end;
859  
860   { TIBSQLProperty }
# Line 592 | Line 863 | procedure TIBSQLProperty.Edit;
863   var
864    IBSQL: TIBSQL;
865   begin
866 <  IBSQL := TIBSQL(GetComponent(0));
867 <  if Assigned(IBSQL.Database) then
597 <  begin
598 <    FGetTableNamesProc := IBSQL.Database.GetTableNames;
599 <    FGetFieldNamesProc := IBSQL.Database.GetFieldNames;
600 <  end
601 <  else
602 <  begin
603 <    FGetTableNamesProc := nil;
604 <    FGetFieldNamesProc := nil;
605 <  end;
606 <  EditSQL;
866 >  IBSQL := GetComponent(0) as TIBSQL;
867 >  if IBSQLEditor.EditSQL(IBSQL) then Modified;
868   end;
869  
870   { TIBUpdateSQLEditor }
871  
872   procedure TIBUpdateSQLEditor.ExecuteVerb(Index: Integer);
873   begin
874 <  if EditIBUpdateSQL(TIBUpdateSQL(Component)) then Designer.Modified;
874 >  if IBUpdateSQLEditor.EditIBUpdateSQL(TIBUpdateSQL(Component)) then Modified;
875   end;
876  
877   function TIBUpdateSQLEditor.GetVerb(Index: Integer): string;
878   begin
879    case Index of
880      0 : Result := SIBUpdateSQLEditor;
881 <    2: Result := SInterbaseExpressVersion;
881 >    1: Result := SInterbaseExpressVersion ;
882    end;
883   end;
884  
885   function TIBUpdateSQLEditor.GetVerbCount: Integer;
886   begin
887 <  Result := 2;
887 >  Result :=  2;
888   end;
889  
890   { TIBDataSetEditor }
891  
631 – procedure TIBDataSetEditor.EditSQL;
632 – var
633 –  SQLText: string;
634 –  SQL: TStrings;
635 – begin
636 –  SQL := TStringList.Create;
637 –  try
638 –    SQL.Assign(TIBDataset(Component).SelectSQL);
639 –    SQLText := SQL.Text;
640 –    if (SQLEdit.EditSQL(SQLText, FGetTableNamesProc, FGetFieldNamesProc)) and
641 –      (SQL.Text <> SQLText) then
642 –    begin
643 –      SQL.Text := SQLText;
644 –      TIBDataset(Component).SelectSQL.Assign(SQL);
645 –    end;
646 –  finally
647 –    SQL.free;
648 –  end;
649 – end;
650 –
892   procedure TIBDataSetEditor.ExecuteVerb(Index: Integer);
652 – var
653 –  IBDataset: TIBDataset;
893   begin
894    if Index < inherited GetVerbCount then
895      inherited ExecuteVerb(Index) else
# Line 658 | Line 897 | begin
897      Dec(Index, inherited GetVerbCount);
898      case Index of
899        0:
900 <        if EditIBDataSet(TIBDataSet(Component)) then
900 >        if IBDataSetEditor.EditIBDataSet(TIBDataSet(Component)) then
901            Designer.Modified;
902        1: (Component as TIBDataSet).ExecSQL;
664 –      2:
665 –      begin
666 –        IBDataset := TIBDataset(Component);
667 –        if Assigned(IBDataSet.Database) then
668 –        begin
669 –          FGetTableNamesProc := IBDataset.Database.GetTableNames;
670 –          FGetFieldNamesProc := IBDataset.Database.GetFieldNames;
671 –        end
672 –        else
673 –        begin
674 –          FGetTableNamesProc := nil;
675 –          FGetFieldNamesProc := nil;
676 –        end;
677 –        EditSQL;
678 –      end;
903      end;
904    end;
905   end;
# Line 689 | Line 913 | begin
913      case Index of
914        0: Result := SIBDataSetEditor;
915        1: Result := SExecute;
916 <      2: Result := SEditSQL;
693 <      3: Result := SInterbaseExpressVersion;
916 >      2: Result := SInterbaseExpressVersion ;
917      end;
918    end;
919   end;
920  
921   function TIBDataSetEditor.GetVerbCount: Integer;
922   begin
923 <  Result := inherited GetVerbCount + 4;
923 >  Result := inherited GetVerbCount + 3;
924   end;
925  
926   { TIBEventListProperty }
927  
928   function TIBEventListProperty.GetAttributes: TPropertyAttributes;
929   begin
930 <  Result := inherited GetAttributes + [paDialog] - [paSubProperties];
930 >  Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
931   end;
932  
933   procedure TIBEventListProperty.Edit;
934   var
935    Events: TStrings;
936 +  IBEvents: TIBEvents;
937   begin
938 +  IBEvents := GetComponent(0) as TIBEvents;
939    Events := TStringList.Create;
940    try
941 <    Events.Assign( TStrings(GetOrdValue));
942 <    if EditAlerterEvents( Events) then SetOrdValue( longint(Events));
941 >    Events.Assign( IBEvents.Events);
942 >    if EditAlerterEvents( Events) then
943 >    begin
944 >      IBEvents.Events.Assign(Events);
945 >      Modified
946 >    end;
947    finally
948      Events.Free;
949    end;
# Line 741 | Line 970 | begin
970      Dec(Index, inherited GetVerbCount);
971      case Index of
972        0: Result := SIBDatabaseEditor;
973 <      1 : Result := SInterbaseExpressVersion;
973 >      1 : Result := SInterbaseExpressVersion ;
974      end;
975    end;
976   end;
# Line 764 | Line 993 | function TIBTransactionEditor.GetVerb(In
993   begin
994    case Index of
995      0: Result := SIBTransactionEditor;
996 <    1: Result := SInterbaseExpressVersion;
996 >    1: Result := SInterbaseExpressVersion ;
997    end;
998   end;
999  
# Line 775 | Line 1004 | end;
1004  
1005   { TIBQueryEditor }
1006  
778 – procedure TIBQueryEditor.EditSQL;
779 – var
780 –  SQLText: string;
781 –  SQL: TStrings;
782 – begin
783 –  SQL := TStringList.Create;
784 –  try
785 –    SQL.Assign(TIBQuery(Component).SQL);
786 –    SQLText := SQL.Text;
787 –    if (SQLEdit.EditSQL(SQLText, FGetTableNamesProc, FGetFieldNamesProc)) and
788 –      (SQL.Text <> SQLText) then
789 –    begin
790 –      SQL.Text := SQLText;
791 –      TIBQuery(Component).SQL.Assign(SQL);
792 –    end;
793 –  finally
794 –    SQL.free;
795 –  end;
796 – end;
797 –
1007   procedure TIBQueryEditor.ExecuteVerb(Index: Integer);
1008   var
1009    Query: TIBQuery;
# Line 806 | Line 1015 | begin
1015      Dec(Index, inherited GetVerbCount);
1016      case Index of
1017        0: Query.ExecSQL;
1018 <      1:
810 <      begin
811 <        if Assigned(Query.Database) then
812 <        begin
813 <          FGetTableNamesProc := Query.Database.GetTableNames;
814 <          FGetFieldNamesProc := Query.Database.GetFieldNames;
815 <        end
816 <        else
817 <        begin
818 <          FGetTableNamesProc := nil;
819 <          FGetFieldNamesProc := nil;
820 <        end;
821 <        EditSQL;
822 <      end;
1018 >      1: if ibselectsqleditor.EditSQL(Query,Query.SQL) then Designer.Modified;
1019      end;
1020    end;
1021   end;
# Line 833 | Line 1029 | begin
1029      case Index of
1030        0: Result := SExecute;
1031        1: Result := SEditSQL;
1032 <      2: Result := SInterbaseExpressVersion;
1032 >      2: Result := SInterbaseExpressVersion ;
1033      end;
1034    end;
1035   end;
# Line 863 | Line 1059 | begin
1059      Dec(Index, inherited GetVerbCount);
1060      case Index of
1061        0: Result := SExecute;
1062 <      1: Result := SInterbaseExpressVersion;
1062 >      1: Result := SInterbaseExpressVersion ;
1063      end;
1064    end;
1065   end;
# Line 873 | Line 1069 | begin
1069    Result := inherited GetVerbCount + 2;
1070   end;
1071  
876 – { TIBStoredProcParamsProperty }
877 –
878 – procedure TIBStoredProcParamsProperty.Edit;
879 – var
880 –  StoredProc: TIBStoredProc;
881 –  Params: TParams;
882 – begin
883 –  StoredProc := (GetComponent(0) as TIBStoredProc);
884 –  Params := TParams.Create(nil);
885 –  try
886 –    StoredProc.CopyParams(Params);
887 –  finally
888 –    Params.Free;
889 –  end;
890 –  inherited Edit;
891 – end;
892 –
1072   { TIBTableFieldLinkProperty }
1073  
1074   procedure TIBTableFieldLinkProperty.Edit;
1075   begin
1076    FTable := DataSet as TIBTable;
1077 +  if assigned(FTable.Database) then
1078 +    FTable.Database.Connected := true;
1079    inherited Edit;
1080   end;
1081  
1082 + function TIBTableFieldLinkProperty.GetIndexDefs: TIndexDefs;
1083 + begin
1084 +  Result :=  FTable.IndexDefs
1085 + end;
1086 +
1087   function TIBTableFieldLinkProperty.GetIndexFieldNames: string;
1088   begin
1089    Result := FTable.IndexFieldNames;
# Line 918 | Line 1104 | begin
1104    FTable.MasterFields := Value;
1105   end;
1106  
1107 < { TIBDatabaseSprig }
922 <
923 < function TIBDatabaseSprig.AnyProblems: Boolean;
924 < begin
925 <  Result := (TIBDatabase(Item).DatabaseName = '') or
926 <            (TIBDatabase(Item).DefaultTransaction = nil);
927 < end;
928 <
929 < function TIBDatabaseSprig.Caption: string;
930 < begin
931 <  Result := CaptionFor(TIBDatabase(Item).DatabaseName, UniqueName);
932 < end;
933 <
934 < { TIBTransactionSprig }
935 <
936 < function TIBTransactionSprig.AnyProblems: Boolean;
937 < begin
938 <  Result := TIBTransaction(Item).DefaultDatabase = nil;
939 < end;
940 <
941 < function TIBTransactionSprig.Caption: string;
942 < begin
943 <  if (TIBTransaction(Item).DefaultDatabase <> nil) and
944 <     (TIBTransaction(Item).DefaultDatabase.DefaultTransaction = Item) then
945 <    Result := CaptionFor(Format(SDefaultTransaction, [UniqueName]))
946 <  else
947 <    Result := inherited Caption;
948 < end;
949 <
950 < procedure TIBTransactionSprig.FigureParent;
951 < begin
952 <  SeekParent(TIBTransaction(Item).DefaultDatabase).Add(Self);
953 < end;
954 <
955 < function TIBTransactionSprig.DragDropTo(AItem: TSprig): Boolean;
956 < begin
957 <  Result := False;
958 <  if AItem is TIBDatabaseSprig then
959 <  begin
960 <    Result := TIBDatabase(AItem.Item) <> TIBTransaction(Item).DefaultDatabase;
961 <    if Result then
962 <    begin
963 <      TIBTransaction(Item).DefaultDatabase := TIBDatabase(AItem.Item);
964 <      TIBDatabase(AItem.Item).DefaultTransaction := TIBTransaction(Item);
965 <    end;
966 <  end
967 < end;
968 <
969 < function TIBTransactionSprig.DragOverTo(AItem: TSprig): Boolean;
970 < begin
971 <  Result := (AItem is TIBDatabaseSprig);
972 < end;
1107 > { TIBUpdateSQLProperty }
1108  
1109 < class function TIBTransactionSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
1109 > procedure TIBUpdateSQLProperty.Edit;
1110 > var
1111 >  IBDataset: TIBDataset;
1112   begin
1113 <  Result := (AParent is TIBDatabaseSprig);
1113 >  IBDataset := GetComponent(0) as TIBDataset;
1114 >  if IBModifySQLEditor.EditSQL(IBDataSet,IBDataSet.ModifySQL) then Modified;
1115   end;
1116  
1117 < { support stuff for sprigs }
1117 > { TIBUpdateSQLUpdateProperty }
1118  
1119 < function IBAnyProblems(ATransaction: TIBTransaction; ADatabase: TIBDatabase): Boolean;
1119 > procedure TIBUpdateSQLUpdateProperty.Edit;
1120   begin
1121 <  Result := (ATransaction = nil) or
1122 <            (ADatabase = nil) or
985 <            (ATransaction.DefaultDatabase <> ADatabase);
1121 >  GetObjects;
1122 >  if IBModifySQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.ModifySQL) then Modified;
1123   end;
1124  
1125 < procedure IBFigureParent(ASprig: TSprig; ATransaction: TIBTransaction; ADatabase: TIBDatabase);
989 < begin
990 <  if ATransaction <> nil then
991 <    ASprig.SeekParent(ATransaction).Add(ASprig)
992 <  else if ADatabase <> nil then
993 <    ASprig.SeekParent(ADatabase).Add(ASprig)
994 <  else
995 <    ASprig.Root.Add(ASprig);
996 < end;
1125 > { TIBRefreshSQLProperty }
1126  
1127 < function IBDragOver(ASprig: TSprig): Boolean;
999 < begin
1000 <  Result := (ASprig is TIBTransactionSprig) or
1001 <            (ASprig is TIBDatabaseSprig);
1002 < end;
1003 <
1004 < function IBDropOver(AParent: TSprig; var ATransaction: TIBTransaction; var ADatabase: TIBDatabase): Boolean;
1127 > procedure TIBRefreshSQLProperty.Edit;
1128   var
1129 <  vParentTransaction: TIBTransaction;
1007 <  vParentDatabase: TIBDatabase;
1129 >  IBDataset: TIBDataset;
1130   begin
1131 <  Result := False;
1132 <  if AParent is TIBTransactionSprig then
1011 <  begin
1012 <    vParentTransaction := TIBTransaction(AParent.Item);
1013 <    Result := vParentTransaction <> ATransaction;
1014 <    if Result then
1015 <      ATransaction := vParentTransaction;
1016 <    if (vParentTransaction.DefaultDatabase = nil) or
1017 <       (ADatabase <> vParentTransaction.DefaultDatabase) then
1018 <    begin
1019 <      Result := True;
1020 <      ADatabase := vParentTransaction.DefaultDatabase;
1021 <    end;
1022 <  end else if AParent is TIBDatabaseSprig then
1023 <  begin
1024 <    vParentDatabase := TIBDatabase(AParent.Item);
1025 <    Result := vParentDatabase <> ADatabase;
1026 <    if Result then
1027 <      ADatabase := vParentDatabase;
1028 <    if (vParentDatabase.DefaultTransaction = nil) or
1029 <       (ATransaction <> vParentDatabase.DefaultTransaction) then
1030 <    begin
1031 <      Result := True;
1032 <      ATransaction := vParentDatabase.DefaultTransaction;
1033 <    end;
1034 <  end;
1131 >  IBDataset := GetComponent(0) as TIBDataset;
1132 >  if IBRefreshSQLEditor.EditSQL(IBDataSet,IBDataSet.RefreshSQL) then Modified;
1133   end;
1134  
1135 < { TIBSQLSprig }
1135 > { TIBUpdateSQLRefreshSQLProperty }
1136  
1137 < function TIBSQLSprig.AnyProblems: Boolean;
1137 > procedure TIBUpdateSQLRefreshSQLProperty.Edit;
1138   begin
1139 <  Result := IBAnyProblems(TIBSQL(Item).Transaction,
1140 <                          TIBSQL(Item).Database) or
1043 <            (TIBSQL(Item).SQL.Count = 0);
1139 >  GetObjects;
1140 >  if IBRefreshSQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.RefreshSQL) then Modified;
1141   end;
1142  
1143 < function TIBSQLSprig.DragDropTo(AItem: TSprig): Boolean;
1143 > { TIBDeleteSQLProperty }
1144 >
1145 > procedure TIBDeleteSQLProperty.Edit;
1146   var
1147 <  vTransaction: TIBTransaction;
1049 <  vDatabase: TIBDatabase;
1147 >  IBDataset: TIBDataSet;
1148   begin
1149 <  with TIBSQL(Item) do
1150 <  begin
1053 <    vTransaction := Transaction;
1054 <    vDatabase := Database;
1055 <    Result := IBDropOver(AItem, vTransaction, vDatabase);
1056 <    if Result then
1057 <    begin
1058 <      Transaction := vTransaction;
1059 <      Database := vDatabase;
1060 <    end;
1061 <  end;
1149 >  IBDataset := GetComponent(0) as TIBDataSet;
1150 >  if IBDeleteSQLEditor.EditSQL(IBDataSet,IBDataSet.DeleteSQL) then Modified;
1151   end;
1152  
1153 < function TIBSQLSprig.DragOverTo(AItem: TSprig): Boolean;
1065 < begin
1066 <  Result := IBDragOver(AItem);
1067 < end;
1153 > { TIBUpdateSQLDeleteProperty }
1154  
1155 < procedure TIBSQLSprig.FigureParent;
1155 > function TIBUpdateSQLDeleteProperty.GetAttributes: TPropertyAttributes;
1156   begin
1157 <  IBFigureParent(Self, TIBSQL(Item).Transaction,
1072 <                       TIBSQL(Item).Database);
1157 >  Result:=inherited GetAttributes;
1158   end;
1159  
1160 < class function TIBSQLSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
1160 > procedure TIBUpdateSQLDeleteProperty.Edit;
1161   begin
1162 <  Result := IBDragOver(AParent);
1162 >  GetObjects;
1163 >  if IBDeleteSQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.DeleteSQL) then Modified;
1164   end;
1165  
1166 < { TIBCustomDataSetSprig }
1166 > { TUpdateSQLPropertyEditor }
1167  
1168 < function TIBCustomDataSetSprig.AnyProblems: Boolean;
1168 > function TUpdateSQLPropertyEditor.GetObjects: boolean;
1169   begin
1170 <  Result := IBAnyProblems(TIBCustomDataSet(Item).Transaction,
1171 <                          TIBCustomDataSet(Item).Database);
1172 < end;
1173 <
1174 < procedure TIBCustomDataSetSprig.FigureParent;
1175 < begin
1090 <  IBFigureParent(Self, TIBCustomDataSet(Item).Transaction,
1091 <                       TIBCustomDataSet(Item).Database);
1092 < end;
1093 <
1094 < function TIBCustomDataSetSprig.DragDropTo(AItem: TSprig): Boolean;
1095 < var
1096 <  vTransaction: TIBTransaction;
1097 <  vDatabase: TIBDatabase;
1098 < begin
1099 <  with TIBCustomDataSet(Item) do
1170 >  Result := false;
1171 >  FIBUpdateSQL := GetComponent(0) as TIBUpdateSQL;
1172 >  if not assigned(FIBUpdateSQL) or not assigned(FIBUpdateSQL.DataSet) then
1173 >    Exit;
1174 >  FDatabase := nil;
1175 >  if FIBUpdateSQL.DataSet is TIBQuery then
1176    begin
1177 <    vTransaction := Transaction;
1178 <    vDatabase := Database;
1103 <    Result := IBDropOver(AItem, vTransaction, vDatabase);
1104 <    if Result then
1105 <    begin
1106 <      Transaction := vTransaction;
1107 <      Database := vDatabase;
1108 <    end;
1177 >    FDatabase := (FIBUpdateSQL.DataSet as TIBQuery).Database;
1178 >    Result := true
1179    end;
1180   end;
1181  
1182 < function TIBCustomDataSetSprig.DragOverTo(AItem: TSprig): Boolean;
1113 < begin
1114 <  Result := IBDragOver(AItem);
1115 < end;
1116 <
1117 < class function TIBCustomDataSetSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
1118 < begin
1119 <  Result := IBDragOver(AParent);
1120 < end;
1121 <
1122 < { TIBStoredProcSprig }
1123 <
1124 < function TIBStoredProcSprig.AnyProblems: Boolean;
1125 < begin
1126 <  Result := inherited AnyProblems or
1127 <            (TIBStoredProc(Item).StoredProcName = '');
1128 < end;
1129 <
1130 < function TIBStoredProcSprig.Caption: string;
1131 < begin
1132 <  Result := CaptionFor(TIBStoredProc(Item).StoredProcName, UniqueName);
1133 < end;
1134 <
1135 < { TIBTableSprig }
1136 <
1137 < function TIBTableSprig.AnyProblems: Boolean;
1138 < begin
1139 <  Result := inherited AnyProblems or
1140 <            (TIBTable(Item).TableName = '');
1141 < end;
1182 > { TIBInsertSQLProperty }
1183  
1184 < function TIBTableSprig.Caption: string;
1144 < begin
1145 <  Result := CaptionFor(TIBTable(Item).TableName, UniqueName);
1146 < end;
1147 <
1148 < { TIBQuerySprig }
1149 <
1150 < function TIBQuerySprig.AnyProblems: Boolean;
1151 < begin
1152 <  Result := inherited AnyProblems or
1153 <            (TIBQuery(Item).SQL.Count = 0);
1154 < end;
1155 <
1156 < { TIBDatabaseInfoSprig }
1157 <
1158 < class function TIBDatabaseInfoSprig.ParentProperty: string;
1159 < begin
1160 <  Result := 'Database'; { do not localize }
1161 < end;
1162 <
1163 < { TIBUpdateSQLSprig }
1164 <
1165 < function TIBUpdateSQLSprig.AnyProblems: Boolean;
1166 < begin
1167 <  with TIBUpdateSQL(Item) do
1168 <    Result := (ModifySQL.Count = 0) and
1169 <              (InsertSQL.Count = 0) and
1170 <              (DeleteSQL.Count = 0) and
1171 <              (RefreshSQL.Count = 0);
1172 < end;
1173 <
1174 < { TIBEventsSprig }
1175 <
1176 < function TIBEventsSprig.AnyProblems: Boolean;
1177 < begin
1178 <  Result := inherited AnyProblems or
1179 <            (TIBEvents(Item).Events.Count = 0);
1180 < end;
1181 <
1182 < class function TIBEventsSprig.ParentProperty: string;
1183 < begin
1184 <  Result := 'Database'; { do not localize }
1185 < end;
1186 <
1187 < { TIBTableMasterDetailBridge }
1188 <
1189 < function TIBTableMasterDetailBridge.CanEdit: Boolean;
1190 < begin
1191 <  Result := True;
1192 < end;
1193 <
1194 < function TIBTableMasterDetailBridge.Caption: string;
1195 < begin
1196 <  if TIBTable(Omega.Item).MasterFields = '' then
1197 <    Result := SNoMasterFields
1198 <  else
1199 <    Result := TIBTable(Omega.Item).MasterFields;
1200 < end;
1201 <
1202 < function TIBTableMasterDetailBridge.Edit: Boolean;
1184 > procedure TIBInsertSQLProperty.Edit;
1185   var
1186 <  vPropEd: TIBTableFieldLinkProperty;
1205 < begin
1206 <  vPropEd := TIBTableFieldLinkProperty.CreateWith(TDataSet(Omega.Item));
1207 <  try
1208 <    vPropEd.Edit;
1209 <    Result := vPropEd.Changed;
1210 <  finally
1211 <    vPropEd.Free;
1212 <  end;
1213 < end;
1214 <
1215 < class function TIBTableMasterDetailBridge.GetOmegaSource(
1216 <  AItem: TPersistent): TDataSource;
1186 >  IBDataset: TIBDataSet;
1187   begin
1188 <  Result := TIBTable(AItem).MasterSource;
1188 >  IBDataset := GetComponent(0) as TIBDataSet;
1189 >  if IBInsertSQLEditor.EditSQL(IBDataSet,IBDataSet.InsertSQL) then Modified;
1190   end;
1191  
1192 < class function TIBTableMasterDetailBridge.OmegaIslandClass: TIslandClass;
1222 < begin
1223 <  Result := TIBTableIsland;
1224 < end;
1192 > { TIBUpdateSQLInsertSQLProperty }
1193  
1194 < class procedure TIBTableMasterDetailBridge.SetOmegaSource(
1227 <  AItem: TPersistent; ADataSource: TDataSource);
1194 > procedure TIBUpdateSQLInsertSQLProperty.Edit;
1195   begin
1196 <  TIBTable(AItem).MasterSource := ADataSource;
1196 >  GetObjects;
1197 >  if IBInsertSQLEditor.EditSQL(FIBUpdateSQL.Dataset,FIBUpdateSQL.InsertSQL) then Modified;
1198   end;
1199  
1200 < { TIBQueryMasterDetailBridge }
1233 <
1234 < function TIBQueryMasterDetailBridge.Caption: string;
1235 < begin
1236 <  Result := SParamsFields;
1237 < end;
1200 > { TIBGeneratorProperty }
1201  
1202 < class function TIBQueryMasterDetailBridge.GetOmegaSource(
1240 <  AItem: TPersistent): TDataSource;
1202 > function TIBGeneratorProperty.GetAttributes: TPropertyAttributes;
1203   begin
1204 <  Result := TIBQuery(AItem).DataSource;
1204 >  Result:= inherited GetAttributes + [paDialog] - [paMultiSelect,paValueList];
1205   end;
1206  
1207 < class function TIBQueryMasterDetailBridge.OmegaIslandClass: TIslandClass;
1207 > procedure TIBGeneratorProperty.Edit;
1208   begin
1209 <  Result := TIBQueryIsland;
1209 >  if IBGeneratorEditor.EditGenerator(GetPersistentReference as TIBGenerator) then Modified;
1210   end;
1211  
1212 < class function TIBQueryMasterDetailBridge.RemoveMasterFieldsAsWell: Boolean;
1251 < begin
1252 <  Result := False;
1253 < end;
1212 > { TIBSQLEditor }
1213  
1214 < class procedure TIBQueryMasterDetailBridge.SetOmegaSource(
1256 <  AItem: TPersistent; ADataSource: TDataSource);
1214 > procedure TIBSQLEditor.ExecuteVerb(Index: Integer);
1215   begin
1216 <  TIBQuery(AItem).DataSource := ADataSource;
1216 >  if IBSQLEditor.EditSQL(TIBSQL(Component)) then Modified;
1217   end;
1218  
1219 < { TIBCustomDataSetIsland }
1262 <
1263 < function TIBCustomDataSetIsland.VisibleTreeParent: Boolean;
1219 > function TIBSQLEditor.GetVerb(Index: Integer): string;
1220   begin
1221 <  Result := False;
1221 >  case Index of
1222 >    0 : Result := SIBSQLEditor;
1223 >    1: Result := SInterbaseExpressVersion ;
1224 >  end;
1225   end;
1226  
1227 < { TIBSQLIsland }
1269 <
1270 < function TIBSQLIsland.VisibleTreeParent: Boolean;
1227 > function TIBSQLEditor.GetVerbCount: Integer;
1228   begin
1229 <  Result := False;
1229 >  Result:= 2
1230   end;
1231  
1232 < { TIBTransactionIsland }
1232 > { TIBSQLSQLPropertyEditor }
1233  
1234 < function TIBTransactionIsland.VisibleTreeParent: Boolean;
1234 > procedure TIBSQLSQLPropertyEditor.Edit;
1235 > var
1236 >  IBSQL: TIBSQL;
1237   begin
1238 <  Result := TIBTransaction(Sprig.Item).DefaultDatabase = nil;
1238 >  IBSQL := GetComponent(0) as TIBSQL;
1239 >  if IBSQLEditor.EditSQL(IBSQL) then Modified;
1240   end;
1241  
1242 + initialization
1243 +  {$I IBDBReg.lrs}
1244   end.

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines