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 15 by tony, Thu Feb 28 16:56:14 2013 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		*)
#	Line 48 | Line 54 | unit IBDBReg;
54
55		interface
56
57	<	uses Windows, SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
58	<	DsgnIntf, DB, ParentageSupport, dsndb, DBReg, ColnEdit, FldLinks, SQLEdit,
59	<	DataModelSupport, IBTable, IBDatabase, IBUpdateSQLEditor,  IBEventsEditor,
54	<	IBXConst;
57	>	uses {Windows,} SysUtils, Classes, Graphics, Dialogs, Controls, Forms, TypInfo,
58	>	DB, IBTable, IBDatabase,  IBEventsEditor,  LazarusPackageIntf,
59	>	IBUpdateSQL, IBXConst, ComponentEditors, PropEdits, DBPropEdits, FieldsEditor;
60
61		type
62
#	Line 123 | Line 128 | type
128
129		{ TIBQueryEditor }
130
131	<	TIBQueryEditor = class(TDataSetEditor)
127	<	protected
128	<	FGetTableNamesProc: TGetTableNamesProc;
129	<	FGetFieldnamesProc: TGetFieldNamesProc;
131	>	TIBQueryEditor = class(TFieldsComponentEditor)
132		public
131	–	procedure EditSQL;
133		procedure ExecuteVerb(Index: Integer); override;
134		function GetVerb(Index: Integer): string; override;
135		function GetVerbCount: Integer; override;
#	Line 136 | Line 137 | type
137
138		{ TIBStoredProcEditor }
139
140	<	TIBStoredProcEditor = class(TDataSetEditor)
140	>	TIBStoredProcEditor = class(TFieldsComponentEditor)
141		public
142		procedure ExecuteVerb(Index: Integer); override;
143		function GetVerb(Index: Integer): string; override;
#	Line 145 | Line 146 | type
146
147		{ TIBDataSetEditor }
148
149	<	TIBDataSetEditor = class(TDataSetEditor)
149	<	protected
150	<	FGetTableNamesProc: TGetTableNamesProc;
151	<	FGetFieldnamesProc: TGetFieldNamesProc;
149	>	TIBDataSetEditor = class(TFieldsComponentEditor)
150		public
153	–	procedure EditSQL;
151		procedure ExecuteVerb(Index: Integer); override;
152		function GetVerb(Index: Integer): string; override;
153		function GetVerbCount: Integer; override;
#	Line 165 | Line 162 | type
162		function GetVerbCount: Integer; override;
163		end;
164
165	<	TIBStoredProcParamsProperty = class(TCollectionProperty)
165	>	{ TIBSQLEditor }
166	>
167	>	TIBSQLEditor  = class(TComponentEditor)
168		public
169	<	procedure Edit; override;
169	>	procedure ExecuteVerb(Index: Integer); override;
170	>	function GetVerb(Index: Integer): string; override;
171	>	function GetVerbCount: Integer; override;
172		end;
173
174	+	{ TIBServiceEditor}
175	+
176	+	TIBServiceEditor = class(TComponentEditor)
177	+	public
178	+	procedure ExecuteVerb(Index: Integer); override;
179	+	function GetVerb(Index: Integer): string; override;
180	+	function GetVerbCount: Integer; override;
181	+	end;
182	+
183	+	TIBStoredProcParamsProperty = class(TCollectionPropertyEditor)
184	+	public
185	+	procedure Edit; override;
186	+	end;
187	+	(*
188		TIBTableFieldLinkProperty = class(TFieldLinkProperty)
189		private
190		FTable: TIBTable;
#	Line 181 | Line 196 | type
196		public
197		procedure Edit; override;
198		end;
199	<
199	>	*)
200		{ TSQLPropertyEditor }
201
202	<	TSQLPropertyEditor = class(TClassProperty)
188	<	protected
189	<	FGetTableNamesProc: TGetTableNamesProc;
190	<	FGetFieldnamesProc: TGetFieldNamesProc;
202	>	TSQLPropertyEditor = class(TStringsPropertyEditor)
203		public
192	–	procedure EditSQL;
204		function GetAttributes: TPropertyAttributes; override;
205		end;
206
#	Line 200 | Line 211 | type
211		procedure Edit; override;
212		end;
213
214	+	{TIBSQLSQLPropertyEditor }
215	+
216	+	TIBSQLSQLPropertyEditor = class(TSQLPropertyEditor)
217	+	public
218	+	procedure Edit; override;
219	+	end;
220	+
221		{ TIBDatasetSQLProperty }
222
223		TIBDatasetSQLProperty = class(TSQLPropertyEditor)
#	Line 214 | Line 232 | type
232		procedure Edit; override;
233		end;
234
235	<	TIBEventListProperty = class(TClassProperty)
235	>	{ TUpdateSQLPropertyEditor }
236	>
237	>	TUpdateSQLPropertyEditor = class(TSQLPropertyEditor)
238	>	protected
239	>	FIBUpdateSQL: TIBUpdateSQL;
240	>	FDatabase: TIBDatabase;
241	>	function GetObjects: boolean;
242	>	end;
243	>
244	>	{ TIBUpdateSQLProperty }
245	>
246	>	TIBUpdateSQLProperty = class(TSQLPropertyEditor)
247		public
219	–	function GetAttributes: TPropertyAttributes; override;
248		procedure Edit; override;
249		end;
250
251	<	{ DataModel Designer stuff }
251	>	{ TIBRefreshSQLProperty }
252
253	<	TIBSQLSprig = class(TSprig)
253	>	TIBRefreshSQLProperty = class(TSQLPropertyEditor)
254		public
255	<	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;
255	>	procedure Edit; override;
256		end;
257
258	<	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;
258	>	{ TIBInsertSQLProperty }
259
260	<	TIBQuerySprig = class(TIBCustomDataSetSprig)
260	>	TIBInsertSQLProperty = class(TSQLPropertyEditor)
261		public
262	<	function AnyProblems: Boolean; override;
262	>	procedure Edit; override;
263		end;
264
265	<	TIBTableSprig = class(TIBCustomDataSetSprig)
249	<	public
250	<	function AnyProblems: Boolean; override;
251	<	function Caption: string; override;
252	<	end;
265	>	{ TIBDeleteSQLProperty }
266
267	<	TIBStoredProcSprig = class(TIBCustomDataSetSprig)
267	>	TIBDeleteSQLProperty = class(TSQLPropertyEditor)
268		public
269	<	function AnyProblems: Boolean; override;
257	<	function Caption: string; override;
269	>	procedure Edit; override;
270		end;
271
272	<	TIBUpdateSQLSprig = class(TSprigAtRoot)
261	<	public
262	<	function AnyProblems: Boolean; override;
263	<	end;
272	>	{ TIBUpdateSQLUpdateProperty }
273
274	<	TIBDatabaseSprig = class(TSprigAtRoot)
274	>	TIBUpdateSQLUpdateProperty = class(TUpdateSQLPropertyEditor)
275		public
276	<	function AnyProblems: Boolean; override;
268	<	function Caption: string; override;
276	>	procedure Edit; override;
277		end;
278
279	<	TIBTransactionSprig = class(TSprig)
272	<	public
273	<	function Caption: string; override;
274	<	procedure FigureParent; override;
275	<	function AnyProblems: Boolean; override;
276	<	function DragDropTo(AItem: TSprig): Boolean; override;
277	<	function DragOverTo(AItem: TSprig): Boolean; override;
278	<	class function PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean; override;
279	<	end;
279	>	{ TIBUpdateSQLRefreshSQLProperty }
280
281	<	TIBDatabaseInfoSprig = class(TSprig)
281	>	TIBUpdateSQLRefreshSQLProperty = class(TUpdateSQLPropertyEditor)
282		public
283	<	class function ParentProperty: string; override;
283	>	procedure Edit; override;
284		end;
285
286	<	TIBEventsSprig = class(TSprig)
287	<	public
288	<	class function ParentProperty: string; override;
289	<	function AnyProblems: Boolean; override;
290	<	end;
286	>	{ TIBUpdateSQLInsertSQLProperty }
287
288	<	TIBTransactionIsland = class(TIsland)
288	>	TIBUpdateSQLInsertSQLProperty = class(TUpdateSQLPropertyEditor)
289		public
290	<	function VisibleTreeParent: Boolean; override;
290	>	procedure Edit; override;
291		end;
292
293	<	TIBSQLIsland = class(TIsland)
298	<	public
299	<	function VisibleTreeParent: Boolean; override;
300	<	end;
293	>	{ TIBUpdateSQLDeleteProperty }
294
295	<	TIBCustomDataSetIsland = class(TDataSetIsland)
295	>	TIBUpdateSQLDeleteProperty = class(TUpdateSQLPropertyEditor)
296		public
297	<	function VisibleTreeParent: Boolean; override;
297	>	function GetAttributes: TPropertyAttributes; override;
298	>	procedure Edit; override;
299		end;
300
301	<	TIBTableIsland = class(TIBCustomDataSetIsland)
308	<	end;
301	>	{ TIBEventListProperty }
302
303	<	TIBTableMasterDetailBridge = class(TMasterDetailBridge)
303	>	TIBEventListProperty = class(TClassProperty)
304		public
305	<	function CanEdit: Boolean; override;
306	<	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;
305	>	function GetAttributes: TPropertyAttributes; override;
306	>	procedure Edit; override;
307		end;
308
309	<	TIBQueryIsland = class(TIBCustomDataSetIsland)
321	<	end;
309	>	{TIBGeneratorProperty}
310
311	<	TIBQueryMasterDetailBridge = class(TMasterDetailBridge)
311	>	TIBGeneratorProperty = class(TPersistentPropertyEditor)
312		public
313	<	class function RemoveMasterFieldsAsWell: Boolean; override;
314	<	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;
313	>	function GetAttributes: TPropertyAttributes; override;
314	>	procedure Edit; override;
315		end;
316
317		procedure Register;
318
319		implementation
320
321	<	uses IB, IBQuery, IBStoredProc, IBUpdateSQL, IBCustomDataSet,
321	>	uses IB, IBQuery, IBStoredProc, IBCustomDataSet,
322		IBIntf, IBSQL, IBSQLMonitor, IBDatabaseInfo, IBEvents,
323	<	IBServices, IBInstall, IBDatabaseEdit, IBTransactionEdit,
324	<	IBBatchMove, DBLogDlg;
323	>	IBServices, IBDatabaseEdit, IBTransactionEdit,
324	>	IBBatchMove, DBLoginDlg, IBExtract,LResources, IBSelectSQLEditor,
325	>	IBModifySQLEditor,IBDeleteSQLEditor,IBRefreshSQLEditor,
326	>	IBInsertSQLEditor, IBGeneratorEditor, IBUpdateSQLEditor, IBDataSetEditor,
327	>	IBSQLEditor, ibserviceeditor, LCLVersion;
328	>
329	>
330
331		procedure Register;
332		begin
333	<	RegisterComponents(IBPalette1, [TIBTable, TIBQuery,
334	<	TIBStoredProc, TIBDatabase, TIBTransaction, TIBUpdateSQL,
335	<	TIBDataSet, TIBSQL, TIBDatabaseInfo, TIBSQLMonitor, TIBEvents]);
336	<	{$IFDEF IB6_ONLY}
337	<	if (TryIBLoad) and (GetIBClientVersion >= 6) then
333	>	if not TryIBLoad then
334	>	begin
335	>	MessageDlg('IBX is unable to locate the Firebird Library - have you remembered to install it?',mtError,[mbOK],0);
336	>	Exit;
337	>	end;
338	>
339	>	RegisterNoIcon([TIBStringField, TIBBCDField]);
340	>	{$if lcl_fullversion < 01010000}
341	>	{see http://bugs.freepascal.org/view.php?id=19035 }
342	>	RegisterNoIcon([TIntegerField]);
343	>	{$endif}
344	>	RegisterComponents(IBPalette1, [ TIBQuery, TIBDataSet,
345	>	TIBDatabase, TIBTransaction, TIBUpdateSQL, TIBEvents,
346	>	TIBSQL, TIBDatabaseInfo, TIBSQLMonitor,
347	>	TIBStoredProc,TIBBatchMove,  TIBTable,TIBExtract]);
348	>	if IBServiceAPIPresent  then
349		RegisterComponents(IBPalette2, [TIBConfigService, TIBBackupService,
350		TIBRestoreService, TIBValidationService, TIBStatisticalService,
351	<	TIBLogService, TIBSecurityService, TIBServerProperties,
351	<	TIBInstall, TIBUninstall]);
352	<	{$ENDIF}
353	<	RegisterClasses([TIBStringField, TIBBCDField]);
354	<	RegisterFields([TIBStringField, TIBBCDField]);
351	>	TIBLogService, TIBSecurityService, TIBServerProperties]);
352		RegisterPropertyEditor(TypeInfo(TIBFileName), TIBDatabase, 'DatabaseName', TIBFileNameProperty); {do not localize}
353		RegisterPropertyEditor(TypeInfo(string), TIBStoredProc, 'StoredProcName', TIBStoredProcNameProperty); {do not localize}
354		RegisterPropertyEditor(TypeInfo(TParams), TIBStoredProc, 'Params', TIBStoredProcParamsProperty);
355		RegisterPropertyEditor(TypeInfo(string), TIBTable, 'TableName', TIBTableNameProperty); {do not localize}
356		RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexName', TIBIndexNameProperty); {do not localize}
357		RegisterPropertyEditor(TypeInfo(string), TIBTable, 'IndexFieldNames', TIBIndexFieldNamesProperty); {do not localize}
358	<	RegisterPropertyEditor(TypeInfo(string), TIBTable, 'MasterFields', TIBTableFieldLinkProperty); {do not localize}
358	>	//  RegisterPropertyEditor(TypeInfo(string), TIBTable, 'MasterFields', TIBTableFieldLinkProperty); {do not localize}
359		RegisterPropertyEditor(TypeInfo(TStrings), TIBQuery, 'SQL', TIBQuerySQLProperty); {do not localize}
360		RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'SelectSQL', TIBDatasetSQLProperty); {do not localize}
361	<	RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLProperty); {do not localize}
361	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'ModifySQL', TIBUpdateSQLProperty); {do not localize}
362	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'InsertSQL', TIBInsertSQLProperty); {do not localize}
363	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'RefreshSQL', TIBRefreshSQLProperty); {do not localize}
364	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBDataSet, 'DeleteSQL', TIBDeleteSQLProperty); {do not localize}
365	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBSQL, 'SQL', TIBSQLSQLPropertyEditor); {do not localize}
366	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'RefreshSQL', TIBUpdateSQLRefreshSQLProperty); {do not localize}
367	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'ModifySQL', TIBUpdateSQLUpdateProperty); {do not localize}
368	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'InsertSQL', TIBUpdateSQLInsertSQLProperty); {do not localize}
369	>	RegisterPropertyEditor(TypeInfo(TStrings), TIBUpdateSQL, 'DeleteSQL', TIBUpdateSQLDeleteProperty); {do not localize}
370		RegisterPropertyEditor(TypeInfo(TStrings), TIBEvents, 'Events', TIBEventListProperty); {do not localize}
371	+	RegisterPropertyEditor(TypeInfo(TPersistent), TIBDataSet, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
372	+	RegisterPropertyEditor(TypeInfo(TPersistent), TIBQuery, 'GeneratorField', TIBGeneratorProperty);  {do not localize}
373
374		RegisterComponentEditor(TIBDatabase, TIBDatabaseEditor);
375		RegisterComponentEditor(TIBTransaction, TIBTransactionEditor);
#	Line 370 | Line 377 | begin
377		RegisterComponentEditor(TIBDataSet, TIBDataSetEditor);
378		RegisterComponentEditor(TIBQuery, TIBQueryEditor);
379		RegisterComponentEditor(TIBStoredProc, TIBStoredProcEditor);
380	+	RegisterComponentEditor(TIBSQL, TIBSQLEditor);
381	+	RegisterComponentEditor(TIBCustomService, TIBServiceEditor);
382	+	end;
383
384	<	RegisterSprigType(TIBDatabase, TIBDatabaseSprig);
375	<	RegisterSprigType(TIBTransaction, TIBTransactionSprig);
384	>	{ TIBServiceEditor }
385
386	<	RegisterSprigType(TIBDatabaseInfo, TIBDatabaseInfoSprig);
387	<	RegisterSprigType(TIBEvents, TIBEventsSprig);
388	<	RegisterSprigType(TIBSQL, TIBSQLSprig);
389	<
390	<	RegisterSprigType(TIBUpdateSQL, TIBUpdateSQLSprig);
391	<
392	<	RegisterSprigType(TIBCustomDataSet, TIBCustomDataSetSprig);
393	<	RegisterSprigType(TIBQuery, TIBQuerySprig);
394	<	RegisterSprigType(TIBTable, TIBTableSprig);
395	<	RegisterSprigType(TIBStoredProc, TIBStoredProcSprig);
396	<
397	<	RegisterIslandType(TIBTransactionSprig, TIBTransactionIsland);
398	<	RegisterIslandType(TIBSQLSprig, TIBSQLIsland);
399	<	RegisterIslandType(TIBCustomDataSetSprig, TIBCustomDataSetIsland);
400	<	RegisterIslandType(TIBTableSprig, TIBTableIsland);
401	<	RegisterIslandType(TIBQuerySprig, TIBQueryIsland);
386	>	procedure TIBServiceEditor.ExecuteVerb(Index: Integer);
387	>	begin
388	>	if Index < inherited GetVerbCount then
389	>	inherited ExecuteVerb(Index) else
390	>	begin
391	>	Dec(Index, inherited GetVerbCount);
392	>	case Index of
393	>	0 : if ibserviceeditor.EditIBService(TIBCustomService(Component)) then Designer.Modified;
394	>	end;
395	>	end;
396	>	end;
397	>
398	>	function TIBServiceEditor.GetVerb(Index: Integer): string;
399	>	begin
400	>	if Index < inherited GetVerbCount then
401	>	Result := inherited GetVerb(Index) else
402	>	begin
403	>	Dec(Index, inherited GetVerbCount);
404	>	case Index of
405	>	0: Result := SIBServiceEditor;
406	>	1 : Result := SInterbaseExpressVersion;
407	>	end;
408	>	end;
409	>	end;
410
411	<	RegisterBridgeType(TDataSetIsland, TIBTableIsland, TIBTableMasterDetailBridge);
412	<	RegisterBridgeType(TDataSetIsland, TIBQueryIsland, TIBQueryMasterDetailBridge);
411	>	function TIBServiceEditor.GetVerbCount: Integer;
412	>	begin
413	>	Result := inherited GetVerbCount + 2;
414		end;
415
416		{ TIBFileNameProperty }
#	Line 401 | Line 419 | begin
419		with TOpenDialog.Create(Application) do
420		try
421		InitialDir := ExtractFilePath(GetStrValue);
422	<	Filter := 'Database Files|*.gdb'; {do not localize}
422	>	Filter := SDatabaseFilter; {do not localize}
423		if Execute then
424		SetStrValue(FileName);
425		finally
#	Line 429 | Line 447 | var
447		i : integer;
448		begin
449		StoredProc := GetComponent(0) as TIBStoredProc;
450	+	if StoredProc.Database = nil then
451	+	Exit;
452	+
453		with StoredProc do
454	+	try
455		for I := 0 to StoredProcedureNames.Count - 1 do
456		Proc (StoredProcedureNames[i]);
457	+	except on E: Exception do
458	+	MessageDlg(E.Message,mtError,[mbOK],0)
459	+	end;
460		end;
461
462		{ TIBTableNameProperty }
#	Line 521 | Line 546 | end;
546
547		{ TSQLPropertyEditor }
548
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	–
549		function TSQLPropertyEditor.GetAttributes: TPropertyAttributes;
550		begin
551	<	Result := inherited GetAttributes + [paDialog] - [paSubProperties];
551	>	Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
552		end;
553
554		{ TIBQuerySQLProperty }
#	Line 552 | Line 557 | procedure TIBQuerySQLProperty.Edit;
557		var
558		Query: TIBQuery;
559		begin
560	<	Query := TIBQuery(GetComponent(0));
561	<	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;
560	>	Query := GetComponent(0) as TIBQuery;
561	>	if IBSelectSQLEditor.EditSQL(Query.Database,Query.SQL) then Modified;
562		end;
563
564		{ TIBDatasetSQLProperty }
#	Line 572 | Line 567 | procedure TIBDatasetSQLProperty.Edit;
567		var
568		IBDataset: TIBDataset;
569		begin
570	<	IBDataset := TIBDataset(GetComponent(0));
571	<	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;
570	>	IBDataset := GetComponent(0) as TIBDataset;
571	>	if IBSelectSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.SelectSQL) then Modified;
572		end;
573
574		{ TIBSQLProperty }
#	Line 592 | Line 577 | procedure TIBSQLProperty.Edit;
577		var
578		IBSQL: TIBSQL;
579		begin
580	<	IBSQL := TIBSQL(GetComponent(0));
581	<	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;
580	>	IBSQL := GetComponent(0) as TIBSQL;
581	>	if IBSelectSQLEditor.EditSQL(IBSQL.Database,IBSQL.SQL) then Modified;
582		end;
583
584		{ TIBUpdateSQLEditor }
585
586		procedure TIBUpdateSQLEditor.ExecuteVerb(Index: Integer);
587		begin
588	<	if EditIBUpdateSQL(TIBUpdateSQL(Component)) then Designer.Modified;
588	>	if IBUpdateSQLEditor.EditIBUpdateSQL(TIBUpdateSQL(Component)) then Modified;
589		end;
590
591		function TIBUpdateSQLEditor.GetVerb(Index: Integer): string;
592		begin
593		case Index of
594		0 : Result := SIBUpdateSQLEditor;
595	<	2: Result := SInterbaseExpressVersion;
595	>	1: Result := SInterbaseExpressVersion;
596		end;
597		end;
598
599		function TIBUpdateSQLEditor.GetVerbCount: Integer;
600		begin
601	<	Result := 2;
601	>	Result :=  2;
602		end;
603
604		{ TIBDataSetEditor }
605
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	–
606		procedure TIBDataSetEditor.ExecuteVerb(Index: Integer);
607		var
608		IBDataset: TIBDataset;
#	Line 658 | Line 613 | begin
613		Dec(Index, inherited GetVerbCount);
614		case Index of
615		0:
616	<	if EditIBDataSet(TIBDataSet(Component)) then
616	>	if IBDataSetEditor.EditIBDataSet(TIBDataSet(Component)) then
617		Designer.Modified;
618		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;
619		end;
620		end;
621		end;
#	Line 689 | Line 629 | begin
629		case Index of
630		0: Result := SIBDataSetEditor;
631		1: Result := SExecute;
632	<	2: Result := SEditSQL;
693	<	3: Result := SInterbaseExpressVersion;
632	>	2: Result := SInterbaseExpressVersion;
633		end;
634		end;
635		end;
636
637		function TIBDataSetEditor.GetVerbCount: Integer;
638		begin
639	<	Result := inherited GetVerbCount + 4;
639	>	Result := inherited GetVerbCount + 3;
640		end;
641
642		{ TIBEventListProperty }
643
644		function TIBEventListProperty.GetAttributes: TPropertyAttributes;
645		begin
646	<	Result := inherited GetAttributes + [paDialog] - [paSubProperties];
646	>	Result := inherited GetAttributes + [paDialog] - [paMultiSelect,paSubProperties];
647		end;
648
649		procedure TIBEventListProperty.Edit;
650		var
651		Events: TStrings;
652	+	IBEvents: TIBEvents;
653		begin
654	+	IBEvents := GetComponent(0) as TIBEvents;
655		Events := TStringList.Create;
656		try
657	<	Events.Assign( TStrings(GetOrdValue));
658	<	if EditAlerterEvents( Events) then SetOrdValue( longint(Events));
657	>	Events.Assign( IBEvents.Events);
658	>	if EditAlerterEvents( Events) then
659	>	begin
660	>	IBEvents.Events.Assign(Events);
661	>	Modified
662	>	end;
663		finally
664		Events.Free;
665		end;
#	Line 775 | Line 720 | end;
720
721		{ TIBQueryEditor }
722
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	–
723		procedure TIBQueryEditor.ExecuteVerb(Index: Integer);
724		var
725		Query: TIBQuery;
#	Line 806 | Line 731 | begin
731		Dec(Index, inherited GetVerbCount);
732		case Index of
733		0: Query.ExecSQL;
734	<	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;
734	>	1: if ibselectsqleditor.EditSQL(Query.Database,Query.SQL) then Designer.Modified;
735		end;
736		end;
737		end;
#	Line 889 | Line 801 | begin
801		end;
802		inherited Edit;
803		end;
804	<
804	>	(*
805		{ TIBTableFieldLinkProperty }
806
807		procedure TIBTableFieldLinkProperty.Edit;
#	Line 916 | Line 828 | end;
828		procedure TIBTableFieldLinkProperty.SetMasterFields(const Value: string);
829		begin
830		FTable.MasterFields := Value;
831	<	end;
920	<
921	<	{ TIBDatabaseSprig }
922	<
923	<	function TIBDatabaseSprig.AnyProblems: Boolean;
924	<	begin
925	<	Result := (TIBDatabase(Item).DatabaseName = '') or
926	<	(TIBDatabase(Item).DefaultTransaction = nil);
927	<	end;
928	<
929	<	function TIBDatabaseSprig.Caption: string;
930	<	begin
931	<	Result := CaptionFor(TIBDatabase(Item).DatabaseName, UniqueName);
932	<	end;
933	<
934	<	{ TIBTransactionSprig }
935	<
936	<	function TIBTransactionSprig.AnyProblems: Boolean;
937	<	begin
938	<	Result := TIBTransaction(Item).DefaultDatabase = nil;
939	<	end;
831	>	end;*)
832
833	<	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;
833	>	{ TIBUpdateSQLProperty }
834
835	<	class function TIBTransactionSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
835	>	procedure TIBUpdateSQLProperty.Edit;
836	>	var
837	>	IBDataset: TIBDataset;
838		begin
839	<	Result := (AParent is TIBDatabaseSprig);
839	>	IBDataset := GetComponent(0) as TIBDataset;
840	>	if IBModifySQLEditor.EditSQL(IBDataSet.Database,IBDataSet.ModifySQL) then Modified;
841		end;
842
843	<	{ support stuff for sprigs }
843	>	{ TIBUpdateSQLUpdateProperty }
844
845	<	function IBAnyProblems(ATransaction: TIBTransaction; ADatabase: TIBDatabase): Boolean;
845	>	procedure TIBUpdateSQLUpdateProperty.Edit;
846		begin
847	<	Result := (ATransaction = nil) or
848	<	(ADatabase = nil) or
985	<	(ATransaction.DefaultDatabase <> ADatabase);
847	>	GetObjects;
848	>	if IBModifySQLEditor.EditSQL(FDatabase,FIBUpdateSQL.ModifySQL) then Modified;
849		end;
850
851	<	procedure IBFigureParent(ASprig: TSprig; ATransaction: TIBTransaction; ADatabase: TIBDatabase);
989	<	begin
990	<	if ATransaction <> nil then
991	<	ASprig.SeekParent(ATransaction).Add(ASprig)
992	<	else if ADatabase <> nil then
993	<	ASprig.SeekParent(ADatabase).Add(ASprig)
994	<	else
995	<	ASprig.Root.Add(ASprig);
996	<	end;
997	<
998	<	function IBDragOver(ASprig: TSprig): Boolean;
999	<	begin
1000	<	Result := (ASprig is TIBTransactionSprig) or
1001	<	(ASprig is TIBDatabaseSprig);
1002	<	end;
851	>	{ TIBRefreshSQLProperty }
852
853	<	function IBDropOver(AParent: TSprig; var ATransaction: TIBTransaction; var ADatabase: TIBDatabase): Boolean;
853	>	procedure TIBRefreshSQLProperty.Edit;
854		var
855	<	vParentTransaction: TIBTransaction;
856	<	vParentDatabase: TIBDatabase;
855	>	IBDataset: TIBDataset;
856	>	aDatabase: TIBDatabase;
857		begin
858	<	Result := False;
859	<	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;
858	>	IBDataset := GetComponent(0) as TIBDataset;
859	>	if IBRefreshSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.RefreshSQL) then Modified;
860		end;
861
862	<	{ TIBSQLSprig }
862	>	{ TIBUpdateSQLRefreshSQLProperty }
863
864	<	function TIBSQLSprig.AnyProblems: Boolean;
864	>	procedure TIBUpdateSQLRefreshSQLProperty.Edit;
865		begin
866	<	Result := IBAnyProblems(TIBSQL(Item).Transaction,
867	<	TIBSQL(Item).Database) or
1043	<	(TIBSQL(Item).SQL.Count = 0);
866	>	GetObjects;
867	>	if IBRefreshSQLEditor.EditSQL(FDatabase,FIBUpdateSQL.RefreshSQL) then Modified;
868		end;
869
870	<	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;
870	>	{ TIBDeleteSQLProperty }
871
872	<	function TIBSQLSprig.DragOverTo(AItem: TSprig): Boolean;
872	>	procedure TIBDeleteSQLProperty.Edit;
873	>	var
874	>	IBDataset: TIBDataset;
875		begin
876	<	Result := IBDragOver(AItem);
876	>	IBDataset := GetComponent(0) as TIBDataset;
877	>	if IBDeleteSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.DeleteSQL) then Modified;
878		end;
879
880	<	procedure TIBSQLSprig.FigureParent;
1070	<	begin
1071	<	IBFigureParent(Self, TIBSQL(Item).Transaction,
1072	<	TIBSQL(Item).Database);
1073	<	end;
880	>	{ TIBUpdateSQLDeleteProperty }
881
882	<	class function TIBSQLSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
882	>	function TIBUpdateSQLDeleteProperty.GetAttributes: TPropertyAttributes;
883		begin
884	<	Result := IBDragOver(AParent);
884	>	Result:=inherited GetAttributes;
885		end;
886
887	<	{ TIBCustomDataSetSprig }
1081	<
1082	<	function TIBCustomDataSetSprig.AnyProblems: Boolean;
887	>	procedure TIBUpdateSQLDeleteProperty.Edit;
888		begin
889	<	Result := IBAnyProblems(TIBCustomDataSet(Item).Transaction,
890	<	TIBCustomDataSet(Item).Database);
889	>	GetObjects;
890	>	if IBDeleteSQLEditor.EditSQL(FDatabase,FIBUpdateSQL.DeleteSQL) then Modified;
891		end;
892
893	<	procedure TIBCustomDataSetSprig.FigureParent;
1089	<	begin
1090	<	IBFigureParent(Self, TIBCustomDataSet(Item).Transaction,
1091	<	TIBCustomDataSet(Item).Database);
1092	<	end;
893	>	{ TUpdateSQLPropertyEditor }
894
895	<	function TIBCustomDataSetSprig.DragDropTo(AItem: TSprig): Boolean;
1095	<	var
1096	<	vTransaction: TIBTransaction;
1097	<	vDatabase: TIBDatabase;
895	>	function TUpdateSQLPropertyEditor.GetObjects: boolean;
896		begin
897	<	with TIBCustomDataSet(Item) do
897	>	Result := false;
898	>	FIBUpdateSQL := GetComponent(0) as TIBUpdateSQL;
899	>	if not assigned(FIBUpdateSQL) or not assigned(FIBUpdateSQL.DataSet) then
900	>	Exit;
901	>	FDatabase := nil;
902	>	if FIBUpdateSQL.DataSet is TIBQuery then
903		begin
904	<	vTransaction := Transaction;
905	<	vDatabase := Database;
1103	<	Result := IBDropOver(AItem, vTransaction, vDatabase);
1104	<	if Result then
1105	<	begin
1106	<	Transaction := vTransaction;
1107	<	Database := vDatabase;
1108	<	end;
904	>	FDatabase := (FIBUpdateSQL.DataSet as TIBQuery).Database;
905	>	Result := true
906		end;
907		end;
908
909	<	function TIBCustomDataSetSprig.DragOverTo(AItem: TSprig): Boolean;
1113	<	begin
1114	<	Result := IBDragOver(AItem);
1115	<	end;
1116	<
1117	<	class function TIBCustomDataSetSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
1118	<	begin
1119	<	Result := IBDragOver(AParent);
1120	<	end;
1121	<
1122	<	{ TIBStoredProcSprig }
1123	<
1124	<	function TIBStoredProcSprig.AnyProblems: Boolean;
1125	<	begin
1126	<	Result := inherited AnyProblems or
1127	<	(TIBStoredProc(Item).StoredProcName = '');
1128	<	end;
1129	<
1130	<	function TIBStoredProcSprig.Caption: string;
1131	<	begin
1132	<	Result := CaptionFor(TIBStoredProc(Item).StoredProcName, UniqueName);
1133	<	end;
1134	<
1135	<	{ TIBTableSprig }
1136	<
1137	<	function TIBTableSprig.AnyProblems: Boolean;
1138	<	begin
1139	<	Result := inherited AnyProblems or
1140	<	(TIBTable(Item).TableName = '');
1141	<	end;
1142	<
1143	<	function TIBTableSprig.Caption: string;
1144	<	begin
1145	<	Result := CaptionFor(TIBTable(Item).TableName, UniqueName);
1146	<	end;
1147	<
1148	<	{ TIBQuerySprig }
1149	<
1150	<	function TIBQuerySprig.AnyProblems: Boolean;
1151	<	begin
1152	<	Result := inherited AnyProblems or
1153	<	(TIBQuery(Item).SQL.Count = 0);
1154	<	end;
1155	<
1156	<	{ TIBDatabaseInfoSprig }
1157	<
1158	<	class function TIBDatabaseInfoSprig.ParentProperty: string;
1159	<	begin
1160	<	Result := 'Database'; { do not localize }
1161	<	end;
1162	<
1163	<	{ TIBUpdateSQLSprig }
1164	<
1165	<	function TIBUpdateSQLSprig.AnyProblems: Boolean;
1166	<	begin
1167	<	with TIBUpdateSQL(Item) do
1168	<	Result := (ModifySQL.Count = 0) and
1169	<	(InsertSQL.Count = 0) and
1170	<	(DeleteSQL.Count = 0) and
1171	<	(RefreshSQL.Count = 0);
1172	<	end;
1173	<
1174	<	{ TIBEventsSprig }
1175	<
1176	<	function TIBEventsSprig.AnyProblems: Boolean;
1177	<	begin
1178	<	Result := inherited AnyProblems or
1179	<	(TIBEvents(Item).Events.Count = 0);
1180	<	end;
1181	<
1182	<	class function TIBEventsSprig.ParentProperty: string;
1183	<	begin
1184	<	Result := 'Database'; { do not localize }
1185	<	end;
1186	<
1187	<	{ TIBTableMasterDetailBridge }
1188	<
1189	<	function TIBTableMasterDetailBridge.CanEdit: Boolean;
1190	<	begin
1191	<	Result := True;
1192	<	end;
1193	<
1194	<	function TIBTableMasterDetailBridge.Caption: string;
1195	<	begin
1196	<	if TIBTable(Omega.Item).MasterFields = '' then
1197	<	Result := SNoMasterFields
1198	<	else
1199	<	Result := TIBTable(Omega.Item).MasterFields;
1200	<	end;
909	>	{ TIBInsertSQLProperty }
910
911	<	function TIBTableMasterDetailBridge.Edit: Boolean;
911	>	procedure TIBInsertSQLProperty.Edit;
912		var
913	<	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;
913	>	IBDataset: TIBDataset;
914		begin
915	<	Result := TIBTable(AItem).MasterSource;
915	>	IBDataset := GetComponent(0) as TIBDataset;
916	>	if IBInsertSQLEditor.EditSQL(IBDataSet.Database,IBDataSet.InsertSQL) then Modified;
917		end;
918
919	<	class function TIBTableMasterDetailBridge.OmegaIslandClass: TIslandClass;
1222	<	begin
1223	<	Result := TIBTableIsland;
1224	<	end;
919	>	{ TIBUpdateSQLInsertSQLProperty }
920
921	<	class procedure TIBTableMasterDetailBridge.SetOmegaSource(
1227	<	AItem: TPersistent; ADataSource: TDataSource);
921	>	procedure TIBUpdateSQLInsertSQLProperty.Edit;
922		begin
923	<	TIBTable(AItem).MasterSource := ADataSource;
923	>	GetObjects;
924	>	if IBInsertSQLEditor.EditSQL(FDatabase,FIBUpdateSQL.InsertSQL) then Modified;
925		end;
926
927	<	{ TIBQueryMasterDetailBridge }
927	>	{ TIBGeneratorProperty }
928
929	<	function TIBQueryMasterDetailBridge.Caption: string;
929	>	function TIBGeneratorProperty.GetAttributes: TPropertyAttributes;
930		begin
931	<	Result := SParamsFields;
931	>	Result:= inherited GetAttributes + [paDialog] - [paMultiSelect,paValueList];
932		end;
933
934	<	class function TIBQueryMasterDetailBridge.GetOmegaSource(
1240	<	AItem: TPersistent): TDataSource;
934	>	procedure TIBGeneratorProperty.Edit;
935		begin
936	<	Result := TIBQuery(AItem).DataSource;
936	>	if IBGeneratorEditor.EditGenerator(GetPersistentReference as TIBGenerator) then Modified;
937		end;
938
939	<	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;
939	>	{ TIBSQLEditor }
940
941	<	class procedure TIBQueryMasterDetailBridge.SetOmegaSource(
1256	<	AItem: TPersistent; ADataSource: TDataSource);
941	>	procedure TIBSQLEditor.ExecuteVerb(Index: Integer);
942		begin
943	<	TIBQuery(AItem).DataSource := ADataSource;
943	>	if IBSQLEditor.EditIBSQL(TIBSQL(Component)) then Modified;
944		end;
945
946	<	{ TIBCustomDataSetIsland }
1262	<
1263	<	function TIBCustomDataSetIsland.VisibleTreeParent: Boolean;
946	>	function TIBSQLEditor.GetVerb(Index: Integer): string;
947		begin
948	<	Result := False;
948	>	case Index of
949	>	0 : Result := SIBSQLEditor;
950	>	1: Result := SInterbaseExpressVersion;
951	>	end;
952		end;
953
954	<	{ TIBSQLIsland }
1269	<
1270	<	function TIBSQLIsland.VisibleTreeParent: Boolean;
954	>	function TIBSQLEditor.GetVerbCount: Integer;
955		begin
956	<	Result := False;
956	>	Result:= 2
957		end;
958
959	<	{ TIBTransactionIsland }
959	>	{ TIBSQLSQLPropertyEditor }
960
961	<	function TIBTransactionIsland.VisibleTreeParent: Boolean;
961	>	procedure TIBSQLSQLPropertyEditor.Edit;
962	>	var
963	>	IBSQL: TIBSQL;
964		begin
965	<	Result := TIBTransaction(Sprig.Item).DefaultDatabase = nil;
965	>	IBSQL := GetComponent(0) as TIBSQL;
966	>	if IBSQLEditor.EditIBSQL(IBSQL) then Modified;
967		end;
968
969	+	initialization
970	+	{$I IBDBReg.lrs}
971		end.

Diff Legend

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