IDE Plugin / IDE ansteuern...

[Jonas Shinaniganz]

hallo dp,

ich beschäftige mich zur Zeit mit XE3 und möchte gerne 3 Dinge versuchen.

1. Ich würde gerne per Knopfdruck aus einer eigenen Anwendung herraus ProgrammCode in eine grade geöffnete PAS-Datei der IDE einfügen.

2. Anschließen noch das Projekt erstellen/ausführen.

3. Evtl. noch das Debug Fenster auslesen.

Quasi eine sehr simple Fernbedienung für die IDE... (nur Einfügen, Starten und Fehlerrückgabe).

Gibts dazu Links/Democode oder eher nicht möglich?
Muss ich mich evtl in die Plugin-Möglichkeit der IDE einlesen?

Falls jemand schon eine Lösung für ein Teilproblem hat wäre das super, ich hab leider erst am Wochenende wieder so richtig Zeit mich drumm zu kümmern.

Beste Grüße!

[stahli]

Die Thematik interessiert mich (demnächst) auch.

Im Wiki gibt es einige Hinweise: http://docwiki.embarcadero.com/RADSt...eitern_-_Index
Erfahrungen habe ich diesbezüglich aber noch nicht.

[RWarnecke]

Nach diesen Stichwörtern solltest Du suchen : OpenTools API, BorlandIDEServices, IOTAActionServices, IOTAEditorServices

[stahli]

Ich kapere mal den Thread

Ich kann jetzt ein neues Projekt erzeugen, komme dann aber noch nicht ausreichend weiter...

Der Packagename "TestBL" incl. FileName und Ordner wird schon mal zugewiesen (noch etwas provisorisch). Das Package wird erzeugt.
Ich möchte nun noch dass das Package
- gleich noch gespeichert wird
- sofort installiert wird.

Vorläufig habe ich das speichern und Installieren von Hand durchgeführt.

Bei weiteren Aufrufen werden dann aber TestBL1, TestBL2 usw. erzeugt, also eine bestehende Installation nicht erkannt.

Wenn die beiden offenen Punkte erledigt sind will ich noch dem Package noch im Dateisystem existierende Units hinzu fügen oder auch wieder Units entfernen.

Das Ganze ist etwas schwierig nachzuvollziehen, da das Debugen eines Designtimepackages etwas langwierig ist und Hilfe im Detail etwas löchrig.
Hat jemand Tipps?

Delphi-Quellcode:

procedure TFormSsFWEditor.CornerButton1Click(Sender: TObject);
var
  PackageTest: IOTAPackageServices;
  I: Integer;
  ProjectCreator: TGxProjectCreator;
  F: Boolean;
begin
  ssFWPM.ssFWP.CreateUnits;

  F := False;
  PackageTest := (BorlandIDEServices as IOTAPackageServices);
  for I := 0 to PackageTest.GetPackageCount - 1 do
    if PackageTest.GetPackageName(I) = 'TestBL' then  // alternate: 'TestBL.bpl'
    begin
      F := True;
      Break;
    end;
  if not F then
    (BorlandIDEServices as IOTAModuleServices).CreateModule(TGxProjectCreator.Create)
  else
    Beep;

  exit;

  PackageTest := (BorlandIDEServices as IOTAPackageServices);
  for I := 0 to PackageTest.GetPackageCount - 1 do
    if PackageTest.GetPackageName(I) = 'ssPackage' then
      exit;
  PackageTest.InstallPackage('ssPackage');
end;

////////////////////////////////////////////

unit ssFWProjectCreator;

interface

uses Windows, ToolsApi;

type

  // TProjectWizard = class(TNotifierObject, IOTAMenuWizard, IOTAWizard)
  // public
  // procedure Execute;
  // function GetIDString: string;
  // function GetMenuText: string;
  // function GetName: string;
  // function GetState: TWizardState;
  // end;

  TGxProjectCreator = class(TInterfacedObject, IOTACreator, IOTAProjectCreator)
  public
    // IOTACreator
    function GetCreatorType: string;
    function GetExisting: Boolean;
    function GetFileSystem: string;
    function GetOwner: IOTAModule;
    function GetUnnamed: Boolean;
    // IOTAProjectCreator
    function GetFileName: string;
    function GetOptionFileName: string;
    function GetShowSource: Boolean;
    procedure NewDefaultModule;
    function NewOptionSource(const ProjectName: string): IOTAFile;
    procedure NewProjectResource(const Project: IOTAProject);
    function NewProjectSource(const ProjectName: string): IOTAFile;
  end;

  // procedure Register;

