unit uDADataTableWizards;

{----------------------------------------------------------------------------}
{ 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}
{$ELSE}
{$I ../DataAbstract.inc}
{$ENDIF}

interface

uses
  {$IFDEF MSWINDOWS}Windows, {$ENDIF}
  Classes, Types, Controls,{$IFDEF FPC}ComponentEditors,PropEdits,{$ELSE}ToolsAPI, DesignIntf,{$ENDIF}
  uDAClasses, uDADataTable;

type
  {$IFDEF FPC}
  IDesigner = TComponentEditorDesigner;
  {$ENDIF}

  TDataTableWizards = class
  private
    class procedure GetDataTables(const aName: string);
  public
    class function CreateDataTables(aDesigner: IDesigner; aAdapter: TDABaseRemoteDataAdapter; aSchema: TDASchema; aCoordinates: TPoint): boolean; overload;
    {$IFNDEF FPC}
    class function CreateDataTables(aForm: IOTAFormEditor; aAdapter: TDABaseRemoteDataAdapter; aSchema: TDASchema; aCoordinates: TPoint): boolean; overload;
    {$ENDIF}
  end;
  
implementation

uses
  Forms, SysUtils, Dialogs, Registry, TypInfo,
  uROClasses,
  uDAInterfaces, uDAPleaseWaitForm, uDASelectDataTablesForm, uDAMemDataTable {, uDARemoteDataAdapter};


function ComponentExists(aDesigner: IDesigner; aName: string): boolean;
var
  i: integer;
begin
  for i := 0 to aDesigner.{$IFDEF FPC}Form{$ELSE}Root{$ENDIF}.ComponentCount-1 do
    if aDesigner.{$IFDEF FPC}Form{$ELSE}Root{$ENDIF}.Components[i].Name = aName then begin
      result := true;
      exit;
    end;
  result := false;
end;

procedure CreateDataTable(aDesigner: IDesigner; aClass:TDADataTableClass; aAdapter: TDABaseRemoteDataAdapter; aSchema: TDASchema;
                          const aDataTableName: String; X,Y: integer; aCreateDataSource: boolean=true); overload;
var
  lDataTable:TDADataTable;
  lDataSource:TDADataSource;
  lBaseName:string;
  lDataTablePrefix,lDataSourcePrefix:string;
  lDataset: TDADataSet;
  lField: TDAField;
begin
  with TRegistry.Create do try
    RootKey := HKEY_CURRENT_USER;
    OpenKey('Software\RemObjects\Data Abstract\IDE\ComponentPrefixes',false);
    lDataTablePrefix := ReadString('TDADataTable');
    lDataSourcePrefix := ReadString('TDADataSource');
  finally
    Free();
  end;
  if lDataTablePrefix = '' then lDataTablePrefix := 'tbl_';
  if lDataSourcePrefix = '' then lDataSourcePrefix := 'ds_';

  {$IFDEF FPC}
  lDataTable := aClass.Create(aDesigner.Form);
  LongRec(lDataTable.DesignInfo).Lo := X;
  LongRec(lDataTable.DesignInfo).Hi := Y;
  {$ELSE}
  lDataTable := aDesigner.CreateComponent(aClass, nil, X, Y, 24, 24) as TDADataTable;
  {$ENDIF}
  lDataset := aSchema.FindDataset(aDataTableName);
  if Assigned(lDataset) then begin
    lDataTable.LogicalName := lDataset.Name;
    lDataTable.CustomAttributes.Assign(lDataset.CustomAttributes);
    lDataTable.Fields.AssignFieldCollection(lDataset.Fields);
    lDataTable.Params.AssignParamCollection(lDataset.Params);
    lBaseName := lDataset.Name;
    // ToDo: the code below is shared with RDA.FillSchema. Refactor.
    if lDataset is TDAUnionDataTable then begin
      if not Assigned(lDataset.Fields.FindField(def_SourceTableFieldName) as TDAField) then begin
        lField := lDataTable.Fields.Add();
        lField.Name := def_SourceTableFieldName;
        lField.DataType := datInteger;
        lField.InPrimaryKey := True;
        lField.ServerAutoRefresh := True;
      end;
    end;
  end;

  lDataTable.RemoteDataAdapter := aAdapter;

  RemoveExcept(lBaseName,['a'..'z','A'..'Z','0'..'9','_']);
  if ComponentExists(aDesigner, lDataTablePrefix+lBaseName) then
    lDataTable.Name := aDesigner.UniqueName(lDataTablePrefix+lBaseName)
  else
    lDataTable.Name := lDataTablePrefix+lBaseName;


  if aCreateDataSource then begin
    {$IFDEF FPC}
    lDataSource := TDADataSource.Create(aDesigner.Form);
    LongRec(lDataSource.DesignInfo).Lo := X;
    LongRec(lDataSource.DesignInfo).Hi := Y+44;
    {$ELSE}
    lDataSource := aDesigner.CreateComponent(TDADataSource, nil , X, Y+44, 24, 24) as TDADataSource;
    {$ENDIF}
    lDataSource.DataTable := lDataTable;
    if ComponentExists(aDesigner, lDataSourcePrefix+lBaseName) then
      lDataSource.Name := aDesigner.UniqueName(lDataSourcePrefix+lBaseName)
    else
      lDataSource.Name := lDataSourcePrefix+lBaseName;
  end;

