ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/public/ibx/trunk/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 17 by tony, Sat Dec 28 19:22:24 2013 UTC

# Line 1 | Line 1
1 < {************************************************************************}
2 < {                                                                        }
3 < {       Borland Delphi Visual Component Library                          }
4 < {       InterBase Express core components                                }
5 < {                                                                        }
6 < {       Copyright (c) 1998-2000 Inprise Corporation                      }
7 < {                                                                        }
8 < {    InterBase Express is based in part on the product                   }
9 < {    Free IB Components, written by Gregory H. Deatz for                 }
10 < {    Hoagland, Longo, Moran, Dunst & Doukas Company.                     }
11 < {    Free IB Components is used under license.                           }
12 < {                                                                        }
13 < {    The contents of this file are subject to the InterBase              }
14 < {    Public License Version 1.0 (the "License"); you may not             }
15 < {    use this file except in compliance with the License. You            }
16 < {    may obtain a copy of the License at http://www.Inprise.com/IPL.html }
17 < {    Software distributed under the License is distributed on            }
18 < {    an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either              }
19 < {    express or implied. See the License for the specific language       }
20 < {    governing rights and limitations under the License.                 }
21 < {    The Original Code was created by InterBase Software Corporation     }
22 < {       and its successors.                                              }
23 < {    Portions created by Inprise Corporation are Copyright (C) Inprise   }
24 < {       Corporation. All Rights Reserved.                                }
25 < {    Contributor(s): Jeff Overcash                                       }
26 < {                                                                        }
27 < {************************************************************************}
28 <
29 < unit IBDBReg;
30 <
31 < (*
32 < * Compiler defines
33 < *)
34 < {$A+}                           (* Aligned records: On *)
35 < {$B-}                           (* Short circuit boolean expressions: Off *)
36 < {$G+}                           (* Imported data: On *)
37 < {$H+}                           (* Huge Strings: On *)
38 < {$J-}                           (* Modification of Typed Constants: Off *)
39 < {$M+}                           (* Generate run-time type information: On *)
40 < {$O+}                           (* Optimization: On *)
41 < {$Q-}                           (* Overflow checks: Off *)
42 < {$R-}                           (* Range checks: Off *)
43 < {$T+}                           (* Typed address: On *)
44 < {$U+}                           (* Pentim-safe FDIVs: On *)
45 < {$W-}                           (* Always generate stack frames: Off *)
46 < {$X+}                           (* Extended syntax: On *)
47 < {$Z1}                           (* Minimum Enumeration Size: 1 Byte *)
48 <
49 < interface
50 <
51 < uses Windows, SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
52 <     DsgnIntf, DB, ParentageSupport, dsndb, DBReg, ColnEdit, FldLinks, SQLEdit,
53 <     DataModelSupport, IBTable, IBDatabase, IBUpdateSQLEditor,  IBEventsEditor,
54 <     IBXConst;
55 <
56 < type
57 <
58 < { TIBFileNameProperty
59 <  Property editor the DataBase Name property.  Brings up the Open dialog }
60 <
61 <  TIBFileNameProperty = class(TStringProperty)
62 <  public
63 <    procedure Edit; override;
64 <    function GetAttributes: TPropertyAttributes; override;
65 <  end;
66 <
67 <  { TIBNameProperty
68 <  }
69 <  TIBNameProperty = class(TStringProperty)
70 <  public
71 <    function GetAttributes: TPropertyAttributes; override;
72 <  end;
73 <
74 <  { TIBStoredProcNameProperty
75 <    Editor for the TIBStoredProc.StoredProcName property.  Displays a drop-down list of all
76 <    the StoredProcedures in the Database.}
77 <  TIBStoredProcNameProperty = class(TIBNameProperty)
78 <  public
79 <    procedure GetValues(Proc: TGetStrProc); override;
80 <  end;
81 <
82 <  { TIBTableNameProperty
83 <    Editor for the TIBTable.TableName property.  Displays a drop-down list of all
84 <    the Tables in the Database.}
85 <  TIBTableNameProperty = class(TIBNameProperty)
86 <  public
87 <    procedure GetValues(Proc: TGetStrProc); override;
88 <  end;
89 <
90 <  TDBStringProperty = class(TStringProperty)
91 <  public
92 <    function GetAttributes: TPropertyAttributes; override;
93 <    procedure GetValueList(List: TStrings); virtual;
94 <    procedure GetValues(Proc: TGetStrProc); override;
95 <  end;
96 <
97 <  TIBIndexFieldNamesProperty = class(TDBStringProperty)
98 <  public
99 <    procedure GetValueList(List: TStrings); override;
100 <  end;
101 <
102 <  TIBIndexNameProperty = class(TDBStringProperty)
103 <  public
104 <    procedure GetValueList(List: TStrings); override;
105 <  end;
106 <
107 < { TIBDatabaseEditor }
108 <
109 <  TIBDatabaseEditor = class(TComponentEditor)
110 <    procedure ExecuteVerb(Index: Integer); override;
111 <    function GetVerb(Index: Integer): string; override;
112 <    function GetVerbCount: Integer; override;
113 <  end;
114 <
115 < { TIBTransactionEditor }
116 <
117 <  TIBTransactionEditor = class(TComponentEditor)
118 <  public
119 <    procedure ExecuteVerb(Index: Integer); override;
120 <    function GetVerb(Index: Integer): string; override;
121 <    function GetVerbCount: Integer; override;
122 <  end;
123 <
124 < { TIBQueryEditor }
125 <
126 <  TIBQueryEditor = class(TDataSetEditor)
127 <  protected
128 <    FGetTableNamesProc: TGetTableNamesProc;
129 <    FGetFieldnamesProc: TGetFieldNamesProc;
130 <  public
131 <    procedure EditSQL;
132 <    procedure ExecuteVerb(Index: Integer); override;
133 <    function GetVerb(Index: Integer): string; override;
134 <    function GetVerbCount: Integer; override;
135 <  end;
136 <
137 < { TIBStoredProcEditor }
138 <
139 <  TIBStoredProcEditor = class(TDataSetEditor)
140 <  public
141 <    procedure ExecuteVerb(Index: Integer); override;
142 <    function GetVerb(Index: Integer): string; override;
143 <    function GetVerbCount: Integer; override;
144 <  end;
145 <
146 < { TIBDataSetEditor }
147 <
148 <  TIBDataSetEditor = class(TDataSetEditor)
149 <  protected
150 <    FGetTableNamesProc: TGetTableNamesProc;
151 <    FGetFieldnamesProc: TGetFieldNamesProc;
152 <  public
153 <    procedure EditSQL;
154 <    procedure ExecuteVerb(Index: Integer); override;
155 <    function GetVerb(Index: Integer): string; override;
156 <    function GetVerbCount: Integer; override;
157 <  end;
158 <
159 < { TIBUpdateSQLEditor }
160 <
161 <  TIBUpdateSQLEditor = class(TComponentEditor)
162 <  public
163 <    procedure ExecuteVerb(Index: Integer); override;
164 <    function GetVerb(Index: Integer): string; override;
165 <   function GetVerbCount: Integer; override;
166 <  end;
167 <
168 <  TIBStoredProcParamsProperty = class(TCollectionProperty)
169 <  public
170 <    procedure Edit; override;
171 <  end;
172 <
173 <  TIBTableFieldLinkProperty = class(TFieldLinkProperty)
174 <  private
175 <    FTable: TIBTable;
176 <  protected
177 <    function GetIndexFieldNames: string; override;
178 <    function GetMasterFields: string; override;
179 <    procedure SetIndexFieldNames(const Value: string); override;
180 <    procedure SetMasterFields(const Value: string); override;
181 <  public
182 <    procedure Edit; override;
183 <  end;
184 <
185 < { TSQLPropertyEditor }
186 <
187 <  TSQLPropertyEditor = class(TClassProperty)
188 <  protected
189 <    FGetTableNamesProc: TGetTableNamesProc;
190 <    FGetFieldnamesProc: TGetFieldNamesProc;
191 <  public
192 <    procedure EditSQL;
193 <    function GetAttributes: TPropertyAttributes; override;
194 <  end;
195 <
196 < { TIBQuerySQLProperty }
197 <
198 <  TIBQuerySQLProperty = class(TSQLPropertyEditor)
199 <  public
200 <    procedure Edit; override;
201 <  end;
202 <
203 < { TIBDatasetSQLProperty }
204 <
205 <  TIBDatasetSQLProperty = class(TSQLPropertyEditor)
206 <  public
207 <    procedure Edit; override;
208 <  end;
209 <
210 < { TIBSQLProperty }
211 <
212 <  TIBSQLProperty = class(TSQLPropertyEditor)
213 <  public
214 <    procedure Edit; override;
215 <  end;
216 <
217 <  TIBEventListProperty = class(TClassProperty)
218 <  public
219 <    function GetAttributes: TPropertyAttributes; override;
220 <    procedure Edit; override;
221 <  end;
222 <
223 < { DataModel Designer stuff }
224 <
225 <  TIBSQLSprig = class(TSprig)
226 <  public
227 <    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;
232 <  end;
233 <
234 <  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;
242 <
243 <  TIBQuerySprig = class(TIBCustomDataSetSprig)
244 <  public
245 <    function AnyProblems: Boolean; override;
246 <  end;
247 <
248 <  TIBTableSprig = class(TIBCustomDataSetSprig)
249 <  public
250 <    function AnyProblems: Boolean; override;
251 <    function Caption: string; override;
252 <  end;
253 <
254 <  TIBStoredProcSprig = class(TIBCustomDataSetSprig)
255 <  public
256 <    function AnyProblems: Boolean; override;
257 <    function Caption: string; override;
258 <  end;
259 <
260 <  TIBUpdateSQLSprig = class(TSprigAtRoot)
261 <  public
262 <    function AnyProblems: Boolean; override;
263 <  end;
264 <
265 <  TIBDatabaseSprig = class(TSprigAtRoot)
266 <  public
267 <    function AnyProblems: Boolean; override;
268 <    function Caption: string; override;
269 <  end;
270 <
271 <  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;
280 <
281 <  TIBDatabaseInfoSprig = class(TSprig)
282 <  public
283 <    class function ParentProperty: string; override;
284 <  end;
285 <
286 <  TIBEventsSprig = class(TSprig)
287 <  public
288 <    class function ParentProperty: string; override;
289 <    function AnyProblems: Boolean; override;
290 <  end;
291 <
292 <  TIBTransactionIsland = class(TIsland)
293 <  public
294 <    function VisibleTreeParent: Boolean; override;
295 <  end;
296 <
297 <  TIBSQLIsland = class(TIsland)
298 <  public
299 <    function VisibleTreeParent: Boolean; override;
300 <  end;
301 <
302 <  TIBCustomDataSetIsland = class(TDataSetIsland)
303 <  public
304 <    function VisibleTreeParent: Boolean; override;
305 <  end;
306 <
307 <  TIBTableIsland = class(TIBCustomDataSetIsland)
308 <  end;
309 <
310 <  TIBTableMasterDetailBridge = class(TMasterDetailBridge)
311 <  public
312 <    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;
318 <  end;
319 <
320 <  TIBQueryIsland = class(TIBCustomDataSetIsland)
321 <  end;
322 <
323 <  TIBQueryMasterDetailBridge = class(TMasterDetailBridge)
324 <  public
325 <    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;
330 <  end;
331 <
332 < procedure Register;
333 <
334 < implementation
335 <
336 < uses IB, IBQuery, IBStoredProc, IBUpdateSQL, IBCustomDataSet,
337 <     IBIntf, IBSQL, IBSQLMonitor, IBDatabaseInfo, IBEvents,
338 <     IBServices, IBInstall, IBDatabaseEdit, IBTransactionEdit,
339 <     IBBatchMove, DBLogDlg;
340 <
341 < procedure Register;
342 < begin
343 <  RegisterComponents(IBPalette1, [TIBTable, TIBQuery,
344 <    TIBStoredProc, TIBDatabase, TIBTransaction, TIBUpdateSQL,
345 <    TIBDataSet, TIBSQL, TIBDatabaseInfo, TIBSQLMonitor, TIBEvents]);
346 < {$IFDEF IB6_ONLY}
347 <  if (TryIBLoad) and (GetIBClientVersion >= 6) then
348 <    RegisterComponents(IBPalette2, [TIBConfigService, TIBBackupService,
349 <      TIBRestoreService, TIBValidationService, TIBStatisticalService,
350 <      TIBLogService, TIBSecurityService, TIBServerProperties,
351 <      TIBInstall, TIBUninstall]);
352 < {$ENDIF}
353 <  RegisterClasses([TIBStringField, TIBBCDField]);
354 <  RegisterFields([TIBStringField, TIBBCDField]);
355 <  RegisterPropertyEditor(TypeInfo(TIBFileName), TIBDatabase, 'DatabaseName', TIBFileNameProperty); {do not localize}
356 <  RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'StoredProcName', TIBStoredProcNameProperty); {do not localize}
357 <  RegisterPropertyEditor(TypeInfo(TParams), TIBStoredProc, 'Params', TIBStoredProcParamsProperty);
358 <  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'TableName', TIBTableNameProperty); {do not localize}
359 <  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexName', TIBIndexNameProperty); {do not localize}
360 <  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexFieldNames', TIBIndexFieldNamesProperty); {do not localize}
361 <  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'MasterFields', TIBTableFieldLinkProperty); {do not localize}
362 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBQuery, 'SQL', TIBQuerySQLProperty); {do not localize}
363 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'SelectSQL', TIBDatasetSQLProperty); {do not localize}
364 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLProperty); {do not localize}
365 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBEvents, 'Events', TIBEventListProperty); {do not localize}
366 <
367 <  RegisterComponentEditor(TIBDatabase, TIBDatabaseEditor);
368 <  RegisterComponentEditor(TIBTransaction, TIBTransactionEditor);
369 <  RegisterComponentEditor(TIBUpdateSQL, TIBUpdateSQLEditor);
370 <  RegisterComponentEditor(TIBDataSet, TIBDataSetEditor);
371 <  RegisterComponentEditor(TIBQuery, TIBQueryEditor);
372 <  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);
396 < end;
397 <
398 < { TIBFileNameProperty }
399 < procedure TIBFileNameProperty.Edit;
400 < begin
401 <  with TOpenDialog.Create(Application) do
402 <    try
403 <      InitialDir := ExtractFilePath(GetStrValue);
404 <      Filter := 'Database Files|*.gdb'; {do not localize}
405 <      if Execute then
406 <        SetStrValue(FileName);
407 <    finally
408 <      Free
409 <    end;
410 < end;
411 <
412 < function TIBFileNameProperty.GetAttributes: TPropertyAttributes;
413 < begin
414 <  Result := [paDialog];
415 < end;
416 <
417 < { TIBNameProperty }
418 <
419 < function TIBNameProperty.GetAttributes: TPropertyAttributes;
420 < begin
421 <  Result := [paValueList, paSortList];
422 < end;
423 <
424 < { TIBStoredProcNameProperty }
425 <
426 < procedure TIBStoredProcNameProperty.GetValues(Proc: TGetStrProc);
427 < var
428 <   StoredProc : TIBStoredProc;
429 <   i : integer;
430 < begin
431 <    StoredProc := GetComponent(0) as TIBStoredProc;
432 <    with StoredProc do
433 <      for I := 0 to StoredProcedureNames.Count - 1 do
434 <        Proc (StoredProcedureNames[i]);
435 < end;
436 <
437 < { TIBTableNameProperty }
438 <
439 < procedure TIBTableNameProperty.GetValues(Proc: TGetStrProc);
440 < var
441 <   TableName : TIBTable;
442 <   i : integer;
443 < begin
444 <  TableName := GetComponent(0) as TIBTable;
445 <  with TableName do
446 <    for I := 0 to TableNames.Count - 1 do
447 <      Proc (TableNames[i]);
448 < end;
449 <
450 < { TDBStringProperty }
451 <
452 < function TDBStringProperty.GetAttributes: TPropertyAttributes;
453 < begin
454 <  Result := [paValueList, paSortList, paMultiSelect];
455 < end;
456 <
457 < procedure TDBStringProperty.GetValueList(List: TStrings);
458 < begin
459 < end;
460 <
461 < procedure TDBStringProperty.GetValues(Proc: TGetStrProc);
462 < var
463 <  I: Integer;
464 <  Values: TStringList;
465 < begin
466 <  Values := TStringList.Create;
467 <  try
468 <    GetValueList(Values);
469 <    for I := 0 to Values.Count - 1 do Proc(Values[I]);
470 <  finally
471 <    Values.Free;
472 <  end;
473 < end;
474 <
475 < { Utility Functions }
476 <
477 < function GetPropertyValue(Instance: TPersistent; const PropName: string): TPersistent;
478 < var
479 <  PropInfo: PPropInfo;
480 < begin
481 <  Result := nil;
482 <  PropInfo := TypInfo.GetPropInfo(Instance.ClassInfo, PropName);
483 <  if (PropInfo <> nil) and (PropInfo^.PropType^.Kind = tkClass) then
484 <    Result := TObject(GetOrdProp(Instance, PropInfo)) as TPersistent;
485 < end;
486 <
487 < function GetIndexDefs(Component: TPersistent): TIndexDefs;
488 < var
489 <  DataSet: TDataSet;
490 < begin
491 <  DataSet := Component as TDataSet;
492 <  Result := GetPropertyValue(DataSet, 'IndexDefs') as TIndexDefs; {do not localize}
493 <  if Assigned(Result) then
494 <  begin
495 <    Result.Updated := False;
496 <    Result.Update;
497 <  end;
498 < end;
499 <
500 < { TIBIndexFieldNamesProperty }
501 <
502 < procedure TIBIndexFieldNamesProperty.GetValueList(List: TStrings);
503 < var
504 <  I: Integer;
505 <  IndexDefs: TIndexDefs;
506 < begin
507 <  IndexDefs := GetIndexDefs(GetComponent(0));
508 <  for I := 0 to IndexDefs.Count - 1 do
509 <    with IndexDefs[I] do
510 <      if (Options * [ixExpression, ixDescending] = []) and (Fields <> '') then
511 <        List.Add(Fields);
512 < end;
513 <
514 <
515 < { TIBIndexNameProperty }
516 <
517 < procedure TIBIndexNameProperty.GetValueList(List: TStrings);
518 < begin
519 <  GetIndexDefs(GetComponent(0)).GetItemNames(List);
520 < end;
521 <
522 < { TSQLPropertyEditor }
523 <
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 <
544 < function TSQLPropertyEditor.GetAttributes: TPropertyAttributes;
545 < begin
546 <  Result := inherited GetAttributes + [paDialog] - [paSubProperties];
547 < end;
548 <
549 < { TIBQuerySQLProperty }
550 <
551 < procedure TIBQuerySQLProperty.Edit;
552 < var
553 <  Query: TIBQuery;
554 < begin
555 <  Query := TIBQuery(GetComponent(0));
556 <  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;
567 < end;
568 <
569 < { TIBDatasetSQLProperty }
570 <
571 < procedure TIBDatasetSQLProperty.Edit;
572 < var
573 <  IBDataset: TIBDataset;
574 < begin
575 <  IBDataset := TIBDataset(GetComponent(0));
576 <  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;
587 < end;
588 <
589 < { TIBSQLProperty }
590 <
591 < procedure TIBSQLProperty.Edit;
592 < var
593 <  IBSQL: TIBSQL;
594 < begin
595 <  IBSQL := TIBSQL(GetComponent(0));
596 <  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;
607 < end;
608 <
609 < { TIBUpdateSQLEditor }
610 <
611 < procedure TIBUpdateSQLEditor.ExecuteVerb(Index: Integer);
612 < begin
613 <  if EditIBUpdateSQL(TIBUpdateSQL(Component)) then Designer.Modified;
614 < end;
615 <
616 < function TIBUpdateSQLEditor.GetVerb(Index: Integer): string;
617 < begin
618 <  case Index of
619 <    0 : Result := SIBUpdateSQLEditor;
620 <    2: Result := SInterbaseExpressVersion;
621 <  end;
622 < end;
623 <
624 < function TIBUpdateSQLEditor.GetVerbCount: Integer;
625 < begin
626 <  Result := 2;
627 < end;
628 <
629 < { TIBDataSetEditor }
630 <
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 <
651 < procedure TIBDataSetEditor.ExecuteVerb(Index: Integer);
652 < var
653 <  IBDataset: TIBDataset;
654 < begin
655 <  if Index < inherited GetVerbCount then
656 <    inherited ExecuteVerb(Index) else
657 <  begin
658 <    Dec(Index, inherited GetVerbCount);
659 <    case Index of
660 <      0:
661 <        if EditIBDataSet(TIBDataSet(Component)) then
662 <          Designer.Modified;
663 <      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;
679 <    end;
680 <  end;
681 < end;
682 <
683 < function TIBDataSetEditor.GetVerb(Index: Integer): string;
684 < begin
685 <  if Index < inherited GetVerbCount then
686 <    Result := inherited GetVerb(Index) else
687 <  begin
688 <    Dec(Index, inherited GetVerbCount);
689 <    case Index of
690 <      0: Result := SIBDataSetEditor;
691 <      1: Result := SExecute;
692 <      2: Result := SEditSQL;
693 <      3: Result := SInterbaseExpressVersion;
694 <    end;
695 <  end;
696 < end;
697 <
698 < function TIBDataSetEditor.GetVerbCount: Integer;
699 < begin
700 <  Result := inherited GetVerbCount + 4;
701 < end;
702 <
703 < { TIBEventListProperty }
704 <
705 < function TIBEventListProperty.GetAttributes: TPropertyAttributes;
706 < begin
707 <  Result := inherited GetAttributes + [paDialog] - [paSubProperties];
708 < end;
709 <
710 < procedure TIBEventListProperty.Edit;
711 < var
712 <  Events: TStrings;
713 < begin
714 <  Events := TStringList.Create;
715 <  try
716 <    Events.Assign( TStrings(GetOrdValue));
717 <    if EditAlerterEvents( Events) then SetOrdValue( longint(Events));
718 <  finally
719 <    Events.Free;
720 <  end;
721 < end;
722 <
723 < { TIBDatabaseEditor }
724 < procedure TIBDatabaseEditor.ExecuteVerb(Index: Integer);
725 < begin
726 <  if Index < inherited GetVerbCount then
727 <    inherited ExecuteVerb(Index) else
728 <  begin
729 <    Dec(Index, inherited GetVerbCount);
730 <    case Index of
731 <      0 : if EditIBDatabase(TIBDatabase(Component)) then Designer.Modified;
732 <    end;
733 <  end;
734 < end;
735 <
736 < function TIBDatabaseEditor.GetVerb(Index: Integer): string;
737 < begin
738 <  if Index < inherited GetVerbCount then
739 <    Result := inherited GetVerb(Index) else
740 <  begin
741 <    Dec(Index, inherited GetVerbCount);
742 <    case Index of
743 <      0: Result := SIBDatabaseEditor;
744 <      1 : Result := SInterbaseExpressVersion;
745 <    end;
746 <  end;
747 < end;
748 <
749 < function TIBDatabaseEditor.GetVerbCount: Integer;
750 < begin
751 <  Result := inherited GetVerbCount + 2;
752 < end;
753 <
754 < { TIBTransactionEditor }
755 <
756 < procedure TIBTransactionEditor.ExecuteVerb(Index: Integer);
757 < begin
758 <  case Index of
759 <    0: if EditIBTransaction(TIBTransaction(Component)) then Designer.Modified;
760 <  end;
761 < end;
762 <
763 < function TIBTransactionEditor.GetVerb(Index: Integer): string;
764 < begin
765 <  case Index of
766 <    0: Result := SIBTransactionEditor;
767 <    1: Result := SInterbaseExpressVersion;
768 <  end;
769 < end;
770 <
771 < function TIBTransactionEditor.GetVerbCount: Integer;
772 < begin
773 <  Result := 2;
774 < end;
775 <
776 < { TIBQueryEditor }
777 <
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 <
798 < procedure TIBQueryEditor.ExecuteVerb(Index: Integer);
799 < var
800 <  Query: TIBQuery;
801 < begin
802 <  if Index < inherited GetVerbCount then
803 <    inherited ExecuteVerb(Index) else
804 <  begin
805 <    Query := Component as TIBQuery;
806 <    Dec(Index, inherited GetVerbCount);
807 <    case Index of
808 <      0: Query.ExecSQL;
809 <      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;
823 <    end;
824 <  end;
825 < end;
826 <
827 < function TIBQueryEditor.GetVerb(Index: Integer): string;
828 < begin
829 <  if Index < inherited GetVerbCount then
830 <    Result := inherited GetVerb(Index) else
831 <  begin
832 <    Dec(Index, inherited GetVerbCount);
833 <    case Index of
834 <      0: Result := SExecute;
835 <      1: Result := SEditSQL;
836 <      2: Result := SInterbaseExpressVersion;
837 <    end;
838 <  end;
839 < end;
840 <
841 < function TIBQueryEditor.GetVerbCount: Integer;
842 < begin
843 <  Result := inherited GetVerbCount + 3;
844 < end;
845 <
846 < { TIBStoredProcEditor }
847 <
848 < procedure TIBStoredProcEditor.ExecuteVerb(Index: Integer);
849 < begin
850 <  if Index < inherited GetVerbCount then
851 <    inherited ExecuteVerb(Index) else
852 <  begin
853 <    Dec(Index, inherited GetVerbCount);
854 <    if Index = 0 then (Component as TIBStoredProc).ExecProc;
855 <  end;
856 < end;
857 <
858 < function TIBStoredProcEditor.GetVerb(Index: Integer): string;
859 < begin
860 <  if Index < inherited GetVerbCount then
861 <    Result := inherited GetVerb(Index) else
862 <  begin
863 <    Dec(Index, inherited GetVerbCount);
864 <    case Index of
865 <      0: Result := SExecute;
866 <      1: Result := SInterbaseExpressVersion;
867 <    end;
868 <  end;
869 < end;
870 <
871 < function TIBStoredProcEditor.GetVerbCount: Integer;
872 < begin
873 <  Result := inherited GetVerbCount + 2;
874 < end;
875 <
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 <
893 < { TIBTableFieldLinkProperty }
894 <
895 < procedure TIBTableFieldLinkProperty.Edit;
896 < begin
897 <  FTable := DataSet as TIBTable;
898 <  inherited Edit;
899 < end;
900 <
901 < function TIBTableFieldLinkProperty.GetIndexFieldNames: string;
902 < begin
903 <  Result := FTable.IndexFieldNames;
904 < end;
905 <
906 < function TIBTableFieldLinkProperty.GetMasterFields: string;
907 < begin
908 <  Result := FTable.MasterFields;
909 < end;
910 <
911 < procedure TIBTableFieldLinkProperty.SetIndexFieldNames(const Value: string);
912 < begin
913 <  FTable.IndexFieldNames := Value;
914 < end;
915 <
916 < procedure TIBTableFieldLinkProperty.SetMasterFields(const Value: string);
917 < begin
918 <  FTable.MasterFields := Value;
919 < end;
920 <
921 < { 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;
973 <
974 < class function TIBTransactionSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
975 < begin
976 <  Result := (AParent is TIBDatabaseSprig);
977 < end;
978 <
979 < { support stuff for sprigs }
980 <
981 < function IBAnyProblems(ATransaction: TIBTransaction; ADatabase: TIBDatabase): Boolean;
982 < begin
983 <  Result := (ATransaction = nil) or
984 <            (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)
994 <  else
995 <    ASprig.Root.Add(ASprig);
996 < end;
997 <
998 < 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;
1005 < var
1006 <  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;
1065 < begin
1066 <  Result := IBDragOver(AItem);
1067 < end;
1068 <
1069 < procedure TIBSQLSprig.FigureParent;
1070 < begin
1071 <  IBFigureParent(Self, TIBSQL(Item).Transaction,
1072 <                       TIBSQL(Item).Database);
1073 < end;
1074 <
1075 < class function TIBSQLSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
1076 < begin
1077 <  Result := IBDragOver(AParent);
1078 < end;
1079 <
1080 < { TIBCustomDataSetSprig }
1081 <
1082 < function TIBCustomDataSetSprig.AnyProblems: Boolean;
1083 < begin
1084 <  Result := IBAnyProblems(TIBCustomDataSet(Item).Transaction,
1085 <                          TIBCustomDataSet(Item).Database);
1086 < end;
1087 <
1088 < procedure TIBCustomDataSetSprig.FigureParent;
1089 < 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
1100 <  begin
1101 <    vTransaction := Transaction;
1102 <    vDatabase := Database;
1103 <    Result := IBDropOver(AItem, vTransaction, vDatabase);
1104 <    if Result then
1105 <    begin
1106 <      Transaction := vTransaction;
1107 <      Database := vDatabase;
1108 <    end;
1109 <  end;
1110 < end;
1111 <
1112 < 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;
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;
1203 < var
1204 <  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);
1257 < begin
1258 <  TIBQuery(AItem).DataSource := ADataSource;
1259 < end;
1260 <
1261 < { TIBCustomDataSetIsland }
1262 <
1263 < function TIBCustomDataSetIsland.VisibleTreeParent: Boolean;
1264 < begin
1265 <  Result := False;
1266 < end;
1267 <
1268 < { TIBSQLIsland }
1269 <
1270 < function TIBSQLIsland.VisibleTreeParent: Boolean;
1271 < begin
1272 <  Result := False;
1273 < end;
1274 <
1275 < { TIBTransactionIsland }
1276 <
1277 < function TIBTransactionIsland.VisibleTreeParent: Boolean;
1278 < begin
1279 <  Result := TIBTransaction(Sprig.Item).DefaultDatabase = nil;
1280 < end;
1281 <
1282 < end.
1 > {************************************************************************}
2 > {                                                                        }
3 > {       Borland Delphi Visual Component Library                          }
4 > {       InterBase Express core components                                }
5 > {                                                                        }
6 > {       Copyright (c) 1998-2000 Inprise Corporation                      }
7 > {                                                                        }
8 > {    InterBase Express is based in part on the product                   }
9 > {    Free IB Components, written by Gregory H. Deatz for                 }
10 > {    Hoagland, Longo, Moran, Dunst & Doukas Company.                     }
11 > {    Free IB Components is used under license.                           }
12 > {                                                                        }
13 > {    The contents of this file are subject to the InterBase              }
14 > {    Public License Version 1.0 (the "License"); you may not             }
15 > {    use this file except in compliance with the License. You            }
16 > {    may obtain a copy of the License at http://www.Inprise.com/IPL.html }
17 > {    Software distributed under the License is distributed on            }
18 > {    an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either              }
19 > {    express or implied. See the License for the specific language       }
20 > {    governing rights and limitations under the License.                 }
21 > {    The Original Code was created by InterBase Software Corporation     }
22 > {       and its successors.                                              }
23 > {    Portions created by Inprise Corporation are Copyright (C) Inprise   }
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 *)
42 > {$G+}                           (* Imported data: On *)
43 > {$H+}                           (* Huge Strings: On *)
44 > {$J-}                           (* Modification of Typed Constants: Off *)
45 > {$M+}                           (* Generate run-time type information: On *)
46 > {$O+}                           (* Optimization: On *)
47 > {$Q-}                           (* Overflow checks: Off *)
48 > {$R-}                           (* Range checks: Off *)
49 > {$T+}                           (* Typed address: On *)
50 > {$U+}                           (* Pentim-safe FDIVs: On *)
51 > {$W-}                           (* Always generate stack frames: Off *)
52 > {$X+}                           (* Extended syntax: On *)
53 > {$Z1}                           (* Minimum Enumeration Size: 1 Byte *)
54 >
55 > interface
56 >
57 > uses {Windows,} SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
58 >     DB, IBTable, IBDatabase,  IBEventsEditor,  LazarusPackageIntf,
59 >      IBUpdateSQL, IBXConst, ComponentEditors, PropEdits, DBPropEdits, FieldsEditor;
60 >
61 > type
62 >
63 > { TIBFileNameProperty
64 >  Property editor the DataBase Name property.  Brings up the Open dialog }
65 >
66 >  TIBFileNameProperty = class(TStringProperty)
67 >  public
68 >    procedure Edit; override;
69 >    function GetAttributes: TPropertyAttributes; override;
70 >  end;
71 >
72 >  { TIBNameProperty
73 >  }
74 >  TIBNameProperty = class(TStringProperty)
75 >  public
76 >    function GetAttributes: TPropertyAttributes; override;
77 >  end;
78 >
79 >  { TIBStoredProcNameProperty
80 >    Editor for the TIBStoredProc.StoredProcName property.  Displays a drop-down list of all
81 >    the StoredProcedures in the Database.}
82 >  TIBStoredProcNameProperty = class(TIBNameProperty)
83 >  public
84 >    procedure GetValues(Proc: TGetStrProc); override;
85 >  end;
86 >
87 >  { TIBTableNameProperty
88 >    Editor for the TIBTable.TableName property.  Displays a drop-down list of all
89 >    the Tables in the Database.}
90 >  TIBTableNameProperty = class(TIBNameProperty)
91 >  public
92 >    procedure GetValues(Proc: TGetStrProc); override;
93 >  end;
94 >
95 >  TDBStringProperty = class(TStringProperty)
96 >  public
97 >    function GetAttributes: TPropertyAttributes; override;
98 >    procedure GetValueList(List: TStrings); virtual;
99 >    procedure GetValues(Proc: TGetStrProc); override;
100 >  end;
101 >
102 >  TIBIndexFieldNamesProperty = class(TDBStringProperty)
103 >  public
104 >    procedure GetValueList(List: TStrings); override;
105 >  end;
106 >
107 >  TIBIndexNameProperty = class(TDBStringProperty)
108 >  public
109 >    procedure GetValueList(List: TStrings); override;
110 >  end;
111 >
112 > { TIBDatabaseEditor }
113 >
114 >  TIBDatabaseEditor = class(TComponentEditor)
115 >    procedure ExecuteVerb(Index: Integer); override;
116 >    function GetVerb(Index: Integer): string; override;
117 >    function GetVerbCount: Integer; override;
118 >  end;
119 >
120 > { TIBTransactionEditor }
121 >
122 >  TIBTransactionEditor = class(TComponentEditor)
123 >  public
124 >    procedure ExecuteVerb(Index: Integer); override;
125 >    function GetVerb(Index: Integer): string; override;
126 >    function GetVerbCount: Integer; override;
127 >  end;
128 >
129 > { TIBQueryEditor }
130 >
131 >  TIBQueryEditor = class(TFieldsComponentEditor)
132 >  public
133 >    procedure ExecuteVerb(Index: Integer); override;
134 >    function GetVerb(Index: Integer): string; override;
135 >    function GetVerbCount: Integer; override;
136 >  end;
137 >
138 > { TIBStoredProcEditor }
139 >
140 >  TIBStoredProcEditor = class(TFieldsComponentEditor)
141 >  public
142 >    procedure ExecuteVerb(Index: Integer); override;
143 >    function GetVerb(Index: Integer): string; override;
144 >    function GetVerbCount: Integer; override;
145 >  end;
146 >
147 > { TIBDataSetEditor }
148 >
149 >  TIBDataSetEditor = class(TFieldsComponentEditor)
150 >  public
151 >    procedure ExecuteVerb(Index: Integer); override;
152 >    function GetVerb(Index: Integer): string; override;
153 >    function GetVerbCount: Integer; override;
154 >  end;
155 >
156 > { TIBUpdateSQLEditor }
157 >
158 >  TIBUpdateSQLEditor = class(TComponentEditor)
159 >  public
160 >    procedure ExecuteVerb(Index: Integer); override;
161 >    function GetVerb(Index: Integer): string; override;
162 >   function GetVerbCount: Integer; override;
163 >  end;
164 >
165 > { TIBSQLEditor }
166 >
167 >  TIBSQLEditor  = class(TComponentEditor)
168 >  public
169 >    procedure ExecuteVerb(Index: Integer); override;
170 >    function GetVerb(Index: Integer): string; override;
171 >   function GetVerbCount: Integer; override;
172 >  end;
173 >
174 > { TIBServiceEditor}
175 >
176 >  TIBServiceEditor = class(TComponentEditor)
177 >  public
178 >    procedure ExecuteVerb(Index: Integer); override;
179 >    function GetVerb(Index: Integer): string; override;
180 >   function GetVerbCount: Integer; override;
181 >  end;
182 >
183 >  TIBStoredProcParamsProperty = class(TCollectionPropertyEditor)
184 >  public
185 >    procedure Edit; override;
186 >  end;
187 > (*
188 >  TIBTableFieldLinkProperty = class(TFieldLinkProperty)
189 >  private
190 >    FTable: TIBTable;
191 >  protected
192 >    function GetIndexFieldNames: string; override;
193 >    function GetMasterFields: string; override;
194 >    procedure SetIndexFieldNames(const Value: string); override;
195 >    procedure SetMasterFields(const Value: string); override;
196 >  public
197 >    procedure Edit; override;
198 >  end;
199 > *)
200 > { TSQLPropertyEditor }
201 >
202 >  TSQLPropertyEditor = class(TStringsPropertyEditor)
203 >  public
204 >    function GetAttributes: TPropertyAttributes; override;
205 >  end;
206 >
207 > { TIBQuerySQLProperty }
208 >
209 >  TIBQuerySQLProperty = class(TSQLPropertyEditor)
210 >  public
211 >    procedure Edit; override;
212 >  end;
213 >
214 > {TIBSQLSQLPropertyEditor }
215 >
216 >  TIBSQLSQLPropertyEditor = class(TSQLPropertyEditor)
217 >  public
218 >    procedure Edit; override;
219 >  end;
220 >
221 > { TIBDatasetSQLProperty }
222 >
223 >  TIBDatasetSQLProperty = class(TSQLPropertyEditor)
224 >  public
225 >    procedure Edit; override;
226 >  end;
227 >
228 > { TIBSQLProperty }
229 >
230 >  TIBSQLProperty = class(TSQLPropertyEditor)
231 >  public
232 >    procedure Edit; override;
233 >  end;
234 >
235 > { TUpdateSQLPropertyEditor }
236 >
237 >   TUpdateSQLPropertyEditor = class(TSQLPropertyEditor)
238 >   protected
239 >     FIBUpdateSQL: TIBUpdateSQL;
240 >     FDatabase: TIBDatabase;
241 >     function GetObjects: boolean;
242 >   end;
243 >
244 > { TIBUpdateSQLProperty }
245 >
246 >  TIBUpdateSQLProperty = class(TSQLPropertyEditor)
247 >  public
248 >    procedure Edit; override;
249 >  end;
250 >
251 > { TIBRefreshSQLProperty }
252 >
253 >  TIBRefreshSQLProperty = class(TSQLPropertyEditor)
254 >  public
255 >    procedure Edit; override;
256 >  end;
257 >
258 > { TIBInsertSQLProperty }
259 >
260 >  TIBInsertSQLProperty = class(TSQLPropertyEditor)
261 >  public
262 >    procedure Edit; override;
263 >  end;
264 >
265 > { TIBDeleteSQLProperty }
266 >
267 >  TIBDeleteSQLProperty = class(TSQLPropertyEditor)
268 >  public
269 >    procedure Edit; override;
270 >  end;
271 >
272 >  { TIBUpdateSQLUpdateProperty }
273 >
274 >  TIBUpdateSQLUpdateProperty = class(TUpdateSQLPropertyEditor)
275 >  public
276 >    procedure Edit; override;
277 >  end;
278 >
279 > { TIBUpdateSQLRefreshSQLProperty }
280 >
281 >  TIBUpdateSQLRefreshSQLProperty = class(TUpdateSQLPropertyEditor)
282 >  public
283 >    procedure Edit; override;
284 >  end;
285 >
286 > { TIBUpdateSQLInsertSQLProperty }
287 >
288 >  TIBUpdateSQLInsertSQLProperty = class(TUpdateSQLPropertyEditor)
289 >  public
290 >    procedure Edit; override;
291 >  end;
292 >
293 >  { TIBUpdateSQLDeleteProperty }
294 >
295 >  TIBUpdateSQLDeleteProperty = class(TUpdateSQLPropertyEditor)
296 >  public
297 >    function GetAttributes: TPropertyAttributes; override;
298 >    procedure Edit; override;
299 >  end;
300 >
301 > { TIBEventListProperty }
302 >
303 >  TIBEventListProperty = class(TClassProperty)
304 >  public
305 >    function GetAttributes: TPropertyAttributes; override;
306 >    procedure Edit; override;
307 >  end;
308 >
309 > {TIBGeneratorProperty}
310 >
311 >  TIBGeneratorProperty = class(TPersistentPropertyEditor)
312 >  public
313 >    function GetAttributes: TPropertyAttributes; override;
314 >    procedure Edit; override;
315 >  end;
316 >
317 > procedure Register;
318 >
319 > implementation
320 >
321 > uses IB, IBQuery, IBStoredProc, IBCustomDataSet,
322 >     IBIntf, IBSQL, IBSQLMonitor, IBDatabaseInfo, IBEvents,
323 >     IBServices, IBDatabaseEdit, IBTransactionEdit,
324 >     IBBatchMove, DBLoginDlg, IBExtract,LResources, IBSelectSQLEditor,
325 >     IBModifySQLEditor,IBDeleteSQLEditor,IBRefreshSQLEditor,
326 >     IBInsertSQLEditor, IBGeneratorEditor, IBUpdateSQLEditor, IBDataSetEditor,
327 >     IBSQLEditor, ibserviceeditor, LCLVersion;
328 >
329 >
330 >
331 > procedure Register;
332 > begin
333 >  if not TryIBLoad then
334 >  begin
335 >    MessageDlg('IBX is unable to locate the Firebird Library - have you remembered to install it?',mtError,[mbOK],0);
336 >    Exit;
337 >  end;
338 >
339 >  RegisterNoIcon([TIBStringField, TIBBCDField]);
340 >  {$if lcl_fullversion < 01010000}
341 >  {see http://bugs.freepascal.org/view.php?id=19035 }
342 >  RegisterNoIcon([TIntegerField]);
343 >  {$endif}
344 >  RegisterComponents(IBPalette1, [ TIBQuery, TIBDataSet,
345 >   TIBDatabase, TIBTransaction, TIBUpdateSQL, TIBEvents,
346 >     TIBSQL, TIBDatabaseInfo, TIBSQLMonitor,
347 >       TIBStoredProc,TIBBatchMove,  TIBTable,TIBExtract]);
348 >  if IBServiceAPIPresent  then
349 >    RegisterComponents(IBPalette2, [TIBConfigService, TIBBackupService,
350 >      TIBRestoreService, TIBValidationService, TIBStatisticalService,
351 >      TIBLogService, TIBSecurityService, TIBServerProperties]);
352 >  RegisterPropertyEditor(TypeInfo(TIBFileName), TIBDatabase, 'DatabaseName', TIBFileNameProperty); {do not localize}
353 >  RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'StoredProcName', TIBStoredProcNameProperty); {do not localize}
354 >  RegisterPropertyEditor(TypeInfo(TParams), TIBStoredProc, 'Params', TIBStoredProcParamsProperty);
355 >  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'TableName', TIBTableNameProperty); {do not localize}
356 >  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexName', TIBIndexNameProperty); {do not localize}
357 >  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexFieldNames', TIBIndexFieldNamesProperty); {do not localize}
358 > //  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'MasterFields', TIBTableFieldLinkProperty); {do not localize}
359 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBQuery, 'SQL', TIBQuerySQLProperty); {do not localize}
360 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'SelectSQL', TIBDatasetSQLProperty); {do not localize}
361 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'ModifySQL', TIBUpdateSQLProperty); {do not localize}
362 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'InsertSQL', TIBInsertSQLProperty); {do not localize}
363 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'RefreshSQL', TIBRefreshSQLProperty); {do not localize}
364 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'DeleteSQL', TIBDeleteSQLProperty); {do not localize}
365 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLSQLPropertyEditor); {do not localize}
366 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'RefreshSQL', TIBUpdateSQLRefreshSQLProperty); {do not localize}
367 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'ModifySQL', TIBUpdateSQLUpdateProperty); {do not localize}
368 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'InsertSQL', TIBUpdateSQLInsertSQLProperty); {do not localize}
369 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'DeleteSQL', TIBUpdateSQLDeleteProperty); {do not localize}
370 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBEvents, 'Events', TIBEventListProperty); {do not localize}
371 >  RegisterPropertyEditor(TypeInfo(TPersistent), TIBDataSet, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
372 >  RegisterPropertyEditor(TypeInfo(TPersistent), TIBQuery, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
373 >
374 >  RegisterComponentEditor(TIBDatabase, TIBDatabaseEditor);
375 >  RegisterComponentEditor(TIBTransaction, TIBTransactionEditor);
376 >  RegisterComponentEditor(TIBUpdateSQL, TIBUpdateSQLEditor);
377 >  RegisterComponentEditor(TIBDataSet, TIBDataSetEditor);
378 >  RegisterComponentEditor(TIBQuery, TIBQueryEditor);
379 >  RegisterComponentEditor(TIBStoredProc, TIBStoredProcEditor);
380 >  RegisterComponentEditor(TIBSQL, TIBSQLEditor);
381 >  RegisterComponentEditor(TIBCustomService, TIBServiceEditor);
382 > end;
383 >
384 > { TIBServiceEditor }
385 >
386 > procedure TIBServiceEditor.ExecuteVerb(Index: Integer);
387 > begin
388 >  if Index < inherited GetVerbCount then
389 >    inherited ExecuteVerb(Index) else
390 >  begin
391 >    Dec(Index, inherited GetVerbCount);
392 >    case Index of
393 >      0 : if ibserviceeditor.EditIBService(TIBCustomService(Component)) then Designer.Modified;
394 >    end;
395 >  end;
396 > end;
397 >
398 > function TIBServiceEditor.GetVerb(Index: Integer): string;
399 > begin
400 >  if Index < inherited GetVerbCount then
401 >    Result := inherited GetVerb(Index) else
402 >  begin
403 >    Dec(Index, inherited GetVerbCount);
404 >    case Index of
405 >      0: Result := SIBServiceEditor;
406 >      1 : Result := SInterbaseExpressVersion;
407 >    end;
408 >  end;
409 > end;
410 >
411 > function TIBServiceEditor.GetVerbCount: Integer;
412 > begin
413 >  Result := inherited GetVerbCount + 2;
414 > end;
415 >
416 > { TIBFileNameProperty }
417 > procedure TIBFileNameProperty.Edit;
418 > begin
419 >  with TOpenDialog.Create(Application) do
420 >    try
421 >      InitialDir := ExtractFilePath(GetStrValue);
422 >      Filter := SDatabaseFilter; {do not localize}
423 >      if Execute then
424 >        SetStrValue(FileName);
425 >    finally
426 >      Free
427 >    end;
428 > end;
429 >
430 > function TIBFileNameProperty.GetAttributes: TPropertyAttributes;
431 > begin
432 >  Result := [paDialog];
433 > end;
434 >
435 > { TIBNameProperty }
436 >
437 > function TIBNameProperty.GetAttributes: TPropertyAttributes;
438 > begin
439 >  Result := [paValueList, paSortList];
440 > end;
441 >
442 > { TIBStoredProcNameProperty }
443 >
444 > procedure TIBStoredProcNameProperty.GetValues(Proc: TGetStrProc);
445 > var
446 >   StoredProc : TIBStoredProc;
447 >   i : integer;
448 > begin
449 >    StoredProc := GetComponent(0) as TIBStoredProc;
450 >    if StoredProc.Database = nil then
451 >      Exit;
452 >
453 >    with StoredProc do
454 >    try
455 >      for I := 0 to StoredProcedureNames.Count - 1 do
456 >        Proc (StoredProcedureNames[i]);
457 >    except on E: Exception do
458 >      MessageDlg(E.Message,mtError,[mbOK],0)
459 >    end;
460 > end;
461 >
462 > { TIBTableNameProperty }
463 >
464 > procedure TIBTableNameProperty.GetValues(Proc: TGetStrProc);
465 > var
466 >   TableName : TIBTable;
467 >   i : integer;
468 > begin
469 >  TableName := GetComponent(0) as TIBTable;
470 >  with TableName do
471 >    for I := 0 to TableNames.Count - 1 do
472 >      Proc (TableNames[i]);
473 > end;
474 >
475 > { TDBStringProperty }
476 >
477 > function TDBStringProperty.GetAttributes: TPropertyAttributes;
478 > begin
479 >  Result := [paValueList, paSortList, paMultiSelect];
480 > end;
481 >
482 > procedure TDBStringProperty.GetValueList(List: TStrings);
483 > begin
484 > end;
485 >
486 > procedure TDBStringProperty.GetValues(Proc: TGetStrProc);
487 > var
488 >  I: Integer;
489 >  Values: TStringList;
490 > begin
491 >  Values := TStringList.Create;
492 >  try
493 >    GetValueList(Values);
494 >    for I := 0 to Values.Count - 1 do Proc(Values[I]);
495 >  finally
496 >    Values.Free;
497 >  end;
498 > end;
499 >
500 > { Utility Functions }
501 >
502 > function GetPropertyValue(Instance: TPersistent; const PropName: string): TPersistent;
503 > var
504 >  PropInfo: PPropInfo;
505 > begin
506 >  Result := nil;
507 >  PropInfo := TypInfo.GetPropInfo(Instance.ClassInfo, PropName);
508 >  if (PropInfo <> nil) and (PropInfo^.PropType^.Kind = tkClass) then
509 >    Result := TObject(GetOrdProp(Instance, PropInfo)) as TPersistent;
510 > end;
511 >
512 > function GetIndexDefs(Component: TPersistent): TIndexDefs;
513 > var
514 >  DataSet: TDataSet;
515 > begin
516 >  DataSet := Component as TDataSet;
517 >  Result := GetPropertyValue(DataSet, 'IndexDefs') as TIndexDefs; {do not localize}
518 >  if Assigned(Result) then
519 >  begin
520 >    Result.Updated := False;
521 >    Result.Update;
522 >  end;
523 > end;
524 >
525 > { TIBIndexFieldNamesProperty }
526 >
527 > procedure TIBIndexFieldNamesProperty.GetValueList(List: TStrings);
528 > var
529 >  I: Integer;
530 >  IndexDefs: TIndexDefs;
531 > begin
532 >  IndexDefs := GetIndexDefs(GetComponent(0));
533 >  for I := 0 to IndexDefs.Count - 1 do
534 >    with IndexDefs[I] do
535 >      if (Options * [ixExpression, ixDescending] = []) and (Fields <> '') then
536 >        List.Add(Fields);
537 > end;
538 >
539 >
540 > { TIBIndexNameProperty }
541 >
542 > procedure TIBIndexNameProperty.GetValueList(List: TStrings);
543 > begin
544 >  GetIndexDefs(GetComponent(0)).GetItemNames(List);
545 > end;
546 >
547 > { TSQLPropertyEditor }
548 >
549 > function TSQLPropertyEditor.GetAttributes: TPropertyAttributes;
550 > begin
551 >  Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
552 > end;
553 >
554 > { TIBQuerySQLProperty }
555 >
556 > procedure TIBQuerySQLProperty.Edit;
557 > var
558 >  Query: TIBQuery;
559 > begin
560 >  Query := GetComponent(0) as TIBQuery;
561 >  if IBSelectSQLEditor.EditSQL(Query.Database,Query.SQL) then Modified;
562 > end;
563 >
564 > { TIBDatasetSQLProperty }
565 >
566 > procedure TIBDatasetSQLProperty.Edit;
567 > var
568 >  IBDataset: TIBDataset;
569 > begin
570 >  IBDataset := GetComponent(0) as TIBDataset;
571 >  if IBSelectSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.SelectSQL) then Modified;
572 > end;
573 >
574 > { TIBSQLProperty }
575 >
576 > procedure TIBSQLProperty.Edit;
577 > var
578 >  IBSQL: TIBSQL;
579 > begin
580 >  IBSQL := GetComponent(0) as TIBSQL;
581 >  if IBSelectSQLEditor.EditSQL(IBSQL.Database,IBSQL.SQL) then Modified;
582 > end;
583 >
584 > { TIBUpdateSQLEditor }
585 >
586 > procedure TIBUpdateSQLEditor.ExecuteVerb(Index: Integer);
587 > begin
588 >  if IBUpdateSQLEditor.EditIBUpdateSQL(TIBUpdateSQL(Component)) then Modified;
589 > end;
590 >
591 > function TIBUpdateSQLEditor.GetVerb(Index: Integer): string;
592 > begin
593 >  case Index of
594 >    0 : Result := SIBUpdateSQLEditor;
595 >    1: Result := SInterbaseExpressVersion;
596 >  end;
597 > end;
598 >
599 > function TIBUpdateSQLEditor.GetVerbCount: Integer;
600 > begin
601 >  Result :=  2;
602 > end;
603 >
604 > { TIBDataSetEditor }
605 >
606 > procedure TIBDataSetEditor.ExecuteVerb(Index: Integer);
607 > var
608 >  IBDataset: TIBDataset;
609 > begin
610 >  if Index < inherited GetVerbCount then
611 >    inherited ExecuteVerb(Index) else
612 >  begin
613 >    Dec(Index, inherited GetVerbCount);
614 >    case Index of
615 >      0:
616 >        if IBDataSetEditor.EditIBDataSet(TIBDataSet(Component)) then
617 >          Designer.Modified;
618 >      1: (Component as TIBDataSet).ExecSQL;
619 >    end;
620 >  end;
621 > end;
622 >
623 > function TIBDataSetEditor.GetVerb(Index: Integer): string;
624 > begin
625 >  if Index < inherited GetVerbCount then
626 >    Result := inherited GetVerb(Index) else
627 >  begin
628 >    Dec(Index, inherited GetVerbCount);
629 >    case Index of
630 >      0: Result := SIBDataSetEditor;
631 >      1: Result := SExecute;
632 >      2: Result := SInterbaseExpressVersion;
633 >    end;
634 >  end;
635 > end;
636 >
637 > function TIBDataSetEditor.GetVerbCount: Integer;
638 > begin
639 >  Result := inherited GetVerbCount + 3;
640 > end;
641 >
642 > { TIBEventListProperty }
643 >
644 > function TIBEventListProperty.GetAttributes: TPropertyAttributes;
645 > begin
646 >  Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
647 > end;
648 >
649 > procedure TIBEventListProperty.Edit;
650 > var
651 >  Events: TStrings;
652 >  IBEvents: TIBEvents;
653 > begin
654 >  IBEvents := GetComponent(0) as TIBEvents;
655 >  Events := TStringList.Create;
656 >  try
657 >    Events.Assign( IBEvents.Events);
658 >    if EditAlerterEvents( Events) then
659 >    begin
660 >      IBEvents.Events.Assign(Events);
661 >      Modified
662 >    end;
663 >  finally
664 >    Events.Free;
665 >  end;
666 > end;
667 >
668 > { TIBDatabaseEditor }
669 > procedure TIBDatabaseEditor.ExecuteVerb(Index: Integer);
670 > begin
671 >  if Index < inherited GetVerbCount then
672 >    inherited ExecuteVerb(Index) else
673 >  begin
674 >    Dec(Index, inherited GetVerbCount);
675 >    case Index of
676 >      0 : if EditIBDatabase(TIBDatabase(Component)) then Designer.Modified;
677 >    end;
678 >  end;
679 > end;
680 >
681 > function TIBDatabaseEditor.GetVerb(Index: Integer): string;
682 > begin
683 >  if Index < inherited GetVerbCount then
684 >    Result := inherited GetVerb(Index) else
685 >  begin
686 >    Dec(Index, inherited GetVerbCount);
687 >    case Index of
688 >      0: Result := SIBDatabaseEditor;
689 >      1 : Result := SInterbaseExpressVersion;
690 >    end;
691 >  end;
692 > end;
693 >
694 > function TIBDatabaseEditor.GetVerbCount: Integer;
695 > begin
696 >  Result := inherited GetVerbCount + 2;
697 > end;
698 >
699 > { TIBTransactionEditor }
700 >
701 > procedure TIBTransactionEditor.ExecuteVerb(Index: Integer);
702 > begin
703 >  case Index of
704 >    0: if EditIBTransaction(TIBTransaction(Component)) then Designer.Modified;
705 >  end;
706 > end;
707 >
708 > function TIBTransactionEditor.GetVerb(Index: Integer): string;
709 > begin
710 >  case Index of
711 >    0: Result := SIBTransactionEditor;
712 >    1: Result := SInterbaseExpressVersion;
713 >  end;
714 > end;
715 >
716 > function TIBTransactionEditor.GetVerbCount: Integer;
717 > begin
718 >  Result := 2;
719 > end;
720 >
721 > { TIBQueryEditor }
722 >
723 > procedure TIBQueryEditor.ExecuteVerb(Index: Integer);
724 > var
725 >  Query: TIBQuery;
726 > begin
727 >  if Index < inherited GetVerbCount then
728 >    inherited ExecuteVerb(Index) else
729 >  begin
730 >    Query := Component as TIBQuery;
731 >    Dec(Index, inherited GetVerbCount);
732 >    case Index of
733 >      0: Query.ExecSQL;
734 >      1: if ibselectsqleditor.EditSQL(Query.Database,Query.SQL) then Designer.Modified;
735 >    end;
736 >  end;
737 > end;
738 >
739 > function TIBQueryEditor.GetVerb(Index: Integer): string;
740 > begin
741 >  if Index < inherited GetVerbCount then
742 >    Result := inherited GetVerb(Index) else
743 >  begin
744 >    Dec(Index, inherited GetVerbCount);
745 >    case Index of
746 >      0: Result := SExecute;
747 >      1: Result := SEditSQL;
748 >      2: Result := SInterbaseExpressVersion;
749 >    end;
750 >  end;
751 > end;
752 >
753 > function TIBQueryEditor.GetVerbCount: Integer;
754 > begin
755 >  Result := inherited GetVerbCount + 3;
756 > end;
757 >
758 > { TIBStoredProcEditor }
759 >
760 > procedure TIBStoredProcEditor.ExecuteVerb(Index: Integer);
761 > begin
762 >  if Index < inherited GetVerbCount then
763 >    inherited ExecuteVerb(Index) else
764 >  begin
765 >    Dec(Index, inherited GetVerbCount);
766 >    if Index = 0 then (Component as TIBStoredProc).ExecProc;
767 >  end;
768 > end;
769 >
770 > function TIBStoredProcEditor.GetVerb(Index: Integer): string;
771 > begin
772 >  if Index < inherited GetVerbCount then
773 >    Result := inherited GetVerb(Index) else
774 >  begin
775 >    Dec(Index, inherited GetVerbCount);
776 >    case Index of
777 >      0: Result := SExecute;
778 >      1: Result := SInterbaseExpressVersion;
779 >    end;
780 >  end;
781 > end;
782 >
783 > function TIBStoredProcEditor.GetVerbCount: Integer;
784 > begin
785 >  Result := inherited GetVerbCount + 2;
786 > end;
787 >
788 > { TIBStoredProcParamsProperty }
789 >
790 > procedure TIBStoredProcParamsProperty.Edit;
791 > var
792 >  StoredProc: TIBStoredProc;
793 >  Params: TParams;
794 > begin
795 >  StoredProc := (GetComponent(0) as TIBStoredProc);
796 >  Params := TParams.Create(nil);
797 >  try
798 >    StoredProc.CopyParams(Params);
799 >  finally
800 >    Params.Free;
801 >  end;
802 >  inherited Edit;
803 > end;
804 > (*
805 > { TIBTableFieldLinkProperty }
806 >
807 > procedure TIBTableFieldLinkProperty.Edit;
808 > begin
809 >  FTable := DataSet as TIBTable;
810 >  inherited Edit;
811 > end;
812 >
813 > function TIBTableFieldLinkProperty.GetIndexFieldNames: string;
814 > begin
815 >  Result := FTable.IndexFieldNames;
816 > end;
817 >
818 > function TIBTableFieldLinkProperty.GetMasterFields: string;
819 > begin
820 >  Result := FTable.MasterFields;
821 > end;
822 >
823 > procedure TIBTableFieldLinkProperty.SetIndexFieldNames(const Value: string);
824 > begin
825 >  FTable.IndexFieldNames := Value;
826 > end;
827 >
828 > procedure TIBTableFieldLinkProperty.SetMasterFields(const Value: string);
829 > begin
830 >  FTable.MasterFields := Value;
831 > end;*)
832 >
833 > { TIBUpdateSQLProperty }
834 >
835 > procedure TIBUpdateSQLProperty.Edit;
836 > var
837 >  IBDataset: TIBDataset;
838 > begin
839 >  IBDataset := GetComponent(0) as TIBDataset;
840 >  if IBModifySQLEditor.EditSQL(IBDataSet.Database,IBDataSet.ModifySQL) then Modified;
841 > end;
842 >
843 > { TIBUpdateSQLUpdateProperty }
844 >
845 > procedure TIBUpdateSQLUpdateProperty.Edit;
846 > begin
847 >  GetObjects;
848 >  if IBModifySQLEditor.EditSQL(FDatabase,FIBUpdateSQL.ModifySQL) then Modified;
849 > end;
850 >
851 > { TIBRefreshSQLProperty }
852 >
853 > procedure TIBRefreshSQLProperty.Edit;
854 > var
855 >  IBDataset: TIBDataset;
856 >  aDatabase: TIBDatabase;
857 > begin
858 >  IBDataset := GetComponent(0) as TIBDataset;
859 >  if IBRefreshSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.RefreshSQL) then Modified;
860 > end;
861 >
862 > { TIBUpdateSQLRefreshSQLProperty }
863 >
864 > procedure TIBUpdateSQLRefreshSQLProperty.Edit;
865 > begin
866 >  GetObjects;
867 >  if IBRefreshSQLEditor.EditSQL(FDatabase,FIBUpdateSQL.RefreshSQL) then Modified;
868 > end;
869 >
870 > { TIBDeleteSQLProperty }
871 >
872 > procedure TIBDeleteSQLProperty.Edit;
873 > var
874 >  IBDataset: TIBDataset;
875 > begin
876 >  IBDataset := GetComponent(0) as TIBDataset;
877 >  if IBDeleteSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.DeleteSQL) then Modified;
878 > end;
879 >
880 > { TIBUpdateSQLDeleteProperty }
881 >
882 > function TIBUpdateSQLDeleteProperty.GetAttributes: TPropertyAttributes;
883 > begin
884 >  Result:=inherited GetAttributes;
885 > end;
886 >
887 > procedure TIBUpdateSQLDeleteProperty.Edit;
888 > begin
889 >  GetObjects;
890 >  if IBDeleteSQLEditor.EditSQL(FDatabase,FIBUpdateSQL.DeleteSQL) then Modified;
891 > end;
892 >
893 > { TUpdateSQLPropertyEditor }
894 >
895 > function TUpdateSQLPropertyEditor.GetObjects: boolean;
896 > begin
897 >  Result := false;
898 >  FIBUpdateSQL := GetComponent(0) as TIBUpdateSQL;
899 >  if not assigned(FIBUpdateSQL) or not assigned(FIBUpdateSQL.DataSet) then
900 >    Exit;
901 >  FDatabase := nil;
902 >  if FIBUpdateSQL.DataSet is TIBQuery then
903 >  begin
904 >    FDatabase := (FIBUpdateSQL.DataSet as TIBQuery).Database;
905 >    Result := true
906 >  end;
907 > end;
908 >
909 > { TIBInsertSQLProperty }
910 >
911 > procedure TIBInsertSQLProperty.Edit;
912 > var
913 >  IBDataset: TIBDataset;
914 > begin
915 >  IBDataset := GetComponent(0) as TIBDataset;
916 >  if IBInsertSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.InsertSQL) then Modified;
917 > end;
918 >
919 > { TIBUpdateSQLInsertSQLProperty }
920 >
921 > procedure TIBUpdateSQLInsertSQLProperty.Edit;
922 > begin
923 >  GetObjects;
924 >  if IBInsertSQLEditor.EditSQL(FDatabase,FIBUpdateSQL.InsertSQL) then Modified;
925 > end;
926 >
927 > { TIBGeneratorProperty }
928 >
929 > function TIBGeneratorProperty.GetAttributes: TPropertyAttributes;
930 > begin
931 >  Result:= inherited GetAttributes + [paDialog] - [paMultiSelect,paValueList];
932 > end;
933 >
934 > procedure TIBGeneratorProperty.Edit;
935 > begin
936 >  if IBGeneratorEditor.EditGenerator(GetPersistentReference as TIBGenerator) then Modified;
937 > end;
938 >
939 > { TIBSQLEditor }
940 >
941 > procedure TIBSQLEditor.ExecuteVerb(Index: Integer);
942 > begin
943 >  if IBSQLEditor.EditIBSQL(TIBSQL(Component)) then Modified;
944 > end;
945 >
946 > function TIBSQLEditor.GetVerb(Index: Integer): string;
947 > begin
948 >  case Index of
949 >    0 : Result := SIBSQLEditor;
950 >    1: Result := SInterbaseExpressVersion;
951 >  end;
952 > end;
953 >
954 > function TIBSQLEditor.GetVerbCount: Integer;
955 > begin
956 >  Result:= 2
957 > end;
958 >
959 > { TIBSQLSQLPropertyEditor }
960 >
961 > procedure TIBSQLSQLPropertyEditor.Edit;
962 > var
963 >  IBSQL: TIBSQL;
964 > begin
965 >  IBSQL := GetComponent(0) as TIBSQL;
966 >  if IBSQLEditor.EditIBSQL(IBSQL) then Modified;
967 > end;
968 >
969 > initialization
970 >  {$I IBDBReg.lrs}
971 > end.

Diff Legend

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