david
2824855ea7
- Recompilación en Delphi10 de todos los paquetes de RO para generar las DCU's en Lib\D10 - Recompilación en Delphi10 de todos los paquetes de DA para generar las DCU's en Lib\D10 git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.RemObjects@9 b6239004-a887-0f4b-9937-50029ccdca16
1287 lines
40 KiB
ObjectPascal
1287 lines
40 KiB
ObjectPascal
unit uDADataAbstractEditors;
|
|
|
|
{----------------------------------------------------------------------------}
|
|
{ Data Abstract Library - IDE Library
|
|
{
|
|
{ compiler: Delphi 6 and up, Kylix 3 and up
|
|
{ platform: Win32, Linux
|
|
{
|
|
{ (c)opyright RemObjects Software. all rights reserved.
|
|
{
|
|
{ Using this code requires a valid license of the Data Abstract
|
|
{ which can be obtained at http://www.remobjects.com.
|
|
{----------------------------------------------------------------------------}
|
|
|
|
{$IFDEF MSWINDOWS}
|
|
{$I ..\DataAbstract.inc}
|
|
{$ENDIF MSWINDOWS}
|
|
{$IFDEF LINUX}
|
|
{$I ../DataAbstract.inc}
|
|
{$ENDIF LINUX}
|
|
|
|
interface
|
|
|
|
uses
|
|
Windows, Classes, uDAClasses, DesignIntf, DesignEditors, uRODL, ColnEdit,uDARes,
|
|
uDAClientDataModule, uDADataTable, uDARemoteDataAdapter, uROClient, SysUtils,
|
|
uRORemoteService;
|
|
|
|
type { TDADriverManagerEditor }
|
|
TDADriverManagerEditor = class(TComponentEditor)
|
|
private
|
|
public
|
|
procedure ExecuteVerb(Index: Integer); override;
|
|
function GetVerb(Index: Integer): string; override;
|
|
function GetVerbCount: Integer; override;
|
|
end;
|
|
|
|
{ TDAConnectionManagerEditor }
|
|
TDAConnectionManagerEditor = class(TComponentEditor)
|
|
private
|
|
public
|
|
procedure ExecuteVerb(Index: Integer); override;
|
|
function GetVerb(Index: Integer): string; override;
|
|
function GetVerbCount: Integer; override;
|
|
end;
|
|
|
|
{ TDADataDictionaryEditor }
|
|
TDADataDictionaryEditor = class(TComponentEditor)
|
|
private
|
|
public
|
|
procedure ExecuteVerb(Index: Integer); override;
|
|
function GetVerb(Index: Integer): string; override;
|
|
function GetVerbCount: Integer; override;
|
|
end;
|
|
|
|
{ TDASchemaEditor }
|
|
TDASchemaEditor = class(TComponentEditor)
|
|
protected
|
|
public
|
|
procedure ExecuteVerb(Index: Integer); override;
|
|
function GetVerb(Index: Integer): string; override;
|
|
function GetVerbCount: Integer; override;
|
|
end;
|
|
|
|
{ TDADesigntimeCallEditor }
|
|
TDADesigntimeCallEditor = class(TComponentEditor)
|
|
protected
|
|
public
|
|
procedure ExecuteVerb(Index: Integer); override;
|
|
function GetVerb(Index: Integer): string; override;
|
|
function GetVerbCount: Integer; override;
|
|
end;
|
|
|
|
{ TDADataRequestCallMethodNameEditor }
|
|
TDADataRequestCallMethodNameEditor = class(TStringProperty)
|
|
private
|
|
function RetrieveLibrary: TRODLLibrary;
|
|
|
|
protected
|
|
public
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
procedure GetValues(Proc: TGetStrProc); override;
|
|
procedure SetValue(const Value: string); override;
|
|
end;
|
|
|
|
{ TDALoginAwareComponentEditor }
|
|
TDALoginAwareComponentEditor = class(TComponentEditor)
|
|
protected
|
|
fRemoteService: TRORemoteService;
|
|
function GetAdapterSchema(aAdapter: TDARemoteDataAdapter): TDASchema;
|
|
procedure OnLoginNeeded(Sender: TROTransportChannel; anException: Exception; var aRetry: Boolean);
|
|
end;
|
|
|
|
{ TDADataTableEditor }
|
|
TDADataTableEditor = class(TDALoginAwareComponentEditor)
|
|
protected
|
|
public
|
|
procedure ExecuteVerb(Index: Integer); override;
|
|
function GetVerb(Index: Integer): string; override;
|
|
function GetVerbCount: Integer; override;
|
|
end;
|
|
|
|
{ TDARemoteDataAdapterEditor }
|
|
TDARemoteDataAdapterEditor = class(TDALoginAwareComponentEditor)
|
|
private
|
|
fDataTables: TStringList;
|
|
function HookUpDataTables: boolean;
|
|
procedure GetDataTables(const aName: string);
|
|
public
|
|
procedure ExecuteVerb(Index: Integer); override;
|
|
function GetVerb(Index: Integer): string; override;
|
|
function GetVerbCount: Integer; override;
|
|
end;
|
|
|
|
{ TDADataTableMasterDetailProps }
|
|
{$IFDEF MSWINDOWS}
|
|
TDADataTableMasterDetailProps = class(TStringProperty)
|
|
protected
|
|
public
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
procedure Edit; override;
|
|
end;
|
|
{$ENDIF MSWINDOWS}
|
|
|
|
{ TDABusinessProcessorCommandProperty }
|
|
TDABusinessProcessorCommandProperty = class(TStringProperty)
|
|
protected
|
|
public
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
procedure GetValues(Proc: TGetStrProc); override;
|
|
end;
|
|
|
|
{ TDABusinessProcessorRefDatasetProperty }
|
|
TDABusinessProcessorRefDatasetProperty = class(TStringProperty)
|
|
protected
|
|
public
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
procedure GetValues(Proc: TGetStrProc); override;
|
|
end;
|
|
|
|
{ TDACollectionProperty }
|
|
TDACollectionProperty = class(TCollectionProperty)
|
|
private
|
|
protected
|
|
public
|
|
procedure Edit; override;
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
end;
|
|
|
|
{ TDADataTableLogicalNameEditor }
|
|
TDADataTableLogicalNameEditor = class(TStringProperty)
|
|
private
|
|
function GetSchema: TDASchema;
|
|
public
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
procedure GetValues(Proc: TGetStrProc); override;
|
|
end;
|
|
|
|
{ TDACollectionItemDatasetNameEditor }
|
|
TDACollectionItemDatasetNameEditor = class(TStringProperty)
|
|
private
|
|
public
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
procedure GetValues(Proc: TGetStrProc); override;
|
|
end;
|
|
|
|
{ TDADataTableLocalConnection }
|
|
TDADataTableLocalConnection = class(TStringProperty)
|
|
private
|
|
public
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
procedure GetValues(Proc: TGetStrProc); override;
|
|
end;
|
|
|
|
{ TDADriverManagerDirectory }
|
|
TDADriverManagerDirectory = class(TStringProperty)
|
|
private
|
|
public
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
procedure GetValues(Proc: TGetStrProc); override;
|
|
procedure SetValue(const Value: string); override;
|
|
end;
|
|
|
|
{ TDADataTableReferenceDataTable }
|
|
TDADataTableReferenceDataTable = class(TComponentProperty)
|
|
public
|
|
procedure GetValues(Proc: TGetStrProc); override;
|
|
end;
|
|
|
|
{ TDALookupSourceProperty }
|
|
TDALookupSourceProperty = class(TStringProperty)
|
|
private
|
|
public
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
procedure GetValues(Proc: TGetStrProc); override;
|
|
end;
|
|
|
|
{ TDALookupDestProperty }
|
|
TDALookupDestProperty = class(TStringProperty)
|
|
private
|
|
public
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
procedure GetValues(Proc: TGetStrProc); override;
|
|
end;
|
|
|
|
{ TDALookupResultFieldProperty }
|
|
TDALookupResultFieldProperty = class(TDALookupDestProperty)
|
|
private
|
|
public
|
|
function GetAttributes: TPropertyAttributes; override;
|
|
procedure SetValue(const Value: string); override;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses
|
|
Dialogs, ToolsAPI, ShellAPI, Graphics, Controls, FileCtrl,
|
|
TypInfo, Forms, ClipBrd, DB,
|
|
uROTypes,
|
|
uDAUtils, uDADriverManager, uDADriverInfo, uDASupportClasses,
|
|
uROClasses,
|
|
{$IFDEF MSWINDOWS}
|
|
uROIDETools, uROIDEMenu, uROPleaseWaitForm, uDASchemaUnitsGenerator,
|
|
uDAIDEMenu, uDADataTableMasterLinkWizardForm, uDAPleaseWaitForm,
|
|
{$ENDIF MSWINDOWS}
|
|
uRODLToXML, uDAInterfaces, uDABusinessProcessor, uDAIDERes,
|
|
IniFiles, Registry, uDAIDEData, uDADesigntimeCall, uDASelectDataTablesForm,
|
|
uRODynamicRequest, uDADataTableWizards, uROLoginNeededForm;
|
|
|
|
{ TDASchemaEditor }
|
|
|
|
const
|
|
{$IFDEF MSWINDOWS}
|
|
COMMAND_INDEX_EDIT = 0;
|
|
COMMAND_INDEX_PUBLISH = 1;
|
|
COMMAND_INDEX_SEPARATOR_1 = 2;
|
|
COMMAND_INDEX_SAVE = 3;
|
|
COMMAND_INDEX_LOAD = 4;
|
|
COMMAND_INDEX_SEPARATOR_2 = 5;
|
|
COMMAND_INDEX_GENCODE = 6;
|
|
COMMAND_INDEX_GENCONSTS = 7;
|
|
{$ENDIF MSWINDOWS}
|
|
{$IFDEF LINUX}
|
|
COMMAND_INDEX_EDIT = -1;
|
|
COMMAND_INDEX_PUBLISH = -2;
|
|
COMMAND_INDEX_SAVE = 0;
|
|
COMMAND_INDEX_LOAD = 1;
|
|
{$ENDIF LINUX}
|
|
|
|
procedure TDASchemaEditor.ExecuteVerb(Index: Integer);
|
|
var
|
|
schema :TDASchema;
|
|
connmgr : TDAConnectionManager;
|
|
lSchemaAge:integer;
|
|
sfname,
|
|
cmfname, dadname,diagramname :string;
|
|
i, x : integer;
|
|
s : string;
|
|
lDesigner:IDesignerNotify;
|
|
params: TStringList;
|
|
begin
|
|
schema := GetComponent as TDASchema;
|
|
connmgr := schema.ConnectionManager;
|
|
|
|
{$IFDEF MSWINDOWS}
|
|
if (Index=COMMAND_INDEX_GENCONSTS) then begin
|
|
params := TStringList.Create;
|
|
with schema do try
|
|
params.Sorted := TRUE;
|
|
|
|
s := '';
|
|
if Datasets.Count>0 then begin
|
|
s := Format(' { Dataset names contained in schema "%s" }',[schema.Name])+#13#10;
|
|
for i := 0 to (Datasets.Count-1) do begin
|
|
s := s+Format(' ds_%s = ''%s'';', [MakeValidIdentifier(Datasets[i].Name), Datasets[i].Name])+#13#10;
|
|
end;
|
|
end;
|
|
|
|
if Commands.Count>0 then begin
|
|
s := s+#13#10+Format(' { Command names contained in schema "%s"}',[schema.Name])+#13#10;
|
|
for i := 0 to (Commands.Count-1) do begin
|
|
s := s+Format(' cmd_%s = ''%s'';', [MakeValidIdentifier(Commands[i].Name), Commands[i].Name])+#13#10;
|
|
end;
|
|
end;
|
|
|
|
s := s+' { Dataset and command parameters }'+#13#10;
|
|
for i := 0 to (Datasets.Count-1) do begin
|
|
for x := 0 to (Datasets[i].Params.Count-1) do begin
|
|
// Checks for duplicates
|
|
if params.IndexOf(UpperCase(Datasets[i].Params[x].Name))<0
|
|
then params.Add(UpperCase(Datasets[i].Params[x].Name))
|
|
else Continue;
|
|
|
|
s := s+Format(' par_%s = ''%s'';', [Datasets[i].Params[x].Name, Datasets[i].Params[x].Name])+#13#10;
|
|
end;
|
|
end;
|
|
|
|
for i := 0 to (Commands.Count-1) do begin
|
|
for x := 0 to (Commands[i].Params.Count-1) do begin
|
|
// Checks for duplicates
|
|
if params.IndexOf(UpperCase(Commands[i].Params[x].Name))<0
|
|
then params.Add(UpperCase(Commands[i].Params[x].Name))
|
|
else Continue;
|
|
|
|
s := s+Format(' par_%s = ''%s'';', [Commands[i].Params[x].Name, Commands[i].Params[x].Name])+#13#10;
|
|
end;
|
|
end;
|
|
finally
|
|
params.Free;
|
|
end;
|
|
|
|
Clipboard.AsText := s;
|
|
Exit;
|
|
end;
|
|
{$ENDIF MSWINDOWS}
|
|
|
|
if (Index<>COMMAND_INDEX_LOAD) {$IFDEF MSWINDOWS} and (Index<>COMMAND_INDEX_GENCODE) {$ENDIF} then begin
|
|
Check(connmgr=NIL, 'The schema doesn''t have a connection manager associated. Cannot launch Schema Modeler');
|
|
|
|
if (Index=COMMAND_INDEX_SAVE) then begin
|
|
sfname := schema.Name;
|
|
if not PromptForFileName(sfname, 'Data Abstract Schema (*'+daFileExtSchemaFile+')|*'+daFileExtSchemaFile+'|All Files (*.*)|*.*', daFileExtSchemaFile, 'Save Schema '+schema.Name, '', TRUE)
|
|
then Exit;
|
|
end
|
|
else begin
|
|
sfname := GetTempFileName(daFileExtSchemaFile);
|
|
end;
|
|
|
|
schema.SaveToFile(sfname, pfXML);
|
|
lSchemaAge := FileAge(sfname);
|
|
|
|
cmfname := ChangeFileExt(sfname, daFileExtConnectionMgrFile);
|
|
connmgr.SaveToFile(cmfname, pfXML);
|
|
|
|
dadname := '';
|
|
if Assigned(schema.DataDictionary) then begin
|
|
dadname := ChangeFileExt(sfname, daFileExtDataDictionaryFile);
|
|
schema.DataDictionary.SaveToFile(dadname, pfXML);
|
|
end;
|
|
|
|
diagramname := '';
|
|
if Assigned(schema.Diagrams) then begin
|
|
diagramname := ChangeFileExt(sfname, DAFileExtDiagramsFile);
|
|
schema.Diagrams.SaveToFile(diagramname);
|
|
end;
|
|
|
|
if (Index=COMMAND_INDEX_LOAD) then Exit; // Only wants to save!
|
|
|
|
case Index of
|
|
{$IFDEF MSWINDOWS}
|
|
COMMAND_INDEX_EDIT:try
|
|
with CreatePleaseWaitForm('Running the Schema Modeler...') do try
|
|
Show();
|
|
ExecuteAndWait(GetSchemaModelerPath, '/ns /platform:Delphi /projectname:"'+GetComponent().Name+'" /autosave /schemafile:"'+sfname+'"');
|
|
Hide();
|
|
finally
|
|
Free();
|
|
end;
|
|
|
|
if lSchemaAge < FileAge(sfname) then begin
|
|
|
|
schema.LoadFromFile(sfname, pfXML);
|
|
Designer.Modified();
|
|
|
|
connmgr.LoadFromFile(cmfname, pfXML);
|
|
lDesigner := FindRootDesigner(connmgr);
|
|
if Assigned(lDesigner) then lDesigner.Modified();
|
|
|
|
if dadname <> '' then begin
|
|
schema.DataDictionary.LoadFromFile(dadname, pfXML);
|
|
lDesigner := FindRootDesigner(schema.DataDictionary);
|
|
if Assigned(lDesigner) then lDesigner.Modified();
|
|
end;
|
|
|
|
if diagramname <> '' then begin
|
|
schema.Diagrams.LoadFromFile(diagramname);
|
|
lDesigner := FindRootDesigner(schema.DataDictionary);
|
|
if Assigned(lDesigner) then lDesigner.Modified();
|
|
end;
|
|
|
|
end;
|
|
finally
|
|
DeleteFile(sfname);
|
|
DeleteFile(cmfname);
|
|
if dadname <> '' then DeleteFile(dadname);
|
|
end;
|
|
COMMAND_INDEX_PUBLISH:try
|
|
with CreatePleaseWaitForm('Running the Service Builder...') do try
|
|
Show();
|
|
{$IFDEF SB2}
|
|
LaunchServiceBuilderForCurrentProject('/dataabstract-import-schema /schemafile:"'+sfname+'" /schemacomponentname:"'+schema.Name+'" /ServiceName:"'+schema.Owner.Name+'"',true,true);
|
|
{$ELSE}
|
|
LaunchServiceBuilderForCurrentProject('/execute:"DataAbstract.PublishSchemaWizard" /execute-options:"Schema='+sfname+';ServiceName='+schema.Owner.Name+';SchemaComponentName='+schema.Name+'"',true,true);
|
|
{$ENDIF}
|
|
Hide();
|
|
finally
|
|
Free();
|
|
end;
|
|
finally
|
|
DeleteFile(sfname);
|
|
DeleteFile(cmfname);
|
|
if dadname <> '' then DeleteFile(dadname);
|
|
if diagramname <> '' then DeleteFile(diagramname);
|
|
end;
|
|
{$ENDIF MSWINDOWS}
|
|
COMMAND_INDEX_SAVE:exit;
|
|
end;
|
|
end
|
|
|
|
{$IFDEF MSWINDOWS}
|
|
else if (Index=COMMAND_INDEX_GENCODE) then begin
|
|
//MessageDlg('Not available yet', mtWarning, [mbOK], 0);
|
|
GenerateSchemaUnits(schema);
|
|
end
|
|
{$ENDIF MSWINDOWS}
|
|
|
|
else begin
|
|
if PromptForFileName(sfname, 'Data Abstract Schema (*'+daFileExtSchemaFile+')|*'+daFileExtSchemaFile+'|All Files (*.*)|*.*', daFileExtSchemaFile, 'Load Schema')
|
|
then schema.LoadFromFile(sfname, pfXML);
|
|
end;
|
|
end;
|
|
|
|
function TDASchemaEditor.GetVerb(Index: Integer): string;
|
|
begin
|
|
case Index of
|
|
{$IFDEF MSWINDOWS}
|
|
COMMAND_INDEX_SEPARATOR_1,
|
|
COMMAND_INDEX_SEPARATOR_2 : result := '-';
|
|
{$ENDIF MSWINDOWS}
|
|
COMMAND_INDEX_EDIT : result := 'Edit '+GetComponent.Name;
|
|
COMMAND_INDEX_PUBLISH : result := 'Publish '+GetComponent.Name+'...';
|
|
COMMAND_INDEX_SAVE : result := 'Save '+GetComponent.Name+' to Disk...';
|
|
COMMAND_INDEX_LOAD : result := 'Load '+GetComponent.Name+' from Disk...';
|
|
{$IFDEF MSWINDOWS}
|
|
COMMAND_INDEX_GENCODE : result := 'Generate '+GetComponent.Name+' strongly-typed access units...';
|
|
COMMAND_INDEX_GENCONSTS : result := 'Copy Dataset and Command Names to Clipboard';
|
|
{$ENDIF MSWINDOWS}
|
|
end;
|
|
end;
|
|
|
|
function TDASchemaEditor.GetVerbCount: Integer;
|
|
begin
|
|
{$IFDEF MSWINDOWS}
|
|
result := 8;
|
|
{$ENDIF MSWINDOWS}
|
|
{$IFDEF LINUX}
|
|
result := 4;
|
|
{$ENDIF LINUX}
|
|
end;
|
|
|
|
{ TDADriverManagerEditor }
|
|
|
|
procedure TDADriverManagerEditor.ExecuteVerb(Index: Integer);
|
|
var
|
|
s : string;
|
|
i: Integer;
|
|
sl : IROStrings;
|
|
dm : TDADriverManager;
|
|
begin
|
|
dm := TDADriverManager(GetComponent);
|
|
s := '';
|
|
|
|
case Index of
|
|
0 : ShowDriverInfo(dm);
|
|
|
|
1: begin
|
|
if (dm.DriverCount=0) then begin
|
|
MessageDlg('No drivers to unload.', mtWarning, [mbOK], 0);
|
|
end
|
|
else begin
|
|
dm.UnloadAllDrivers;
|
|
MessageDlg('Drivers unloaded.', mtInformation, [mbOK], 0);
|
|
end;
|
|
end;
|
|
|
|
2 : begin
|
|
if (dm.DriverDirectory='') then begin
|
|
MessageDlg('DriverDirectory is empty. Cannot load drivers.', mtWarning, [mbOK], 0);
|
|
end
|
|
else begin
|
|
dm.ListDrivers(dm.DriverDirectory, sl);
|
|
if (sl.Count=0) then begin
|
|
MessageDlg('No drivers were found', mtInformation, [mbOK], 0);
|
|
end
|
|
else begin
|
|
{$IFDEF MSWINOWS}
|
|
with CreatePleaseWaitForm('Loading Drivers...') do try
|
|
{$ENDIF MSWINOWS}
|
|
for i := 0 to sl.Count-1 do try
|
|
{$IFDEF MSWINOWS}
|
|
Show(Format('Loading %s...',[ExtractFileName(sl[i])]));
|
|
{$ENDIF MSWINOWS}
|
|
dm.LoadDriver(sl[i]);
|
|
except
|
|
on E:EDADriverAlreadyLoaded do;
|
|
on E:EDASchemaModelerOnly do;
|
|
on E:Exception do begin
|
|
{$IFDEF MSWINOWS}
|
|
Hide();
|
|
{$ENDIF MSWINOWS}
|
|
ShowMessageFmt('There was an error loading the %s driver:'#13#13'%s: %s',[ExtractFileName(sl[i]),E.ClassName,E.Message]);
|
|
end;
|
|
end; { for }
|
|
{$IFDEF MSWINOWS}
|
|
end;
|
|
{$ENDIF MSWINOWS}
|
|
MessageDlg(IntToStr(dm.DriverCount)+' Drivers loaded.', mtInformation, [mbOK], 0);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TDADriverManagerEditor.GetVerb(Index: Integer): string;
|
|
var dir : string;
|
|
begin
|
|
case Index of
|
|
0 : result := 'Display Driver Information...';
|
|
1 : result := 'Unload All Drivers';
|
|
2 : begin
|
|
dir := TranslateFileName(TDADriverManager(GetComponent).DriverDirectory);
|
|
if (dir='')
|
|
then dir := '<DriverDirectory property is empty!>';
|
|
result := 'Load Drivers in '+dir;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TDADriverManagerEditor.GetVerbCount: Integer;
|
|
begin
|
|
result := 3;
|
|
end;
|
|
|
|
{ TDAConnectionManagerEditor }
|
|
|
|
procedure TDAConnectionManagerEditor.ExecuteVerb(Index: Integer);
|
|
var connmgr : TDAConnectionManager;
|
|
sfname : string;
|
|
begin
|
|
connmgr := GetComponent as TDAConnectionManager;
|
|
sfname := connmgr.Name+daFileExtConnectionMgrFile;
|
|
|
|
case Index of
|
|
0:begin
|
|
ShowCollectionEditor(Designer, connmgr, connmgr.Connections, 'Connections');
|
|
end;
|
|
|
|
1 : {separator};
|
|
|
|
2 : begin
|
|
if not PromptForFileName(sfname, 'Data Abstract Connections (*'+daFileExtConnectionMgrFile+')|*'+daFileExtConnectionMgrFile+'|All Files (*.*)|*.*', daFileExtConnectionMgrFile, 'Save Connections '+connmgr.Name, '', TRUE)
|
|
then Exit;
|
|
|
|
connmgr.SaveToFile(sfname, pfXML);
|
|
end;
|
|
|
|
3: begin
|
|
if not PromptForFileName(sfname, 'Data Abstract Connections (*'+daFileExtConnectionMgrFile+')|*'+daFileExtConnectionMgrFile+'|All Files (*.*)|*.*', DAFileExtConnectionMgrFile, 'Load Connections '+connmgr.Name, '')
|
|
then Exit;
|
|
|
|
connmgr.LoadFromFile(sfname, pfXML);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TDAConnectionManagerEditor.GetVerb(Index: Integer): string;
|
|
begin
|
|
case Index of
|
|
0 : result := 'Connection List Editor';
|
|
1 : result := '-';
|
|
2 : result := 'Save '+GetComponent.Name+' To Disk...';
|
|
3 : result := 'Load '+GetComponent.Name+' From Disk...';
|
|
end;
|
|
end;
|
|
|
|
function TDAConnectionManagerEditor.GetVerbCount: Integer;
|
|
begin
|
|
result := 4;
|
|
end;
|
|
|
|
{ TDADataRequestAccessParamEditor }
|
|
|
|
procedure CheckCondition(InvalidSituation : boolean; const anErrorMessage : string);
|
|
begin
|
|
if InvalidSituation then begin
|
|
MessageDlg(anErrorMessage, mtError, [mbOK], 0);
|
|
Abort;
|
|
end;
|
|
end;
|
|
|
|
|
|
{ TDADataRequestCallMethodNameEditor }
|
|
|
|
function TDADataRequestCallMethodNameEditor.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
result := [paValueList]
|
|
end;
|
|
|
|
function TDADataRequestCallMethodNameEditor.RetrieveLibrary : TRODLLibrary;
|
|
var datamethod : TDARemoteRequest;
|
|
//datatable : TDADataTable;
|
|
//adapter : TDADataAdapter;
|
|
rs : TRORemoteService;
|
|
svcname : string;
|
|
begin
|
|
//result := NIL;
|
|
|
|
// Sets the variable we need
|
|
datamethod := GetComponent(0) as TDARemoteRequest;
|
|
rs := datamethod.RemoteService;
|
|
|
|
CheckCondition(rs=NIL, 'RemoteService must be assigned.');
|
|
|
|
svcname := Trim(rs.ServiceName);
|
|
CheckCondition(svcname='', rs.Name+'.ServiceName must be assigned.');
|
|
|
|
{adapter := datamethod.Owner.Adapter;
|
|
CheckCondition(adapter=NIL, 'The Adpater property is not set');}
|
|
|
|
result := rs.GetRODLLibrary;
|
|
end;
|
|
|
|
procedure TDADataRequestCallMethodNameEditor.GetValues(Proc: TGetStrProc);
|
|
var lib : TRODLLibrary;
|
|
i,j : integer;
|
|
svc : TRODLService;
|
|
svcintf : TRODLServiceInterface;
|
|
svcname : string;
|
|
sl : IROStrings;
|
|
anchestors : TList;
|
|
method: TDARemoteRequest;
|
|
begin
|
|
lib := RetrieveLibrary;
|
|
if not assigned(lib) then
|
|
raise Exception.Create('RODL library could npt be retrieved from server.');
|
|
|
|
anchestors := TList.Create;
|
|
try
|
|
|
|
method := GetComponent(0) as TDARemoteRequest;
|
|
svcname := method.RemoteService.ServiceName;
|
|
|
|
svc := lib.FindService(svcname);
|
|
if not assigned(svc) then raise Exception.Create('Service "'+svcname+'" could not be found in RODL.');
|
|
|
|
repeat
|
|
anchestors.Add(svc.Default);
|
|
if (Trim(svc.Ancestor)<>'') then begin
|
|
svc := lib.FindService(svc.Ancestor);
|
|
if not assigned(svc) then break;
|
|
end
|
|
else break;
|
|
until false;
|
|
|
|
// Methods
|
|
sl := NewROStrings;
|
|
sl.Sorted := TRUE;
|
|
|
|
for i := 0 to anchestors.Count-1 do begin
|
|
svcintf := TRODLServiceInterface(anchestors[i]);
|
|
|
|
for j := 0 to (svcintf.Count-1) do begin
|
|
{if (svcintf.Items[i].Result=NIL) or
|
|
not (StrToDataType(svcintf.Items[i].Result.DataType)=method.Owner.Adapter.TargetDataType)
|
|
then Continue;}
|
|
|
|
sl.Add(svcintf.Items[j].Name);
|
|
end;
|
|
end;
|
|
|
|
for i := 0 to (sl.Count-1)
|
|
do Proc(sl[i]);
|
|
|
|
finally
|
|
anchestors.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TDADataRequestCallMethodNameEditor.SetValue(const Value: string);
|
|
var
|
|
lRemoteRequest: TDARemoteRequest;
|
|
lOldMethodName: String;
|
|
begin
|
|
lRemoteRequest := TDARemoteRequest(GetComponent(0));
|
|
lOldMethodName := lRemoteRequest.MethodName;
|
|
lRemoteRequest.MethodName := Value;
|
|
if (Trim(lOldMethodName) <> Trim(Value))
|
|
then Designer.Modified();
|
|
|
|
if (Trim(Value)='') then Exit;
|
|
|
|
if MessageDlg('Do you want to retrieve the parameters of the method '+Value+'?', mtConfirmation, [mbYes, mbNo], 0) = mrYes then begin
|
|
{$IFDEF MSWINOWS}
|
|
with CreatePleaseWaitForm('Retrieving Parameters...') do begin
|
|
{$ENDIF MSWINOWS}
|
|
lRemoteRequest.RefreshParams(true);
|
|
{$IFDEF MSWINOWS}
|
|
Hide();
|
|
Designer.Modified();
|
|
end;
|
|
{$ENDIF MSWINOWS}
|
|
end;
|
|
|
|
end;
|
|
|
|
{ TDALoginAwareComponentEditor }
|
|
|
|
procedure TDALoginAwareComponentEditor.OnLoginNeeded(Sender: TROTransportChannel; anException: Exception; var aRetry: Boolean);
|
|
begin
|
|
aRetry := TROLoginNeededForm.Execute(fRemoteService);
|
|
end;
|
|
|
|
function TDALoginAwareComponentEditor.GetAdapterSchema(aAdapter: TDARemoteDataAdapter): TDASchema;
|
|
var
|
|
lSaved: TROExceptionEvent;
|
|
begin
|
|
if aAdapter.RemoteService.Channel = nil then
|
|
raise EROException.Create('Channel not assigned');
|
|
lSaved := aAdapter.RemoteService.Channel.OnLoginNeeded;
|
|
aAdapter.RemoteService.Channel.OnLoginNeeded := OnLoginNeeded;
|
|
try
|
|
fRemoteService := aAdapter.RemoteService;
|
|
result := aAdapter.ReadSchema(True);
|
|
finally
|
|
aAdapter.RemoteService.Channel.OnLoginNeeded := lSaved;
|
|
end;
|
|
end;
|
|
|
|
{ TDARemoteDataAdapterEditor }
|
|
|
|
procedure TDARemoteDataAdapterEditor.GetDataTables(const aName: string);
|
|
begin
|
|
fDataTables.Add(aName);
|
|
end;
|
|
|
|
function TDARemoteDataAdapterEditor.HookUpDataTables: boolean;
|
|
var
|
|
lForm: TDASelectDataTablesForm;
|
|
i: integer;
|
|
begin
|
|
fDataTables := TStringList.Create;
|
|
try
|
|
fDataTables.Sorted := true;
|
|
Designer.GetComponentNames(GetTypeData(TypeInfo(TDADataTable)), GetDataTables);
|
|
if fDataTables.Count > 0 then begin
|
|
lForm := TDASelectDataTablesForm.Create(nil);
|
|
try
|
|
for i := 0 to fDataTables.Count - 1 do begin
|
|
lForm.lb_DataTables.Items.AddObject(fDataTables[i], nil);
|
|
lForm.lb_DataTables.Checked[lForm.lb_DataTables.Items.Count-1] := not assigned((Designer.GetComponent(fDataTables[i]) as TDADataTable).RemoteDataAdapter);
|
|
end;
|
|
lForm.UpdateCheckBoxState();
|
|
lForm.OkButtonCaption := '&Hook Up';
|
|
result := (lForm.ShowModal() = idOk);
|
|
if result then begin
|
|
for i := 0 to lForm.lb_DataTables.Items.Count - 1 do
|
|
if lForm.lb_DataTables.Checked[i] then
|
|
(Designer.GetComponent(lForm.lb_DataTables.Items[i]) as TDADataTable).RemoteDataAdapter := TDARemoteDataAdapter(GetComponent);
|
|
end;
|
|
finally
|
|
FreeAndNil(lForm);
|
|
end;
|
|
end
|
|
else begin
|
|
result := false;
|
|
ShowMessage('No data tables were found on module.')
|
|
end;
|
|
finally
|
|
FreeAndNil(fDataTables);
|
|
end;
|
|
end;
|
|
|
|
procedure TDARemoteDataAdapterEditor.ExecuteVerb(Index: Integer);
|
|
var
|
|
lAdapter: TDARemoteDataAdapter;
|
|
begin
|
|
lAdapter := TDARemoteDataAdapter(GetComponent);
|
|
case Index of
|
|
0: lAdapter.SetupDefaultRequest();
|
|
1: lAdapter.SetupDefaultRequestV3();
|
|
2: { Separator };
|
|
3: if not HookUpDataTables() then exit;
|
|
4: if not TDataTableWizards.CreateDataTables(Designer, lAdapter, GetAdapterSchema(lAdapter), Point(0,0)) then exit;
|
|
end;
|
|
Designer.Modified();
|
|
end;
|
|
|
|
function TDARemoteDataAdapterEditor.GetVerb(Index: Integer): string;
|
|
begin
|
|
case Index of
|
|
0 : result := '&Reset Calls to Default';
|
|
1 : result := 'Reset Calls to Default (Legacy v&3.0)';
|
|
2 : result := '-';
|
|
3 : result := '&Hook up Data Tables...';
|
|
4 : result := '&Create Data Tables...';
|
|
end;
|
|
end;
|
|
|
|
function TDARemoteDataAdapterEditor.GetVerbCount: Integer;
|
|
begin
|
|
result := 5;
|
|
end;
|
|
|
|
{ TDADataTableEditor }
|
|
|
|
procedure TDADataTableEditor.ExecuteVerb(Index: Integer);
|
|
var
|
|
dt: TDADataTable;
|
|
ds: TDADataset;
|
|
lTempSchema: TDASchema;
|
|
lTempSchemaDataSet: TDADataset;
|
|
s: string;
|
|
lSaved: TROExceptionEvent;
|
|
begin
|
|
dt := TDADataTable(GetComponent);
|
|
|
|
case Index of
|
|
0:begin
|
|
ShowCollectionEditor(Designer, dt, dt.Fields, 'Fields');
|
|
end;
|
|
1:{ Seperator };
|
|
2:begin
|
|
if not (MessageDlg('Do you want to retrieve the schema of '+dt.Name+'?'#13+
|
|
'This will overwrite the current field and parameter settings.',
|
|
mtWarning, [mbYes, mbNo], 0)=mrYes) then Exit;
|
|
|
|
if dt.LogicalName = '' then
|
|
raise Exception.Create('LogicalName must be set.');
|
|
|
|
if assigned(dt.RemoteDataAdapter) then begin
|
|
(dt.RemoteDataAdapter as TDARemoteDataAdapter).CheckProperties();
|
|
fRemoteService := (dt.RemoteDataAdapter as TDARemoteDataAdapter).RemoteService;
|
|
lSaved := fRemoteService.Channel.OnLoginNeeded;
|
|
fRemoteService.Channel.OnLoginNeeded := OnLoginNeeded;
|
|
(dt.RemoteDataAdapter as TDARemoteDataAdapter).FlushSchema;
|
|
try
|
|
dt.LoadSchema(true, true);
|
|
finally
|
|
fRemoteService.Channel.OnLoginNeeded := lSaved;
|
|
end;
|
|
end
|
|
else if assigned(dt.LocalSchema) and assigned(dt.LocalDataStreamer) then begin
|
|
ds := dt.LocalSchema.Datasets.DatasetByName(dt.LogicalName);
|
|
dt.Fields.AssignFieldCollection(ds.Fields);
|
|
dt.Params.AssignParamCollection(ds.Params);
|
|
end
|
|
else begin
|
|
MessageDlg('Either RemoteDataAdapter or LocalSchema/LocalDataStreamer must be assigned.', mtError, [mbOK], 0);
|
|
Exit;
|
|
end;
|
|
|
|
s := 'Schema loaded successfully. '+IntToStr(dt.Fields.Count)+' fields';
|
|
if (dt.Params.Count>0) then s := s+' and '+IntToStr(dt.Params.Count)+' params';
|
|
s := s+' have been created. Original lookup- and client calculated fields have been preserved.';
|
|
|
|
MessageDlg(s, mtInformation, [mbOK], 0);
|
|
|
|
Designer.Modified;
|
|
end;
|
|
{$IFDEF MSWINDOWS}
|
|
3: if TDADataTableMasterLinkWizard.ExecuteWizard(dt, Designer) then
|
|
Designer.Modified();
|
|
4:{ Seperator };
|
|
5:begin
|
|
lTempSchema := TDASchema.Create(NIL);
|
|
try
|
|
lTempSchema.Name := MakeValidIdentifier(dt.LogicalName);
|
|
if lTempSchema.Name = '' then lTempSchema.Name := dt.Name;
|
|
|
|
lTempSchemaDataSet := lTempSchema.Datasets.Add();
|
|
lTempSchemaDataSet.Name := lTempSchema.Name;
|
|
lTempSchemaDataSet.Fields.AssignFieldCollection(dt.Fields);
|
|
|
|
GenerateSchemaUnits(lTempSchema);
|
|
finally
|
|
lTempSchema.Free;
|
|
end;
|
|
end;
|
|
6:{ Seperator };
|
|
7:begin
|
|
with TDAIdeData.Create(nil) do try
|
|
if dlg_OpenBriefcase.Execute then begin
|
|
dt.LoadFromFile(dlg_OpenBriefcase.Filename);
|
|
Designer.Modified();
|
|
end;
|
|
finally
|
|
Free();
|
|
end;
|
|
end;
|
|
8:begin
|
|
if not dt.Active then
|
|
raise Exception.Create('DataTable is not active.');
|
|
|
|
with TDAIdeData.Create(nil) do try
|
|
if dlg_SaveBriefcase.Execute then begin
|
|
dt.SaveToFile(dlg_SaveBriefcase.Filename);
|
|
end;
|
|
finally
|
|
Free();
|
|
end;
|
|
end;
|
|
10:begin
|
|
if dt.LogicalName = '' then
|
|
raise Exception.Create('LogicalName must be set.');
|
|
|
|
if assigned(dt.RemoteDataAdapter) then begin
|
|
(dt.RemoteDataAdapter as TDARemoteDataAdapter).CheckProperties();
|
|
fRemoteService := (dt.RemoteDataAdapter as TDARemoteDataAdapter).RemoteService;
|
|
lSaved := fRemoteService.Channel.OnLoginNeeded;
|
|
fRemoteService.Channel.OnLoginNeeded := OnLoginNeeded;
|
|
try
|
|
dt.Open();
|
|
finally
|
|
fRemoteService.Channel.OnLoginNeeded := lSaved;
|
|
end;
|
|
end;
|
|
Designer.Modified;
|
|
end;
|
|
|
|
{$ENDIF MSWINDOWS}
|
|
end; { case }
|
|
end;
|
|
|
|
function TDADataTableEditor.GetVerb(Index: Integer): string;
|
|
begin
|
|
case Index of
|
|
0 : result := 'Field Collection Editor';
|
|
1 : result := '-';
|
|
//2 : result := 'Dynamic Method Binding Setup Wizard (Legacy v3.0)';
|
|
//3 : result := '-';
|
|
2 : result := 'Retrieve DataTable Schema';
|
|
3 : result := 'Master/Detail Wizard';
|
|
4 : result := '-';
|
|
5 : result := 'Generate Business Class...';
|
|
6 : result := '-';
|
|
7 : result := 'Load Data from briefcase file...';
|
|
8 : result := 'Save Data to briefcase file...';
|
|
9 : result := '-';
|
|
10 : result := 'Get Design-Time Data';
|
|
end;
|
|
end;
|
|
|
|
function TDADataTableEditor.GetVerbCount: Integer;
|
|
begin
|
|
{$IFDEF MSWINDOWS}
|
|
result := 9;
|
|
if not TDADataTable(GetComponent).Active and (assigned(TDADataTable(GetComponent).RemoteDataAdapter)) then inc(result,2);
|
|
{$ENDIF MSWINDOWS}
|
|
{$IFDEF LINUX}
|
|
result := 3;
|
|
{$ENDIF LINUX}
|
|
end;
|
|
|
|
{ TDABusinessProcessorCommandProperty }
|
|
|
|
function TDABusinessProcessorCommandProperty.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
result := [paValueList, paSortList]
|
|
end;
|
|
|
|
procedure TDABusinessProcessorCommandProperty.GetValues(Proc: TGetStrProc);
|
|
var biz : TDABusinessProcessor;
|
|
i : integer;
|
|
list : IROStrings;
|
|
begin
|
|
biz := GetComponent(0) as TDABusinessProcessor;
|
|
if (biz.Schema=NIL) then Exit;
|
|
|
|
list := NewROStrings;
|
|
for i := 0 to (biz.Schema.Commands.Count-1) do
|
|
list.Add(biz.Schema.Commands[i].Name);
|
|
|
|
list.Sorted := TRUE;
|
|
|
|
for i := 0 to (list.Count-1) do
|
|
Proc(list[i]);
|
|
end;
|
|
|
|
type
|
|
TPersistentCracker = class(TPersistent);
|
|
|
|
{ TDACollectionProperty }
|
|
|
|
procedure TDACollectionProperty.Edit;
|
|
var coll : TCollection;
|
|
begin
|
|
coll := GetObjectProp(GetComponent(0), GetName) as TCollection;
|
|
|
|
if (coll=NIL) then ShowMessage('no way!')
|
|
else showmessage(GetName+' has #'+INtToSTr(coll.count)+' '+TComponent(integer(coll.Owner)).ClassName);
|
|
|
|
ShowCollectionEditor(Designer, TComponent(GetComponent(0)), coll, GetName);
|
|
end;
|
|
|
|
function TDACollectionProperty.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
result := [paDialog, paReadOnly];
|
|
end;
|
|
|
|
{ TDABusinessProcessorRefDatasetProperty }
|
|
|
|
function TDABusinessProcessorRefDatasetProperty.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
result := [paValueList, paSortList]
|
|
end;
|
|
|
|
procedure TDABusinessProcessorRefDatasetProperty.GetValues( Proc: TGetStrProc);
|
|
var biz : TDABusinessProcessor;
|
|
i : integer;
|
|
list : IROStrings;
|
|
begin
|
|
biz := GetComponent(0) as TDABusinessProcessor;
|
|
if (biz.Schema=NIL) then Exit;
|
|
|
|
list := NewROStrings;
|
|
for i := 0 to (biz.Schema.Datasets.Count-1) do
|
|
list.Add(biz.Schema.Datasets[i].Name);
|
|
|
|
list.Sorted := TRUE;
|
|
|
|
for i := 0 to (list.Count-1) do
|
|
Proc(list[i]);
|
|
end;
|
|
|
|
{ TDADataTableLogicalNameEditor }
|
|
|
|
function TDADataTableLogicalNameEditor.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
result := [paValueList, paSortList]
|
|
end;
|
|
|
|
function TDADataTableLogicalNameEditor.GetSchema: TDASchema;
|
|
begin
|
|
Result:=nil;
|
|
try
|
|
with TDADataTable(GetComponent(0)) do
|
|
if not RemoteFetchEnabled then
|
|
Result := LocalSchema
|
|
else if (RemoteDataAdapter <> nil) and (RemoteDataAdapter is TDARemoteDataAdapter) then
|
|
Result:= (RemoteDataAdapter as TDARemoteDataAdapter).Schema;
|
|
except
|
|
// hide exception, when RDA can't receive SCHEMA
|
|
end;
|
|
end;
|
|
|
|
procedure TDADataTableLogicalNameEditor.GetValues(Proc: TGetStrProc);
|
|
var i : integer;
|
|
_Schema: TDASchema;
|
|
begin
|
|
_Schema:= GetSchema;
|
|
if _Schema <> nil then begin
|
|
for i := 0 to (_Schema.Datasets.Count-1) do
|
|
if _Schema.Datasets[i].IsPublic then Proc(_Schema.Datasets[i].Name);
|
|
for i := 0 to (_Schema.UnionDataTables.Count-1) do
|
|
if _Schema.UnionDataTables[i].IsPublic then Proc(_Schema.UnionDataTables[i].Name);
|
|
for i := 0 to (_Schema.JoinDataTables.Count-1) do
|
|
if _Schema.JoinDataTables[i].IsPublic then Proc(_Schema.JoinDataTables[i].Name);
|
|
end;
|
|
end;
|
|
|
|
{ TDADataTableLocalConnection }
|
|
|
|
function TDADataTableLocalConnection.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
if (TDADataTable(GetComponent(0)).LocalSchema<>NIL) and (TDADataTable(GetComponent(0)).LocalSchema.ConnectionManager<>NIL)
|
|
then result := [paValueList]
|
|
else result := []
|
|
end;
|
|
|
|
procedure TDADataTableLocalConnection.GetValues(Proc: TGetStrProc);
|
|
var i : integer;
|
|
begin
|
|
with TDADataTable(GetComponent(0)) do begin
|
|
if (LocalSchema=NIL) or (LocalSchema.ConnectionManager=NIL) then Exit;
|
|
|
|
for i := 0 to (LocalSchema.ConnectionManager.Connections.Count-1) do
|
|
Proc(LocalSchema.ConnectionManager.Connections[i].Name);
|
|
end;
|
|
end;
|
|
|
|
{ TDADriverManagerDirectory }
|
|
|
|
function TDADriverManagerDirectory.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
result := [paValueList]
|
|
end;
|
|
|
|
const SelectDirOption = '<Select directory>';
|
|
|
|
procedure TDADriverManagerDirectory.GetValues(Proc: TGetStrProc);
|
|
begin
|
|
inherited;
|
|
|
|
Proc(alias_ModuleDir);
|
|
Proc(alias_System);
|
|
Proc(SelectDirOption);
|
|
end;
|
|
|
|
{$IFDEF KYLIX}
|
|
function GetDllPath: String;
|
|
var TheFileName : array[0..MAX_PATH] of char;
|
|
begin
|
|
FillChar(TheFileName, SizeOf(TheFileName), #0);
|
|
{$IFDEF KYLIX}System.{$ENDIF}GetModuleFileName(hInstance, TheFileName, sizeof(TheFileName));
|
|
Result := ExtractFilePath(TheFileName);
|
|
end;
|
|
{$ENDIF}
|
|
procedure TDADriverManagerDirectory.SetValue(const Value: string);
|
|
var dir : string;
|
|
begin
|
|
if (Value=SelectDirOption) then begin
|
|
if SelectDirectory(dir, [sdPrompt, sdAllowCreate], 0)
|
|
then inherited SetValue(dir);
|
|
end
|
|
|
|
else if (Value=alias_DABinDir) then begin
|
|
dir := IncludeTrailingPathDelimiter(Copy(GetDllPath, 1, Length(GetDLLPath)-7))+'Bin';
|
|
inherited SetValue(dir);
|
|
end
|
|
|
|
else inherited;
|
|
end;
|
|
|
|
{ TDADataDictionaryEditor }
|
|
|
|
procedure TDADataDictionaryEditor.ExecuteVerb(Index: Integer);
|
|
var
|
|
dict: TDADataDictionary;
|
|
sfname: string;
|
|
begin
|
|
inherited;
|
|
|
|
dict := GetComponent as TDADataDictionary;
|
|
sfname := dict.Name+DAFileExtDataDictionaryFile;
|
|
|
|
case Index of
|
|
0:ShowCollectionEditor(Designer, GetComponent(), dict.Fields, 'Fields');
|
|
1:{separater};
|
|
2:if PromptForFileName(sfname, 'Data Abstract DataDictionaries (*'+DAFileExtDataDictionaryFile+')|*'+daFileExtConnectionMgrFile+'|All Files (*.*)|*.*', daFileExtConnectionMgrFile, 'Save DataDictionary '+dict.Name, '', TRUE) then
|
|
dict.SaveToFile(sfname, pfXML);
|
|
3:if PromptForFileName(sfname, 'Data Abstract DataDictionaries (*'+DAFileExtDataDictionaryFile+')|*'+daFileExtConnectionMgrFile+'|All Files (*.*)|*.*', daFileExtConnectionMgrFile, 'Load DataDictionary '+dict.Name, '') then
|
|
dict.LoadFromFile(sfname, pfXML);
|
|
end;
|
|
end;
|
|
|
|
function TDADataDictionaryEditor.GetVerb(Index: Integer): string;
|
|
begin
|
|
case Index of
|
|
0:result := 'DataDictionary Editor';
|
|
1:result := '-';
|
|
2: result := 'Save '+GetComponent.Name+' to Disk...';
|
|
3: result := 'Load '+GetComponent.Name+' from Disk...';
|
|
end;
|
|
end;
|
|
|
|
function TDADataDictionaryEditor.GetVerbCount: Integer;
|
|
begin
|
|
result := 4;
|
|
end;
|
|
|
|
{ TDAClientDataModuleEditor }
|
|
|
|
{ TDADataTableMasterDetailProps }
|
|
|
|
{$IFDEF MSWINDOWS}
|
|
procedure TDADataTableMasterDetailProps.Edit;
|
|
begin
|
|
if TDADataTableMasterLinkWizard.ExecuteWizard(TDADataTable(GetComponent(0)), Designer) then
|
|
Designer.Modified();
|
|
end;
|
|
|
|
function TDADataTableMasterDetailProps.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
result := [paDialog]
|
|
end;
|
|
{$ENDIF MSWINDOWS}
|
|
|
|
{ TDACollectionItemDatasetNameEditor }
|
|
|
|
function TDACollectionItemDatasetNameEditor.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
result := [paValueList, paSortList]
|
|
end;
|
|
|
|
procedure TDACollectionItemDatasetNameEditor.GetValues(Proc: TGetStrProc);
|
|
var schema : TDASchema;
|
|
i : integer;
|
|
begin
|
|
schema := TSearcheableCollection(TCollectionItem(GetComponent(0)).Collection).Owner as TDASchema;
|
|
for i := 0 to schema.Datasets.Count-1 do begin
|
|
Proc(schema.Datasets[i].Name);
|
|
end;
|
|
end;
|
|
|
|
{ TDADesigntimeCallEditor }
|
|
|
|
procedure TDADesigntimeCallEditor.ExecuteVerb(Index: Integer);
|
|
begin
|
|
inherited;
|
|
(GetComponent as TDADesigntimeCall).MakeRequest;
|
|
ShowMessage('The call to the server was executed.');
|
|
end;
|
|
|
|
function TDADesigntimeCallEditor.GetVerb(Index: Integer): string;
|
|
begin
|
|
result := 'Make Call';
|
|
end;
|
|
|
|
function TDADesigntimeCallEditor.GetVerbCount: Integer;
|
|
begin
|
|
result := 1;
|
|
end;
|
|
|
|
{ TDADataTableReferenceDataTable }
|
|
|
|
procedure TDADataTableReferenceDataTable.GetValues(Proc: TGetStrProc);
|
|
begin
|
|
Designer.GetComponentNames(GetTypeData(TypeInfo(TDADataTable)), Proc);
|
|
Designer.GetComponentNames(GetTypeData(TypeInfo(TDataset)), Proc);
|
|
end;
|
|
|
|
{ TDALookupSourceProperty }
|
|
|
|
function TDALookupSourceProperty.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
result := [paValueList, paSortList, paMultiSelect];
|
|
end;
|
|
|
|
procedure TDALookupSourceProperty.GetValues(Proc: TGetStrProc);
|
|
var
|
|
i: integer;
|
|
begin
|
|
with GetComponent(0) as TDAField do
|
|
for i := 0 to (FieldCollection.Count - 1) do
|
|
Proc(FieldCollection[i].Name);
|
|
end;
|
|
|
|
{ TDALookupDestProperty }
|
|
|
|
function TDALookupDestProperty.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
result := [paValueList, paSortList, paMultiSelect];
|
|
end;
|
|
|
|
procedure TDALookupDestProperty.GetValues(Proc: TGetStrProc);
|
|
var
|
|
lValues: TStringList;
|
|
i: Integer;
|
|
begin
|
|
lValues := TStringList.Create;
|
|
with GetComponent(0) as TDAField do try
|
|
if Assigned(LookupSource) then begin
|
|
LookupSource.DataSet.GetFieldNames(lValues);
|
|
for i := 0 to lValues.Count - 1 do
|
|
Proc(lValues[i]);
|
|
end;
|
|
finally
|
|
lValues.free;
|
|
end;
|
|
end;
|
|
|
|
{ TDALookupResultFieldProperty }
|
|
|
|
function TDALookupResultFieldProperty.GetAttributes: TPropertyAttributes;
|
|
begin
|
|
result := [paValueList, paSortList];
|
|
end;
|
|
|
|
procedure TDALookupResultFieldProperty.SetValue(const Value: string);
|
|
var
|
|
lResultField, lLookupField: TDAField;
|
|
begin
|
|
lResultField := GetComponent(0) as TDAField;
|
|
if Assigned(lResultField.LookupSource) then begin
|
|
with TDADataSource(lResultField.LookupSource).DataTable do
|
|
lLookupField := FindField(Value);
|
|
if Assigned(lLookupField) then begin
|
|
lResultField.DataType := lLookupField.DataType;
|
|
lResultField.Size := lLookupField.Size;
|
|
end;
|
|
end;
|
|
|
|
inherited;
|
|
end;
|
|
|
|
end.
|