ViewVC Help

View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing

root/public/ibx/branches/journaling/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 143 by tony, Fri Feb 23 12:11:21 2018 UTC

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

Diff Legend

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