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 5 by tony, Fri Feb 18 16:26:16 2011 UTC

# Line 28 | Line 28
28  
29   unit IBDBReg;
30  
31 + {$MODE Delphi}
32 +
33   (*
34   * Compiler defines
35   *)
# Line 48 | Line 50 | unit IBDBReg;
50  
51   interface
52  
53 < uses Windows, SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
54 <     DsgnIntf, DB, ParentageSupport, dsndb, DBReg, ColnEdit, FldLinks, SQLEdit,
55 <     DataModelSupport, IBTable, IBDatabase, IBUpdateSQLEditor,  IBEventsEditor,
54 <     IBXConst;
53 > uses {Windows,} SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
54 >     DB, IBTable, IBDatabase,  IBEventsEditor,
55 >      IBUpdateSQL, IBXConst, ComponentEditors, PropEdits, DBPropEdits, FieldsEditor;
56  
57   type
58  
# Line 123 | Line 124 | type
124  
125   { TIBQueryEditor }
126  
127 <  TIBQueryEditor = class(TDataSetEditor)
127 <  protected
128 <    FGetTableNamesProc: TGetTableNamesProc;
129 <    FGetFieldnamesProc: TGetFieldNamesProc;
127 >  TIBQueryEditor = class(TComponentEditor)
128    public
131    procedure EditSQL;
129      procedure ExecuteVerb(Index: Integer); override;
130      function GetVerb(Index: Integer): string; override;
131      function GetVerbCount: Integer; override;
# Line 136 | Line 133 | type
133  
134   { TIBStoredProcEditor }
135  
136 <  TIBStoredProcEditor = class(TDataSetEditor)
136 >  TIBStoredProcEditor = class(TComponentEditor)
137    public
138      procedure ExecuteVerb(Index: Integer); override;
139      function GetVerb(Index: Integer): string; override;
# Line 145 | Line 142 | type
142  
143   { TIBDataSetEditor }
144  
145 <  TIBDataSetEditor = class(TDataSetEditor)
149 <  protected
150 <    FGetTableNamesProc: TGetTableNamesProc;
151 <    FGetFieldnamesProc: TGetFieldNamesProc;
145 >  TIBDataSetEditor = class(TComponentEditor)
146    public
153    procedure EditSQL;
147      procedure ExecuteVerb(Index: Integer); override;
148      function GetVerb(Index: Integer): string; override;
149      function GetVerbCount: Integer; override;
# Line 165 | Line 158 | type
158     function GetVerbCount: Integer; override;
159    end;
160  
161 <  TIBStoredProcParamsProperty = class(TCollectionProperty)
161 >  TIBStoredProcParamsProperty = class(TCollectionPropertyEditor)
162    public
163      procedure Edit; override;
164    end;
165 <
165 > (*
166    TIBTableFieldLinkProperty = class(TFieldLinkProperty)
167    private
168      FTable: TIBTable;
# Line 181 | Line 174 | type
174    public
175      procedure Edit; override;
176    end;
177 <
177 > *)
178   { TSQLPropertyEditor }
179  
180 <  TSQLPropertyEditor = class(TClassProperty)
188 <  protected
189 <    FGetTableNamesProc: TGetTableNamesProc;
190 <    FGetFieldnamesProc: TGetFieldNamesProc;
180 >  TSQLPropertyEditor = class(TStringsPropertyEditor)
181    public
192    procedure EditSQL;
182      function GetAttributes: TPropertyAttributes; override;
183    end;
184  
# Line 214 | Line 203 | type
203      procedure Edit; override;
204    end;
205  
206 <  TIBEventListProperty = class(TClassProperty)
206 > { TUpdateSQLPropertyEditor }
207 >
208 >   TUpdateSQLPropertyEditor = class(TSQLPropertyEditor)
209 >   protected
210 >     FIBUpdateSQL: TIBUpdateSQL;
211 >     FDatabase: TIBDatabase;
212 >     function GetObjects: boolean;
213 >   end;
214 >
215 > { TIBUpdateSQLProperty }
216 >
217 >  TIBUpdateSQLProperty = class(TSQLPropertyEditor)
218    public
219    function GetAttributes: TPropertyAttributes; override;
219      procedure Edit; override;
220    end;
221  
222 < { DataModel Designer stuff }
222 > { TIBRefreshSQLProperty }
223  
224 <  TIBSQLSprig = class(TSprig)
224 >  TIBRefreshSQLProperty = class(TSQLPropertyEditor)
225    public
226 <    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;
226 >    procedure Edit; override;
227    end;
228  
229 <  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;
229 > { TIBInsertSQLProperty }
230  
231 <  TIBQuerySprig = class(TIBCustomDataSetSprig)
231 >  TIBInsertSQLProperty = class(TSQLPropertyEditor)
232    public
233 <    function AnyProblems: Boolean; override;
233 >    procedure Edit; override;
234    end;
235  
236 <  TIBTableSprig = class(TIBCustomDataSetSprig)
249 <  public
250 <    function AnyProblems: Boolean; override;
251 <    function Caption: string; override;
252 <  end;
236 > { TIBDeleteSQLProperty }
237  
238 <  TIBStoredProcSprig = class(TIBCustomDataSetSprig)
238 >  TIBDeleteSQLProperty = class(TSQLPropertyEditor)
239    public
240 <    function AnyProblems: Boolean; override;
257 <    function Caption: string; override;
240 >    procedure Edit; override;
241    end;
242  
243 <  TIBUpdateSQLSprig = class(TSprigAtRoot)
261 <  public
262 <    function AnyProblems: Boolean; override;
263 <  end;
243 >  { TIBUpdateSQLUpdateProperty }
244  
245 <  TIBDatabaseSprig = class(TSprigAtRoot)
245 >  TIBUpdateSQLUpdateProperty = class(TUpdateSQLPropertyEditor)
246    public
247 <    function AnyProblems: Boolean; override;
268 <    function Caption: string; override;
247 >    procedure Edit; override;
248    end;
249  
250 <  TIBTransactionSprig = class(TSprig)
272 <  public
273 <    function Caption: string; override;
274 <    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;
279 <  end;
250 > { TIBUpdateSQLRefreshSQLProperty }
251  
252 <  TIBDatabaseInfoSprig = class(TSprig)
252 >  TIBUpdateSQLRefreshSQLProperty = class(TUpdateSQLPropertyEditor)
253    public
254 <    class function ParentProperty: string; override;
254 >    procedure Edit; override;
255    end;
256  
257 <  TIBEventsSprig = class(TSprig)
287 <  public
288 <    class function ParentProperty: string; override;
289 <    function AnyProblems: Boolean; override;
290 <  end;
257 > { TIBUpdateSQLInsertSQLProperty }
258  
259 <  TIBTransactionIsland = class(TIsland)
259 >  TIBUpdateSQLInsertSQLProperty = class(TUpdateSQLPropertyEditor)
260    public
261 <    function VisibleTreeParent: Boolean; override;
261 >    procedure Edit; override;
262    end;
263  
264 <  TIBSQLIsland = class(TIsland)
298 <  public
299 <    function VisibleTreeParent: Boolean; override;
300 <  end;
264 >  { TIBUpdateSQLDeleteProperty }
265  
266 <  TIBCustomDataSetIsland = class(TDataSetIsland)
266 >  TIBUpdateSQLDeleteProperty = class(TUpdateSQLPropertyEditor)
267    public
268 <    function VisibleTreeParent: Boolean; override;
268 >    function GetAttributes: TPropertyAttributes; override;
269 >    procedure Edit; override;
270    end;
271  
272 <  TIBTableIsland = class(TIBCustomDataSetIsland)
308 <  end;
272 > { TIBEventListProperty }
273  
274 <  TIBTableMasterDetailBridge = class(TMasterDetailBridge)
274 >  TIBEventListProperty = class(TClassProperty)
275    public
276 <    function CanEdit: Boolean; override;
277 <    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;
276 >    function GetAttributes: TPropertyAttributes; override;
277 >    procedure Edit; override;
278    end;
279  
280 <  TIBQueryIsland = class(TIBCustomDataSetIsland)
321 <  end;
280 > {TIBGeneratorProperty}
281  
282 <  TIBQueryMasterDetailBridge = class(TMasterDetailBridge)
282 >  TIBGeneratorProperty = class(TPersistentPropertyEditor)
283    public
284 <    class function RemoveMasterFieldsAsWell: Boolean; override;
285 <    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;
284 >    function GetAttributes: TPropertyAttributes; override;
285 >    procedure Edit; override;
286    end;
287  
288   procedure Register;
289  
290   implementation
291  
292 < uses IB, IBQuery, IBStoredProc, IBUpdateSQL, IBCustomDataSet,
293 <     IBIntf, IBSQL, IBSQLMonitor, IBDatabaseInfo, IBEvents,
294 <     IBServices, IBInstall, IBDatabaseEdit, IBTransactionEdit,
295 <     IBBatchMove, DBLogDlg;
292 > uses IB, IBQuery, IBStoredProc, IBCustomDataSet,
293 >     IBIntf, IBSQL, (*IBSQLMonitor,*) IBDatabaseInfo, IBEvents,
294 >     IBServices, (*IBInstall,*) IBDatabaseEdit, IBTransactionEdit,
295 >     IBBatchMove, DBLoginDlg, IBExtract,LResources, IBSelectSQLEditor,
296 >     IBModifySQLEditor,IBDeleteSQLEditor,IBRefreshSQLEditor,
297 >     IBInsertSQLEditor, IBGeneratorEditor, IBUpdateSQLEditor, IBDataSetEditor;
298  
299   procedure Register;
300   begin
301    RegisterComponents(IBPalette1, [TIBTable, TIBQuery,
302 <    TIBStoredProc, TIBDatabase, TIBTransaction, TIBUpdateSQL,
303 <    TIBDataSet, TIBSQL, TIBDatabaseInfo, TIBSQLMonitor, TIBEvents]);
304 < {$IFDEF IB6_ONLY}
347 <  if (TryIBLoad) and (GetIBClientVersion >= 6) then
302 >    TIBStoredProc, TIBDatabase, TIBTransaction, TIBUpdateSQL, TIBBatchMove,
303 >    TIBDataSet, TIBSQL, TIBDatabaseInfo, (*TIBSQLMonitor,*) TIBEvents, TIBExtract]);
304 >  if (TryIBLoad) and IBServiceAPIPresent  then
305      RegisterComponents(IBPalette2, [TIBConfigService, TIBBackupService,
306        TIBRestoreService, TIBValidationService, TIBStatisticalService,
307 <      TIBLogService, TIBSecurityService, TIBServerProperties,
351 <      TIBInstall, TIBUninstall]);
352 < {$ENDIF}
307 >      TIBLogService, TIBSecurityService, TIBServerProperties]);
308    RegisterClasses([TIBStringField, TIBBCDField]);
309 <  RegisterFields([TIBStringField, TIBBCDField]);
309 > //  RegisterFields([TIBStringField, TIBBCDField]); --not sure if this is needed in lazarus
310    RegisterPropertyEditor(TypeInfo(TIBFileName), TIBDatabase, 'DatabaseName', TIBFileNameProperty); {do not localize}
311    RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'StoredProcName', TIBStoredProcNameProperty); {do not localize}
312    RegisterPropertyEditor(TypeInfo(TParams), TIBStoredProc, 'Params', TIBStoredProcParamsProperty);
313    RegisterPropertyEditor(TypeInfo(string), TIBTable, 'TableName', TIBTableNameProperty); {do not localize}
314    RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexName', TIBIndexNameProperty); {do not localize}
315    RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexFieldNames', TIBIndexFieldNamesProperty); {do not localize}
316 <  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'MasterFields', TIBTableFieldLinkProperty); {do not localize}
316 > //  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'MasterFields', TIBTableFieldLinkProperty); {do not localize}
317    RegisterPropertyEditor(TypeInfo(TStrings), TIBQuery, 'SQL', TIBQuerySQLProperty); {do not localize}
318    RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'SelectSQL', TIBDatasetSQLProperty); {do not localize}
319 +  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'ModifySQL', TIBUpdateSQLProperty); {do not localize}
320 +  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'InsertSQL', TIBInsertSQLProperty); {do not localize}
321 +  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'RefreshSQL', TIBRefreshSQLProperty); {do not localize}
322 +  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'DeleteSQL', TIBDeleteSQLProperty); {do not localize}
323    RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLProperty); {do not localize}
324 +  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'RefreshSQL', TIBUpdateSQLRefreshSQLProperty); {do not localize}
325 +  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'ModifySQL', TIBUpdateSQLUpdateProperty); {do not localize}
326 +  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'InsertSQL', TIBUpdateSQLInsertSQLProperty); {do not localize}
327 +  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'DeleteSQL', TIBUpdateSQLDeleteProperty); {do not localize}
328    RegisterPropertyEditor(TypeInfo(TStrings), TIBEvents, 'Events', TIBEventListProperty); {do not localize}
329 +  RegisterPropertyEditor(TypeInfo(TPersistent), TIBDataSet, 'Generator', TIBGeneratorProperty);  {do not localize}
330  
331    RegisterComponentEditor(TIBDatabase, TIBDatabaseEditor);
332    RegisterComponentEditor(TIBTransaction, TIBTransactionEditor);
# Line 370 | Line 334 | begin
334    RegisterComponentEditor(TIBDataSet, TIBDataSetEditor);
335    RegisterComponentEditor(TIBQuery, TIBQueryEditor);
336    RegisterComponentEditor(TIBStoredProc, TIBStoredProcEditor);
373
374  RegisterSprigType(TIBDatabase, TIBDatabaseSprig);
375  RegisterSprigType(TIBTransaction, TIBTransactionSprig);
376
377  RegisterSprigType(TIBDatabaseInfo, TIBDatabaseInfoSprig);
378  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);
393
394  RegisterBridgeType(TDataSetIsland, TIBTableIsland, TIBTableMasterDetailBridge);
395  RegisterBridgeType(TDataSetIsland, TIBQueryIsland, TIBQueryMasterDetailBridge);
337   end;
338  
339   { TIBFileNameProperty }
# Line 521 | Line 462 | end;
462  
463   { TSQLPropertyEditor }
464  
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
465   function TSQLPropertyEditor.GetAttributes: TPropertyAttributes;
466   begin
467 <  Result := inherited GetAttributes + [paDialog] - [paSubProperties];
467 >  Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
468   end;
469  
470   { TIBQuerySQLProperty }
# Line 552 | Line 473 | procedure TIBQuerySQLProperty.Edit;
473   var
474    Query: TIBQuery;
475   begin
476 <  Query := TIBQuery(GetComponent(0));
477 <  if Assigned(Query.Database) then
478 <  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;
476 >  Query := GetComponent(0) as TIBQuery;
477 >  if Assigned(Query.Database) and
478 >    IBSelectSQLEditor.EditSQL(Query.Database,Query.Transaction,Query.SQL) then Modified;
479   end;
480  
481   { TIBDatasetSQLProperty }
# Line 572 | Line 484 | procedure TIBDatasetSQLProperty.Edit;
484   var
485    IBDataset: TIBDataset;
486   begin
487 <  IBDataset := TIBDataset(GetComponent(0));
488 <  if Assigned(IBDataSet.Database) then
489 <  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;
487 >  IBDataset := GetComponent(0) as TIBDataset;
488 >  if Assigned(IBDataSet.Database) and
489 >     IBSelectSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.Transaction,IBDataSet.SelectSQL) then Modified;
490   end;
491  
492   { TIBSQLProperty }
# Line 592 | Line 495 | procedure TIBSQLProperty.Edit;
495   var
496    IBSQL: TIBSQL;
497   begin
498 <  IBSQL := TIBSQL(GetComponent(0));
499 <  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;
498 >  IBSQL := GetComponent(0) as TIBSQL;
499 >  if IBSelectSQLEditor.EditSQL(IBSQL.Database,IBSQL.Transaction,IBSQL.SQL) then Modified;
500   end;
501  
502   { TIBUpdateSQLEditor }
503  
504   procedure TIBUpdateSQLEditor.ExecuteVerb(Index: Integer);
505   begin
506 <  if EditIBUpdateSQL(TIBUpdateSQL(Component)) then Designer.Modified;
506 >  if IBUpdateSQLEditor.EditIBUpdateSQL(TIBUpdateSQL(Component)) then Modified;
507   end;
508  
509   function TIBUpdateSQLEditor.GetVerb(Index: Integer): string;
510   begin
511    case Index of
512      0 : Result := SIBUpdateSQLEditor;
513 <    2: Result := SInterbaseExpressVersion;
513 >    1: Result := SInterbaseExpressVersion;
514    end;
515   end;
516  
# Line 628 | Line 521 | end;
521  
522   { TIBDataSetEditor }
523  
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
524   procedure TIBDataSetEditor.ExecuteVerb(Index: Integer);
525   var
526    IBDataset: TIBDataset;
527   begin
655  if Index < inherited GetVerbCount then
656    inherited ExecuteVerb(Index) else
657  begin
658    Dec(Index, inherited GetVerbCount);
528      case Index of
529        0:
530 <        if EditIBDataSet(TIBDataSet(Component)) then
530 >        if IBDataSetEditor.EditIBDataSet(TIBDataSet(Component)) then
531            Designer.Modified;
532        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;
533      end;
680  end;
534   end;
535  
536   function TIBDataSetEditor.GetVerb(Index: Integer): string;
# Line 689 | Line 542 | begin
542      case Index of
543        0: Result := SIBDataSetEditor;
544        1: Result := SExecute;
545 <      2: Result := SEditSQL;
693 <      3: Result := SInterbaseExpressVersion;
545 >      2: Result := SInterbaseExpressVersion;
546      end;
547    end;
548   end;
549  
550   function TIBDataSetEditor.GetVerbCount: Integer;
551   begin
552 <  Result := inherited GetVerbCount + 4;
552 >  Result := 3;
553   end;
554  
555   { TIBEventListProperty }
556  
557   function TIBEventListProperty.GetAttributes: TPropertyAttributes;
558   begin
559 <  Result := inherited GetAttributes + [paDialog] - [paSubProperties];
559 >  Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
560   end;
561  
562   procedure TIBEventListProperty.Edit;
563   var
564    Events: TStrings;
565 +  IBEvents: TIBEvents;
566   begin
567 +  IBEvents := GetComponent(0) as TIBEvents;
568    Events := TStringList.Create;
569    try
570 <    Events.Assign( TStrings(GetOrdValue));
571 <    if EditAlerterEvents( Events) then SetOrdValue( longint(Events));
570 >    Events.Assign( IBEvents.Events);
571 >    if EditAlerterEvents( Events) then IBEvents.Events.Assign(Events);
572    finally
573      Events.Free;
574    end;
# Line 775 | Line 629 | end;
629  
630   { TIBQueryEditor }
631  
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
632   procedure TIBQueryEditor.ExecuteVerb(Index: Integer);
633   var
634    Query: TIBQuery;
635   begin
802  if Index < inherited GetVerbCount then
803    inherited ExecuteVerb(Index) else
804  begin
636      Query := Component as TIBQuery;
637      Dec(Index, inherited GetVerbCount);
638      case Index of
639        0: Query.ExecSQL;
640 <      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;
640 >      1: if ibselectsqleditor.EditSQL(Query.Database,Query.Transaction,Query.SQL) then Designer.Modified;
641      end;
824  end;
642   end;
643  
644   function TIBQueryEditor.GetVerb(Index: Integer): string;
# Line 840 | Line 657 | end;
657  
658   function TIBQueryEditor.GetVerbCount: Integer;
659   begin
660 <  Result := inherited GetVerbCount + 3;
660 >  Result :=  3;
661   end;
662  
663   { TIBStoredProcEditor }
664  
665   procedure TIBStoredProcEditor.ExecuteVerb(Index: Integer);
666   begin
850  if Index < inherited GetVerbCount then
851    inherited ExecuteVerb(Index) else
852  begin
853    Dec(Index, inherited GetVerbCount);
667      if Index = 0 then (Component as TIBStoredProc).ExecProc;
855  end;
668   end;
669  
670   function TIBStoredProcEditor.GetVerb(Index: Integer): string;
671   begin
860  if Index < inherited GetVerbCount then
861    Result := inherited GetVerb(Index) else
862  begin
863    Dec(Index, inherited GetVerbCount);
672      case Index of
673        0: Result := SExecute;
674        1: Result := SInterbaseExpressVersion;
675      end;
868  end;
676   end;
677  
678   function TIBStoredProcEditor.GetVerbCount: Integer;
# Line 889 | Line 696 | begin
696    end;
697    inherited Edit;
698   end;
699 <
699 > (*
700   { TIBTableFieldLinkProperty }
701  
702   procedure TIBTableFieldLinkProperty.Edit;
# Line 916 | Line 723 | end;
723   procedure TIBTableFieldLinkProperty.SetMasterFields(const Value: string);
724   begin
725    FTable.MasterFields := Value;
726 < end;
726 > end;*)
727  
728 < { TIBDatabaseSprig }
728 > { TIBUpdateSQLProperty }
729  
730 < function TIBDatabaseSprig.AnyProblems: Boolean;
731 < begin
732 <  Result := (TIBDatabase(Item).DatabaseName = '') or
926 <            (TIBDatabase(Item).DefaultTransaction = nil);
927 < end;
928 <
929 < function TIBDatabaseSprig.Caption: string;
730 > procedure TIBUpdateSQLProperty.Edit;
731 > var
732 >  IBDataset: TIBDataset;
733   begin
734 <  Result := CaptionFor(TIBDatabase(Item).DatabaseName, UniqueName);
734 >  IBDataset := GetComponent(0) as TIBDataset;
735 >  if Assigned(IBDataSet.Database) and
736 >    IBModifySQLEditor.EditSQL(IBDataSet.Database,IBDataSet.Transaction,IBDataSet.ModifySQL) then Modified;
737   end;
738  
739 < { TIBTransactionSprig }
935 <
936 < function TIBTransactionSprig.AnyProblems: Boolean;
937 < begin
938 <  Result := TIBTransaction(Item).DefaultDatabase = nil;
939 < end;
739 > { TIBUpdateSQLUpdateProperty }
740  
741 < function TIBTransactionSprig.Caption: string;
741 > procedure TIBUpdateSQLUpdateProperty.Edit;
742   begin
743 <  if (TIBTransaction(Item).DefaultDatabase <> nil) and
744 <     (TIBTransaction(Item).DefaultDatabase.DefaultTransaction = Item) then
945 <    Result := CaptionFor(Format(SDefaultTransaction, [UniqueName]))
743 >  if not GetObjects then
744 >    ShowMessage('Not Linked to an IBQuery object or Database not assigned')
745    else
746 <    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
746 >  if IBModifySQLEditor.EditSQL(FDatabase,FDatabase.DefaultTransaction,FIBUpdateSQL.ModifySQL) then Modified;
747   end;
748  
749 < function TIBTransactionSprig.DragOverTo(AItem: TSprig): Boolean;
970 < begin
971 <  Result := (AItem is TIBDatabaseSprig);
972 < end;
749 > { TIBRefreshSQLProperty }
750  
751 < class function TIBTransactionSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
751 > procedure TIBRefreshSQLProperty.Edit;
752 > var
753 >  IBDataset: TIBDataset;
754   begin
755 <  Result := (AParent is TIBDatabaseSprig);
755 >  IBDataset := GetComponent(0) as TIBDataset;
756 >  if Assigned(IBDataSet.Database) and
757 >    IBRefreshSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.Transaction,IBDataSet.RefreshSQL) then Modified;
758   end;
759  
760 < { support stuff for sprigs }
760 > { TIBUpdateSQLRefreshSQLProperty }
761  
762 < function IBAnyProblems(ATransaction: TIBTransaction; ADatabase: TIBDatabase): Boolean;
762 > procedure TIBUpdateSQLRefreshSQLProperty.Edit;
763   begin
764 <  Result := (ATransaction = nil) or
765 <            (ADatabase = nil) or
985 <            (ATransaction.DefaultDatabase <> ADatabase);
986 < end;
987 <
988 < 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)
764 >  if not GetObjects then
765 >    ShowMessage('Not Linked to an IBQuery object or Database not assigned')
766    else
767 <    ASprig.Root.Add(ASprig);
767 >  if IBRefreshSQLEditor.EditSQL(FDatabase,FDatabase.DefaultTransaction,FIBUpdateSQL.RefreshSQL) then Modified;
768   end;
769  
770 < function IBDragOver(ASprig: TSprig): Boolean;
999 < begin
1000 <  Result := (ASprig is TIBTransactionSprig) or
1001 <            (ASprig is TIBDatabaseSprig);
1002 < end;
770 > { TIBDeleteSQLProperty }
771  
772 < function IBDropOver(AParent: TSprig; var ATransaction: TIBTransaction; var ADatabase: TIBDatabase): Boolean;
772 > procedure TIBDeleteSQLProperty.Edit;
773   var
774 <  vParentTransaction: TIBTransaction;
1007 <  vParentDatabase: TIBDatabase;
1008 < begin
1009 <  Result := False;
1010 <  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;
1035 < end;
1036 <
1037 < { TIBSQLSprig }
1038 <
1039 < function TIBSQLSprig.AnyProblems: Boolean;
1040 < begin
1041 <  Result := IBAnyProblems(TIBSQL(Item).Transaction,
1042 <                          TIBSQL(Item).Database) or
1043 <            (TIBSQL(Item).SQL.Count = 0);
1044 < end;
1045 <
1046 < function TIBSQLSprig.DragDropTo(AItem: TSprig): Boolean;
1047 < var
1048 <  vTransaction: TIBTransaction;
1049 <  vDatabase: TIBDatabase;
1050 < begin
1051 <  with TIBSQL(Item) do
1052 <  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;
1062 < end;
1063 <
1064 < function TIBSQLSprig.DragOverTo(AItem: TSprig): Boolean;
774 >  IBDataset: TIBDataset;
775   begin
776 <  Result := IBDragOver(AItem);
776 >  IBDataset := GetComponent(0) as TIBDataset;
777 >  if Assigned(IBDataSet.Database) and
778 >    IBDeleteSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.Transaction,IBDataSet.DeleteSQL) then Modified;
779   end;
780  
781 < procedure TIBSQLSprig.FigureParent;
1070 < begin
1071 <  IBFigureParent(Self, TIBSQL(Item).Transaction,
1072 <                       TIBSQL(Item).Database);
1073 < end;
781 > { TIBUpdateSQLDeleteProperty }
782  
783 < class function TIBSQLSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
783 > function TIBUpdateSQLDeleteProperty.GetAttributes: TPropertyAttributes;
784   begin
785 <  Result := IBDragOver(AParent);
785 >  Result:=inherited GetAttributes;
786   end;
787  
788 < { TIBCustomDataSetSprig }
1081 <
1082 < function TIBCustomDataSetSprig.AnyProblems: Boolean;
788 > procedure TIBUpdateSQLDeleteProperty.Edit;
789   begin
790 <  Result := IBAnyProblems(TIBCustomDataSet(Item).Transaction,
791 <                          TIBCustomDataSet(Item).Database);
790 >  if not GetObjects then
791 >    ShowMessage('Not Linked to an IBQuery object or Database not assigned')
792 >  else
793 >  if IBDeleteSQLEditor.EditSQL(FDatabase,FDatabase.DefaultTransaction,FIBUpdateSQL.DeleteSQL) then Modified;
794   end;
795  
796 < procedure TIBCustomDataSetSprig.FigureParent;
1089 < begin
1090 <  IBFigureParent(Self, TIBCustomDataSet(Item).Transaction,
1091 <                       TIBCustomDataSet(Item).Database);
1092 < end;
796 > { TUpdateSQLPropertyEditor }
797  
798 < function TIBCustomDataSetSprig.DragDropTo(AItem: TSprig): Boolean;
1095 < var
1096 <  vTransaction: TIBTransaction;
1097 <  vDatabase: TIBDatabase;
798 > function TUpdateSQLPropertyEditor.GetObjects: boolean;
799   begin
800 <  with TIBCustomDataSet(Item) do
800 >  Result := false;
801 >  FIBUpdateSQL := GetComponent(0) as TIBUpdateSQL;
802 >  if not assigned(FIBUpdateSQL) or not assigned(FIBUpdateSQL.DataSet) then
803 >    Exit;
804 >  if FIBUpdateSQL.DataSet is TIBQuery then
805    begin
806 <    vTransaction := Transaction;
807 <    vDatabase := Database;
1103 <    Result := IBDropOver(AItem, vTransaction, vDatabase);
1104 <    if Result then
1105 <    begin
1106 <      Transaction := vTransaction;
1107 <      Database := vDatabase;
1108 <    end;
806 >    FDatabase := (FIBUpdateSQL.DataSet as TIBQuery).Database;
807 >    Result := true
808    end;
809   end;
810  
811 < 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;
1142 <
1143 < 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;
811 > { TIBInsertSQLProperty }
812  
813 < { 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;
813 > procedure TIBInsertSQLProperty.Edit;
814   var
815 <  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;
1217 < begin
1218 <  Result := TIBTable(AItem).MasterSource;
1219 < end;
1220 <
1221 < class function TIBTableMasterDetailBridge.OmegaIslandClass: TIslandClass;
1222 < begin
1223 <  Result := TIBTableIsland;
1224 < end;
1225 <
1226 < class procedure TIBTableMasterDetailBridge.SetOmegaSource(
1227 <  AItem: TPersistent; ADataSource: TDataSource);
1228 < begin
1229 <  TIBTable(AItem).MasterSource := ADataSource;
1230 < end;
1231 <
1232 < { TIBQueryMasterDetailBridge }
1233 <
1234 < function TIBQueryMasterDetailBridge.Caption: string;
1235 < begin
1236 <  Result := SParamsFields;
1237 < end;
1238 <
1239 < class function TIBQueryMasterDetailBridge.GetOmegaSource(
1240 <  AItem: TPersistent): TDataSource;
1241 < begin
1242 <  Result := TIBQuery(AItem).DataSource;
1243 < end;
1244 <
1245 < class function TIBQueryMasterDetailBridge.OmegaIslandClass: TIslandClass;
1246 < begin
1247 <  Result := TIBQueryIsland;
1248 < end;
1249 <
1250 < class function TIBQueryMasterDetailBridge.RemoveMasterFieldsAsWell: Boolean;
1251 < begin
1252 <  Result := False;
1253 < end;
1254 <
1255 < class procedure TIBQueryMasterDetailBridge.SetOmegaSource(
1256 <  AItem: TPersistent; ADataSource: TDataSource);
815 >  IBDataset: TIBDataset;
816   begin
817 <  TIBQuery(AItem).DataSource := ADataSource;
817 >  IBDataset := GetComponent(0) as TIBDataset;
818 >  if Assigned(IBDataSet.Database) and
819 >    IBInsertSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.Transaction,IBDataSet.InsertSQL) then Modified;
820   end;
821  
822 < { TIBCustomDataSetIsland }
822 > { TIBUpdateSQLInsertSQLProperty }
823  
824 < function TIBCustomDataSetIsland.VisibleTreeParent: Boolean;
824 > procedure TIBUpdateSQLInsertSQLProperty.Edit;
825   begin
826 <  Result := False;
826 >  if not GetObjects then
827 >    ShowMessage('Not Linked to an IBQuery object or Database not assigned')
828 >  else
829 >  if IBInsertSQLEditor.EditSQL(FDatabase,FDatabase.DefaultTransaction,FIBUpdateSQL.InsertSQL) then Modified;
830   end;
831  
832 < { TIBSQLIsland }
832 > { TIBGeneratorProperty }
833  
834 < function TIBSQLIsland.VisibleTreeParent: Boolean;
834 > function TIBGeneratorProperty.GetAttributes: TPropertyAttributes;
835   begin
836 <  Result := False;
836 >  Result:= inherited GetAttributes + [paDialog] - [paMultiSelect,paValueList];
837   end;
838  
839 < { TIBTransactionIsland }
1276 <
1277 < function TIBTransactionIsland.VisibleTreeParent: Boolean;
839 > procedure TIBGeneratorProperty.Edit;
840   begin
841 <  Result := TIBTransaction(Sprig.Item).DefaultDatabase = nil;
841 >  if IBGeneratorEditor.EditGenerator(GetPersistentReference as TIBGenerator) then Modified;
842   end;
843  
844 + initialization
845 +  {$I IBDBReg.lrs}
846   end.

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines