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 19 by tony, Mon Jul 7 13:00:15 2014 UTC vs.
Revision 315 by tony, Thu Feb 25 11:56:36 2021 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 < {    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 SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
58 <     DB, IBTable, IBDatabase,  IBEventsEditor,  LazarusPackageIntf,
59 <      IBUpdateSQL, IBXConst, ComponentEditors, PropEdits, DBPropEdits, FieldsEditor,
60 <     dbFieldLinkPropEditor;
61 <
62 < type
63 <
64 < { TIBFileNameProperty
65 <  Property editor the DataBase Name property.  Brings up the Open dialog }
66 <
67 <  TIBFileNameProperty = class(TStringProperty)
68 <  public
69 <    procedure Edit; override;
70 <    function GetAttributes: TPropertyAttributes; override;
71 <  end;
72 <
73 <  { TIBNameProperty
74 <  }
75 <  TIBNameProperty = class(TStringProperty)
76 <  public
77 <    function GetAttributes: TPropertyAttributes; override;
78 <  end;
79 <
80 <  { TIBStoredProcNameProperty
81 <    Editor for the TIBStoredProc.StoredProcName property.  Displays a drop-down list of all
82 <    the StoredProcedures in the Database.}
83 <  TIBStoredProcNameProperty = class(TIBNameProperty)
84 <  public
85 <    procedure GetValues(Proc: TGetStrProc); override;
86 <  end;
87 <
88 <  { TIBTableNameProperty
89 <    Editor for the TIBTable.TableName property.  Displays a drop-down list of all
90 <    the Tables in the Database.}
91 <  TIBTableNameProperty = class(TIBNameProperty)
92 <  public
93 <    procedure GetValues(Proc: TGetStrProc); override;
94 <  end;
95 <
96 <  { TDBStringProperty }
97 <
98 <  TDBStringProperty = class(TStringProperty)
99 <  private
100 <    function ConnecttoDB: boolean;
101 <  public
102 <    function GetAttributes: TPropertyAttributes; override;
103 <    procedure GetValueList(List: TStrings); virtual;
104 <    procedure GetValues(Proc: TGetStrProc); override;
105 <    procedure Edit; override;
106 <  end;
107 <
108 <  { TIBIndexFieldNamesProperty }
109 <
110 <  TIBIndexFieldNamesProperty = class(TDBStringProperty)
111 <  public
112 <    procedure GetValueList(List: TStrings); override;
113 <  end;
114 <
115 <  TIBIndexNameProperty = class(TDBStringProperty)
116 <  public
117 <    procedure GetValueList(List: TStrings); override;
118 <  end;
119 <
120 < { TIBDatabaseEditor }
121 <
122 <  TIBDatabaseEditor = class(TComponentEditor)
123 <    procedure ExecuteVerb(Index: Integer); override;
124 <    function GetVerb(Index: Integer): string; override;
125 <    function GetVerbCount: Integer; override;
126 <  end;
127 <
128 < { TIBTransactionEditor }
129 <
130 <  TIBTransactionEditor = class(TComponentEditor)
131 <  public
132 <    procedure ExecuteVerb(Index: Integer); override;
133 <    function GetVerb(Index: Integer): string; override;
134 <    function GetVerbCount: Integer; override;
135 <  end;
136 <
137 < { TIBQueryEditor }
138 <
139 <  TIBQueryEditor = class(TFieldsComponentEditor)
140 <  public
141 <    procedure ExecuteVerb(Index: Integer); override;
142 <    function GetVerb(Index: Integer): string; override;
143 <    function GetVerbCount: Integer; override;
144 <  end;
145 <
146 < { TIBStoredProcEditor }
147 <
148 <  TIBStoredProcEditor = class(TFieldsComponentEditor)
149 <  public
150 <    procedure ExecuteVerb(Index: Integer); override;
151 <    function GetVerb(Index: Integer): string; override;
152 <    function GetVerbCount: Integer; override;
153 <  end;
154 <
155 < { TIBDataSetEditor }
156 <
157 <  TIBDataSetEditor = class(TFieldsComponentEditor)
158 <  public
159 <    procedure ExecuteVerb(Index: Integer); override;
160 <    function GetVerb(Index: Integer): string; override;
161 <    function GetVerbCount: Integer; override;
162 <  end;
163 <
164 < { TIBUpdateSQLEditor }
165 <
166 <  TIBUpdateSQLEditor = class(TComponentEditor)
167 <  public
168 <    procedure ExecuteVerb(Index: Integer); override;
169 <    function GetVerb(Index: Integer): string; override;
170 <   function GetVerbCount: Integer; override;
171 <  end;
172 <
173 < { TIBSQLEditor }
174 <
175 <  TIBSQLEditor  = class(TComponentEditor)
176 <  public
177 <    procedure ExecuteVerb(Index: Integer); override;
178 <    function GetVerb(Index: Integer): string; override;
179 <   function GetVerbCount: Integer; override;
180 <  end;
181 <
182 < { TIBServiceEditor}
183 <
184 <  TIBServiceEditor = class(TComponentEditor)
185 <  public
186 <    procedure ExecuteVerb(Index: Integer); override;
187 <    function GetVerb(Index: Integer): string; override;
188 <   function GetVerbCount: Integer; override;
189 <  end;
190 <
191 <  TIBStoredProcParamsProperty = class(TCollectionPropertyEditor)
192 <  public
193 <    procedure Edit; override;
194 <  end;
195 <
196 <  { TIBTableFieldLinkProperty }
197 <
198 <  TIBTableFieldLinkProperty = class(TFieldLinkProperty)
199 <  private
200 <    FTable: TIBTable;
201 <  protected
202 <    function GetIndexDefs: TIndexDefs; override;
203 <    function GetIndexFieldNames: string; override;
204 <    function GetMasterFields: string; override;
205 <    procedure SetIndexFieldNames(const Value: string); override;
206 <    procedure SetMasterFields(const Value: string); override;
207 <  public
208 <    procedure Edit; override;
209 <  end;
210 <
211 < { TSQLPropertyEditor }
212 <
213 <  TSQLPropertyEditor = class(TStringsPropertyEditor)
214 <  public
215 <    function GetAttributes: TPropertyAttributes; override;
216 <  end;
217 <
218 < { TIBQuerySQLProperty }
219 <
220 <  TIBQuerySQLProperty = class(TSQLPropertyEditor)
221 <  public
222 <    procedure Edit; override;
223 <  end;
224 <
225 < {TIBSQLSQLPropertyEditor }
226 <
227 <  TIBSQLSQLPropertyEditor = class(TSQLPropertyEditor)
228 <  public
229 <    procedure Edit; override;
230 <  end;
231 <
232 < { TIBDatasetSQLProperty }
233 <
234 <  TIBDatasetSQLProperty = class(TSQLPropertyEditor)
235 <  public
236 <    procedure Edit; override;
237 <  end;
238 <
239 < { TIBSQLProperty }
240 <
241 <  TIBSQLProperty = class(TSQLPropertyEditor)
242 <  public
243 <    procedure Edit; override;
244 <  end;
245 <
246 < { TUpdateSQLPropertyEditor }
247 <
248 <   TUpdateSQLPropertyEditor = class(TSQLPropertyEditor)
249 <   protected
250 <     FIBUpdateSQL: TIBUpdateSQL;
251 <     FDatabase: TIBDatabase;
252 <     function GetObjects: boolean;
253 <   end;
254 <
255 < { TIBUpdateSQLProperty }
256 <
257 <  TIBUpdateSQLProperty = class(TSQLPropertyEditor)
258 <  public
259 <    procedure Edit; override;
260 <  end;
261 <
262 < { TIBRefreshSQLProperty }
263 <
264 <  TIBRefreshSQLProperty = class(TSQLPropertyEditor)
265 <  public
266 <    procedure Edit; override;
267 <  end;
268 <
269 < { TIBInsertSQLProperty }
270 <
271 <  TIBInsertSQLProperty = class(TSQLPropertyEditor)
272 <  public
273 <    procedure Edit; override;
274 <  end;
275 <
276 < { TIBDeleteSQLProperty }
277 <
278 <  TIBDeleteSQLProperty = class(TSQLPropertyEditor)
279 <  public
280 <    procedure Edit; override;
281 <  end;
282 <
283 <  { TIBUpdateSQLUpdateProperty }
284 <
285 <  TIBUpdateSQLUpdateProperty = class(TUpdateSQLPropertyEditor)
286 <  public
287 <    procedure Edit; override;
288 <  end;
289 <
290 < { TIBUpdateSQLRefreshSQLProperty }
291 <
292 <  TIBUpdateSQLRefreshSQLProperty = class(TUpdateSQLPropertyEditor)
293 <  public
294 <    procedure Edit; override;
295 <  end;
296 <
297 < { TIBUpdateSQLInsertSQLProperty }
298 <
299 <  TIBUpdateSQLInsertSQLProperty = class(TUpdateSQLPropertyEditor)
300 <  public
301 <    procedure Edit; override;
302 <  end;
303 <
304 <  { TIBUpdateSQLDeleteProperty }
305 <
306 <  TIBUpdateSQLDeleteProperty = class(TUpdateSQLPropertyEditor)
307 <  public
308 <    function GetAttributes: TPropertyAttributes; override;
309 <    procedure Edit; override;
310 <  end;
311 <
312 < { TIBEventListProperty }
313 <
314 <  TIBEventListProperty = class(TClassProperty)
315 <  public
316 <    function GetAttributes: TPropertyAttributes; override;
317 <    procedure Edit; override;
318 <  end;
319 <
320 < {TIBGeneratorProperty}
321 <
322 <  TIBGeneratorProperty = class(TPersistentPropertyEditor)
323 <  public
324 <    function GetAttributes: TPropertyAttributes; override;
325 <    procedure Edit; override;
326 <  end;
327 <
328 < procedure Register;
329 <
330 < implementation
331 <
332 < uses IB, IBQuery, IBStoredProc, IBCustomDataSet,
333 <     IBIntf, IBSQL, IBSQLMonitor, IBDatabaseInfo, IBEvents,
334 <     IBServices, IBDatabaseEdit, IBTransactionEdit,
335 <     IBBatchMove, DBLoginDlg, IBExtract,LResources, IBSelectSQLEditor,
336 <     IBModifySQLEditor,IBDeleteSQLEditor,IBRefreshSQLEditor,
337 <     IBInsertSQLEditor, IBGeneratorEditor, IBUpdateSQLEditor, IBDataSetEditor,
338 <     IBSQLEditor, ibserviceeditor, LCLVersion;
339 <
340 <
341 <
342 < procedure Register;
343 < begin
344 <  if not TryIBLoad then
345 <  begin
346 <    MessageDlg('IBX is unable to locate the Firebird Library - have you remembered to install it?',mtError,[mbOK],0);
347 <    Exit;
348 <  end;
349 <
350 <  RegisterNoIcon([TIBStringField, TIBBCDField]);
351 <  {$if lcl_fullversion < 01010000}
352 <  {see http://bugs.freepascal.org/view.php?id=19035 }
353 <  RegisterNoIcon([TIntegerField]);
354 <  {$endif}
355 <  RegisterComponents(IBPalette1, [ TIBQuery, TIBDataSet,
356 <   TIBDatabase, TIBTransaction, TIBUpdateSQL, TIBEvents,
357 <     TIBSQL, TIBDatabaseInfo, TIBSQLMonitor,
358 <       TIBStoredProc,TIBBatchMove,  TIBTable,TIBExtract]);
359 <  if IBServiceAPIPresent  then
360 <    RegisterComponents(IBPalette2, [TIBConfigService, TIBBackupService,
361 <      TIBRestoreService, TIBValidationService, TIBStatisticalService,
362 <      TIBLogService, TIBSecurityService, TIBServerProperties]);
363 <  RegisterPropertyEditor(TypeInfo(TIBFileName), TIBDatabase, 'DatabaseName', TIBFileNameProperty); {do not localize}
364 <  RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'StoredProcName', TIBStoredProcNameProperty); {do not localize}
365 <  RegisterPropertyEditor(TypeInfo(TParams), TIBStoredProc, 'Params', TIBStoredProcParamsProperty);
366 <  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'TableName', TIBTableNameProperty); {do not localize}
367 <  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexName', TIBIndexNameProperty); {do not localize}
368 <  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexFieldNames', TIBIndexFieldNamesProperty); {do not localize}
369 <  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'MasterFields', TIBTableFieldLinkProperty); {do not localize}
370 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBQuery, 'SQL', TIBQuerySQLProperty); {do not localize}
371 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'SelectSQL', TIBDatasetSQLProperty); {do not localize}
372 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'ModifySQL', TIBUpdateSQLProperty); {do not localize}
373 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'InsertSQL', TIBInsertSQLProperty); {do not localize}
374 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'RefreshSQL', TIBRefreshSQLProperty); {do not localize}
375 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'DeleteSQL', TIBDeleteSQLProperty); {do not localize}
376 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLSQLPropertyEditor); {do not localize}
377 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'RefreshSQL', TIBUpdateSQLRefreshSQLProperty); {do not localize}
378 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'ModifySQL', TIBUpdateSQLUpdateProperty); {do not localize}
379 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'InsertSQL', TIBUpdateSQLInsertSQLProperty); {do not localize}
380 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'DeleteSQL', TIBUpdateSQLDeleteProperty); {do not localize}
381 <  RegisterPropertyEditor(TypeInfo(TStrings), TIBEvents, 'Events', TIBEventListProperty); {do not localize}
382 <  RegisterPropertyEditor(TypeInfo(TPersistent), TIBDataSet, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
383 <  RegisterPropertyEditor(TypeInfo(TPersistent), TIBQuery, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
384 <
385 <  RegisterComponentEditor(TIBDatabase, TIBDatabaseEditor);
386 <  RegisterComponentEditor(TIBTransaction, TIBTransactionEditor);
387 <  RegisterComponentEditor(TIBUpdateSQL, TIBUpdateSQLEditor);
388 <  RegisterComponentEditor(TIBDataSet, TIBDataSetEditor);
389 <  RegisterComponentEditor(TIBQuery, TIBQueryEditor);
390 <  RegisterComponentEditor(TIBStoredProc, TIBStoredProcEditor);
391 <  RegisterComponentEditor(TIBSQL, TIBSQLEditor);
392 <  RegisterComponentEditor(TIBCustomService, TIBServiceEditor);
393 < end;
394 <
395 < { TIBServiceEditor }
396 <
397 < procedure TIBServiceEditor.ExecuteVerb(Index: Integer);
398 < begin
399 <  if Index < inherited GetVerbCount then
400 <    inherited ExecuteVerb(Index) else
401 <  begin
402 <    Dec(Index, inherited GetVerbCount);
403 <    case Index of
404 <      0 : if ibserviceeditor.EditIBService(TIBCustomService(Component)) then Designer.Modified;
405 <    end;
406 <  end;
407 < end;
408 <
409 < function TIBServiceEditor.GetVerb(Index: Integer): string;
410 < begin
411 <  if Index < inherited GetVerbCount then
412 <    Result := inherited GetVerb(Index) else
413 <  begin
414 <    Dec(Index, inherited GetVerbCount);
415 <    case Index of
416 <      0: Result := SIBServiceEditor;
417 <      1 : Result := SInterbaseExpressVersion;
418 <    end;
419 <  end;
420 < end;
421 <
422 < function TIBServiceEditor.GetVerbCount: Integer;
423 < begin
424 <  Result := inherited GetVerbCount + 2;
425 < end;
426 <
427 < { TIBFileNameProperty }
428 < procedure TIBFileNameProperty.Edit;
429 < begin
430 <  with TOpenDialog.Create(Application) do
431 <    try
432 <      InitialDir := ExtractFilePath(GetStrValue);
433 <      Filter := SDatabaseFilter; {do not localize}
434 <      if Execute then
435 <        SetStrValue(FileName);
436 <    finally
437 <      Free
438 <    end;
439 < end;
440 <
441 < function TIBFileNameProperty.GetAttributes: TPropertyAttributes;
442 < begin
443 <  Result := [paDialog];
444 < end;
445 <
446 < { TIBNameProperty }
447 <
448 < function TIBNameProperty.GetAttributes: TPropertyAttributes;
449 < begin
450 <  Result := [paValueList, paSortList];
451 < end;
452 <
453 < { TIBStoredProcNameProperty }
454 <
455 < procedure TIBStoredProcNameProperty.GetValues(Proc: TGetStrProc);
456 < var
457 <   StoredProc : TIBStoredProc;
458 <   i : integer;
459 < begin
460 <    StoredProc := GetComponent(0) as TIBStoredProc;
461 <    if StoredProc.Database = nil then
462 <      Exit;
463 <
464 <    with StoredProc do
465 <    try
466 <      for I := 0 to StoredProcedureNames.Count - 1 do
467 <        Proc (StoredProcedureNames[i]);
468 <    except on E: Exception do
469 <      MessageDlg(E.Message,mtError,[mbOK],0)
470 <    end;
471 < end;
472 <
473 < { TIBTableNameProperty }
474 <
475 < procedure TIBTableNameProperty.GetValues(Proc: TGetStrProc);
476 < var
477 <   Table : TIBTable;
478 <   i : integer;
479 < begin
480 <  Table := GetComponent(0) as TIBTable;
481 <   if Table.Database = nil then
482 <      Exit;
483 <  with Table do
484 <    for I := 0 to TableNames.Count - 1 do
485 <      Proc (TableNames[i]);
486 < end;
487 <
488 < { TDBStringProperty }
489 <
490 < function TDBStringProperty.ConnecttoDB: boolean;
491 < var DataSet: TIBCustomDataSet;
492 < begin
493 <  Result := false;
494 <  DataSet := (GetComponent(0) as TIBCustomDataSet);
495 <  if assigned(Dataset.Database) then
496 <  begin
497 <    try
498 <      DataSet.Database.Connected := true;
499 <    except on E: Exception do
500 <      ShowMessage(E.Message)
501 <    end;
502 <    Result := DataSet.Database.Connected
503 <  end;
504 < end;
505 <
506 < function TDBStringProperty.GetAttributes: TPropertyAttributes;
507 < begin
508 <  Result := [paValueList, paSortList, paMultiSelect];
509 < end;
510 <
511 < procedure TDBStringProperty.GetValueList(List: TStrings);
512 < begin
513 < end;
514 <
515 < procedure TDBStringProperty.GetValues(Proc: TGetStrProc);
516 < var
517 <  I: Integer;
518 <  Values: TStringList;
519 < begin
520 <  if not ConnecttoDB then Exit;
521 <  Values := TStringList.Create;
522 <  try
523 <    GetValueList(Values);
524 <    for I := 0 to Values.Count - 1 do Proc(Values[I]);
525 <  finally
526 <    Values.Free;
527 <  end;
528 < end;
529 <
530 < procedure TDBStringProperty.Edit;
531 < begin
532 <  if ConnecttoDB then
533 <    inherited Edit;
534 < end;
535 <
536 < { Utility Functions }
537 <
538 < function GetPropertyValue(Instance: TPersistent; const PropName: string): TPersistent;
539 < var
540 <  PropInfo: PPropInfo;
541 < begin
542 <  Result := nil;
543 <  PropInfo := TypInfo.GetPropInfo(Instance.ClassInfo, PropName);
544 <  if (PropInfo <> nil) and (PropInfo^.PropType^.Kind = tkClass) then
545 <    Result := TObject(GetOrdProp(Instance, PropInfo)) as TPersistent;
546 < end;
547 <
548 < function GetIndexDefs(Component: TPersistent): TIndexDefs;
549 < var
550 <  DataSet: TDataSet;
551 < begin
552 <  DataSet := Component as TDataSet;
553 <  Result := GetPropertyValue(DataSet, 'IndexDefs') as TIndexDefs; {do not localize}
554 <  if Assigned(Result) then
555 <  begin
556 <    Result.Updated := False;
557 <    Result.Update;
558 <  end;
559 < end;
560 <
561 < { TIBIndexFieldNamesProperty }
562 <
563 < procedure TIBIndexFieldNamesProperty.GetValueList(List: TStrings);
564 < var
565 <  I: Integer;
566 <  IndexDefs: TIndexDefs;
567 < begin
568 <  IndexDefs := GetIndexDefs(GetComponent(0));
569 <  for I := 0 to IndexDefs.Count - 1 do
570 <    with IndexDefs[I] do
571 <      if (Options * [ixExpression, ixDescending] = []) and (Fields <> '') then
572 <        List.Add(Fields);
573 < end;
574 <
575 <
576 < { TIBIndexNameProperty }
577 <
578 < procedure TIBIndexNameProperty.GetValueList(List: TStrings);
579 < begin
580 <  GetIndexDefs(GetComponent(0)).GetItemNames(List);
581 < end;
582 <
583 < { TSQLPropertyEditor }
584 <
585 < function TSQLPropertyEditor.GetAttributes: TPropertyAttributes;
586 < begin
587 <  Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
588 < end;
589 <
590 < { TIBQuerySQLProperty }
591 <
592 < procedure TIBQuerySQLProperty.Edit;
593 < var
594 <  Query: TIBQuery;
595 < begin
596 <  Query := GetComponent(0) as TIBQuery;
597 <  if IBSelectSQLEditor.EditSQL(Query,Query.SQL) then Modified;
598 < end;
599 <
600 < { TIBDatasetSQLProperty }
601 <
602 < procedure TIBDatasetSQLProperty.Edit;
603 < var
604 <  IBDataset: TIBDataset;
605 < begin
606 <  IBDataset := GetComponent(0) as TIBDataset;
607 <  if IBSelectSQLEditor.EditSQL(IBDataSet,IBDataSet.SelectSQL) then Modified;
608 < end;
609 <
610 < { TIBSQLProperty }
611 <
612 < procedure TIBSQLProperty.Edit;
613 < var
614 <  IBSQL: TIBSQL;
615 < begin
616 <  IBSQL := GetComponent(0) as TIBSQL;
617 <  if IBSQLEditor.EditIBSQL(IBSQL) then Modified;
618 < end;
619 <
620 < { TIBUpdateSQLEditor }
621 <
622 < procedure TIBUpdateSQLEditor.ExecuteVerb(Index: Integer);
623 < begin
624 <  if IBUpdateSQLEditor.EditIBUpdateSQL(TIBUpdateSQL(Component)) then Modified;
625 < end;
626 <
627 < function TIBUpdateSQLEditor.GetVerb(Index: Integer): string;
628 < begin
629 <  case Index of
630 <    0 : Result := SIBUpdateSQLEditor;
631 <    1: Result := SInterbaseExpressVersion;
632 <  end;
633 < end;
634 <
635 < function TIBUpdateSQLEditor.GetVerbCount: Integer;
636 < begin
637 <  Result :=  2;
638 < end;
639 <
640 < { TIBDataSetEditor }
641 <
642 < procedure TIBDataSetEditor.ExecuteVerb(Index: Integer);
643 < var
644 <  IBDataset: TIBDataset;
645 < begin
646 <  if Index < inherited GetVerbCount then
647 <    inherited ExecuteVerb(Index) else
648 <  begin
649 <    Dec(Index, inherited GetVerbCount);
650 <    case Index of
651 <      0:
652 <        if IBDataSetEditor.EditIBDataSet(TIBDataSet(Component)) then
653 <          Designer.Modified;
654 <      1: (Component as TIBDataSet).ExecSQL;
655 <    end;
656 <  end;
657 < end;
658 <
659 < function TIBDataSetEditor.GetVerb(Index: Integer): string;
660 < begin
661 <  if Index < inherited GetVerbCount then
662 <    Result := inherited GetVerb(Index) else
663 <  begin
664 <    Dec(Index, inherited GetVerbCount);
665 <    case Index of
666 <      0: Result := SIBDataSetEditor;
667 <      1: Result := SExecute;
668 <      2: Result := SInterbaseExpressVersion;
669 <    end;
670 <  end;
671 < end;
672 <
673 < function TIBDataSetEditor.GetVerbCount: Integer;
674 < begin
675 <  Result := inherited GetVerbCount + 3;
676 < end;
677 <
678 < { TIBEventListProperty }
679 <
680 < function TIBEventListProperty.GetAttributes: TPropertyAttributes;
681 < begin
682 <  Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
683 < end;
684 <
685 < procedure TIBEventListProperty.Edit;
686 < var
687 <  Events: TStrings;
688 <  IBEvents: TIBEvents;
689 < begin
690 <  IBEvents := GetComponent(0) as TIBEvents;
691 <  Events := TStringList.Create;
692 <  try
693 <    Events.Assign( IBEvents.Events);
694 <    if EditAlerterEvents( Events) then
695 <    begin
696 <      IBEvents.Events.Assign(Events);
697 <      Modified
698 <    end;
699 <  finally
700 <    Events.Free;
701 <  end;
702 < end;
703 <
704 < { TIBDatabaseEditor }
705 < procedure TIBDatabaseEditor.ExecuteVerb(Index: Integer);
706 < begin
707 <  if Index < inherited GetVerbCount then
708 <    inherited ExecuteVerb(Index) else
709 <  begin
710 <    Dec(Index, inherited GetVerbCount);
711 <    case Index of
712 <      0 : if EditIBDatabase(TIBDatabase(Component)) then Designer.Modified;
713 <    end;
714 <  end;
715 < end;
716 <
717 < function TIBDatabaseEditor.GetVerb(Index: Integer): string;
718 < begin
719 <  if Index < inherited GetVerbCount then
720 <    Result := inherited GetVerb(Index) else
721 <  begin
722 <    Dec(Index, inherited GetVerbCount);
723 <    case Index of
724 <      0: Result := SIBDatabaseEditor;
725 <      1 : Result := SInterbaseExpressVersion;
726 <    end;
727 <  end;
728 < end;
729 <
730 < function TIBDatabaseEditor.GetVerbCount: Integer;
731 < begin
732 <  Result := inherited GetVerbCount + 2;
733 < end;
734 <
735 < { TIBTransactionEditor }
736 <
737 < procedure TIBTransactionEditor.ExecuteVerb(Index: Integer);
738 < begin
739 <  case Index of
740 <    0: if EditIBTransaction(TIBTransaction(Component)) then Designer.Modified;
741 <  end;
742 < end;
743 <
744 < function TIBTransactionEditor.GetVerb(Index: Integer): string;
745 < begin
746 <  case Index of
747 <    0: Result := SIBTransactionEditor;
748 <    1: Result := SInterbaseExpressVersion;
749 <  end;
750 < end;
751 <
752 < function TIBTransactionEditor.GetVerbCount: Integer;
753 < begin
754 <  Result := 2;
755 < end;
756 <
757 < { TIBQueryEditor }
758 <
759 < procedure TIBQueryEditor.ExecuteVerb(Index: Integer);
760 < var
761 <  Query: TIBQuery;
762 < begin
763 <  if Index < inherited GetVerbCount then
764 <    inherited ExecuteVerb(Index) else
765 <  begin
766 <    Query := Component as TIBQuery;
767 <    Dec(Index, inherited GetVerbCount);
768 <    case Index of
769 <      0: Query.ExecSQL;
770 <      1: if ibselectsqleditor.EditSQL(Query,Query.SQL) then Designer.Modified;
771 <    end;
772 <  end;
773 < end;
774 <
775 < function TIBQueryEditor.GetVerb(Index: Integer): string;
776 < begin
777 <  if Index < inherited GetVerbCount then
778 <    Result := inherited GetVerb(Index) else
779 <  begin
780 <    Dec(Index, inherited GetVerbCount);
781 <    case Index of
782 <      0: Result := SExecute;
783 <      1: Result := SEditSQL;
784 <      2: Result := SInterbaseExpressVersion;
785 <    end;
786 <  end;
787 < end;
788 <
789 < function TIBQueryEditor.GetVerbCount: Integer;
790 < begin
791 <  Result := inherited GetVerbCount + 3;
792 < end;
793 <
794 < { TIBStoredProcEditor }
795 <
796 < procedure TIBStoredProcEditor.ExecuteVerb(Index: Integer);
797 < begin
798 <  if Index < inherited GetVerbCount then
799 <    inherited ExecuteVerb(Index) else
800 <  begin
801 <    Dec(Index, inherited GetVerbCount);
802 <    if Index = 0 then (Component as TIBStoredProc).ExecProc;
803 <  end;
804 < end;
805 <
806 < function TIBStoredProcEditor.GetVerb(Index: Integer): string;
807 < begin
808 <  if Index < inherited GetVerbCount then
809 <    Result := inherited GetVerb(Index) else
810 <  begin
811 <    Dec(Index, inherited GetVerbCount);
812 <    case Index of
813 <      0: Result := SExecute;
814 <      1: Result := SInterbaseExpressVersion;
815 <    end;
816 <  end;
817 < end;
818 <
819 < function TIBStoredProcEditor.GetVerbCount: Integer;
820 < begin
821 <  Result := inherited GetVerbCount + 2;
822 < end;
823 <
824 < { TIBStoredProcParamsProperty }
825 <
826 < procedure TIBStoredProcParamsProperty.Edit;
827 < var
828 <  StoredProc: TIBStoredProc;
829 <  Params: TParams;
830 < begin
831 <  StoredProc := (GetComponent(0) as TIBStoredProc);
832 <  Params := TParams.Create(nil);
833 <  try
834 <    StoredProc.CopyParams(Params);
835 <  finally
836 <    Params.Free;
837 <  end;
838 <  inherited Edit;
839 < end;
840 <
841 < { TIBTableFieldLinkProperty }
842 <
843 < procedure TIBTableFieldLinkProperty.Edit;
844 < begin
845 <  FTable := DataSet as TIBTable;
846 <  if assigned(FTable.Database) then
847 <    FTable.Database.Connected := true;
848 <  inherited Edit;
849 < end;
850 <
851 < function TIBTableFieldLinkProperty.GetIndexDefs: TIndexDefs;
852 < begin
853 <  Result :=  FTable.IndexDefs
854 < end;
855 <
856 < function TIBTableFieldLinkProperty.GetIndexFieldNames: string;
857 < begin
858 <  Result := FTable.IndexFieldNames;
859 < end;
860 <
861 < function TIBTableFieldLinkProperty.GetMasterFields: string;
862 < begin
863 <  Result := FTable.MasterFields;
864 < end;
865 <
866 < procedure TIBTableFieldLinkProperty.SetIndexFieldNames(const Value: string);
867 < begin
868 <  FTable.IndexFieldNames := Value;
869 < end;
870 <
871 < procedure TIBTableFieldLinkProperty.SetMasterFields(const Value: string);
872 < begin
873 <  FTable.MasterFields := Value;
874 < end;
875 <
876 < { TIBUpdateSQLProperty }
877 <
878 < procedure TIBUpdateSQLProperty.Edit;
879 < var
880 <  IBDataset: TIBDataset;
881 < begin
882 <  IBDataset := GetComponent(0) as TIBDataset;
883 <  if IBModifySQLEditor.EditSQL(IBDataSet,IBDataSet.ModifySQL) then Modified;
884 < end;
885 <
886 < { TIBUpdateSQLUpdateProperty }
887 <
888 < procedure TIBUpdateSQLUpdateProperty.Edit;
889 < begin
890 <  GetObjects;
891 <  if IBModifySQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.ModifySQL) then Modified;
892 < end;
893 <
894 < { TIBRefreshSQLProperty }
895 <
896 < procedure TIBRefreshSQLProperty.Edit;
897 < var
898 <  IBDataset: TIBDataset;
899 <  aDatabase: TIBDatabase;
900 < begin
901 <  IBDataset := GetComponent(0) as TIBDataset;
902 <  if IBRefreshSQLEditor.EditSQL(IBDataSet,IBDataSet.RefreshSQL) then Modified;
903 < end;
904 <
905 < { TIBUpdateSQLRefreshSQLProperty }
906 <
907 < procedure TIBUpdateSQLRefreshSQLProperty.Edit;
908 < begin
909 <  GetObjects;
910 <  if IBRefreshSQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.RefreshSQL) then Modified;
911 < end;
912 <
913 < { TIBDeleteSQLProperty }
914 <
915 < procedure TIBDeleteSQLProperty.Edit;
916 < var
917 <  IBDataset: TIBDataSet;
918 < begin
919 <  IBDataset := GetComponent(0) as TIBDataSet;
920 <  if IBDeleteSQLEditor.EditSQL(IBDataSet,IBDataSet.DeleteSQL) then Modified;
921 < end;
922 <
923 < { TIBUpdateSQLDeleteProperty }
924 <
925 < function TIBUpdateSQLDeleteProperty.GetAttributes: TPropertyAttributes;
926 < begin
927 <  Result:=inherited GetAttributes;
928 < end;
929 <
930 < procedure TIBUpdateSQLDeleteProperty.Edit;
931 < begin
932 <  GetObjects;
933 <  if IBDeleteSQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.DeleteSQL) then Modified;
934 < end;
935 <
936 < { TUpdateSQLPropertyEditor }
937 <
938 < function TUpdateSQLPropertyEditor.GetObjects: boolean;
939 < begin
940 <  Result := false;
941 <  FIBUpdateSQL := GetComponent(0) as TIBUpdateSQL;
942 <  if not assigned(FIBUpdateSQL) or not assigned(FIBUpdateSQL.DataSet) then
943 <    Exit;
944 <  FDatabase := nil;
945 <  if FIBUpdateSQL.DataSet is TIBQuery then
946 <  begin
947 <    FDatabase := (FIBUpdateSQL.DataSet as TIBQuery).Database;
948 <    Result := true
949 <  end;
950 < end;
951 <
952 < { TIBInsertSQLProperty }
953 <
954 < procedure TIBInsertSQLProperty.Edit;
955 < var
956 <  IBDataset: TIBDataSet;
957 < begin
958 <  IBDataset := GetComponent(0) as TIBDataSet;
959 <  if IBInsertSQLEditor.EditSQL(IBDataSet,IBDataSet.InsertSQL) then Modified;
960 < end;
961 <
962 < { TIBUpdateSQLInsertSQLProperty }
963 <
964 < procedure TIBUpdateSQLInsertSQLProperty.Edit;
965 < begin
966 <  GetObjects;
967 <  if IBInsertSQLEditor.EditSQL(FIBUpdateSQL.Dataset,FIBUpdateSQL.InsertSQL) then Modified;
968 < end;
969 <
970 < { TIBGeneratorProperty }
971 <
972 < function TIBGeneratorProperty.GetAttributes: TPropertyAttributes;
973 < begin
974 <  Result:= inherited GetAttributes + [paDialog] - [paMultiSelect,paValueList];
975 < end;
976 <
977 < procedure TIBGeneratorProperty.Edit;
978 < begin
979 <  if IBGeneratorEditor.EditGenerator(GetPersistentReference as TIBGenerator) then Modified;
980 < end;
981 <
982 < { TIBSQLEditor }
983 <
984 < procedure TIBSQLEditor.ExecuteVerb(Index: Integer);
985 < begin
986 <  if IBSQLEditor.EditIBSQL(TIBSQL(Component)) then Modified;
987 < end;
988 <
989 < function TIBSQLEditor.GetVerb(Index: Integer): string;
990 < begin
991 <  case Index of
992 <    0 : Result := SIBSQLEditor;
993 <    1: Result := SInterbaseExpressVersion;
994 <  end;
995 < end;
996 <
997 < function TIBSQLEditor.GetVerbCount: Integer;
998 < begin
999 <  Result:= 2
1000 < end;
1001 <
1002 < { TIBSQLSQLPropertyEditor }
1003 <
1004 < procedure TIBSQLSQLPropertyEditor.Edit;
1005 < var
1006 <  IBSQL: TIBSQL;
1007 < begin
1008 <  IBSQL := GetComponent(0) as TIBSQL;
1009 <  if IBSQLEditor.EditIBSQL(IBSQL) then Modified;
1010 < end;
1011 <
1012 < initialization
1013 <  {$I IBDBReg.lrs}
1014 < 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 - 2018                                               }
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 > {$H+}                           (* Huge Strings: On *)
43 > {$J-}                           (* Modification of Typed Constants: Off *)
44 > {$M+}                           (* Generate run-time type information: On *)
45 > {$O+}                           (* Optimization: On *)
46 > {$Q-}                           (* Overflow checks: Off *)
47 > {$R-}                           (* Range checks: Off *)
48 > {$T+}                           (* Typed address: On *)
49 > {$W-}                           (* Always generate stack frames: Off *)
50 > {$X+}                           (* Extended syntax: On *)
51 > {$Z1}                           (* Minimum Enumeration Size: 1 Byte *)
52 >
53 > interface
54 >
55 > uses SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
56 >     DB, IBTable, IBDatabase,  IBEventsEditor,  LazarusPackageIntf,
57 >      IBUpdateSQL, IBUpdate, ComponentEditors, PropEdits, DBPropEdits, FieldsEditor,
58 >     dbFieldLinkPropEditor, dbFieldListPropEditor, IBDialogs;
59 >
60 > type
61 >
62 > { TIBFileNameProperty
63 >  Property editor the DataBase Name property.  Brings up the Open dialog }
64 >
65 >  TIBFileNameProperty = class(TStringProperty)
66 >  protected
67 >    function GetFilter: string; virtual;
68 >  public
69 >    procedure Edit; override;
70 >    function GetAttributes: TPropertyAttributes; override;
71 >  end;
72 >
73 >  { TIBLibraryNameProperty }
74 >
75 >  TIBLibraryNameProperty = class(TIBFileNameProperty)
76 >  protected
77 >    function GetFilter: string; override;
78 >  end;
79 >
80 >  { TIBNameProperty
81 >  }
82 >  TIBNameProperty = class(TStringProperty)
83 >  public
84 >    function GetAttributes: TPropertyAttributes; override;
85 >  end;
86 >
87 >  { TIBStoredProcNameProperty
88 >    Editor for the TIBStoredProc.StoredProcName property.  Displays a drop-down list of all
89 >    the StoredProcedures in the Database.}
90 >  TIBStoredProcNameProperty = class(TIBNameProperty)
91 >  public
92 >    procedure GetValues(Proc: TGetStrProc); override;
93 >  end;
94 >
95 >  { TIBPackageNameProperty
96 >    Editor for the TIBStoredProc.PackageName property.  Displays a drop-down list of all
97 >    the StoredProcedures in the Database.}
98 >  TIBPackageNameProperty = class(TIBNameProperty)
99 >  public
100 >    procedure GetValues(Proc: TGetStrProc); override;
101 >  end;
102 >
103 >  { TIBTableNameProperty
104 >    Editor for the TIBTable.TableName property.  Displays a drop-down list of all
105 >    the Tables in the Database.}
106 >  TIBTableNameProperty = class(TIBNameProperty)
107 >  public
108 >    procedure GetValues(Proc: TGetStrProc); override;
109 >  end;
110 >
111 >  { TDBStringProperty }
112 >
113 >  TDBStringProperty = class(TStringProperty)
114 >  private
115 >    function ConnecttoDB: boolean;
116 >  public
117 >    function GetAttributes: TPropertyAttributes; override;
118 >    procedure GetValueList(List: TStrings); virtual;
119 >    procedure GetValues(Proc: TGetStrProc); override;
120 >    procedure Edit; override;
121 >  end;
122 >
123 >  { TIBIndexFieldNamesProperty }
124 >
125 >  TIBIndexFieldNamesProperty = class(TDBStringProperty)
126 >  public
127 >    procedure GetValueList(List: TStrings); override;
128 >  end;
129 >
130 >  TIBIndexNameProperty = class(TDBStringProperty)
131 >  public
132 >    procedure GetValueList(List: TStrings); override;
133 >  end;
134 >
135 > { TIBDatabaseEditor }
136 >
137 >  TIBDatabaseEditor = class(TComponentEditor)
138 >    procedure ExecuteVerb(Index: Integer); override;
139 >    function GetVerb(Index: Integer): string; override;
140 >    function GetVerbCount: Integer; override;
141 >  end;
142 >
143 > { TIBTransactionEditor }
144 >
145 >  TIBTransactionEditor = class(TComponentEditor)
146 >  public
147 >    procedure ExecuteVerb(Index: Integer); override;
148 >    function GetVerb(Index: Integer): string; override;
149 >    function GetVerbCount: Integer; override;
150 >  end;
151 >
152 >  { TIBArrayGridEditor }
153 >
154 >  TIBArrayGridEditor = class(TComponentEditor)
155 >  public
156 >    procedure ExecuteVerb(Index: Integer); override;
157 >    function GetVerb(Index: Integer): string; override;
158 >    function GetVerbCount: Integer; override;
159 >  end;
160 >
161 > { TIBQueryEditor }
162 >
163 >  TIBQueryEditor = class(TFieldsComponentEditor)
164 >  public
165 >    procedure ExecuteVerb(Index: Integer); override;
166 >    function GetVerb(Index: Integer): string; override;
167 >    function GetVerbCount: Integer; override;
168 >  end;
169 >
170 > { TIBStoredProcEditor }
171 >
172 >  TIBStoredProcEditor = class(TFieldsComponentEditor)
173 >  public
174 >    procedure ExecuteVerb(Index: Integer); override;
175 >    function GetVerb(Index: Integer): string; override;
176 >    function GetVerbCount: Integer; override;
177 >  end;
178 >
179 > { TIBDataSetEditor }
180 >
181 >  TIBDataSetEditor = class(TFieldsComponentEditor)
182 >  public
183 >    procedure ExecuteVerb(Index: Integer); override;
184 >    function GetVerb(Index: Integer): string; override;
185 >    function GetVerbCount: Integer; override;
186 >  end;
187 >
188 > { TIBUpdateSQLEditor }
189 >
190 >  TIBUpdateSQLEditor = class(TComponentEditor)
191 >  public
192 >    procedure ExecuteVerb(Index: Integer); override;
193 >    function GetVerb(Index: Integer): string; override;
194 >   function GetVerbCount: Integer; override;
195 >  end;
196 >
197 > { TIBSQLEditor }
198 >
199 >  TIBSQLEditor  = class(TComponentEditor)
200 >  public
201 >    procedure ExecuteVerb(Index: Integer); override;
202 >    function GetVerb(Index: Integer): string; override;
203 >   function GetVerbCount: Integer; override;
204 >  end;
205 >
206 > { TIBServiceEditor}
207 >
208 >  TIBServiceEditor = class(TComponentEditor)
209 >  public
210 >    procedure ExecuteVerb(Index: Integer); override;
211 >    function GetVerb(Index: Integer): string; override;
212 >   function GetVerbCount: Integer; override;
213 >  end;
214 >
215 >  { TIBXServiceEditor }
216 >
217 >  TIBXServiceEditor = class(TComponentEditor)
218 >  public
219 >    procedure ExecuteVerb(Index: Integer); override;
220 >    function GetVerb(Index: Integer): string; override;
221 >    function GetVerbCount: Integer; override;
222 >  end;
223 >
224 >  TIBStoredProcParamsProperty = class(TCollectionPropertyEditor)
225 >  end;
226 >
227 >  { TIBTableFieldLinkProperty }
228 >
229 >  TIBTableFieldLinkProperty = class(TFieldLinkProperty)
230 >  private
231 >    FTable: TIBTable;
232 >  protected
233 >    function GetIndexDefs: TIndexDefs; override;
234 >    function GetIndexFieldNames: string; override;
235 >    function GetMasterFields: string; override;
236 >    procedure SetIndexFieldNames(const Value: string); override;
237 >    procedure SetMasterFields(const Value: string); override;
238 >  public
239 >    procedure Edit; override;
240 >  end;
241 >
242 > { TSQLPropertyEditor }
243 >
244 >  TSQLPropertyEditor = class(TStringsPropertyEditor)
245 >  public
246 >    function GetAttributes: TPropertyAttributes; override;
247 >  end;
248 >
249 > { TIBQuerySQLProperty }
250 >
251 >  TIBQuerySQLProperty = class(TSQLPropertyEditor)
252 >  public
253 >    procedure Edit; override;
254 >  end;
255 >
256 > {TIBSQLSQLPropertyEditor }
257 >
258 >  TIBSQLSQLPropertyEditor = class(TSQLPropertyEditor)
259 >  public
260 >    procedure Edit; override;
261 >  end;
262 >
263 > { TIBDatasetSQLProperty }
264 >
265 >  TIBDatasetSQLProperty = class(TSQLPropertyEditor)
266 >  public
267 >    procedure Edit; override;
268 >  end;
269 >
270 > { TIBSQLProperty }
271 >
272 >  TIBSQLProperty = class(TSQLPropertyEditor)
273 >  public
274 >    procedure Edit; override;
275 >  end;
276 >
277 > { TUpdateSQLPropertyEditor }
278 >
279 >   TUpdateSQLPropertyEditor = class(TSQLPropertyEditor)
280 >   protected
281 >     FIBUpdateSQL: TIBUpdateSQL;
282 >     FDatabase: TIBDatabase;
283 >     function GetObjects: boolean;
284 >   end;
285 >
286 > { TIBUpdateSQLProperty }
287 >
288 >  TIBUpdateSQLProperty = class(TSQLPropertyEditor)
289 >  public
290 >    procedure Edit; override;
291 >  end;
292 >
293 > { TIBRefreshSQLProperty }
294 >
295 >  TIBRefreshSQLProperty = class(TSQLPropertyEditor)
296 >  public
297 >    procedure Edit; override;
298 >  end;
299 >
300 > { TIBInsertSQLProperty }
301 >
302 >  TIBInsertSQLProperty = class(TSQLPropertyEditor)
303 >  public
304 >    procedure Edit; override;
305 >  end;
306 >
307 > { TIBDeleteSQLProperty }
308 >
309 >  TIBDeleteSQLProperty = class(TSQLPropertyEditor)
310 >  public
311 >    procedure Edit; override;
312 >  end;
313 >
314 >  { TIBUpdateSQLUpdateProperty }
315 >
316 >  TIBUpdateSQLUpdateProperty = class(TUpdateSQLPropertyEditor)
317 >  public
318 >    procedure Edit; override;
319 >  end;
320 >
321 > { TIBUpdateSQLRefreshSQLProperty }
322 >
323 >  TIBUpdateSQLRefreshSQLProperty = class(TUpdateSQLPropertyEditor)
324 >  public
325 >    procedure Edit; override;
326 >  end;
327 >
328 > { TIBUpdateSQLInsertSQLProperty }
329 >
330 >  TIBUpdateSQLInsertSQLProperty = class(TUpdateSQLPropertyEditor)
331 >  public
332 >    procedure Edit; override;
333 >  end;
334 >
335 >  { TIBUpdateSQLDeleteProperty }
336 >
337 >  TIBUpdateSQLDeleteProperty = class(TUpdateSQLPropertyEditor)
338 >  public
339 >    function GetAttributes: TPropertyAttributes; override;
340 >    procedure Edit; override;
341 >  end;
342 >
343 >  { TIBUpdateRefreshSQLProperty }
344 >
345 >  TIBUpdateRefreshSQLProperty = class(TSQLPropertyEditor)
346 >  protected
347 >    FIBUpdate: TIBUpdate;
348 >    FDatabase: TIBDatabase;
349 >    function GetObjects: boolean;
350 >  public
351 >    procedure Edit; override;
352 >  end;
353 >
354 >
355 > { TIBEventListProperty }
356 >
357 >  TIBEventListProperty = class(TClassProperty)
358 >  public
359 >    function GetAttributes: TPropertyAttributes; override;
360 >    procedure Edit; override;
361 >  end;
362 >
363 > {TIBGeneratorProperty}
364 >
365 >  TIBGeneratorProperty = class(TPersistentPropertyEditor)
366 >  public
367 >    function GetAttributes: TPropertyAttributes; override;
368 >    procedure Edit; override;
369 >  end;
370 >
371 >  { TDBDynamicGridFieldProperty }
372 >
373 >  TDBDynamicGridFieldProperty = class(TFieldProperty)
374 >  public
375 >    procedure FillValues(const Values: TStringList); override;
376 >  end;
377 >
378 >  { TDBLookupPropertiesGridFieldProperty }
379 >
380 >  TDBLookupPropertiesGridFieldProperty = class(TFieldProperty)
381 >  public
382 >    procedure FillValues(const Values: TStringList); override;
383 >  end;
384 >
385 >  { TIBTreeViewFieldProperty }
386 >
387 >  TIBTreeViewFieldProperty = class(TFieldProperty)
388 >  public
389 >    procedure FillValues(const Values: TStringList); override;
390 >  end;
391 >
392 >  { TIBDynamicGridIndexNamesProperty }
393 >
394 >  TIBDynamicGridIndexNamesProperty = class(TIndexFieldNamesProperty)
395 >  protected
396 >    function GetFieldDefs: TFieldDefs; override;
397 >    function GetIndexFieldNames: string; override;
398 >    procedure SetIndexFieldNames(const Value: string); override;
399 >  end;
400 >
401 >  { TIBFieldDefsProperty }
402 >
403 >  TIBFieldDefsProperty = class(TCollectionPropertyEditor)
404 >  public
405 >    procedure Edit; override;
406 >  end;
407 >
408 >  { TIBIndexDefsProperty }
409 >
410 >  TIBIndexDefsProperty = class(TCollectionPropertyEditor)
411 >  public
412 >    procedure Edit; override;
413 >  end;
414 >
415 >
416 > procedure Register;
417 >
418 > implementation
419 >
420 > uses IB, IBQuery, IBStoredProc, IBCustomDataSet, IBMessages,
421 >     IBSQL, IBSQLMonitor, IBDatabaseInfo, IBEvents, IBInternals,
422 >     IBServices, IBXServices, IBDatabaseEdit, IBTransactionEdit,
423 >     IBBatchMove, IBExtract,LResources, IBSelectSQLEditor,
424 >     IBModifySQLEditor,IBDeleteSQLEditor,IBRefreshSQLEditor,
425 >     IBInsertSQLEditor, IBGeneratorEditor, IBUpdateSQLEditor, IBDataSetEditor,
426 >     IBSQLEditor, ibserviceeditor, LCLVersion, IBDynamicGrid, IBLookupComboEditBox,
427 >     IBTreeView, DBControlGrid, ibxscript, IBLocalDBSupport, IBDSDialogs,
428 >     IBArrayGrid, IBVersion, IBDataOutput, IBXServiceEditor;
429 >
430 > const
431 >  IBPalette1 = 'Firebird'; {do not localize}
432 >  IBPalette2 = 'Firebird Legacy Admin'; {do not localize}
433 >  IBPalette3 = 'Firebird Data Controls';   {do not localize}
434 >  IBPalette4 = 'Firebird Admin'; {do not localize}
435 >
436 > resourcestring
437 >   SInterbaseExpressVersion = 'Firebird Express for Lazarus ' + IBX_VERSION;
438 >   SEditSQL = 'Edit SQL';
439 >   SIBSQLEditor = 'IBSQL Editor';
440 >   SIBServiceEditor = 'Edit IB Service';
441 >   SIBUpdateSQLEditor = '&UpdateSQL Editor...';
442 >   SIBDataSetEditor = '&Dataset Editor...';
443 >   SExecute = 'E&xecute';
444 >   SIBDatabaseEditor = 'Da&tabase Editor...';
445 >   SIBTransactionEditor = '&Transaction Editor...';
446 >   SIBUpdateLayout = 'Update Layout';
447 >
448 > procedure Register;
449 > begin
450 >  AllowUseOfFBLIB := true;
451 >  if not TryIBLoad then
452 >  begin
453 >    MessageDlg('IBX is unable to locate the Firebird Library - have you remembered to install it?',mtError,[mbOK],0);
454 >    Exit;
455 >  end;
456 >
457 >  RegisterNoIcon([TIBStringField, TIBBCDField, TIBMemoField, TIBArrayField,
458 >    TIBSmallintField, TIBIntegerField, TIBLargeIntField, TIBDateTimeField,
459 >    TIBTimeField]);
460 >  {$if lcl_fullversion < 01010000}
461 >  {see http://bugs.freepascal.org/view.php?id=19035 }
462 >  RegisterNoIcon([TIntegerField]);
463 >  {$endif}
464 >  RegisterComponents(IBPalette1, [ TIBQuery, TIBDataSet,
465 >   TIBDatabase, TIBTransaction, TIBUpdateSQL, TIBUpdate, TIBEvents,
466 >     TIBSQL, TIBDatabaseInfo, TIBSQLMonitor,
467 >       TIBStoredProc,TIBBatchMove,  TIBTable,TIBExtract, TIBXScript, TIBLocalDBSupport,
468 >       TIBBlockFormatOut,TIBCSVDataOut,TIBInsertStmtsOut]);
469 >  if FirebirdAPI.HasServiceAPI  then
470 >  begin
471 >    RegisterComponents(IBPalette4, [TIBXServicesConnection, TIBXConfigService,
472 >      TIBXClientSideBackupService, TIBXServerSideBackupService,
473 >      TIBXClientSideRestoreService, TIBXServerSideRestoreService,
474 >      TIBXValidationService, TIBXOnlineValidationService, TIBXStatisticalService,
475 >      TIBXLogService, TIBXSecurityService, TIBXServerProperties,
476 >      TIBXLimboTransactionResolutionService,TIBXServicesUserList, TIBXServicesLimboTransactionsList]);
477 >    RegisterComponents(IBPalette2, [TIBConfigService, TIBBackupService,
478 >      TIBRestoreService, TIBValidationService,
479 >      TIBOnlineValidationService, TIBStatisticalService,
480 >      TIBLogService, TIBSecurityService, TIBServerProperties]);
481 >  end;
482 >
483 >  RegisterComponents(IBPalette3,[TIBLookupComboEditBox,TIBDynamicGrid,TIBTreeView,TDBControlGrid, TIBArrayGrid]);
484 >
485 >  RegisterPropertyEditor(TypeInfo(TIBFileName), TIBDatabase, 'DatabaseName', TIBFileNameProperty); {do not localize}
486 >  RegisterPropertyEditor(TypeInfo(TIBFileName), TIBDatabase, 'FirebirdLibraryPathName', TIBLibraryNameProperty); {do not localize}
487 >  RegisterPropertyEditor(TypeInfo(TIBFileName), TIBXServicesConnection, 'FirebirdLibraryPathName', TIBLibraryNameProperty); {do not localize}
488 >  RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'StoredProcName', TIBStoredProcNameProperty); {do not localize}
489 >  RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'PackageName', TIBPackageNameProperty); {do not localize}
490 >  RegisterPropertyEditor(TypeInfo(TParams), TIBStoredProc, 'Params', TIBStoredProcParamsProperty);
491 >  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'TableName', TIBTableNameProperty); {do not localize}
492 >  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexName', TIBIndexNameProperty); {do not localize}
493 >  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexFieldNames', TIBIndexFieldNamesProperty); {do not localize}
494 >  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'MasterFields', TIBTableFieldLinkProperty); {do not localize}
495 >  RegisterPropertyEditor(TypeInfo(TFieldDefs), TIBTable, 'FieldDefs', TIBFieldDefsProperty); {do not localize}
496 >  RegisterPropertyEditor(TypeInfo(TIndexDefs), TIBTable, 'IndexDefs', TIBIndexDefsProperty); {do not localize}
497 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBQuery, 'SQL', TIBQuerySQLProperty); {do not localize}
498 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'SelectSQL', TIBDatasetSQLProperty); {do not localize}
499 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'ModifySQL', TIBUpdateSQLProperty); {do not localize}
500 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'InsertSQL', TIBInsertSQLProperty); {do not localize}
501 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'RefreshSQL', TIBRefreshSQLProperty); {do not localize}
502 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'DeleteSQL', TIBDeleteSQLProperty); {do not localize}
503 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLSQLPropertyEditor); {do not localize}
504 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'RefreshSQL', TIBUpdateSQLRefreshSQLProperty); {do not localize}
505 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'ModifySQL', TIBUpdateSQLUpdateProperty); {do not localize}
506 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'InsertSQL', TIBUpdateSQLInsertSQLProperty); {do not localize}
507 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'DeleteSQL', TIBUpdateSQLDeleteProperty); {do not localize}
508 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdate, 'RefreshSQL', TIBUpdateRefreshSQLProperty); {do not localize}
509 >  RegisterPropertyEditor(TypeInfo(TStrings), TIBEvents, 'Events', TIBEventListProperty); {do not localize}
510 >  RegisterPropertyEditor(TypeInfo(TPersistent), TIBDataSet, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
511 >  RegisterPropertyEditor(TypeInfo(TPersistent), TIBQuery, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
512 >  RegisterPropertyEditor(TypeInfo(TPersistent), TIBTable, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
513 >
514 >  RegisterComponentEditor(TIBDatabase, TIBDatabaseEditor);
515 >  RegisterComponentEditor(TIBTransaction, TIBTransactionEditor);
516 >  RegisterComponentEditor(TIBUpdateSQL, TIBUpdateSQLEditor);
517 >  RegisterComponentEditor(TIBDataSet, TIBDataSetEditor);
518 >  RegisterComponentEditor(TIBQuery, TIBQueryEditor);
519 >  RegisterComponentEditor(TIBStoredProc, TIBStoredProcEditor);
520 >  RegisterComponentEditor(TIBSQL, TIBSQLEditor);
521 >  RegisterComponentEditor(TIBCustomService, TIBServiceEditor);
522 >  RegisterComponentEditor(TIBArrayGrid, TIBArrayGridEditor);
523 >  RegisterComponentEditor(TIBXServicesConnection, TIBXServiceEditor);
524 >
525 >
526 >  {Firebird Data Access Controls}
527 >  RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'KeyField', TDBDynamicGridFieldProperty);
528 >  RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'ListField', TDBDynamicGridFieldProperty);
529 >  RegisterPropertyEditor(TypeInfo(string), TIBDynamicGrid, 'IndexFieldNames', TIBDynamicGridIndexNamesProperty);
530 >  RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'DataFieldName', TDBLookupPropertiesGridFieldProperty);
531 >  RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'KeyField', TIBTreeViewFieldProperty);
532 >  RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'TextField', TIBTreeViewFieldProperty);
533 >  RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'ParentField', TIBTreeViewFieldProperty);
534 >  RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'HasChildField', TIBTreeViewFieldProperty);
535 >  RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'ImageIndexField', TIBTreeViewFieldProperty);
536 >  RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'SelectedIndexField', TIBTreeViewFieldProperty);
537 >
538 >  IBGUIInterface :=  TIBDSLCLInterface.Create;
539 > end;
540 >
541 > procedure LoadDataSourceFields(DataSource: TDataSource; List: TStrings);
542 > var
543 >  DataSet: TDataSet;
544 >  i: Integer;
545 > begin
546 >  if Assigned(DataSource) then
547 >  begin
548 >    DataSet := DataSource.DataSet;
549 >    if Assigned(DataSet) then
550 >    begin
551 >      if DataSet.Fields.Count > 0 then
552 >        DataSet.GetFieldNames(List)
553 >      else
554 >      begin
555 >        DataSet.FieldDefs.Update;
556 >        for i := 0 to DataSet.FieldDefs.Count - 1 do
557 >          List.Add(DataSet.FieldDefs[i].Name);
558 >      end;
559 >    end;
560 >  end;
561 > end;
562 >
563 > { TIBLibraryNameProperty }
564 >
565 > function TIBLibraryNameProperty.GetFilter: string;
566 > begin
567 >  Result := SLibraryNameFilter; {do not localise}
568 > end;
569 >
570 > { TIBXServiceEditor }
571 >
572 > procedure TIBXServiceEditor.ExecuteVerb(Index: Integer);
573 > begin
574 >  if Index < inherited GetVerbCount then
575 >    inherited ExecuteVerb(Index) else
576 >  begin
577 >    Dec(Index, inherited GetVerbCount);
578 >    case Index of
579 >      0 : if IBXServiceEditor.EditIBXService(TIBXServicesConnection(Component)) then Designer.Modified;
580 >    end;
581 >  end;
582 > end;
583 >
584 > function TIBXServiceEditor.GetVerb(Index: Integer): string;
585 > begin
586 >  if Index < inherited GetVerbCount then
587 >    Result := inherited GetVerb(Index) else
588 >  begin
589 >    Dec(Index, inherited GetVerbCount);
590 >    case Index of
591 >      0: Result := SIBServiceEditor;
592 >      1 : Result := SInterbaseExpressVersion;
593 >    end;
594 >  end;
595 > end;
596 >
597 > function TIBXServiceEditor.GetVerbCount: Integer;
598 > begin
599 >  Result := inherited GetVerbCount + 2;
600 > end;
601 >
602 > { TIBUpdateRefreshSQLProperty }
603 >
604 > function TIBUpdateRefreshSQLProperty.GetObjects: boolean;
605 > begin
606 >  Result := false;
607 >  FIBUpdate := GetComponent(0) as TIBUpdate;
608 >  if not assigned(FIBUpdate) or not assigned(FIBUpdate.DataSet) then
609 >    Exit;
610 >  FDatabase := nil;
611 >  if FIBUpdate.DataSet is TIBQuery then
612 >  begin
613 >    FDatabase := (FIBUpdate.DataSet as TIBQuery).Database;
614 >    Result := true
615 >  end;
616 > end;
617 >
618 > procedure TIBUpdateRefreshSQLProperty.Edit;
619 > begin
620 >  GetObjects;
621 >  if IBRefreshSQLEditor.EditSQL(FIBUpdate.DataSet,FIBUpdate.RefreshSQL) then Modified;
622 > end;
623 >
624 > { TIBPackageNameProperty }
625 >
626 > procedure TIBPackageNameProperty.GetValues(Proc: TGetStrProc);
627 > var
628 >   StoredProc : TIBStoredProc;
629 >   i : integer;
630 > begin
631 >    StoredProc := GetComponent(0) as TIBStoredProc;
632 >    if StoredProc.Database = nil then
633 >      Exit;
634 >
635 >    with StoredProc do
636 >    try
637 >      for I := 0 to PackageNames.Count - 1 do
638 >        Proc (PackageNames[i]);
639 >    except on E: Exception do
640 >      MessageDlg(E.Message,mtError,[mbOK],0)
641 >    end;
642 > end;
643 >
644 > { TIBIndexDefsProperty }
645 >
646 > procedure TIBIndexDefsProperty.Edit;
647 > var IndexDefs: TIndexDefs;
648 > begin
649 >  IndexDefs := TIndexDefs(GetObjectValue);
650 >  if IndexDefs <> nil then
651 >    IndexDefs.Update;
652 >  inherited Edit;
653 > end;
654 >
655 > { TIBFieldDefsProperty }
656 >
657 > procedure TIBFieldDefsProperty.Edit;
658 > var FieldDefs: TFieldDefs;
659 > begin
660 >  FieldDefs := TFieldDefs(GetObjectValue);
661 >  if FieldDefs <> nil then
662 >    FieldDefs.Update;
663 >  inherited Edit;
664 > end;
665 >
666 > { TIBArrayGridEditor }
667 >
668 > procedure TIBArrayGridEditor.ExecuteVerb(Index: Integer);
669 > begin
670 >  if Index < inherited GetVerbCount then
671 >    inherited ExecuteVerb(Index)
672 >  else
673 >  case Index of
674 >    0: TIBArrayGrid(Component).UpdateLayout;
675 >  end;
676 > end;
677 >
678 > function TIBArrayGridEditor.GetVerb(Index: Integer): string;
679 > begin
680 >  if Index < inherited GetVerbCount then
681 >    Result := inherited GetVerb(Index) else
682 >  begin
683 >    Dec(Index, inherited GetVerbCount);
684 >    case Index of
685 >      0: Result := SIBUpdateLayout;
686 >      1 : Result := SInterbaseExpressVersion ;
687 >    end;
688 >  end;
689 > end;
690 >
691 > function TIBArrayGridEditor.GetVerbCount: Integer;
692 > begin
693 >  Result := 2;
694 > end;
695 >
696 > { TDBLookupPropertiesGridFieldProperty }
697 >
698 > procedure TDBLookupPropertiesGridFieldProperty.FillValues(
699 >  const Values: TStringList);
700 > var
701 >  P: TDBLookupProperties;
702 > begin
703 >  P :=TDBLookupProperties(GetComponent(0));
704 >  if not (P is TDBLookupProperties) then exit;
705 >  LoadDataSourceFields(TIBDynamicGrid(P.Owner.Grid).DataSource, Values);
706 > end;
707 >
708 > { TIBTreeViewFieldProperty }
709 >
710 > procedure TIBTreeViewFieldProperty.FillValues(const Values: TStringList);
711 > var ListSource: TDataSource;
712 > begin
713 >  ListSource :=  TIBTreeView(GetComponent(0)).DataSource;
714 >  LoadDataSourceFields(ListSource, Values);
715 > end;
716 >
717 > { TIBDynamicGridIndexNamesProperty }
718 >
719 > function TIBDynamicGridIndexNamesProperty.GetFieldDefs: TFieldDefs;
720 > var Grid: TIBDynamicGrid;
721 > begin
722 >  Result := nil;
723 >  Grid := TIBDynamicGrid(GetComponent(0));
724 >  if assigned(Grid.DataSource) and assigned(Grid.DataSource.DataSet) then
725 >     Result := Grid.DataSource.DataSet.FieldDefs
726 > end;
727 >
728 > function TIBDynamicGridIndexNamesProperty.GetIndexFieldNames: string;
729 > var Grid: TIBDynamicGrid;
730 > begin
731 >  Grid := TIBDynamicGrid(GetComponent(0));
732 >  Result := Grid.IndexFieldNames
733 > end;
734 >
735 > procedure TIBDynamicGridIndexNamesProperty.SetIndexFieldNames(
736 >  const Value: string);
737 > var Grid: TIBDynamicGrid;
738 > begin
739 >  Grid := TIBDynamicGrid(GetComponent(0));
740 >  Grid.IndexFieldNames := Value
741 > end;
742 >
743 > { TDBDynamicGridFieldProperty }
744 >
745 > procedure TDBDynamicGridFieldProperty.FillValues(const Values: TStringList);
746 > var
747 >  P: TDBLookupProperties;
748 > begin
749 >  P :=TDBLookupProperties(GetComponent(0));
750 >  if not (P is TDBLookupProperties) then exit;
751 >  LoadDataSourceFields(P.ListSource, Values);
752 > end;
753 >
754 > { TIBServiceEditor }
755 >
756 > procedure TIBServiceEditor.ExecuteVerb(Index: Integer);
757 > begin
758 >  if Index < inherited GetVerbCount then
759 >    inherited ExecuteVerb(Index) else
760 >  begin
761 >    Dec(Index, inherited GetVerbCount);
762 >    case Index of
763 >      0 : if ibserviceeditor.EditIBService(TIBCustomService(Component)) then Designer.Modified;
764 >    end;
765 >  end;
766 > end;
767 >
768 > function TIBServiceEditor.GetVerb(Index: Integer): string;
769 > begin
770 >  if Index < inherited GetVerbCount then
771 >    Result := inherited GetVerb(Index) else
772 >  begin
773 >    Dec(Index, inherited GetVerbCount);
774 >    case Index of
775 >      0: Result := SIBServiceEditor;
776 >      1 : Result := SInterbaseExpressVersion;
777 >    end;
778 >  end;
779 > end;
780 >
781 > function TIBServiceEditor.GetVerbCount: Integer;
782 > begin
783 >  Result := inherited GetVerbCount + 2;
784 > end;
785 >
786 > function TIBFileNameProperty.GetFilter: string;
787 > begin
788 >  Result := SDatabaseFilter; {do not localize}
789 > end;
790 >
791 > { TIBFileNameProperty }
792 > procedure TIBFileNameProperty.Edit;
793 > begin
794 >  with TOpenDialog.Create(Application) do
795 >    try
796 >      InitialDir := ExtractFilePath(GetStrValue);
797 >      Filter := GetFilter;
798 >      if Execute then
799 >        SetStrValue(FileName);
800 >    finally
801 >      Free
802 >    end;
803 > end;
804 >
805 > function TIBFileNameProperty.GetAttributes: TPropertyAttributes;
806 > begin
807 >  Result := [paDialog];
808 > end;
809 >
810 > { TIBNameProperty }
811 >
812 > function TIBNameProperty.GetAttributes: TPropertyAttributes;
813 > begin
814 >  Result := [paValueList, paSortList];
815 > end;
816 >
817 > { TIBStoredProcNameProperty }
818 >
819 > procedure TIBStoredProcNameProperty.GetValues(Proc: TGetStrProc);
820 > var
821 >   StoredProc : TIBStoredProc;
822 >   i : integer;
823 > begin
824 >    StoredProc := GetComponent(0) as TIBStoredProc;
825 >    if StoredProc.Database = nil then
826 >      Exit;
827 >
828 >    with StoredProc do
829 >    try
830 >      for I := 0 to StoredProcedureNames.Count - 1 do
831 >        Proc (StoredProcedureNames[i]);
832 >    except on E: Exception do
833 >      MessageDlg(E.Message,mtError,[mbOK],0)
834 >    end;
835 > end;
836 >
837 > { TIBTableNameProperty }
838 >
839 > procedure TIBTableNameProperty.GetValues(Proc: TGetStrProc);
840 > var
841 >   Table : TIBTable;
842 >   i : integer;
843 > begin
844 >  Table := GetComponent(0) as TIBTable;
845 >   if Table.Database = nil then
846 >      Exit;
847 >  with Table do
848 >    for I := 0 to TableNames.Count - 1 do
849 >      Proc (TableNames[i]);
850 > end;
851 >
852 > { TDBStringProperty }
853 >
854 > function TDBStringProperty.ConnecttoDB: boolean;
855 > var DataSet: TIBCustomDataSet;
856 > begin
857 >  Result := false;
858 >  DataSet := (GetComponent(0) as TIBCustomDataSet);
859 >  if assigned(Dataset.Database) then
860 >  begin
861 >    try
862 >      DataSet.Database.Connected := true;
863 >    except on E: Exception do
864 >      ShowMessage(E.Message)
865 >    end;
866 >    Result := DataSet.Database.Connected
867 >  end;
868 > end;
869 >
870 > function TDBStringProperty.GetAttributes: TPropertyAttributes;
871 > begin
872 >  Result := [paValueList, paSortList, paMultiSelect];
873 > end;
874 >
875 > procedure TDBStringProperty.GetValueList(List: TStrings);
876 > begin
877 > end;
878 >
879 > procedure TDBStringProperty.GetValues(Proc: TGetStrProc);
880 > var
881 >  I: Integer;
882 >  Values: TStringList;
883 > begin
884 >  if not ConnecttoDB then Exit;
885 >  Values := TStringList.Create;
886 >  try
887 >    GetValueList(Values);
888 >    for I := 0 to Values.Count - 1 do Proc(Values[I]);
889 >  finally
890 >    Values.Free;
891 >  end;
892 > end;
893 >
894 > procedure TDBStringProperty.Edit;
895 > begin
896 >  if ConnecttoDB then
897 >    inherited Edit;
898 > end;
899 >
900 > { Utility Functions }
901 >
902 > function GetPropertyValue(Instance: TPersistent; const PropName: string): TPersistent;
903 > var
904 >  PropInfo: PPropInfo;
905 > begin
906 >  Result := nil;
907 >  PropInfo := TypInfo.GetPropInfo(Instance.ClassInfo, PropName);
908 >  if (PropInfo <> nil) and (PropInfo^.PropType^.Kind = tkClass) then
909 >    Result := TObject(GetOrdProp(Instance, PropInfo)) as TPersistent;
910 > end;
911 >
912 > function GetIndexDefs(Component: TPersistent): TIndexDefs;
913 > var
914 >  DataSet: TDataSet;
915 > begin
916 >  DataSet := Component as TDataSet;
917 >  Result := GetPropertyValue(DataSet, 'IndexDefs') as TIndexDefs; {do not localize}
918 >  if Assigned(Result) then
919 >  begin
920 >    Result.Updated := False;
921 >    Result.Update;
922 >  end;
923 > end;
924 >
925 > { TIBIndexFieldNamesProperty }
926 >
927 > procedure TIBIndexFieldNamesProperty.GetValueList(List: TStrings);
928 > var
929 >  I: Integer;
930 >  IndexDefs: TIndexDefs;
931 > begin
932 >  IndexDefs := GetIndexDefs(GetComponent(0));
933 >  for I := 0 to IndexDefs.Count - 1 do
934 >    with IndexDefs[I] do
935 >      if (Options * [ixExpression, ixDescending] = []) and (Fields <> '') then
936 >        List.Add(Fields);
937 > end;
938 >
939 >
940 > { TIBIndexNameProperty }
941 >
942 > procedure TIBIndexNameProperty.GetValueList(List: TStrings);
943 > begin
944 >  GetIndexDefs(GetComponent(0)).GetItemNames(List);
945 > end;
946 >
947 > { TSQLPropertyEditor }
948 >
949 > function TSQLPropertyEditor.GetAttributes: TPropertyAttributes;
950 > begin
951 >  Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
952 > end;
953 >
954 > { TIBQuerySQLProperty }
955 >
956 > procedure TIBQuerySQLProperty.Edit;
957 > var
958 >  Query: TIBQuery;
959 > begin
960 >  Query := GetComponent(0) as TIBQuery;
961 >  if IBSelectSQLEditor.EditSQL(Query,Query.SQL) then Modified;
962 > end;
963 >
964 > { TIBDatasetSQLProperty }
965 >
966 > procedure TIBDatasetSQLProperty.Edit;
967 > var
968 >  IBDataset: TIBDataset;
969 > begin
970 >  IBDataset := GetComponent(0) as TIBDataset;
971 >  if IBSelectSQLEditor.EditSQL(IBDataSet,IBDataSet.SelectSQL) then Modified;
972 > end;
973 >
974 > { TIBSQLProperty }
975 >
976 > procedure TIBSQLProperty.Edit;
977 > var
978 >  IBSQL: TIBSQL;
979 > begin
980 >  IBSQL := GetComponent(0) as TIBSQL;
981 >  if IBSQLEditor.EditSQL(IBSQL) then Modified;
982 > end;
983 >
984 > { TIBUpdateSQLEditor }
985 >
986 > procedure TIBUpdateSQLEditor.ExecuteVerb(Index: Integer);
987 > begin
988 >  if IBUpdateSQLEditor.EditIBUpdateSQL(TIBUpdateSQL(Component)) then Modified;
989 > end;
990 >
991 > function TIBUpdateSQLEditor.GetVerb(Index: Integer): string;
992 > begin
993 >  case Index of
994 >    0 : Result := SIBUpdateSQLEditor;
995 >    1: Result := SInterbaseExpressVersion ;
996 >  end;
997 > end;
998 >
999 > function TIBUpdateSQLEditor.GetVerbCount: Integer;
1000 > begin
1001 >  Result :=  2;
1002 > end;
1003 >
1004 > { TIBDataSetEditor }
1005 >
1006 > procedure TIBDataSetEditor.ExecuteVerb(Index: Integer);
1007 > begin
1008 >  if Index < inherited GetVerbCount then
1009 >    inherited ExecuteVerb(Index) else
1010 >  begin
1011 >    Dec(Index, inherited GetVerbCount);
1012 >    case Index of
1013 >      0:
1014 >        if IBDataSetEditor.EditIBDataSet(TIBDataSet(Component)) then
1015 >          Designer.Modified;
1016 >      1: (Component as TIBDataSet).ExecSQL;
1017 >    end;
1018 >  end;
1019 > end;
1020 >
1021 > function TIBDataSetEditor.GetVerb(Index: Integer): string;
1022 > begin
1023 >  if Index < inherited GetVerbCount then
1024 >    Result := inherited GetVerb(Index) else
1025 >  begin
1026 >    Dec(Index, inherited GetVerbCount);
1027 >    case Index of
1028 >      0: Result := SIBDataSetEditor;
1029 >      1: Result := SExecute;
1030 >      2: Result := SInterbaseExpressVersion ;
1031 >    end;
1032 >  end;
1033 > end;
1034 >
1035 > function TIBDataSetEditor.GetVerbCount: Integer;
1036 > begin
1037 >  Result := inherited GetVerbCount + 3;
1038 > end;
1039 >
1040 > { TIBEventListProperty }
1041 >
1042 > function TIBEventListProperty.GetAttributes: TPropertyAttributes;
1043 > begin
1044 >  Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
1045 > end;
1046 >
1047 > procedure TIBEventListProperty.Edit;
1048 > var
1049 >  Events: TStrings;
1050 >  IBEvents: TIBEvents;
1051 > begin
1052 >  IBEvents := GetComponent(0) as TIBEvents;
1053 >  Events := TStringList.Create;
1054 >  try
1055 >    Events.Assign( IBEvents.Events);
1056 >    if EditAlerterEvents( Events) then
1057 >    begin
1058 >      IBEvents.Events.Assign(Events);
1059 >      Modified
1060 >    end;
1061 >  finally
1062 >    Events.Free;
1063 >  end;
1064 > end;
1065 >
1066 > { TIBDatabaseEditor }
1067 > procedure TIBDatabaseEditor.ExecuteVerb(Index: Integer);
1068 > begin
1069 >  if Index < inherited GetVerbCount then
1070 >    inherited ExecuteVerb(Index) else
1071 >  begin
1072 >    Dec(Index, inherited GetVerbCount);
1073 >    case Index of
1074 >      0 : if EditIBDatabase(TIBDatabase(Component)) then Designer.Modified;
1075 >    end;
1076 >  end;
1077 > end;
1078 >
1079 > function TIBDatabaseEditor.GetVerb(Index: Integer): string;
1080 > begin
1081 >  if Index < inherited GetVerbCount then
1082 >    Result := inherited GetVerb(Index) else
1083 >  begin
1084 >    Dec(Index, inherited GetVerbCount);
1085 >    case Index of
1086 >      0: Result := SIBDatabaseEditor;
1087 >      1 : Result := SInterbaseExpressVersion ;
1088 >    end;
1089 >  end;
1090 > end;
1091 >
1092 > function TIBDatabaseEditor.GetVerbCount: Integer;
1093 > begin
1094 >  Result := inherited GetVerbCount + 2;
1095 > end;
1096 >
1097 > { TIBTransactionEditor }
1098 >
1099 > procedure TIBTransactionEditor.ExecuteVerb(Index: Integer);
1100 > begin
1101 >  case Index of
1102 >    0: if EditIBTransaction(TIBTransaction(Component)) then Designer.Modified;
1103 >  end;
1104 > end;
1105 >
1106 > function TIBTransactionEditor.GetVerb(Index: Integer): string;
1107 > begin
1108 >  case Index of
1109 >    0: Result := SIBTransactionEditor;
1110 >    1: Result := SInterbaseExpressVersion ;
1111 >  end;
1112 > end;
1113 >
1114 > function TIBTransactionEditor.GetVerbCount: Integer;
1115 > begin
1116 >  Result := 2;
1117 > end;
1118 >
1119 > { TIBQueryEditor }
1120 >
1121 > procedure TIBQueryEditor.ExecuteVerb(Index: Integer);
1122 > var
1123 >  Query: TIBQuery;
1124 > begin
1125 >  if Index < inherited GetVerbCount then
1126 >    inherited ExecuteVerb(Index) else
1127 >  begin
1128 >    Query := Component as TIBQuery;
1129 >    Dec(Index, inherited GetVerbCount);
1130 >    case Index of
1131 >      0: Query.ExecSQL;
1132 >      1: if ibselectsqleditor.EditSQL(Query,Query.SQL) then Designer.Modified;
1133 >    end;
1134 >  end;
1135 > end;
1136 >
1137 > function TIBQueryEditor.GetVerb(Index: Integer): string;
1138 > begin
1139 >  if Index < inherited GetVerbCount then
1140 >    Result := inherited GetVerb(Index) else
1141 >  begin
1142 >    Dec(Index, inherited GetVerbCount);
1143 >    case Index of
1144 >      0: Result := SExecute;
1145 >      1: Result := SEditSQL;
1146 >      2: Result := SInterbaseExpressVersion ;
1147 >    end;
1148 >  end;
1149 > end;
1150 >
1151 > function TIBQueryEditor.GetVerbCount: Integer;
1152 > begin
1153 >  Result := inherited GetVerbCount + 3;
1154 > end;
1155 >
1156 > { TIBStoredProcEditor }
1157 >
1158 > procedure TIBStoredProcEditor.ExecuteVerb(Index: Integer);
1159 > begin
1160 >  if Index < inherited GetVerbCount then
1161 >    inherited ExecuteVerb(Index) else
1162 >  begin
1163 >    Dec(Index, inherited GetVerbCount);
1164 >    if Index = 0 then (Component as TIBStoredProc).ExecProc;
1165 >  end;
1166 > end;
1167 >
1168 > function TIBStoredProcEditor.GetVerb(Index: Integer): string;
1169 > begin
1170 >  if Index < inherited GetVerbCount then
1171 >    Result := inherited GetVerb(Index) else
1172 >  begin
1173 >    Dec(Index, inherited GetVerbCount);
1174 >    case Index of
1175 >      0: Result := SExecute;
1176 >      1: Result := SInterbaseExpressVersion ;
1177 >    end;
1178 >  end;
1179 > end;
1180 >
1181 > function TIBStoredProcEditor.GetVerbCount: Integer;
1182 > begin
1183 >  Result := inherited GetVerbCount + 2;
1184 > end;
1185 >
1186 > { TIBTableFieldLinkProperty }
1187 >
1188 > procedure TIBTableFieldLinkProperty.Edit;
1189 > begin
1190 >  FTable := DataSet as TIBTable;
1191 >  if assigned(FTable.Database) then
1192 >    FTable.Database.Connected := true;
1193 >  inherited Edit;
1194 > end;
1195 >
1196 > function TIBTableFieldLinkProperty.GetIndexDefs: TIndexDefs;
1197 > begin
1198 >  Result :=  FTable.IndexDefs
1199 > end;
1200 >
1201 > function TIBTableFieldLinkProperty.GetIndexFieldNames: string;
1202 > begin
1203 >  Result := FTable.IndexFieldNames;
1204 > end;
1205 >
1206 > function TIBTableFieldLinkProperty.GetMasterFields: string;
1207 > begin
1208 >  Result := FTable.MasterFields;
1209 > end;
1210 >
1211 > procedure TIBTableFieldLinkProperty.SetIndexFieldNames(const Value: string);
1212 > begin
1213 >  FTable.IndexFieldNames := Value;
1214 > end;
1215 >
1216 > procedure TIBTableFieldLinkProperty.SetMasterFields(const Value: string);
1217 > begin
1218 >  FTable.MasterFields := Value;
1219 > end;
1220 >
1221 > { TIBUpdateSQLProperty }
1222 >
1223 > procedure TIBUpdateSQLProperty.Edit;
1224 > var
1225 >  IBDataset: TIBDataset;
1226 > begin
1227 >  IBDataset := GetComponent(0) as TIBDataset;
1228 >  if IBModifySQLEditor.EditSQL(IBDataSet,IBDataSet.ModifySQL) then Modified;
1229 > end;
1230 >
1231 > { TIBUpdateSQLUpdateProperty }
1232 >
1233 > procedure TIBUpdateSQLUpdateProperty.Edit;
1234 > begin
1235 >  GetObjects;
1236 >  if IBModifySQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.ModifySQL) then Modified;
1237 > end;
1238 >
1239 > { TIBRefreshSQLProperty }
1240 >
1241 > procedure TIBRefreshSQLProperty.Edit;
1242 > var
1243 >  IBDataset: TIBDataset;
1244 > begin
1245 >  IBDataset := GetComponent(0) as TIBDataset;
1246 >  if IBRefreshSQLEditor.EditSQL(IBDataSet,IBDataSet.RefreshSQL) then Modified;
1247 > end;
1248 >
1249 > { TIBUpdateSQLRefreshSQLProperty }
1250 >
1251 > procedure TIBUpdateSQLRefreshSQLProperty.Edit;
1252 > begin
1253 >  GetObjects;
1254 >  if IBRefreshSQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.RefreshSQL) then Modified;
1255 > end;
1256 >
1257 > { TIBDeleteSQLProperty }
1258 >
1259 > procedure TIBDeleteSQLProperty.Edit;
1260 > var
1261 >  IBDataset: TIBDataSet;
1262 > begin
1263 >  IBDataset := GetComponent(0) as TIBDataSet;
1264 >  if IBDeleteSQLEditor.EditSQL(IBDataSet,IBDataSet.DeleteSQL) then Modified;
1265 > end;
1266 >
1267 > { TIBUpdateSQLDeleteProperty }
1268 >
1269 > function TIBUpdateSQLDeleteProperty.GetAttributes: TPropertyAttributes;
1270 > begin
1271 >  Result:=inherited GetAttributes;
1272 > end;
1273 >
1274 > procedure TIBUpdateSQLDeleteProperty.Edit;
1275 > begin
1276 >  GetObjects;
1277 >  if IBDeleteSQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.DeleteSQL) then Modified;
1278 > end;
1279 >
1280 > { TUpdateSQLPropertyEditor }
1281 >
1282 > function TUpdateSQLPropertyEditor.GetObjects: boolean;
1283 > begin
1284 >  Result := false;
1285 >  FIBUpdateSQL := GetComponent(0) as TIBUpdateSQL;
1286 >  if not assigned(FIBUpdateSQL) or not assigned(FIBUpdateSQL.DataSet) then
1287 >    Exit;
1288 >  FDatabase := nil;
1289 >  if FIBUpdateSQL.DataSet is TIBQuery then
1290 >  begin
1291 >    FDatabase := (FIBUpdateSQL.DataSet as TIBQuery).Database;
1292 >    Result := true
1293 >  end;
1294 > end;
1295 >
1296 > { TIBInsertSQLProperty }
1297 >
1298 > procedure TIBInsertSQLProperty.Edit;
1299 > var
1300 >  IBDataset: TIBDataSet;
1301 > begin
1302 >  IBDataset := GetComponent(0) as TIBDataSet;
1303 >  if IBInsertSQLEditor.EditSQL(IBDataSet,IBDataSet.InsertSQL) then Modified;
1304 > end;
1305 >
1306 > { TIBUpdateSQLInsertSQLProperty }
1307 >
1308 > procedure TIBUpdateSQLInsertSQLProperty.Edit;
1309 > begin
1310 >  GetObjects;
1311 >  if IBInsertSQLEditor.EditSQL(FIBUpdateSQL.Dataset,FIBUpdateSQL.InsertSQL) then Modified;
1312 > end;
1313 >
1314 > { TIBGeneratorProperty }
1315 >
1316 > function TIBGeneratorProperty.GetAttributes: TPropertyAttributes;
1317 > begin
1318 >  Result:= inherited GetAttributes + [paDialog] - [paMultiSelect,paValueList];
1319 > end;
1320 >
1321 > procedure TIBGeneratorProperty.Edit;
1322 > begin
1323 >  if IBGeneratorEditor.EditGenerator(GetPersistentReference as TIBGenerator) then Modified;
1324 > end;
1325 >
1326 > { TIBSQLEditor }
1327 >
1328 > procedure TIBSQLEditor.ExecuteVerb(Index: Integer);
1329 > begin
1330 >  if IBSQLEditor.EditSQL(TIBSQL(Component)) then Modified;
1331 > end;
1332 >
1333 > function TIBSQLEditor.GetVerb(Index: Integer): string;
1334 > begin
1335 >  case Index of
1336 >    0 : Result := SIBSQLEditor;
1337 >    1: Result := SInterbaseExpressVersion ;
1338 >  end;
1339 > end;
1340 >
1341 > function TIBSQLEditor.GetVerbCount: Integer;
1342 > begin
1343 >  Result:= 2
1344 > end;
1345 >
1346 > { TIBSQLSQLPropertyEditor }
1347 >
1348 > procedure TIBSQLSQLPropertyEditor.Edit;
1349 > var
1350 >  IBSQL: TIBSQL;
1351 > begin
1352 >  IBSQL := GetComponent(0) as TIBSQL;
1353 >  if IBSQLEditor.EditSQL(IBSQL) then Modified;
1354 > end;
1355 >
1356 > initialization
1357 >  {$I IBDBReg.lrs}
1358 > end.

Diff Legend

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