implementation

// procedure Register;
// begin
// RegisterPackageWizard(TProjectWizard.Create);
// end;

// procedure TProjectWizard.Execute;
// begin
// (BorlandIDEServices as IOTAModuleServices).CreateModule(TGxProjectCreator.Create);
// end;
//
// function TProjectWizard.GetIDString: string;
// begin
// Result := 'GX.ProjectCreator';
// end;
//
// function TProjectWizard.GetMenuText: string;
// begin
// Result := '&GX Project Creator';
// end;
//
// function TProjectWizard.GetName: string;
// begin
// Result := 'GX Project Creator';
// end;
//
// function TProjectWizard.GetState: TWizardState;
// begin
// Result := [wsEnabled];
// end;

{ TGxProjectCreator }

function TGxProjectCreator.GetCreatorType: string;
begin
  Result := sPackage; // Create an application project
end;

function TGxProjectCreator.GetExisting: Boolean;
begin
  Result := False; // Create a new project
end;

function TGxProjectCreator.GetFileName: string;
begin
  Result := 'C:\users\as\Documents\RAD Studio\Projekte\TestBL\' + 'TestBL.dpk'; // Default  const
end;

function TGxProjectCreator.GetFileSystem: string;
begin
  Result := ''; // Default
end;

function TGxProjectCreator.GetOptionFileName: string;
begin
  Result := ''; // Default
end;

function GetCurrentProjectGroup: IOTAProjectGroup;
var
  IModuleServices: IOTAModuleServices;
  IModule: IOTAModule;
  IProjectGroup: IOTAProjectGroup;
  i: Integer;
begin
  Result := nil;
  IModuleServices := BorlandIDEServices as IOTAModuleServices;
  for i := 0 to IModuleServices.ModuleCount - 1 do
  begin
    IModule := IModuleServices.Modules[i];
    if IModule.QueryInterface(IOTAProjectGroup, IProjectGroup) = S_OK then
    begin
      Result := IProjectGroup;
      Break;
    end;
  end;
end;

function TGxProjectCreator.GetOwner: IOTAModule;
begin
  Result := GetCurrentProjectGroup; // Owned by current project group
end;

function TGxProjectCreator.GetShowSource: Boolean;
begin
  Result := False; // Show the source in the editor
end;

function TGxProjectCreator.GetUnnamed: Boolean;
begin
  Result := False; // Project needs to be named/saved
end;

procedure TGxProjectCreator.NewDefaultModule;
begin
  // No default modules are created
end;

function TGxProjectCreator.NewOptionSource(const ProjectName: string): IOTAFile;
begin
  Result := nil; // For BCB only
end;

procedure TGxProjectCreator.NewProjectResource(const Project: IOTAProject);
begin
  // No resources needed
end;

function TGxProjectCreator.NewProjectSource(const ProjectName: string): IOTAFile;
begin
  // Create the default source code for a new application
  Result := nil;
end;

end.

EDIT1: Installierte Packages werden mit Kleinschreibung gefunden:
if PackageTest.GetPackageName(I) = 'testbl.bpl' then // Kleinschreibung

EDIT2: Screenshot

EDIT3: Geil! Jetzt kann ich mein neu erzeugtes Package schon speichern und kompilieren. Fehlt jetzt noch das Hinzufügen der Units (und natürlich das Aufräumen der Testzeilen).

Delphi-Quellcode:

procedure TFormSsFWEditor.CornerButton1Click(Sender: TObject);
var
  PackageTest: IOTAPackageServices;
  I: Integer;
  ProjectCreator: TGxProjectCreator;
  F: Boolean;
  OTAModule: IOTAModule;
begin
  ssFWPM.ssFWP.CreateUnits;

  F := False;
  PackageTest := (BorlandIDEServices as IOTAPackageServices);
  for I := 0 to PackageTest.GetPackageCount - 1 do
    if PackageTest.GetPackageName(I) = 'testbl.bpl' then  // Kleinschreibung
    begin
      F := True;
      Break;
    end;
  if not F then
  begin
    OTAModule := (BorlandIDEServices as IOTAModuleServices).CreateModule(TGxProjectCreator.Create);
    OTAModule.Save(False, True);
    PackageTest.InstallPackage('testbl.bpl');
    OTAModule.Save(False, True);
  end
  else
    Beep;
end;