[ViewVC] Diff of: 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 45 by tony, Tue Dec 6 10:33:46 2016 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 }
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, ComponentEditors, PropEdits, DBPropEdits, FieldsEditor,
58	>	dbFieldLinkPropEditor, dbFieldListPropEditor, IBDialogs;
59
60		type
61
#	Line 87 \| Line 91 \| type
91		procedure GetValues(Proc: TGetStrProc); override;
92		end;
93
94	+	{ TDBStringProperty }
95	+
96		TDBStringProperty = class(TStringProperty)
97	+	private
98	+	function ConnecttoDB: boolean;
99		public
100		function GetAttributes: TPropertyAttributes; override;
101		procedure GetValueList(List: TStrings); virtual;
102		procedure GetValues(Proc: TGetStrProc); override;
103	+	procedure Edit; override;
104		end;
105
106	+	{ TIBIndexFieldNamesProperty }
107	+
108		TIBIndexFieldNamesProperty = class(TDBStringProperty)
109		public
110		procedure GetValueList(List: TStrings); override;
#	Line 121 \| Line 132 \| type
132		function GetVerbCount: Integer; override;
133		end;
134
135	+	{ TIBArrayGridEditor }
136	+
137	+	TIBArrayGridEditor = class(TComponentEditor)
138	+	public
139	+	procedure ExecuteVerb(Index: Integer); override;
140	+	function GetVerb(Index: Integer): string; override;
141	+	function GetVerbCount: Integer; override;
142	+	end;
143	+
144		{ TIBQueryEditor }
145
146	<	TIBQueryEditor = class(TDataSetEditor)
127	<	protected
128	<	FGetTableNamesProc: TGetTableNamesProc;
129	<	FGetFieldnamesProc: TGetFieldNamesProc;
146	>	TIBQueryEditor = class(TFieldsComponentEditor)
147		public
131	–	procedure EditSQL;
148		procedure ExecuteVerb(Index: Integer); override;
149		function GetVerb(Index: Integer): string; override;
150		function GetVerbCount: Integer; override;
#	Line 136 \| Line 152 \| type
152
153		{ TIBStoredProcEditor }
154
155	<	TIBStoredProcEditor = class(TDataSetEditor)
155	>	TIBStoredProcEditor = class(TFieldsComponentEditor)
156		public
157		procedure ExecuteVerb(Index: Integer); override;
158		function GetVerb(Index: Integer): string; override;
#	Line 145 \| Line 161 \| type
161
162		{ TIBDataSetEditor }
163
164	<	TIBDataSetEditor = class(TDataSetEditor)
149	<	protected
150	<	FGetTableNamesProc: TGetTableNamesProc;
151	<	FGetFieldnamesProc: TGetFieldNamesProc;
164	>	TIBDataSetEditor = class(TFieldsComponentEditor)
165		public
153	–	procedure EditSQL;
166		procedure ExecuteVerb(Index: Integer); override;
167		function GetVerb(Index: Integer): string; override;
168		function GetVerbCount: Integer; override;
#	Line 165 \| Line 177 \| type
177		function GetVerbCount: Integer; override;
178		end;
179
180	<	TIBStoredProcParamsProperty = class(TCollectionProperty)
180	>	{ TIBSQLEditor }
181	>
182	>	TIBSQLEditor = class(TComponentEditor)
183	>	public
184	>	procedure ExecuteVerb(Index: Integer); override;
185	>	function GetVerb(Index: Integer): string; override;
186	>	function GetVerbCount: Integer; override;
187	>	end;
188	>
189	>	{ TIBServiceEditor}
190	>
191	>	TIBServiceEditor = class(TComponentEditor)
192	>	public
193	>	procedure ExecuteVerb(Index: Integer); override;
194	>	function GetVerb(Index: Integer): string; override;
195	>	function GetVerbCount: Integer; override;
196	>	end;
197	>
198	>	TIBStoredProcParamsProperty = class(TCollectionPropertyEditor)
199		public
200		procedure Edit; override;
201		end;
202
203	+	{ TIBTableFieldLinkProperty }
204	+
205		TIBTableFieldLinkProperty = class(TFieldLinkProperty)
206		private
207		FTable: TIBTable;
208		protected
209	+	function GetIndexDefs: TIndexDefs; override;
210		function GetIndexFieldNames: string; override;
211		function GetMasterFields: string; override;
212		procedure SetIndexFieldNames(const Value: string); override;
#	Line 184 \| Line 217 \| type
217
218		{ TSQLPropertyEditor }
219
220	<	TSQLPropertyEditor = class(TClassProperty)
188	<	protected
189	<	FGetTableNamesProc: TGetTableNamesProc;
190	<	FGetFieldnamesProc: TGetFieldNamesProc;
220	>	TSQLPropertyEditor = class(TStringsPropertyEditor)
221		public
192	–	procedure EditSQL;
222		function GetAttributes: TPropertyAttributes; override;
223		end;
224
#	Line 200 \| Line 229 \| type
229		procedure Edit; override;
230		end;
231
232	+	{TIBSQLSQLPropertyEditor }
233	+
234	+	TIBSQLSQLPropertyEditor = class(TSQLPropertyEditor)
235	+	public
236	+	procedure Edit; override;
237	+	end;
238	+
239		{ TIBDatasetSQLProperty }
240
241		TIBDatasetSQLProperty = class(TSQLPropertyEditor)
#	Line 214 \| Line 250 \| type
250		procedure Edit; override;
251		end;
252
253	<	TIBEventListProperty = class(TClassProperty)
253	>	{ TUpdateSQLPropertyEditor }
254	>
255	>	TUpdateSQLPropertyEditor = class(TSQLPropertyEditor)
256	>	protected
257	>	FIBUpdateSQL: TIBUpdateSQL;
258	>	FDatabase: TIBDatabase;
259	>	function GetObjects: boolean;
260	>	end;
261	>
262	>	{ TIBUpdateSQLProperty }
263	>
264	>	TIBUpdateSQLProperty = class(TSQLPropertyEditor)
265		public
219	–	function GetAttributes: TPropertyAttributes; override;
266		procedure Edit; override;
267		end;
268
269	<	{ DataModel Designer stuff }
269	>	{ TIBRefreshSQLProperty }
270
271	<	TIBSQLSprig = class(TSprig)
271	>	TIBRefreshSQLProperty = class(TSQLPropertyEditor)
272		public
273	<	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;
273	>	procedure Edit; override;
274		end;
275
276	<	TIBCustomDataSetSprig = class(TDataSetSprig)
235	<	public
236	<	procedure FigureParent; override;
237	<	function AnyProblems: Boolean; override;
238	<	function DragDropTo(AItem: TSprig): Boolean; override;
239	<	function DragOverTo(AItem: TSprig): Boolean; override;
240	<	class function PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean; override;
241	<	end;
276	>	{ TIBInsertSQLProperty }
277
278	<	TIBQuerySprig = class(TIBCustomDataSetSprig)
278	>	TIBInsertSQLProperty = class(TSQLPropertyEditor)
279		public
280	<	function AnyProblems: Boolean; override;
280	>	procedure Edit; override;
281		end;
282
283	<	TIBTableSprig = class(TIBCustomDataSetSprig)
283	>	{ TIBDeleteSQLProperty }
284	>
285	>	TIBDeleteSQLProperty = class(TSQLPropertyEditor)
286		public
287	<	function AnyProblems: Boolean; override;
251	<	function Caption: string; override;
287	>	procedure Edit; override;
288		end;
289
290	<	TIBStoredProcSprig = class(TIBCustomDataSetSprig)
290	>	{ TIBUpdateSQLUpdateProperty }
291	>
292	>	TIBUpdateSQLUpdateProperty = class(TUpdateSQLPropertyEditor)
293		public
294	<	function AnyProblems: Boolean; override;
257	<	function Caption: string; override;
294	>	procedure Edit; override;
295		end;
296
297	<	TIBUpdateSQLSprig = class(TSprigAtRoot)
297	>	{ TIBUpdateSQLRefreshSQLProperty }
298	>
299	>	TIBUpdateSQLRefreshSQLProperty = class(TUpdateSQLPropertyEditor)
300		public
301	<	function AnyProblems: Boolean; override;
301	>	procedure Edit; override;
302		end;
303
304	<	TIBDatabaseSprig = class(TSprigAtRoot)
304	>	{ TIBUpdateSQLInsertSQLProperty }
305	>
306	>	TIBUpdateSQLInsertSQLProperty = class(TUpdateSQLPropertyEditor)
307		public
308	<	function AnyProblems: Boolean; override;
268	<	function Caption: string; override;
308	>	procedure Edit; override;
309		end;
310
311	<	TIBTransactionSprig = class(TSprig)
311	>	{ TIBUpdateSQLDeleteProperty }
312	>
313	>	TIBUpdateSQLDeleteProperty = class(TUpdateSQLPropertyEditor)
314		public
315	<	function Caption: string; override;
316	<	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;
315	>	function GetAttributes: TPropertyAttributes; override;
316	>	procedure Edit; override;
317		end;
318
319	<	TIBDatabaseInfoSprig = class(TSprig)
319	>	{ TIBEventListProperty }
320	>
321	>	TIBEventListProperty = class(TClassProperty)
322		public
323	<	class function ParentProperty: string; override;
323	>	function GetAttributes: TPropertyAttributes; override;
324	>	procedure Edit; override;
325		end;
326
327	<	TIBEventsSprig = class(TSprig)
327	>	{TIBGeneratorProperty}
328	>
329	>	TIBGeneratorProperty = class(TPersistentPropertyEditor)
330		public
331	<	class function ParentProperty: string; override;
332	<	function AnyProblems: Boolean; override;
331	>	function GetAttributes: TPropertyAttributes; override;
332	>	procedure Edit; override;
333		end;
334
335	<	TIBTransactionIsland = class(TIsland)
335	>	{ TDBDynamicGridFieldProperty }
336	>
337	>	TDBDynamicGridFieldProperty = class(TFieldProperty)
338		public
339	<	function VisibleTreeParent: Boolean; override;
339	>	procedure FillValues(const Values: TStringList); override;
340		end;
341
342	<	TIBSQLIsland = class(TIsland)
342	>	{ TDBLookupPropertiesGridFieldProperty }
343	>
344	>	TDBLookupPropertiesGridFieldProperty = class(TFieldProperty)
345		public
346	<	function VisibleTreeParent: Boolean; override;
346	>	procedure FillValues(const Values: TStringList); override;
347		end;
348
349	<	TIBCustomDataSetIsland = class(TDataSetIsland)
349	>	{ TIBTreeViewFieldProperty }
350	>
351	>	TIBTreeViewFieldProperty = class(TFieldProperty)
352		public
353	<	function VisibleTreeParent: Boolean; override;
353	>	procedure FillValues(const Values: TStringList); override;
354		end;
355
356	<	TIBTableIsland = class(TIBCustomDataSetIsland)
356	>	{ TIBDynamicGridIndexNamesProperty }
357	>
358	>	TIBDynamicGridIndexNamesProperty = class(TIndexFieldNamesProperty)
359	>	protected
360	>	function GetFieldDefs: TFieldDefs; override;
361	>	function GetIndexFieldNames: string; override;
362	>	procedure SetIndexFieldNames(const Value: string); override;
363		end;
364
365	<	TIBTableMasterDetailBridge = class(TMasterDetailBridge)
365	>	{ TIBFieldDefsProperty }
366	>
367	>	TIBFieldDefsProperty = class(TCollectionPropertyEditor)
368		public
369	<	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;
369	>	procedure Edit; override;
370		end;
371
372	<	TIBQueryIsland = class(TIBCustomDataSetIsland)
321	<	end;
372	>	{ TIBIndexDefsProperty }
373
374	<	TIBQueryMasterDetailBridge = class(TMasterDetailBridge)
374	>	TIBIndexDefsProperty = class(TCollectionPropertyEditor)
375		public
376	<	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;
376	>	procedure Edit; override;
377		end;
378
379	+
380		procedure Register;
381
382		implementation
383
384	<	uses IB, IBQuery, IBStoredProc, IBUpdateSQL, IBCustomDataSet,
385	<	IBIntf, IBSQL, IBSQLMonitor, IBDatabaseInfo, IBEvents,
386	<	IBServices, IBInstall, IBDatabaseEdit, IBTransactionEdit,
387	<	IBBatchMove, DBLogDlg;
384	>	uses IB, IBQuery, IBStoredProc, IBCustomDataSet, FBMessages,
385	>	IBSQL, IBSQLMonitor, IBDatabaseInfo, IBEvents, IBTypes,
386	>	IBServices, IBDatabaseEdit, IBTransactionEdit,
387	>	IBBatchMove, IBExtract,LResources, IBSelectSQLEditor,
388	>	IBModifySQLEditor,IBDeleteSQLEditor,IBRefreshSQLEditor,
389	>	IBInsertSQLEditor, IBGeneratorEditor, IBUpdateSQLEditor, IBDataSetEditor,
390	>	IBSQLEditor, ibserviceeditor, LCLVersion, IBDynamicGrid, IBLookupComboEditBox,
391	>	IBTreeView, DBControlGrid, ibxscript, IBLocalDBSupport, IBDSDialogs,
392	>	IBArrayGrid;
393	>
394	>	const
395	>	IBPalette1 = 'Firebird'; {do not localize}
396	>	IBPalette2 = 'Firebird Admin'; {do not localize}
397	>	IBPalette3 = 'Firebird Data Controls'; {do not localize}
398	>
399	>	resourcestring
400	>	SInterbaseExpressVersion = 'Firebird Express for Lazarus 2.0.0';
401	>	SEditSQL = 'Edit SQL';
402	>	SIBSQLEditor = 'IBSQL Editor';
403	>	SIBServiceEditor = 'Edit IB Service';
404	>	SIBUpdateSQLEditor = '&UpdateSQL Editor...';
405	>	SIBDataSetEditor = '&Dataset Editor...';
406	>	SExecute = 'E&xecute';
407	>	SIBDatabaseEditor = 'Da&tabase Editor...';
408	>	SIBTransactionEditor = '&Transaction Editor...';
409	>	SIBUpdateLayout = 'Update Layout';
410
411		procedure Register;
412		begin
413	<	RegisterComponents(IBPalette1, [TIBTable, TIBQuery,
414	<	TIBStoredProc, TIBDatabase, TIBTransaction, TIBUpdateSQL,
415	<	TIBDataSet, TIBSQL, TIBDatabaseInfo, TIBSQLMonitor, TIBEvents]);
416	<	{$IFDEF IB6_ONLY}
417	<	if (TryIBLoad) and (GetIBClientVersion >= 6) then
413	>	if not TryIBLoad then
414	>	begin
415	>	MessageDlg('IBX is unable to locate the Firebird Library - have you remembered to install it?',mtError,[mbOK],0);
416	>	Exit;
417	>	end;
418	>
419	>	RegisterNoIcon([TIBStringField, TIBBCDField, TIBMemoField, TIBArrayField]);
420	>	{$if lcl_fullversion < 01010000}
421	>	{see http://bugs.freepascal.org/view.php?id=19035 }
422	>	RegisterNoIcon([TIntegerField]);
423	>	{$endif}
424	>	RegisterComponents(IBPalette1, [ TIBQuery, TIBDataSet,
425	>	TIBDatabase, TIBTransaction, TIBUpdateSQL, TIBEvents,
426	>	TIBSQL, TIBDatabaseInfo, TIBSQLMonitor,
427	>	TIBStoredProc,TIBBatchMove, TIBTable,TIBExtract, TIBXScript, TIBLocalDBSupport]);
428	>	if FirebirdAPI.HasServiceAPI then
429		RegisterComponents(IBPalette2, [TIBConfigService, TIBBackupService,
430		TIBRestoreService, TIBValidationService, TIBStatisticalService,
431	<	TIBLogService, TIBSecurityService, TIBServerProperties,
432	<	TIBInstall, TIBUninstall]);
433	<	{$ENDIF}
434	<	RegisterClasses([TIBStringField, TIBBCDField]);
354	<	RegisterFields([TIBStringField, TIBBCDField]);
431	>	TIBLogService, TIBSecurityService, TIBServerProperties]);
432	>
433	>
434	>	RegisterComponents(IBPalette3,[TIBLookupComboEditBox,TIBDynamicGrid,TIBTreeView,TDBControlGrid, TIBArrayGrid]);
435		RegisterPropertyEditor(TypeInfo(TIBFileName), TIBDatabase, 'DatabaseName', TIBFileNameProperty); {do not localize}
436		RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'StoredProcName', TIBStoredProcNameProperty); {do not localize}
437		RegisterPropertyEditor(TypeInfo(TParams), TIBStoredProc, 'Params', TIBStoredProcParamsProperty);
#	Line 359 \| Line 439 \| begin
439		RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexName', TIBIndexNameProperty); {do not localize}
440		RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexFieldNames', TIBIndexFieldNamesProperty); {do not localize}
441		RegisterPropertyEditor(TypeInfo(string), TIBTable, 'MasterFields', TIBTableFieldLinkProperty); {do not localize}
442	+	RegisterPropertyEditor(TypeInfo(TFieldDefs), TIBTable, 'FieldDefs', TIBFieldDefsProperty); {do not localize}
443	+	RegisterPropertyEditor(TypeInfo(TIndexDefs), TIBTable, 'IndexDefs', TIBIndexDefsProperty); {do not localize}
444		RegisterPropertyEditor(TypeInfo(TStrings), TIBQuery, 'SQL', TIBQuerySQLProperty); {do not localize}
445		RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'SelectSQL', TIBDatasetSQLProperty); {do not localize}
446	<	RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLProperty); {do not localize}
446	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'ModifySQL', TIBUpdateSQLProperty); {do not localize}
447	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'InsertSQL', TIBInsertSQLProperty); {do not localize}
448	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'RefreshSQL', TIBRefreshSQLProperty); {do not localize}
449	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'DeleteSQL', TIBDeleteSQLProperty); {do not localize}
450	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLSQLPropertyEditor); {do not localize}
451	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'RefreshSQL', TIBUpdateSQLRefreshSQLProperty); {do not localize}
452	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'ModifySQL', TIBUpdateSQLUpdateProperty); {do not localize}
453	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'InsertSQL', TIBUpdateSQLInsertSQLProperty); {do not localize}
454	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'DeleteSQL', TIBUpdateSQLDeleteProperty); {do not localize}
455		RegisterPropertyEditor(TypeInfo(TStrings), TIBEvents, 'Events', TIBEventListProperty); {do not localize}
456	+	RegisterPropertyEditor(TypeInfo(TPersistent), TIBDataSet, 'GeneratorField', TIBGeneratorProperty); {do not localize}
457	+	RegisterPropertyEditor(TypeInfo(TPersistent), TIBQuery, 'GeneratorField', TIBGeneratorProperty); {do not localize}
458
459		RegisterComponentEditor(TIBDatabase, TIBDatabaseEditor);
460		RegisterComponentEditor(TIBTransaction, TIBTransactionEditor);
#	Line 370 \| Line 462 \| begin
462		RegisterComponentEditor(TIBDataSet, TIBDataSetEditor);
463		RegisterComponentEditor(TIBQuery, TIBQueryEditor);
464		RegisterComponentEditor(TIBStoredProc, TIBStoredProcEditor);
465	+	RegisterComponentEditor(TIBSQL, TIBSQLEditor);
466	+	RegisterComponentEditor(TIBCustomService, TIBServiceEditor);
467	+	RegisterComponentEditor(TIBArrayGrid, TIBArrayGridEditor);
468	+
469	+
470	+	{Firebird Data Access Controls}
471	+	RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'KeyField', TDBDynamicGridFieldProperty);
472	+	RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'ListField', TDBDynamicGridFieldProperty);
473	+	RegisterPropertyEditor(TypeInfo(string), TIBDynamicGrid, 'IndexFieldNames', TIBDynamicGridIndexNamesProperty);
474	+	RegisterPropertyEditor(TypeInfo(string), TDBLookupProperties, 'DataFieldName', TDBLookupPropertiesGridFieldProperty);
475	+	RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'KeyField', TIBTreeViewFieldProperty);
476	+	RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'TextField', TIBTreeViewFieldProperty);
477	+	RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'ParentField', TIBTreeViewFieldProperty);
478	+	RegisterPropertyEditor(TypeInfo(string), TIBTreeView, 'HasChildField', TIBTreeViewFieldProperty);
479	+
480	+	IBGUIInterface := TIBDSLCLInterface.Create;
481	+	end;
482	+
483	+	procedure LoadDataSourceFields(DataSource: TDataSource; List: TStrings);
484	+	var
485	+	DataSet: TDataSet;
486	+	i: Integer;
487	+	begin
488	+	if Assigned(DataSource) then
489	+	begin
490	+	DataSet := DataSource.DataSet;
491	+	if Assigned(DataSet) then
492	+	begin
493	+	if DataSet.Fields.Count > 0 then
494	+	DataSet.GetFieldNames(List)
495	+	else
496	+	begin
497	+	DataSet.FieldDefs.Update;
498	+	for i := 0 to DataSet.FieldDefs.Count - 1 do
499	+	List.Add(DataSet.FieldDefs[i].Name);
500	+	end;
501	+	end;
502	+	end;
503	+	end;
504	+
505	+	{ TIBIndexDefsProperty }
506	+
507	+	procedure TIBIndexDefsProperty.Edit;
508	+	var IndexDefs: TIndexDefs;
509	+	begin
510	+	IndexDefs := TIndexDefs(GetObjectValue);
511	+	if IndexDefs <> nil then
512	+	IndexDefs.Update;
513	+	inherited Edit;
514	+	end;
515	+
516	+	{ TIBFieldDefsProperty }
517	+
518	+	procedure TIBFieldDefsProperty.Edit;
519	+	var FieldDefs: TFieldDefs;
520	+	begin
521	+	FieldDefs := TFieldDefs(GetObjectValue);
522	+	if FieldDefs <> nil then
523	+	FieldDefs.Update;
524	+	inherited Edit;
525	+	end;
526	+
527	+	{ TIBArrayGridEditor }
528	+
529	+	procedure TIBArrayGridEditor.ExecuteVerb(Index: Integer);
530	+	begin
531	+	if Index < inherited GetVerbCount then
532	+	inherited ExecuteVerb(Index)
533	+	else
534	+	case Index of
535	+	0: TIBArrayGrid(Component).UpdateLayout;
536	+	end;
537	+	end;
538	+
539	+	function TIBArrayGridEditor.GetVerb(Index: Integer): string;
540	+	begin
541	+	if Index < inherited GetVerbCount then
542	+	Result := inherited GetVerb(Index) else
543	+	begin
544	+	Dec(Index, inherited GetVerbCount);
545	+	case Index of
546	+	0: Result := SIBUpdateLayout;
547	+	1 : Result := SInterbaseExpressVersion ;
548	+	end;
549	+	end;
550	+	end;
551
552	<	RegisterSprigType(TIBDatabase, TIBDatabaseSprig);
553	<	RegisterSprigType(TIBTransaction, TIBTransactionSprig);
552	>	function TIBArrayGridEditor.GetVerbCount: Integer;
553	>	begin
554	>	Result := 2;
555	>	end;
556
557	<	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);
557	>	{ TDBLookupPropertiesGridFieldProperty }
558
559	<	RegisterBridgeType(TDataSetIsland, TIBTableIsland, TIBTableMasterDetailBridge);
560	<	RegisterBridgeType(TDataSetIsland, TIBQueryIsland, TIBQueryMasterDetailBridge);
559	>	procedure TDBLookupPropertiesGridFieldProperty.FillValues(
560	>	const Values: TStringList);
561	>	var
562	>	P: TDBLookupProperties;
563	>	begin
564	>	P :=TDBLookupProperties(GetComponent(0));
565	>	if not (P is TDBLookupProperties) then exit;
566	>	LoadDataSourceFields(TIBDynamicGrid(P.Owner.Grid).DataSource, Values);
567	>	end;
568	>
569	>	{ TIBTreeViewFieldProperty }
570	>
571	>	procedure TIBTreeViewFieldProperty.FillValues(const Values: TStringList);
572	>	var ListSource: TDataSource;
573	>	begin
574	>	ListSource := TIBTreeView(GetComponent(0)).DataSource;
575	>	LoadDataSourceFields(ListSource, Values);
576	>	end;
577	>
578	>	{ TIBDynamicGridIndexNamesProperty }
579	>
580	>	function TIBDynamicGridIndexNamesProperty.GetFieldDefs: TFieldDefs;
581	>	var Grid: TIBDynamicGrid;
582	>	begin
583	>	Result := nil;
584	>	Grid := TIBDynamicGrid(GetComponent(0));
585	>	if assigned(Grid.DataSource) and assigned(Grid.DataSource.DataSet) then
586	>	Result := Grid.DataSource.DataSet.FieldDefs
587	>	end;
588	>
589	>	function TIBDynamicGridIndexNamesProperty.GetIndexFieldNames: string;
590	>	var Grid: TIBDynamicGrid;
591	>	begin
592	>	Grid := TIBDynamicGrid(GetComponent(0));
593	>	Result := Grid.IndexFieldNames
594	>	end;
595	>
596	>	procedure TIBDynamicGridIndexNamesProperty.SetIndexFieldNames(
597	>	const Value: string);
598	>	var Grid: TIBDynamicGrid;
599	>	begin
600	>	Grid := TIBDynamicGrid(GetComponent(0));
601	>	Grid.IndexFieldNames := Value
602	>	end;
603	>
604	>	{ TDBDynamicGridFieldProperty }
605	>
606	>	procedure TDBDynamicGridFieldProperty.FillValues(const Values: TStringList);
607	>	var
608	>	P: TDBLookupProperties;
609	>	begin
610	>	P :=TDBLookupProperties(GetComponent(0));
611	>	if not (P is TDBLookupProperties) then exit;
612	>	LoadDataSourceFields(P.ListSource, Values);
613	>	end;
614	>
615	>	{ TIBServiceEditor }
616	>
617	>	procedure TIBServiceEditor.ExecuteVerb(Index: Integer);
618	>	begin
619	>	if Index < inherited GetVerbCount then
620	>	inherited ExecuteVerb(Index) else
621	>	begin
622	>	Dec(Index, inherited GetVerbCount);
623	>	case Index of
624	>	0 : if ibserviceeditor.EditIBService(TIBCustomService(Component)) then Designer.Modified;
625	>	end;
626	>	end;
627	>	end;
628	>
629	>	function TIBServiceEditor.GetVerb(Index: Integer): string;
630	>	begin
631	>	if Index < inherited GetVerbCount then
632	>	Result := inherited GetVerb(Index) else
633	>	begin
634	>	Dec(Index, inherited GetVerbCount);
635	>	case Index of
636	>	0: Result := SIBServiceEditor;
637	>	1 : Result := SInterbaseExpressVersion;
638	>	end;
639	>	end;
640	>	end;
641	>
642	>	function TIBServiceEditor.GetVerbCount: Integer;
643	>	begin
644	>	Result := inherited GetVerbCount + 2;
645		end;
646
647		{ TIBFileNameProperty }
#	Line 401 \| Line 650 \| begin
650		with TOpenDialog.Create(Application) do
651		try
652		InitialDir := ExtractFilePath(GetStrValue);
653	<	Filter := 'Database Files\|*.gdb'; {do not localize}
653	>	Filter := SDatabaseFilter; {do not localize}
654		if Execute then
655		SetStrValue(FileName);
656		finally
#	Line 429 \| Line 678 \| var
678		i : integer;
679		begin
680		StoredProc := GetComponent(0) as TIBStoredProc;
681	+	if StoredProc.Database = nil then
682	+	Exit;
683	+
684		with StoredProc do
685	+	try
686		for I := 0 to StoredProcedureNames.Count - 1 do
687		Proc (StoredProcedureNames[i]);
688	+	except on E: Exception do
689	+	MessageDlg(E.Message,mtError,[mbOK],0)
690	+	end;
691		end;
692
693		{ TIBTableNameProperty }
694
695		procedure TIBTableNameProperty.GetValues(Proc: TGetStrProc);
696		var
697	<	TableName : TIBTable;
697	>	Table : TIBTable;
698		i : integer;
699		begin
700	<	TableName := GetComponent(0) as TIBTable;
701	<	with TableName do
700	>	Table := GetComponent(0) as TIBTable;
701	>	if Table.Database = nil then
702	>	Exit;
703	>	with Table do
704		for I := 0 to TableNames.Count - 1 do
705		Proc (TableNames[i]);
706		end;
707
708		{ TDBStringProperty }
709
710	+	function TDBStringProperty.ConnecttoDB: boolean;
711	+	var DataSet: TIBCustomDataSet;
712	+	begin
713	+	Result := false;
714	+	DataSet := (GetComponent(0) as TIBCustomDataSet);
715	+	if assigned(Dataset.Database) then
716	+	begin
717	+	try
718	+	DataSet.Database.Connected := true;
719	+	except on E: Exception do
720	+	ShowMessage(E.Message)
721	+	end;
722	+	Result := DataSet.Database.Connected
723	+	end;
724	+	end;
725	+
726		function TDBStringProperty.GetAttributes: TPropertyAttributes;
727		begin
728		Result := [paValueList, paSortList, paMultiSelect];
#	Line 463 \| Line 737 \| var
737		I: Integer;
738		Values: TStringList;
739		begin
740	+	if not ConnecttoDB then Exit;
741		Values := TStringList.Create;
742		try
743		GetValueList(Values);
#	Line 472 \| Line 747 \| begin
747		end;
748		end;
749
750	+	procedure TDBStringProperty.Edit;
751	+	begin
752	+	if ConnecttoDB then
753	+	inherited Edit;
754	+	end;
755	+
756		{ Utility Functions }
757
758		function GetPropertyValue(Instance: TPersistent; const PropName: string): TPersistent;
#	Line 521 \| Line 802 \| end;
802
803		{ TSQLPropertyEditor }
804
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	–
805		function TSQLPropertyEditor.GetAttributes: TPropertyAttributes;
806		begin
807	<	Result := inherited GetAttributes + [paDialog] - [paSubProperties];
807	>	Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
808		end;
809
810		{ TIBQuerySQLProperty }
#	Line 552 \| Line 813 \| procedure TIBQuerySQLProperty.Edit;
813		var
814		Query: TIBQuery;
815		begin
816	<	Query := TIBQuery(GetComponent(0));
817	<	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;
816	>	Query := GetComponent(0) as TIBQuery;
817	>	if IBSelectSQLEditor.EditSQL(Query,Query.SQL) then Modified;
818		end;
819
820		{ TIBDatasetSQLProperty }
#	Line 572 \| Line 823 \| procedure TIBDatasetSQLProperty.Edit;
823		var
824		IBDataset: TIBDataset;
825		begin
826	<	IBDataset := TIBDataset(GetComponent(0));
827	<	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;
826	>	IBDataset := GetComponent(0) as TIBDataset;
827	>	if IBSelectSQLEditor.EditSQL(IBDataSet,IBDataSet.SelectSQL) then Modified;
828		end;
829
830		{ TIBSQLProperty }
#	Line 592 \| Line 833 \| procedure TIBSQLProperty.Edit;
833		var
834		IBSQL: TIBSQL;
835		begin
836	<	IBSQL := TIBSQL(GetComponent(0));
837	<	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;
836	>	IBSQL := GetComponent(0) as TIBSQL;
837	>	if IBSQLEditor.EditIBSQL(IBSQL) then Modified;
838		end;
839
840		{ TIBUpdateSQLEditor }
841
842		procedure TIBUpdateSQLEditor.ExecuteVerb(Index: Integer);
843		begin
844	<	if EditIBUpdateSQL(TIBUpdateSQL(Component)) then Designer.Modified;
844	>	if IBUpdateSQLEditor.EditIBUpdateSQL(TIBUpdateSQL(Component)) then Modified;
845		end;
846
847		function TIBUpdateSQLEditor.GetVerb(Index: Integer): string;
848		begin
849		case Index of
850		0 : Result := SIBUpdateSQLEditor;
851	<	2: Result := SInterbaseExpressVersion;
851	>	1: Result := SInterbaseExpressVersion ;
852		end;
853		end;
854
855		function TIBUpdateSQLEditor.GetVerbCount: Integer;
856		begin
857	<	Result := 2;
857	>	Result := 2;
858		end;
859
860		{ TIBDataSetEditor }
861
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	–
862		procedure TIBDataSetEditor.ExecuteVerb(Index: Integer);
652	–	var
653	–	IBDataset: TIBDataset;
863		begin
864		if Index < inherited GetVerbCount then
865		inherited ExecuteVerb(Index) else
#	Line 658 \| Line 867 \| begin
867		Dec(Index, inherited GetVerbCount);
868		case Index of
869		0:
870	<	if EditIBDataSet(TIBDataSet(Component)) then
870	>	if IBDataSetEditor.EditIBDataSet(TIBDataSet(Component)) then
871		Designer.Modified;
872		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;
873		end;
874		end;
875		end;
#	Line 689 \| Line 883 \| begin
883		case Index of
884		0: Result := SIBDataSetEditor;
885		1: Result := SExecute;
886	<	2: Result := SEditSQL;
693	<	3: Result := SInterbaseExpressVersion;
886	>	2: Result := SInterbaseExpressVersion ;
887		end;
888		end;
889		end;
890
891		function TIBDataSetEditor.GetVerbCount: Integer;
892		begin
893	<	Result := inherited GetVerbCount + 4;
893	>	Result := inherited GetVerbCount + 3;
894		end;
895
896		{ TIBEventListProperty }
897
898		function TIBEventListProperty.GetAttributes: TPropertyAttributes;
899		begin
900	<	Result := inherited GetAttributes + [paDialog] - [paSubProperties];
900	>	Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
901		end;
902
903		procedure TIBEventListProperty.Edit;
904		var
905		Events: TStrings;
906	+	IBEvents: TIBEvents;
907		begin
908	+	IBEvents := GetComponent(0) as TIBEvents;
909		Events := TStringList.Create;
910		try
911	<	Events.Assign( TStrings(GetOrdValue));
912	<	if EditAlerterEvents( Events) then SetOrdValue( longint(Events));
911	>	Events.Assign( IBEvents.Events);
912	>	if EditAlerterEvents( Events) then
913	>	begin
914	>	IBEvents.Events.Assign(Events);
915	>	Modified
916	>	end;
917		finally
918		Events.Free;
919		end;
#	Line 741 \| Line 940 \| begin
940		Dec(Index, inherited GetVerbCount);
941		case Index of
942		0: Result := SIBDatabaseEditor;
943	<	1 : Result := SInterbaseExpressVersion;
943	>	1 : Result := SInterbaseExpressVersion ;
944		end;
945		end;
946		end;
#	Line 764 \| Line 963 \| function TIBTransactionEditor.GetVerb(In
963		begin
964		case Index of
965		0: Result := SIBTransactionEditor;
966	<	1: Result := SInterbaseExpressVersion;
966	>	1: Result := SInterbaseExpressVersion ;
967		end;
968		end;
969
#	Line 775 \| Line 974 \| end;
974
975		{ TIBQueryEditor }
976
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	–
977		procedure TIBQueryEditor.ExecuteVerb(Index: Integer);
978		var
979		Query: TIBQuery;
#	Line 806 \| Line 985 \| begin
985		Dec(Index, inherited GetVerbCount);
986		case Index of
987		0: Query.ExecSQL;
988	<	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;
988	>	1: if ibselectsqleditor.EditSQL(Query,Query.SQL) then Designer.Modified;
989		end;
990		end;
991		end;
#	Line 833 \| Line 999 \| begin
999		case Index of
1000		0: Result := SExecute;
1001		1: Result := SEditSQL;
1002	<	2: Result := SInterbaseExpressVersion;
1002	>	2: Result := SInterbaseExpressVersion ;
1003		end;
1004		end;
1005		end;
#	Line 863 \| Line 1029 \| begin
1029		Dec(Index, inherited GetVerbCount);
1030		case Index of
1031		0: Result := SExecute;
1032	<	1: Result := SInterbaseExpressVersion;
1032	>	1: Result := SInterbaseExpressVersion ;
1033		end;
1034		end;
1035		end;
#	Line 895 \| Line 1061 \| end;
1061		procedure TIBTableFieldLinkProperty.Edit;
1062		begin
1063		FTable := DataSet as TIBTable;
1064	+	if assigned(FTable.Database) then
1065	+	FTable.Database.Connected := true;
1066		inherited Edit;
1067		end;
1068
1069	+	function TIBTableFieldLinkProperty.GetIndexDefs: TIndexDefs;
1070	+	begin
1071	+	Result := FTable.IndexDefs
1072	+	end;
1073	+
1074		function TIBTableFieldLinkProperty.GetIndexFieldNames: string;
1075		begin
1076		Result := FTable.IndexFieldNames;
#	Line 918 \| Line 1091 \| begin
1091		FTable.MasterFields := Value;
1092		end;
1093
1094	<	{ TIBDatabaseSprig }
1094	>	{ TIBUpdateSQLProperty }
1095
1096	<	function TIBDatabaseSprig.AnyProblems: Boolean;
1097	<	begin
1098	<	Result := (TIBDatabase(Item).DatabaseName = '') or
926	<	(TIBDatabase(Item).DefaultTransaction = nil);
927	<	end;
928	<
929	<	function TIBDatabaseSprig.Caption: string;
930	<	begin
931	<	Result := CaptionFor(TIBDatabase(Item).DatabaseName, UniqueName);
932	<	end;
933	<
934	<	{ TIBTransactionSprig }
935	<
936	<	function TIBTransactionSprig.AnyProblems: Boolean;
937	<	begin
938	<	Result := TIBTransaction(Item).DefaultDatabase = nil;
939	<	end;
940	<
941	<	function TIBTransactionSprig.Caption: string;
942	<	begin
943	<	if (TIBTransaction(Item).DefaultDatabase <> nil) and
944	<	(TIBTransaction(Item).DefaultDatabase.DefaultTransaction = Item) then
945	<	Result := CaptionFor(Format(SDefaultTransaction, [UniqueName]))
946	<	else
947	<	Result := inherited Caption;
948	<	end;
949	<
950	<	procedure TIBTransactionSprig.FigureParent;
951	<	begin
952	<	SeekParent(TIBTransaction(Item).DefaultDatabase).Add(Self);
953	<	end;
954	<
955	<	function TIBTransactionSprig.DragDropTo(AItem: TSprig): Boolean;
956	<	begin
957	<	Result := False;
958	<	if AItem is TIBDatabaseSprig then
959	<	begin
960	<	Result := TIBDatabase(AItem.Item) <> TIBTransaction(Item).DefaultDatabase;
961	<	if Result then
962	<	begin
963	<	TIBTransaction(Item).DefaultDatabase := TIBDatabase(AItem.Item);
964	<	TIBDatabase(AItem.Item).DefaultTransaction := TIBTransaction(Item);
965	<	end;
966	<	end
967	<	end;
968	<
969	<	function TIBTransactionSprig.DragOverTo(AItem: TSprig): Boolean;
970	<	begin
971	<	Result := (AItem is TIBDatabaseSprig);
972	<	end;
973	<
974	<	class function TIBTransactionSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
1096	>	procedure TIBUpdateSQLProperty.Edit;
1097	>	var
1098	>	IBDataset: TIBDataset;
1099		begin
1100	<	Result := (AParent is TIBDatabaseSprig);
1100	>	IBDataset := GetComponent(0) as TIBDataset;
1101	>	if IBModifySQLEditor.EditSQL(IBDataSet,IBDataSet.ModifySQL) then Modified;
1102		end;
1103
1104	<	{ support stuff for sprigs }
1104	>	{ TIBUpdateSQLUpdateProperty }
1105
1106	<	function IBAnyProblems(ATransaction: TIBTransaction; ADatabase: TIBDatabase): Boolean;
1106	>	procedure TIBUpdateSQLUpdateProperty.Edit;
1107		begin
1108	<	Result := (ATransaction = nil) or
1109	<	(ADatabase = nil) or
985	<	(ATransaction.DefaultDatabase <> ADatabase);
1108	>	GetObjects;
1109	>	if IBModifySQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.ModifySQL) then Modified;
1110		end;
1111
1112	<	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;
1112	>	{ TIBRefreshSQLProperty }
1113
1114	<	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;
1114	>	procedure TIBRefreshSQLProperty.Edit;
1115		var
1116	<	vParentTransaction: TIBTransaction;
1007	<	vParentDatabase: TIBDatabase;
1116	>	IBDataset: TIBDataset;
1117		begin
1118	<	Result := False;
1119	<	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;
1118	>	IBDataset := GetComponent(0) as TIBDataset;
1119	>	if IBRefreshSQLEditor.EditSQL(IBDataSet,IBDataSet.RefreshSQL) then Modified;
1120		end;
1121
1122	<	{ TIBSQLSprig }
1122	>	{ TIBUpdateSQLRefreshSQLProperty }
1123
1124	<	function TIBSQLSprig.AnyProblems: Boolean;
1124	>	procedure TIBUpdateSQLRefreshSQLProperty.Edit;
1125		begin
1126	<	Result := IBAnyProblems(TIBSQL(Item).Transaction,
1127	<	TIBSQL(Item).Database) or
1043	<	(TIBSQL(Item).SQL.Count = 0);
1126	>	GetObjects;
1127	>	if IBRefreshSQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.RefreshSQL) then Modified;
1128		end;
1129
1130	<	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;
1130	>	{ TIBDeleteSQLProperty }
1131
1132	<	function TIBSQLSprig.DragOverTo(AItem: TSprig): Boolean;
1132	>	procedure TIBDeleteSQLProperty.Edit;
1133	>	var
1134	>	IBDataset: TIBDataSet;
1135		begin
1136	<	Result := IBDragOver(AItem);
1136	>	IBDataset := GetComponent(0) as TIBDataSet;
1137	>	if IBDeleteSQLEditor.EditSQL(IBDataSet,IBDataSet.DeleteSQL) then Modified;
1138		end;
1139
1140	<	procedure TIBSQLSprig.FigureParent;
1070	<	begin
1071	<	IBFigureParent(Self, TIBSQL(Item).Transaction,
1072	<	TIBSQL(Item).Database);
1073	<	end;
1140	>	{ TIBUpdateSQLDeleteProperty }
1141
1142	<	class function TIBSQLSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
1142	>	function TIBUpdateSQLDeleteProperty.GetAttributes: TPropertyAttributes;
1143		begin
1144	<	Result := IBDragOver(AParent);
1144	>	Result:=inherited GetAttributes;
1145		end;
1146
1147	<	{ TIBCustomDataSetSprig }
1081	<
1082	<	function TIBCustomDataSetSprig.AnyProblems: Boolean;
1147	>	procedure TIBUpdateSQLDeleteProperty.Edit;
1148		begin
1149	<	Result := IBAnyProblems(TIBCustomDataSet(Item).Transaction,
1150	<	TIBCustomDataSet(Item).Database);
1149	>	GetObjects;
1150	>	if IBDeleteSQLEditor.EditSQL(FIBUpdateSQL.DataSet,FIBUpdateSQL.DeleteSQL) then Modified;
1151		end;
1152
1153	<	procedure TIBCustomDataSetSprig.FigureParent;
1089	<	begin
1090	<	IBFigureParent(Self, TIBCustomDataSet(Item).Transaction,
1091	<	TIBCustomDataSet(Item).Database);
1092	<	end;
1153	>	{ TUpdateSQLPropertyEditor }
1154
1155	<	function TIBCustomDataSetSprig.DragDropTo(AItem: TSprig): Boolean;
1095	<	var
1096	<	vTransaction: TIBTransaction;
1097	<	vDatabase: TIBDatabase;
1155	>	function TUpdateSQLPropertyEditor.GetObjects: boolean;
1156		begin
1157	<	with TIBCustomDataSet(Item) do
1157	>	Result := false;
1158	>	FIBUpdateSQL := GetComponent(0) as TIBUpdateSQL;
1159	>	if not assigned(FIBUpdateSQL) or not assigned(FIBUpdateSQL.DataSet) then
1160	>	Exit;
1161	>	FDatabase := nil;
1162	>	if FIBUpdateSQL.DataSet is TIBQuery then
1163		begin
1164	<	vTransaction := Transaction;
1165	<	vDatabase := Database;
1103	<	Result := IBDropOver(AItem, vTransaction, vDatabase);
1104	<	if Result then
1105	<	begin
1106	<	Transaction := vTransaction;
1107	<	Database := vDatabase;
1108	<	end;
1164	>	FDatabase := (FIBUpdateSQL.DataSet as TIBQuery).Database;
1165	>	Result := true
1166		end;
1167		end;
1168
1169	<	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 }
1169	>	{ TIBInsertSQLProperty }
1170
1171	<	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;
1171	>	procedure TIBInsertSQLProperty.Edit;
1172		var
1173	<	vPropEd: TIBTableFieldLinkProperty;
1173	>	IBDataset: TIBDataSet;
1174		begin
1175	<	vPropEd := TIBTableFieldLinkProperty.CreateWith(TDataSet(Omega.Item));
1176	<	try
1208	<	vPropEd.Edit;
1209	<	Result := vPropEd.Changed;
1210	<	finally
1211	<	vPropEd.Free;
1212	<	end;
1175	>	IBDataset := GetComponent(0) as TIBDataSet;
1176	>	if IBInsertSQLEditor.EditSQL(IBDataSet,IBDataSet.InsertSQL) then Modified;
1177		end;
1178
1179	<	class function TIBTableMasterDetailBridge.GetOmegaSource(
1216	<	AItem: TPersistent): TDataSource;
1217	<	begin
1218	<	Result := TIBTable(AItem).MasterSource;
1219	<	end;
1220	<
1221	<	class function TIBTableMasterDetailBridge.OmegaIslandClass: TIslandClass;
1222	<	begin
1223	<	Result := TIBTableIsland;
1224	<	end;
1179	>	{ TIBUpdateSQLInsertSQLProperty }
1180
1181	<	class procedure TIBTableMasterDetailBridge.SetOmegaSource(
1227	<	AItem: TPersistent; ADataSource: TDataSource);
1181	>	procedure TIBUpdateSQLInsertSQLProperty.Edit;
1182		begin
1183	<	TIBTable(AItem).MasterSource := ADataSource;
1183	>	GetObjects;
1184	>	if IBInsertSQLEditor.EditSQL(FIBUpdateSQL.Dataset,FIBUpdateSQL.InsertSQL) then Modified;
1185		end;
1186
1187	<	{ TIBQueryMasterDetailBridge }
1187	>	{ TIBGeneratorProperty }
1188
1189	<	function TIBQueryMasterDetailBridge.Caption: string;
1189	>	function TIBGeneratorProperty.GetAttributes: TPropertyAttributes;
1190		begin
1191	<	Result := SParamsFields;
1191	>	Result:= inherited GetAttributes + [paDialog] - [paMultiSelect,paValueList];
1192		end;
1193
1194	<	class function TIBQueryMasterDetailBridge.GetOmegaSource(
1240	<	AItem: TPersistent): TDataSource;
1194	>	procedure TIBGeneratorProperty.Edit;
1195		begin
1196	<	Result := TIBQuery(AItem).DataSource;
1196	>	if IBGeneratorEditor.EditGenerator(GetPersistentReference as TIBGenerator) then Modified;
1197		end;
1198
1199	<	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;
1199	>	{ TIBSQLEditor }
1200
1201	<	class procedure TIBQueryMasterDetailBridge.SetOmegaSource(
1256	<	AItem: TPersistent; ADataSource: TDataSource);
1201	>	procedure TIBSQLEditor.ExecuteVerb(Index: Integer);
1202		begin
1203	<	TIBQuery(AItem).DataSource := ADataSource;
1203	>	if IBSQLEditor.EditIBSQL(TIBSQL(Component)) then Modified;
1204		end;
1205
1206	<	{ TIBCustomDataSetIsland }
1262	<
1263	<	function TIBCustomDataSetIsland.VisibleTreeParent: Boolean;
1206	>	function TIBSQLEditor.GetVerb(Index: Integer): string;
1207		begin
1208	<	Result := False;
1208	>	case Index of
1209	>	0 : Result := SIBSQLEditor;
1210	>	1: Result := SInterbaseExpressVersion ;
1211	>	end;
1212		end;
1213
1214	<	{ TIBSQLIsland }
1269	<
1270	<	function TIBSQLIsland.VisibleTreeParent: Boolean;
1214	>	function TIBSQLEditor.GetVerbCount: Integer;
1215		begin
1216	<	Result := False;
1216	>	Result:= 2
1217		end;
1218
1219	<	{ TIBTransactionIsland }
1219	>	{ TIBSQLSQLPropertyEditor }
1220
1221	<	function TIBTransactionIsland.VisibleTreeParent: Boolean;
1221	>	procedure TIBSQLSQLPropertyEditor.Edit;
1222	>	var
1223	>	IBSQL: TIBSQL;
1224		begin
1225	<	Result := TIBTransaction(Sprig.Item).DefaultDatabase = nil;
1225	>	IBSQL := GetComponent(0) as TIBSQL;
1226	>	if IBSQLEditor.EditIBSQL(IBSQL) then Modified;
1227		end;
1228
1229	+	initialization
1230	+	{$I IBDBReg.lrs}
1231		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 45 by tony, Tue Dec 6 10:33:46 2016 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 45 by tony, Tue Dec 6 10:33:46 2016 UTC