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.