[ViewVC] Diff of: public/ibx/trunk/design/IBDBReg.pas

Comparing ibx/trunk/design/IBDBReg.pas (file contents):
Revision 1 by tony, Mon Jul 31 16:43:00 2000 UTC vs.
Revision 347 by tony, Mon Sep 20 22:08:20 2021 UTC

#	Line 24 \| Line 24
24		{ Corporation. All Rights Reserved. }
25		{ Contributor(s): Jeff Overcash }
26		{ }
27	+	{ IBX For Lazarus (Firebird Express) }
28	+	{ Contributor: Tony Whyman, MWA Software http://www.mwasoftware.co.uk }
29	+	{ Portions created by MWA Software are copyright McCallum Whyman }
30	+	{ Associates Ltd 2011 - 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 *)
36	–	{$G+} (* Imported data: On *)
42		{$H+} (* Huge Strings: On *)
43		{$J-} (* Modification of Typed Constants: Off *)
44		{$M+} (* Generate run-time type information: On *)
#	Line 41 \| Line 46 \| unit IBDBReg;
46		{$Q-} (* Overflow checks: Off *)
47		{$R-} (* Range checks: Off *)
48		{$T+} (* Typed address: On *)
44	–	{$U+} (* Pentim-safe FDIVs: On *)
49		{$W-} (* Always generate stack frames: Off *)
50		{$X+} (* Extended syntax: On *)
51		{$Z1} (* Minimum Enumeration Size: 1 Byte *)
52
53		interface
54
55	<	uses Windows, SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
56	<	DsgnIntf, DB, ParentageSupport, dsndb, DBReg, ColnEdit, FldLinks, SQLEdit,
57	<	DataModelSupport, IBTable, IBDatabase, IBUpdateSQLEditor, IBEventsEditor,
58	<	IBXConst;
55	>	uses SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
56	>	DB, IBTable, IBDatabase, IBEventsEditor, LazarusPackageIntf,
57	>	IBUpdateSQL, IBUpdate, ComponentEditors, PropEdits, DBPropEdits, FieldsEditor,
58	>	dbFieldLinkPropEditor, dbFieldListPropEditor, IBDialogs;
59
60		type
61
#	Line 59 \| Line 63 \| type
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)
#	Line 79 \| Line 92 \| type
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.}
#	Line 87 \| Line 108 \| type
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;
#	Line 121 \| Line 149 \| type
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(TDataSetEditor)
127	<	protected
128	<	FGetTableNamesProc: TGetTableNamesProc;
129	<	FGetFieldnamesProc: TGetFieldNamesProc;
163	>	TIBQueryEditor = class(TFieldsComponentEditor)
164		public
131	–	procedure EditSQL;
165		procedure ExecuteVerb(Index: Integer); override;
166		function GetVerb(Index: Integer): string; override;
167		function GetVerbCount: Integer; override;
#	Line 136 \| Line 169 \| type
169
170		{ TIBStoredProcEditor }
171
172	<	TIBStoredProcEditor = class(TDataSetEditor)
172	>	TIBStoredProcEditor = class(TFieldsComponentEditor)
173		public
174		procedure ExecuteVerb(Index: Integer); override;
175		function GetVerb(Index: Integer): string; override;
#	Line 145 \| Line 178 \| type
178
179		{ TIBDataSetEditor }
180
181	<	TIBDataSetEditor = class(TDataSetEditor)
149	<	protected
150	<	FGetTableNamesProc: TGetTableNamesProc;
151	<	FGetFieldnamesProc: TGetFieldNamesProc;
181	>	TIBDataSetEditor = class(TFieldsComponentEditor)
182		public
153	–	procedure EditSQL;
183		procedure ExecuteVerb(Index: Integer); override;
184		function GetVerb(Index: Integer): string; override;
185		function GetVerbCount: Integer; override;
#	Line 165 \| Line 194 \| type
194		function GetVerbCount: Integer; override;
195		end;
196
197	<	TIBStoredProcParamsProperty = class(TCollectionProperty)
197	>	{ TIBSQLEditor }
198	>
199	>	TIBSQLEditor = class(TComponentEditor)
200		public
201	<	procedure Edit; override;
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;
#	Line 184 \| Line 241 \| type
241
242		{ TSQLPropertyEditor }
243
244	<	TSQLPropertyEditor = class(TClassProperty)
188	<	protected
189	<	FGetTableNamesProc: TGetTableNamesProc;
190	<	FGetFieldnamesProc: TGetFieldNamesProc;
244	>	TSQLPropertyEditor = class(TStringsPropertyEditor)
245		public
192	–	procedure EditSQL;
246		function GetAttributes: TPropertyAttributes; override;
247		end;
248
#	Line 200 \| Line 253 \| type
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)
#	Line 214 \| Line 274 \| type
274		procedure Edit; override;
275		end;
276
277	<	TIBEventListProperty = class(TClassProperty)
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
219	–	function GetAttributes: TPropertyAttributes; override;
290		procedure Edit; override;
291		end;
292
293	<	{ DataModel Designer stuff }
293	>	{ TIBRefreshSQLProperty }
294
295	<	TIBSQLSprig = class(TSprig)
295	>	TIBRefreshSQLProperty = class(TSQLPropertyEditor)
296		public
297	<	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;
297	>	procedure Edit; override;
298		end;
299
300	<	TIBCustomDataSetSprig = class(TDataSetSprig)
300	>	{ TIBInsertSQLProperty }
301	>
302	>	TIBInsertSQLProperty = class(TSQLPropertyEditor)
303		public
304	<	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;
304	>	procedure Edit; override;
305		end;
306
307	<	TIBQuerySprig = class(TIBCustomDataSetSprig)
307	>	{ TIBDeleteSQLProperty }
308	>
309	>	TIBDeleteSQLProperty = class(TSQLPropertyEditor)
310		public
311	<	function AnyProblems: Boolean; override;
311	>	procedure Edit; override;
312		end;
313
314	<	TIBTableSprig = class(TIBCustomDataSetSprig)
314	>	{ TIBUpdateSQLUpdateProperty }
315	>
316	>	TIBUpdateSQLUpdateProperty = class(TUpdateSQLPropertyEditor)
317		public
318	<	function AnyProblems: Boolean; override;
251	<	function Caption: string; override;
318	>	procedure Edit; override;
319		end;
320
321	<	TIBStoredProcSprig = class(TIBCustomDataSetSprig)
321	>	{ TIBUpdateSQLRefreshSQLProperty }
322	>
323	>	TIBUpdateSQLRefreshSQLProperty = class(TUpdateSQLPropertyEditor)
324		public
325	<	function AnyProblems: Boolean; override;
257	<	function Caption: string; override;
325	>	procedure Edit; override;
326		end;
327
328	<	TIBUpdateSQLSprig = class(TSprigAtRoot)
328	>	{ TIBUpdateSQLInsertSQLProperty }
329	>
330	>	TIBUpdateSQLInsertSQLProperty = class(TUpdateSQLPropertyEditor)
331		public
332	<	function AnyProblems: Boolean; override;
332	>	procedure Edit; override;
333		end;
334
335	<	TIBDatabaseSprig = class(TSprigAtRoot)
335	>	{ TIBUpdateSQLDeleteProperty }
336	>
337	>	TIBUpdateSQLDeleteProperty = class(TUpdateSQLPropertyEditor)
338		public
339	<	function AnyProblems: Boolean; override;
340	<	function Caption: string; override;
339	>	function GetAttributes: TPropertyAttributes; override;
340	>	procedure Edit; override;
341		end;
342
343	<	TIBTransactionSprig = class(TSprig)
343	>	{ TIBUpdateRefreshSQLProperty }
344	>
345	>	TIBUpdateRefreshSQLProperty = class(TSQLPropertyEditor)
346	>	protected
347	>	FIBUpdate: TIBUpdate;
348	>	FDatabase: TIBDatabase;
349	>	function GetObjects: boolean;
350		public
351	<	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;
351	>	procedure Edit; override;
352		end;
353
354	<	TIBDatabaseInfoSprig = class(TSprig)
354	>
355	>	{ TIBEventListProperty }
356	>
357	>	TIBEventListProperty = class(TClassProperty)
358		public
359	<	class function ParentProperty: string; override;
359	>	function GetAttributes: TPropertyAttributes; override;
360	>	procedure Edit; override;
361		end;
362
363	<	TIBEventsSprig = class(TSprig)
363	>	{TIBGeneratorProperty}
364	>
365	>	TIBGeneratorProperty = class(TPersistentPropertyEditor)
366		public
367	<	class function ParentProperty: string; override;
368	<	function AnyProblems: Boolean; override;
367	>	function GetAttributes: TPropertyAttributes; override;
368	>	procedure Edit; override;
369		end;
370
371	<	TIBTransactionIsland = class(TIsland)
371	>	{ TDBDynamicGridFieldProperty }
372	>
373	>	TDBDynamicGridFieldProperty = class(TFieldProperty)
374		public
375	<	function VisibleTreeParent: Boolean; override;
375	>	procedure FillValues(const Values: TStringList); override;
376		end;
377
378	<	TIBSQLIsland = class(TIsland)
378	>	{ TDBLookupPropertiesGridFieldProperty }
379	>
380	>	TDBLookupPropertiesGridFieldProperty = class(TFieldProperty)
381		public
382	<	function VisibleTreeParent: Boolean; override;
382	>	procedure FillValues(const Values: TStringList); override;
383		end;
384
385	<	TIBCustomDataSetIsland = class(TDataSetIsland)
385	>	{ TIBTreeViewFieldProperty }
386	>
387	>	TIBTreeViewFieldProperty = class(TFieldProperty)
388		public
389	<	function VisibleTreeParent: Boolean; override;
389	>	procedure FillValues(const Values: TStringList); override;
390		end;
391
392	<	TIBTableIsland = class(TIBCustomDataSetIsland)
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	<	TIBTableMasterDetailBridge = class(TMasterDetailBridge)
401	>	{ TIBFieldDefsProperty }
402	>
403	>	TIBFieldDefsProperty = class(TCollectionPropertyEditor)
404		public
405	<	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;
405	>	procedure Edit; override;
406		end;
407
408	<	TIBQueryIsland = class(TIBCustomDataSetIsland)
321	<	end;
408	>	{ TIBIndexDefsProperty }
409
410	<	TIBQueryMasterDetailBridge = class(TMasterDetailBridge)
410	>	TIBIndexDefsProperty = class(TCollectionPropertyEditor)
411		public
412	<	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;
412	>	procedure Edit; override;
413		end;
414
415	+
416		procedure Register;
417
418		implementation
419
420	<	uses IB, IBQuery, IBStoredProc, IBUpdateSQL, IBCustomDataSet,
421	<	IBIntf, IBSQL, IBSQLMonitor, IBDatabaseInfo, IBEvents,
422	<	IBServices, IBInstall, IBDatabaseEdit, IBTransactionEdit,
423	<	IBBatchMove, DBLogDlg;
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	>	SFBLibLoadProblem = 'IBX is unable to locate or otherwise load the Firebird Library - have you remembered to install it?';
448
449		procedure Register;
450		begin
451	<	RegisterComponents(IBPalette1, [TIBTable, TIBQuery,
452	<	TIBStoredProc, TIBDatabase, TIBTransaction, TIBUpdateSQL,
453	<	TIBDataSet, TIBSQL, TIBDatabaseInfo, TIBSQLMonitor, TIBEvents]);
454	<	{$IFDEF IB6_ONLY}
455	<	if (TryIBLoad) and (GetIBClientVersion >= 6) then
451	>	AllowUseOfFBLIB := true;
452	>	try
453	>	if not TryIBLoad then
454	>	begin
455	>	MessageDlg(SFBLibLoadProblem,mtError,[mbOK],0);
456	>	Exit;
457	>	end;
458	>	except on E: Exception do
459	>	begin
460	>	MessageDlg(SFBLibLoadProblem + ' - ' + E.Message,mtError,[mbOK],0);
461	>	Exit;
462	>	end;
463	>	end;
464	>
465	>	RegisterNoIcon([TIBStringField, TIBBCDField, TIBMemoField, TIBArrayField,
466	>	TIBSmallintField, TIBIntegerField, TIBLargeIntField, TIBDateTimeField,
467	>	TIBTimeField]);
468	>	{$if lcl_fullversion < 01010000}
469	>	{see http://bugs.freepascal.org/view.php?id=19035 }
470	>	RegisterNoIcon([TIntegerField]);
471	>	{$endif}
472	>	RegisterComponents(IBPalette1, [ TIBQuery, TIBDataSet,
473	>	TIBDatabase, TIBTransaction, TIBUpdateSQL, TIBUpdate, TIBEvents,
474	>	TIBSQL, TIBDatabaseInfo, TIBSQLMonitor,
475	>	TIBStoredProc,TIBBatchMove, TIBTable,TIBExtract, TIBXScript, TIBLocalDBSupport,
476	>	TIBBlockFormatOut,TIBCSVDataOut,TIBInsertStmtsOut]);
477	>	if FirebirdAPI.HasServiceAPI then
478	>	begin
479	>	RegisterComponents(IBPalette4, [TIBXServicesConnection, TIBXConfigService,
480	>	TIBXClientSideBackupService, TIBXServerSideBackupService,
481	>	TIBXClientSideRestoreService, TIBXServerSideRestoreService,
482	>	TIBXValidationService, TIBXOnlineValidationService, TIBXStatisticalService,
483	>	TIBXLogService, TIBXSecurityService, TIBXServerProperties,
484	>	TIBXLimboTransactionResolutionService,TIBXServicesUserList, TIBXServicesLimboTransactionsList]);
485		RegisterComponents(IBPalette2, [TIBConfigService, TIBBackupService,
486	<	TIBRestoreService, TIBValidationService, TIBStatisticalService,
487	<	TIBLogService, TIBSecurityService, TIBServerProperties,
488	<	TIBInstall, TIBUninstall]);
489	<	{$ENDIF}
490	<	RegisterClasses([TIBStringField, TIBBCDField]);
491	<	RegisterFields([TIBStringField, TIBBCDField]);
486	>	TIBRestoreService, TIBValidationService,
487	>	TIBOnlineValidationService, TIBStatisticalService,
488	>	TIBLogService, TIBSecurityService, TIBServerProperties]);
489	>	end;
490	>
491	>	RegisterComponents(IBPalette3,[TIBLookupComboEditBox,TIBDynamicGrid,TIBTreeView,TDBControlGrid, TIBArrayGrid]);
492	>
493		RegisterPropertyEditor(TypeInfo(TIBFileName), TIBDatabase, 'DatabaseName', TIBFileNameProperty); {do not localize}
494	+	RegisterPropertyEditor(TypeInfo(TIBFileName), TIBDatabase, 'FirebirdLibraryPathName', TIBLibraryNameProperty); {do not localize}
495	+	RegisterPropertyEditor(TypeInfo(TIBFileName), TIBXServicesConnection, 'FirebirdLibraryPathName', TIBLibraryNameProperty); {do not localize}
496		RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'StoredProcName', TIBStoredProcNameProperty); {do not localize}
497	+	RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'PackageName', TIBPackageNameProperty); {do not localize}
498		RegisterPropertyEditor(TypeInfo(TParams), TIBStoredProc, 'Params', TIBStoredProcParamsProperty);
499		RegisterPropertyEditor(TypeInfo(string), TIBTable, 'TableName', TIBTableNameProperty); {do not localize}
500		RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexName', TIBIndexNameProperty); {do not localize}
501		RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexFieldNames', TIBIndexFieldNamesProperty); {do not localize}
502		RegisterPropertyEditor(TypeInfo(string), TIBTable, 'MasterFields', TIBTableFieldLinkProperty); {do not localize}
503	+	RegisterPropertyEditor(TypeInfo(TFieldDefs), TIBTable, 'FieldDefs', TIBFieldDefsProperty); {do not localize}
504	+	RegisterPropertyEditor(TypeInfo(TIndexDefs), TIBTable, 'IndexDefs', TIBIndexDefsProperty); {do not localize}
505		RegisterPropertyEditor(TypeInfo(TStrings), TIBQuery, 'SQL', TIBQuerySQLProperty); {do not localize}
506		RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'SelectSQL', TIBDatasetSQLProperty); {do not localize}
507	<	RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLProperty); {do not localize}
507	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'ModifySQL', TIBUpdateSQLProperty); {do not localize}
508	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'InsertSQL', TIBInsertSQLProperty); {do not localize}
509	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'RefreshSQL', TIBRefreshSQLProperty); {do not localize}
510	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'DeleteSQL', TIBDeleteSQLProperty); {do not localize}
511	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLSQLPropertyEditor); {do not localize}
512	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'RefreshSQL', TIBUpdateSQLRefreshSQLProperty); {do not localize}
513	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'ModifySQL', TIBUpdateSQLUpdateProperty); {do not localize}
514	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'InsertSQL', TIBUpdateSQLInsertSQLProperty); {do not localize}
515	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'DeleteSQL', TIBUpdateSQLDeleteProperty); {do not localize}
516	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdate, 'RefreshSQL', TIBUpdateRefreshSQLProperty); {do not localize}
517		RegisterPropertyEditor(TypeInfo(TStrings), TIBEvents, 'Events', TIBEventListProperty); {do not localize}
518	+	RegisterPropertyEditor(TypeInfo(TPersistent), TIBDataSet, 'GeneratorField', TIBGeneratorProperty); {do not localize}
519	+	RegisterPropertyEditor(TypeInfo(TPersistent), TIBQuery, 'GeneratorField', TIBGeneratorProperty); {do not localize}
520	+	RegisterPropertyEditor(TypeInfo(TPersistent), TIBTable, 'GeneratorField', TIBGeneratorProperty); {do not localize}
521
522		RegisterComponentEditor(TIBDatabase, TIBDatabaseEditor);
523		RegisterComponentEditor(TIBTransaction, TIBTransactionEditor);
#	Line 370 \| Line 525 \| begin
525		RegisterComponentEditor(TIBDataSet, TIBDataSetEditor);
526		RegisterComponentEditor(TIBQuery, TIBQueryEditor);
527		RegisterComponentEditor(TIBStoredProc, TIBStoredProcEditor);
528	+	RegisterComponentEditor(TIBSQL, TIBSQLEditor);
529	+	RegisterComponentEditor(TIBCustomService, TIBServiceEditor);
530	+	RegisterComponentEditor(TIBArrayGrid, TIBArrayGridEditor);
531	+	RegisterComponentEditor(TIBXServicesConnection, TIBXServiceEditor);
532	+
533	+
534	+	{Firebird Data Access Controls}
535	+	RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'KeyField', TDBDynamicGridFieldProperty);
536	+	RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'ListField', TDBDynamicGridFieldProperty);
537	+	RegisterPropertyEditor(TypeInfo(string), TIBDynamicGrid, 'IndexFieldNames', TIBDynamicGridIndexNamesProperty);
538	+	RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'DataFieldName', TDBLookupPropertiesGridFieldProperty);
539	+	RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'KeyField', TIBTreeViewFieldProperty);
540	+	RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'TextField', TIBTreeViewFieldProperty);
541	+	RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'ParentField', TIBTreeViewFieldProperty);
542	+	RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'HasChildField', TIBTreeViewFieldProperty);
543	+	RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'ImageIndexField', TIBTreeViewFieldProperty);
544	+	RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'SelectedIndexField', TIBTreeViewFieldProperty);
545	+
546	+	IBGUIInterface := TIBDSLCLInterface.Create;
547	+	end;
548	+
549	+	procedure LoadDataSourceFields(DataSource: TDataSource; List: TStrings);
550	+	var
551	+	DataSet: TDataSet;
552	+	i: Integer;
553	+	begin
554	+	if Assigned(DataSource) then
555	+	begin
556	+	DataSet := DataSource.DataSet;
557	+	if Assigned(DataSet) then
558	+	begin
559	+	if DataSet.Fields.Count > 0 then
560	+	DataSet.GetFieldNames(List)
561	+	else
562	+	begin
563	+	DataSet.FieldDefs.Update;
564	+	for i := 0 to DataSet.FieldDefs.Count - 1 do
565	+	List.Add(DataSet.FieldDefs[i].Name);
566	+	end;
567	+	end;
568	+	end;
569	+	end;
570	+
571	+	{ TIBLibraryNameProperty }
572	+
573	+	function TIBLibraryNameProperty.GetFilter: string;
574	+	begin
575	+	Result := SLibraryNameFilter; {do not localise}
576	+	end;
577	+
578	+	{ TIBXServiceEditor }
579	+
580	+	procedure TIBXServiceEditor.ExecuteVerb(Index: Integer);
581	+	begin
582	+	if Index < inherited GetVerbCount then
583	+	inherited ExecuteVerb(Index) else
584	+	begin
585	+	Dec(Index, inherited GetVerbCount);
586	+	case Index of
587	+	0 : if IBXServiceEditor.EditIBXService(TIBXServicesConnection(Component)) then Designer.Modified;
588	+	end;
589	+	end;
590	+	end;
591	+
592	+	function TIBXServiceEditor.GetVerb(Index: Integer): string;
593	+	begin
594	+	if Index < inherited GetVerbCount then
595	+	Result := inherited GetVerb(Index) else
596	+	begin
597	+	Dec(Index, inherited GetVerbCount);
598	+	case Index of
599	+	0: Result := SIBServiceEditor;
600	+	1 : Result := SInterbaseExpressVersion;
601	+	end;
602	+	end;
603	+	end;
604	+
605	+	function TIBXServiceEditor.GetVerbCount: Integer;
606	+	begin
607	+	Result := inherited GetVerbCount + 2;
608	+	end;
609	+
610	+	{ TIBUpdateRefreshSQLProperty }
611	+
612	+	function TIBUpdateRefreshSQLProperty.GetObjects: boolean;
613	+	begin
614	+	Result := false;
615	+	FIBUpdate := GetComponent(0) as TIBUpdate;
616	+	if not assigned(FIBUpdate) or not assigned(FIBUpdate.DataSet) then
617	+	Exit;
618	+	FDatabase := nil;
619	+	if FIBUpdate.DataSet is TIBQuery then
620	+	begin
621	+	FDatabase := (FIBUpdate.DataSet as TIBQuery).Database;
622	+	Result := true
623	+	end;
624	+	end;
625	+
626	+	procedure TIBUpdateRefreshSQLProperty.Edit;
627	+	begin
628	+	GetObjects;
629	+	if IBRefreshSQLEditor.EditSQL(FIBUpdate.DataSet,FIBUpdate.RefreshSQL) then Modified;
630	+	end;
631	+
632	+	{ TIBPackageNameProperty }
633	+
634	+	procedure TIBPackageNameProperty.GetValues(Proc: TGetStrProc);
635	+	var
636	+	StoredProc : TIBStoredProc;
637	+	i : integer;
638	+	begin
639	+	StoredProc := GetComponent(0) as TIBStoredProc;
640	+	if StoredProc.Database = nil then
641	+	Exit;
642	+
643	+	with StoredProc do
644	+	try
645	+	for I := 0 to PackageNames.Count - 1 do
646	+	Proc (PackageNames[i]);
647	+	except on E: Exception do
648	+	MessageDlg(E.Message,mtError,[mbOK],0)
649	+	end;
650	+	end;
651	+
652	+	{ TIBIndexDefsProperty }
653	+
654	+	procedure TIBIndexDefsProperty.Edit;
655	+	var IndexDefs: TIndexDefs;
656	+	begin
657	+	IndexDefs := TIndexDefs(GetObjectValue);
658	+	if IndexDefs <> nil then
659	+	IndexDefs.Update;
660	+	inherited Edit;
661	+	end;
662	+
663	+	{ TIBFieldDefsProperty }
664	+
665	+	procedure TIBFieldDefsProperty.Edit;
666	+	var FieldDefs: TFieldDefs;
667	+	begin
668	+	FieldDefs := TFieldDefs(GetObjectValue);
669	+	if FieldDefs <> nil then
670	+	FieldDefs.Update;
671	+	inherited Edit;
672	+	end;
673	+
674	+	{ TIBArrayGridEditor }
675	+
676	+	procedure TIBArrayGridEditor.ExecuteVerb(Index: Integer);
677	+	begin
678	+	if Index < inherited GetVerbCount then
679	+	inherited ExecuteVerb(Index)
680	+	else
681	+	case Index of
682	+	0: TIBArrayGrid(Component).UpdateLayout;
683	+	end;
684	+	end;
685	+
686	+	function TIBArrayGridEditor.GetVerb(Index: Integer): string;
687	+	begin
688	+	if Index < inherited GetVerbCount then
689	+	Result := inherited GetVerb(Index) else
690	+	begin
691	+	Dec(Index, inherited GetVerbCount);
692	+	case Index of
693	+	0: Result := SIBUpdateLayout;
694	+	1 : Result := SInterbaseExpressVersion ;
695	+	end;
696	+	end;
697	+	end;
698	+
699	+	function TIBArrayGridEditor.GetVerbCount: Integer;
700	+	begin
701	+	Result := 2;
702	+	end;
703	+
704	+	{ TDBLookupPropertiesGridFieldProperty }
705	+
706	+	procedure TDBLookupPropertiesGridFieldProperty.FillValues(
707	+	const Values: TStringList);
708	+	var
709	+	P: TDBLookupProperties;
710	+	begin
711	+	P :=TDBLookupProperties(GetComponent(0));
712	+	if not (P is TDBLookupProperties) then exit;
713	+	LoadDataSourceFields(TIBDynamicGrid(P.Owner.Grid).DataSource, Values);
714	+	end;
715	+
716	+	{ TIBTreeViewFieldProperty }
717	+
718	+	procedure TIBTreeViewFieldProperty.FillValues(const Values: TStringList);
719	+	var ListSource: TDataSource;
720	+	begin
721	+	ListSource := TIBTreeView(GetComponent(0)).DataSource;
722	+	LoadDataSourceFields(ListSource, Values);
723	+	end;
724	+
725	+	{ TIBDynamicGridIndexNamesProperty }
726	+
727	+	function TIBDynamicGridIndexNamesProperty.GetFieldDefs: TFieldDefs;
728	+	var Grid: TIBDynamicGrid;
729	+	begin
730	+	Result := nil;
731	+	Grid := TIBDynamicGrid(GetComponent(0));
732	+	if assigned(Grid.DataSource) and assigned(Grid.DataSource.DataSet) then
733	+	Result := Grid.DataSource.DataSet.FieldDefs
734	+	end;
735	+
736	+	function TIBDynamicGridIndexNamesProperty.GetIndexFieldNames: string;
737	+	var Grid: TIBDynamicGrid;
738	+	begin
739	+	Grid := TIBDynamicGrid(GetComponent(0));
740	+	Result := Grid.IndexFieldNames
741	+	end;
742	+
743	+	procedure TIBDynamicGridIndexNamesProperty.SetIndexFieldNames(
744	+	const Value: string);
745	+	var Grid: TIBDynamicGrid;
746	+	begin
747	+	Grid := TIBDynamicGrid(GetComponent(0));
748	+	Grid.IndexFieldNames := Value
749	+	end;
750	+
751	+	{ TDBDynamicGridFieldProperty }
752	+
753	+	procedure TDBDynamicGridFieldProperty.FillValues(const Values: TStringList);
754	+	var
755	+	P: TDBLookupProperties;
756	+	begin
757	+	P :=TDBLookupProperties(GetComponent(0));
758	+	if not (P is TDBLookupProperties) then exit;
759	+	LoadDataSourceFields(P.ListSource, Values);
760	+	end;
761
762	<	RegisterSprigType(TIBDatabase, TIBDatabaseSprig);
375	<	RegisterSprigType(TIBTransaction, TIBTransactionSprig);
762	>	{ TIBServiceEditor }
763
764	<	RegisterSprigType(TIBDatabaseInfo, TIBDatabaseInfoSprig);
765	<	RegisterSprigType(TIBEvents, TIBEventsSprig);
766	<	RegisterSprigType(TIBSQL, TIBSQLSprig);
767	<
768	<	RegisterSprigType(TIBUpdateSQL, TIBUpdateSQLSprig);
769	<
770	<	RegisterSprigType(TIBCustomDataSet, TIBCustomDataSetSprig);
771	<	RegisterSprigType(TIBQuery, TIBQuerySprig);
772	<	RegisterSprigType(TIBTable, TIBTableSprig);
773	<	RegisterSprigType(TIBStoredProc, TIBStoredProcSprig);
774	<
388	<	RegisterIslandType(TIBTransactionSprig, TIBTransactionIsland);
389	<	RegisterIslandType(TIBSQLSprig, TIBSQLIsland);
390	<	RegisterIslandType(TIBCustomDataSetSprig, TIBCustomDataSetIsland);
391	<	RegisterIslandType(TIBTableSprig, TIBTableIsland);
392	<	RegisterIslandType(TIBQuerySprig, TIBQueryIsland);
764	>	procedure TIBServiceEditor.ExecuteVerb(Index: Integer);
765	>	begin
766	>	if Index < inherited GetVerbCount then
767	>	inherited ExecuteVerb(Index) else
768	>	begin
769	>	Dec(Index, inherited GetVerbCount);
770	>	case Index of
771	>	0 : if ibserviceeditor.EditIBService(TIBCustomService(Component)) then Designer.Modified;
772	>	end;
773	>	end;
774	>	end;
775
776	<	RegisterBridgeType(TDataSetIsland, TIBTableIsland, TIBTableMasterDetailBridge);
777	<	RegisterBridgeType(TDataSetIsland, TIBQueryIsland, TIBQueryMasterDetailBridge);
776	>	function TIBServiceEditor.GetVerb(Index: Integer): string;
777	>	begin
778	>	if Index < inherited GetVerbCount then
779	>	Result := inherited GetVerb(Index) else
780	>	begin
781	>	Dec(Index, inherited GetVerbCount);
782	>	case Index of
783	>	0: Result := SIBServiceEditor;
784	>	1 : Result := SInterbaseExpressVersion;
785	>	end;
786	>	end;
787	>	end;
788	>
789	>	function TIBServiceEditor.GetVerbCount: Integer;
790	>	begin
791	>	Result := inherited GetVerbCount + 2;
792	>	end;
793	>
794	>	function TIBFileNameProperty.GetFilter: string;
795	>	begin
796	>	Result := SDatabaseFilter; {do not localize}
797		end;
798
799		{ TIBFileNameProperty }
#	Line 401 \| Line 802 \| begin
802		with TOpenDialog.Create(Application) do
803		try
804		InitialDir := ExtractFilePath(GetStrValue);
805	<	Filter := 'Database Files\|*.gdb'; {do not localize}
805	>	Filter := GetFilter;
806		if Execute then
807		SetStrValue(FileName);
808		finally
#	Line 429 \| Line 830 \| var
830		i : integer;
831		begin
832		StoredProc := GetComponent(0) as TIBStoredProc;
833	+	if StoredProc.Database = nil then
834	+	Exit;
835	+
836		with StoredProc do
837	+	try
838		for I := 0 to StoredProcedureNames.Count - 1 do
839		Proc (StoredProcedureNames[i]);
840	+	except on E: Exception do
841	+	MessageDlg(E.Message,mtError,[mbOK],0)
842	+	end;
843		end;
844
845		{ TIBTableNameProperty }
846
847		procedure TIBTableNameProperty.GetValues(Proc: TGetStrProc);
848		var
849	<	TableName : TIBTable;
849	>	Table : TIBTable;
850		i : integer;
851		begin
852	<	TableName := GetComponent(0) as TIBTable;
853	<	with TableName do
852	>	Table := GetComponent(0) as TIBTable;
853	>	if Table.Database = nil then
854	>	Exit;
855	>	with Table do
856		for I := 0 to TableNames.Count - 1 do
857		Proc (TableNames[i]);
858		end;
859
860		{ TDBStringProperty }
861
862	+	function TDBStringProperty.ConnecttoDB: boolean;
863	+	var DataSet: TIBCustomDataSet;
864	+	begin
865	+	Result := false;
866	+	DataSet := (GetComponent(0) as TIBCustomDataSet);
867	+	if assigned(Dataset.Database) then
868	+	begin
869	+	try
870	+	DataSet.Database.Connected := true;
871	+	except on E: Exception do
872	+	ShowMessage(E.Message)
873	+	end;
874	+	Result := DataSet.Database.Connected
875	+	end;
876	+	end;
877	+
878		function TDBStringProperty.GetAttributes: TPropertyAttributes;
879		begin
880		Result := [paValueList, paSortList, paMultiSelect];
#	Line 463 \| Line 889 \| var
889		I: Integer;
890		Values: TStringList;
891		begin
892	+	if not ConnecttoDB then Exit;
893		Values := TStringList.Create;
894		try
895		GetValueList(Values);
#	Line 472 \| Line 899 \| begin
899		end;
900		end;
901
902	+	procedure TDBStringProperty.Edit;
903	+	begin
904	+	if ConnecttoDB then
905	+	inherited Edit;
906	+	end;
907	+
908		{ Utility Functions }
909
910		function GetPropertyValue(Instance: TPersistent; const PropName: string): TPersistent;
#	Line 521 \| Line 954 \| end;
954
955		{ TSQLPropertyEditor }
956
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	–
957		function TSQLPropertyEditor.GetAttributes: TPropertyAttributes;
958		begin
959	<	Result := inherited GetAttributes + [paDialog] - [paSubProperties];
959	>	Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
960		end;
961
962		{ TIBQuerySQLProperty }
#	Line 552 \| Line 965 \| procedure TIBQuerySQLProperty.Edit;
965		var
966		Query: TIBQuery;
967		begin
968	<	Query := TIBQuery(GetComponent(0));
969	<	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;
968	>	Query := GetComponent(0) as TIBQuery;
969	>	if IBSelectSQLEditor.EditSQL(Query,Query.SQL) then Modified;
970		end;
971
972		{ TIBDatasetSQLProperty }
#	Line 572 \| Line 975 \| procedure TIBDatasetSQLProperty.Edit;
975		var
976		IBDataset: TIBDataset;
977		begin
978	<	IBDataset := TIBDataset(GetComponent(0));
979	<	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;
978	>	IBDataset := GetComponent(0) as TIBDataset;
979	>	if IBSelectSQLEditor.EditSQL(IBDataSet,IBDataSet.SelectSQL) then Modified;
980		end;
981
982		{ TIBSQLProperty }
#	Line 592 \| Line 985 \| procedure TIBSQLProperty.Edit;
985		var
986		IBSQL: TIBSQL;
987		begin
988	<	IBSQL := TIBSQL(GetComponent(0));
989	<	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;
988	>	IBSQL := GetComponent(0) as TIBSQL;
989	>	if IBSQLEditor.EditSQL(IBSQL) then Modified;
990		end;
991
992		{ TIBUpdateSQLEditor }
993
994		procedure TIBUpdateSQLEditor.ExecuteVerb(Index: Integer);
995		begin
996	<	if EditIBUpdateSQL(TIBUpdateSQL(Component)) then Designer.Modified;
996	>	if IBUpdateSQLEditor.EditIBUpdateSQL(TIBUpdateSQL(Component)) then Modified;
997		end;
998
999		function TIBUpdateSQLEditor.GetVerb(Index: Integer): string;
1000		begin
1001		case Index of
1002		0 : Result := SIBUpdateSQLEditor;
1003	<	2: Result := SInterbaseExpressVersion;
1003	>	1: Result := SInterbaseExpressVersion ;
1004		end;
1005		end;
1006
1007		function TIBUpdateSQLEditor.GetVerbCount: Integer;
1008		begin
1009	<	Result := 2;
1009	>	Result := 2;
1010		end;
1011
1012		{ TIBDataSetEditor }
1013
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	–
1014		procedure TIBDataSetEditor.ExecuteVerb(Index: Integer);
652	–	var
653	–	IBDataset: TIBDataset;
1015		begin
1016		if Index < inherited GetVerbCount then
1017		inherited ExecuteVerb(Index) else
#	Line 658 \| Line 1019 \| begin
1019		Dec(Index, inherited GetVerbCount);
1020		case Index of
1021		0:
1022	<	if EditIBDataSet(TIBDataSet(Component)) then
1022	>	if IBDataSetEditor.EditIBDataSet(TIBDataSet(Component)) then
1023		Designer.Modified;
1024		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;
1025		end;
1026		end;
1027		end;
#	Line 689 \| Line 1035 \| begin
1035		case Index of
1036		0: Result := SIBDataSetEditor;
1037		1: Result := SExecute;
1038	<	2: Result := SEditSQL;
693	<	3: Result := SInterbaseExpressVersion;
1038	>	2: Result := SInterbaseExpressVersion ;
1039		end;
1040		end;
1041		end;
1042
1043		function TIBDataSetEditor.GetVerbCount: Integer;
1044		begin
1045	<	Result := inherited GetVerbCount + 4;
1045	>	Result := inherited GetVerbCount + 3;
1046		end;
1047
1048		{ TIBEventListProperty }
1049
1050		function TIBEventListProperty.GetAttributes: TPropertyAttributes;
1051		begin
1052	<	Result := inherited GetAttributes + [paDialog] - [paSubProperties];
1052	>	Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
1053		end;
1054
1055		procedure TIBEventListProperty.Edit;
1056		var
1057		Events: TStrings;
1058	+	IBEvents: TIBEvents;
1059		begin
1060	+	IBEvents := GetComponent(0) as TIBEvents;
1061		Events := TStringList.Create;
1062		try
1063	<	Events.Assign( TStrings(GetOrdValue));
1064	<	if EditAlerterEvents( Events) then SetOrdValue( longint(Events));
1063	>	Events.Assign( IBEvents.Events);
1064	>	if EditAlerterEvents( Events) then
1065	>	begin
1066	>	IBEvents.Events.Assign(Events);
1067	>	Modified
1068	>	end;
1069		finally
1070		Events.Free;
1071		end;
#	Line 741 \| Line 1092 \| begin
1092		Dec(Index, inherited GetVerbCount);
1093		case Index of
1094		0: Result := SIBDatabaseEditor;
1095	<	1 : Result := SInterbaseExpressVersion;
1095	>	1 : Result := SInterbaseExpressVersion ;
1096		end;
1097		end;
1098		end;
#	Line 764 \| Line 1115 \| function TIBTransactionEditor.GetVerb(In
1115		begin
1116		case Index of
1117		0: Result := SIBTransactionEditor;
1118	<	1: Result := SInterbaseExpressVersion;
1118	>	1: Result := SInterbaseExpressVersion ;
1119		end;
1120		end;
1121
#	Line 775 \| Line 1126 \| end;
1126
1127		{ TIBQueryEditor }
1128
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	–
1129		procedure TIBQueryEditor.ExecuteVerb(Index: Integer);
1130		var
1131		Query: TIBQuery;
#	Line 806 \| Line 1137 \| begin
1137		Dec(Index, inherited GetVerbCount);
1138		case Index of
1139		0: Query.ExecSQL;
1140	<	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;
1140	>	1: if ibselectsqleditor.EditSQL(Query,Query.SQL) then Designer.Modified;
1141		end;
1142		end;
1143		end;
#	Line 833 \| Line 1151 \| begin
1151		case Index of
1152		0: Result := SExecute;
1153		1: Result := SEditSQL;
1154	<	2: Result := SInterbaseExpressVersion;
1154	>	2: Result := SInterbaseExpressVersion ;
1155		end;
1156		end;
1157		end;
#	Line 863 \| Line 1181 \| begin
1181		Dec(Index, inherited GetVerbCount);
1182		case Index of
1183		0: Result := SExecute;
1184	<	1: Result := SInterbaseExpressVersion;
1184	>	1: Result := SInterbaseExpressVersion ;
1185		end;
1186		end;
1187		end;
#	Line 873 \| Line 1191 \| begin
1191		Result := inherited GetVerbCount + 2;
1192		end;
1193
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	–
1194		{ TIBTableFieldLinkProperty }
1195
1196		procedure TIBTableFieldLinkProperty.Edit;
1197		begin
1198		FTable := DataSet as TIBTable;
1199	+	if assigned(FTable.Database) then
1200	+	FTable.Database.Connected := true;
1201		inherited Edit;
1202		end;
1203
1204	+	function TIBTableFieldLinkProperty.GetIndexDefs: TIndexDefs;
1205	+	begin
1206	+	Result := FTable.IndexDefs
1207	+	end;
1208	+
1209		function TIBTableFieldLinkProperty.GetIndexFieldNames: string;
1210		begin
1211		Result := FTable.IndexFieldNames;
#	Line 918 \| Line 1226 \| begin
1226		FTable.MasterFields := Value;
1227		end;
1228
1229	<	{ 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;
1229	>	{ TIBUpdateSQLProperty }
1230
1231	<	{ TIBTransactionSprig }
1232	<
1233	<	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;
1231	>	procedure TIBUpdateSQLProperty.Edit;
1232	>	var
1233	>	IBDataset: TIBDataset;
1234		begin
1235	<	Result := (AParent is TIBDatabaseSprig);
1235	>	IBDataset := GetComponent(0) as TIBDataset;
1236	>	if IBModifySQLEditor.EditSQL(IBDataSet,IBDataSet.ModifySQL) then Modified;
1237		end;
1238
1239	<	{ support stuff for sprigs }
1239	>	{ TIBUpdateSQLUpdateProperty }
1240
1241	<	function IBAnyProblems(ATransaction: TIBTransaction; ADatabase: TIBDatabase): Boolean;
1241	>	procedure TIBUpdateSQLUpdateProperty.Edit;
1242		begin
1243	<	Result := (ATransaction = nil) or
1244	<	(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);
1243	>	GetObjects;
1244	>	if IBModifySQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.ModifySQL) then Modified;
1245		end;
1246
1247	<	function IBDragOver(ASprig: TSprig): Boolean;
999	<	begin
1000	<	Result := (ASprig is TIBTransactionSprig) or
1001	<	(ASprig is TIBDatabaseSprig);
1002	<	end;
1247	>	{ TIBRefreshSQLProperty }
1248
1249	<	function IBDropOver(AParent: TSprig; var ATransaction: TIBTransaction; var ADatabase: TIBDatabase): Boolean;
1249	>	procedure TIBRefreshSQLProperty.Edit;
1250		var
1251	<	vParentTransaction: TIBTransaction;
1007	<	vParentDatabase: TIBDatabase;
1251	>	IBDataset: TIBDataset;
1252		begin
1253	<	Result := False;
1254	<	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;
1253	>	IBDataset := GetComponent(0) as TIBDataset;
1254	>	if IBRefreshSQLEditor.EditSQL(IBDataSet,IBDataSet.RefreshSQL) then Modified;
1255		end;
1256
1257	<	{ TIBSQLSprig }
1257	>	{ TIBUpdateSQLRefreshSQLProperty }
1258
1259	<	function TIBSQLSprig.AnyProblems: Boolean;
1259	>	procedure TIBUpdateSQLRefreshSQLProperty.Edit;
1260		begin
1261	<	Result := IBAnyProblems(TIBSQL(Item).Transaction,
1262	<	TIBSQL(Item).Database) or
1043	<	(TIBSQL(Item).SQL.Count = 0);
1261	>	GetObjects;
1262	>	if IBRefreshSQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.RefreshSQL) then Modified;
1263		end;
1264
1265	<	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;
1265	>	{ TIBDeleteSQLProperty }
1266
1267	<	function TIBSQLSprig.DragOverTo(AItem: TSprig): Boolean;
1267	>	procedure TIBDeleteSQLProperty.Edit;
1268	>	var
1269	>	IBDataset: TIBDataSet;
1270		begin
1271	<	Result := IBDragOver(AItem);
1271	>	IBDataset := GetComponent(0) as TIBDataSet;
1272	>	if IBDeleteSQLEditor.EditSQL(IBDataSet,IBDataSet.DeleteSQL) then Modified;
1273		end;
1274
1275	<	procedure TIBSQLSprig.FigureParent;
1070	<	begin
1071	<	IBFigureParent(Self, TIBSQL(Item).Transaction,
1072	<	TIBSQL(Item).Database);
1073	<	end;
1275	>	{ TIBUpdateSQLDeleteProperty }
1276
1277	<	class function TIBSQLSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
1277	>	function TIBUpdateSQLDeleteProperty.GetAttributes: TPropertyAttributes;
1278		begin
1279	<	Result := IBDragOver(AParent);
1279	>	Result:=inherited GetAttributes;
1280		end;
1281
1282	<	{ TIBCustomDataSetSprig }
1081	<
1082	<	function TIBCustomDataSetSprig.AnyProblems: Boolean;
1282	>	procedure TIBUpdateSQLDeleteProperty.Edit;
1283		begin
1284	<	Result := IBAnyProblems(TIBCustomDataSet(Item).Transaction,
1285	<	TIBCustomDataSet(Item).Database);
1284	>	GetObjects;
1285	>	if IBDeleteSQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.DeleteSQL) then Modified;
1286		end;
1287
1288	<	procedure TIBCustomDataSetSprig.FigureParent;
1089	<	begin
1090	<	IBFigureParent(Self, TIBCustomDataSet(Item).Transaction,
1091	<	TIBCustomDataSet(Item).Database);
1092	<	end;
1288	>	{ TUpdateSQLPropertyEditor }
1289
1290	<	function TIBCustomDataSetSprig.DragDropTo(AItem: TSprig): Boolean;
1095	<	var
1096	<	vTransaction: TIBTransaction;
1097	<	vDatabase: TIBDatabase;
1290	>	function TUpdateSQLPropertyEditor.GetObjects: boolean;
1291		begin
1292	<	with TIBCustomDataSet(Item) do
1292	>	Result := false;
1293	>	FIBUpdateSQL := GetComponent(0) as TIBUpdateSQL;
1294	>	if not assigned(FIBUpdateSQL) or not assigned(FIBUpdateSQL.DataSet) then
1295	>	Exit;
1296	>	FDatabase := nil;
1297	>	if FIBUpdateSQL.DataSet is TIBQuery then
1298		begin
1299	<	vTransaction := Transaction;
1300	<	vDatabase := Database;
1103	<	Result := IBDropOver(AItem, vTransaction, vDatabase);
1104	<	if Result then
1105	<	begin
1106	<	Transaction := vTransaction;
1107	<	Database := vDatabase;
1108	<	end;
1299	>	FDatabase := (FIBUpdateSQL.DataSet as TIBQuery).Database;
1300	>	Result := true
1301		end;
1302		end;
1303
1304	<	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;
1304	>	{ TIBInsertSQLProperty }
1305
1306	<	function TIBTableMasterDetailBridge.Edit: Boolean;
1306	>	procedure TIBInsertSQLProperty.Edit;
1307		var
1308	<	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;
1308	>	IBDataset: TIBDataSet;
1309		begin
1310	<	Result := TIBTable(AItem).MasterSource;
1310	>	IBDataset := GetComponent(0) as TIBDataSet;
1311	>	if IBInsertSQLEditor.EditSQL(IBDataSet,IBDataSet.InsertSQL) then Modified;
1312		end;
1313
1314	<	class function TIBTableMasterDetailBridge.OmegaIslandClass: TIslandClass;
1222	<	begin
1223	<	Result := TIBTableIsland;
1224	<	end;
1314	>	{ TIBUpdateSQLInsertSQLProperty }
1315
1316	<	class procedure TIBTableMasterDetailBridge.SetOmegaSource(
1227	<	AItem: TPersistent; ADataSource: TDataSource);
1316	>	procedure TIBUpdateSQLInsertSQLProperty.Edit;
1317		begin
1318	<	TIBTable(AItem).MasterSource := ADataSource;
1318	>	GetObjects;
1319	>	if IBInsertSQLEditor.EditSQL(FIBUpdateSQL.Dataset,FIBUpdateSQL.InsertSQL) then Modified;
1320		end;
1321
1322	<	{ TIBQueryMasterDetailBridge }
1322	>	{ TIBGeneratorProperty }
1323
1324	<	function TIBQueryMasterDetailBridge.Caption: string;
1324	>	function TIBGeneratorProperty.GetAttributes: TPropertyAttributes;
1325		begin
1326	<	Result := SParamsFields;
1326	>	Result:= inherited GetAttributes + [paDialog] - [paMultiSelect,paValueList];
1327		end;
1328
1329	<	class function TIBQueryMasterDetailBridge.GetOmegaSource(
1240	<	AItem: TPersistent): TDataSource;
1329	>	procedure TIBGeneratorProperty.Edit;
1330		begin
1331	<	Result := TIBQuery(AItem).DataSource;
1331	>	if IBGeneratorEditor.EditGenerator(GetPersistentReference as TIBGenerator) then Modified;
1332		end;
1333
1334	<	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;
1334	>	{ TIBSQLEditor }
1335
1336	<	class procedure TIBQueryMasterDetailBridge.SetOmegaSource(
1256	<	AItem: TPersistent; ADataSource: TDataSource);
1336	>	procedure TIBSQLEditor.ExecuteVerb(Index: Integer);
1337		begin
1338	<	TIBQuery(AItem).DataSource := ADataSource;
1338	>	if IBSQLEditor.EditSQL(TIBSQL(Component)) then Modified;
1339		end;
1340
1341	<	{ TIBCustomDataSetIsland }
1262	<
1263	<	function TIBCustomDataSetIsland.VisibleTreeParent: Boolean;
1341	>	function TIBSQLEditor.GetVerb(Index: Integer): string;
1342		begin
1343	<	Result := False;
1343	>	case Index of
1344	>	0 : Result := SIBSQLEditor;
1345	>	1: Result := SInterbaseExpressVersion ;
1346	>	end;
1347		end;
1348
1349	<	{ TIBSQLIsland }
1269	<
1270	<	function TIBSQLIsland.VisibleTreeParent: Boolean;
1349	>	function TIBSQLEditor.GetVerbCount: Integer;
1350		begin
1351	<	Result := False;
1351	>	Result:= 2
1352		end;
1353
1354	<	{ TIBTransactionIsland }
1354	>	{ TIBSQLSQLPropertyEditor }
1355
1356	<	function TIBTransactionIsland.VisibleTreeParent: Boolean;
1356	>	procedure TIBSQLSQLPropertyEditor.Edit;
1357	>	var
1358	>	IBSQL: TIBSQL;
1359		begin
1360	<	Result := TIBTransaction(Sprig.Item).DefaultDatabase = nil;
1360	>	IBSQL := GetComponent(0) as TIBSQL;
1361	>	if IBSQLEditor.EditSQL(IBSQL) then Modified;
1362		end;
1363
1364	+	initialization
1365	+	{$I IBDBReg.lrs}
1366		end.

Diff Legend

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

Comparing ibx/trunk/design/IBDBReg.pas (file contents): Revision 1 by tony, Mon Jul 31 16:43:00 2000 UTC vs. Revision 347 by tony, Mon Sep 20 22:08:20 2021 UTC

Diff Legend

Comparing ibx/trunk/design/IBDBReg.pas (file contents):
Revision 1 by tony, Mon Jul 31 16:43:00 2000 UTC vs.
Revision 347 by tony, Mon Sep 20 22:08:20 2021 UTC