end;

{$IFNDEF FPC}
class function TDataTableWizards.CreateDataTables(aForm: IOTAFormEditor; aAdapter: TDABaseRemoteDataAdapter; aSchema: TDASchema; aCoordinates: TPoint): boolean;
begin
  result := CreateDataTables((aForm as INTAFormEditor).FormDesigner, aAdapter, aSchema, aCoordinates);
end;
{$ENDIF}

var
  gDataTables: TStringList;
  gDesigner: IDesigner;

class procedure TDataTableWizards.GetDataTables(const aName: string);
var
  lComponent: TComponent;
begin
  {$IFDEF FPC}
  lComponent := gDesigner.PropertyEditorHook.GetComponent(aName);
  {$ELSE}
  lComponent := gDesigner.GetComponent(aName);
  {$ENDIF}
  if assigned(lComponent) then
    gDataTables.Add((lComponent as TDADataTable).LogicalName);
end;

class function TDataTableWizards.CreateDataTables(aDesigner: IDesigner; aAdapter: TDABaseRemoteDataAdapter; aSchema: TDASchema; aCoordinates: TPoint): boolean;
var
  lForm: TDASelectDataTablesForm;
  lDataTables: TStringList;
  i: integer;
  Y: integer;
  {$IFDEF FPC}
  ldesigner: TPropertyEditorHook;
  {$ELSE}
  ldesigner: IDesigner;
  {$ENDIF}
begin
  {$IFDEF FPC}
  ldesigner:= aDesigner.PropertyEditorHook;
  {$ELSE}
  ldesigner := aDesigner;
  {$ENDIF}
  lDataTables := TStringList.Create;
  try
    lDataTables.Sorted := true;
    for i := 0 to aSchema.Datasets.Count-1 do
      if aSchema.Datasets[i].IsPublic then
        lDataTables.AddObject(aSchema.Datasets[i].Name, aSchema.Datasets[i]);

    for i := 0 to aSchema.UnionDataTables.Count-1 do
      if aSchema.UnionDataTables[i].IsPublic then
        lDataTables.AddObject(aSchema.UnionDataTables[i].Name, aSchema.UnionDataTables[i]);

    for i := 0 to aSchema.JoinDataTables.Count-1 do
      if aSchema.JoinDataTables[i].IsPublic then
        lDataTables.AddObject(aSchema.JoinDataTables[i].Name, aSchema.JoinDataTables[i]);

    if lDataTables.Count > 0 then begin

      gDesigner := aDesigner;
      gDataTables := TStringList.Create();
      try
        lDesigner.GetComponentNames(GetTypeData(TypeInfo(TDADataTable)), GetDataTables);
        lForm := TDASelectDataTablesForm.Create(nil);
        try
          for i := 0 to lDataTables.Count-1 do begin
            lForm.lb_DataTables.Items.AddObject(lDataTables[i], lDataTables.Objects[i]);
            lForm.lb_DataTables.Checked[lForm.lb_DataTables.Items.Count-1] := gDataTables.IndexOf(lDataTables[i]) = -1;
          end;
          lForm.UpdateCheckBoxState();
          lForm.OkButtonCaption := '&Create';
          result := (lForm.ShowModal() = mrOk);
          if result then begin
            Y := aCoordinates.Y;
            for i := 0 to lForm.lb_DataTables.Items.Count - 1 do
              if lForm.lb_DataTables.Checked[i] then begin
                CreateDataTable(aDesigner, TDAMemDataTable, aAdapter, aSchema, lForm.lb_DataTables.Items[i], aCoordinates.X, Y, true);
                inc(y, 88); // doesn't seem to work :(
              end;
          end;
        finally
          FreeAndNil(lForm);
        end;

      finally
        FreeAndNil(gDataTables);
        gDesigner := nil;
      end;

    end
    else begin
      ShowMessage('No data tables were found in schema.');
      result := false;
    end;
  finally
    FreeAndNil(lDataTables);
  end;
end;

end.