OpenToolsAPI - Projektionfos

[himitsu]

Moin,

Ist zufällig jemand da, der sich mit der OTA auskennt? (möglichst ohne Fremdkomponenten, da ich den Firmenserver nicht all zu sehr vollmüllen möchte)

Im Prinzip brauch ich nur recht "schnell" ein paar Tipps, wo man eine Notification herbekommt, wenn ein Projekt geladen wird und wie man an die Projekteinstellungen (Pfade) rankommt.

*liebschau*

[jaevencooler]

Moin, Moin,


schau mal hier

http://www.gexperts.org/otafaq.html


Ist vielleicht das was Du suchst....

Cu Michael

[himitsu]

Diese Ecke kenn ich schon, dennoch danke

Ich versuche mich aktuell über ein PreCompileEvent reinzuhacken (zwar'n bissl spät, aber hoffentlich noch rechtzeitig, um die Projektoptionen notfalls noch anzupassen).


Schön wäre es auch, wenn man die ToolsAPI.pas wieder kompilieren könnte, ohne rumgeeiere, wie fehlende Suchpfade und die blöde immernoch fehlende Unit DockForm.
Ich glaub Emba will um jeden Preis verhindern, daß man Schwächen in der IDE selber ausbessert oder sonstwas darin veranstaltet.

[RWarnecke]

Hallo Himitsu,

vielleicht hilft Dir das weiter :

Delphi-Quellcode:

// Den aktuellen Pfad und den Projektnamen ermitteln
(BorlandIDEServices as IOTAModuleServices).GetActiveProject.FileName:string;

// Den Zielnamen und den Zielpfad ermitteln
(BorlandIDEServices as IOTAModuleServices).GetActiveProject.ProjectOptions.TargetName:string;

[chaosben]

Und wann ein Projekt geöffnet wird, erfährt man via IDENotifier

[himitsu]

Ich hab jetzt erstmal das zusammen und es Meldet mir auch fleißig etwas.
Nur ob ich da noch was an den Optionen eändern kann, weiß ich noch nicht.

Delphi-Quellcode:

unit Unit1;

interface

uses ToolsAPI, Dialogs;

implementation

type
  TCompileNotifier = class(TInterfacedObject, IOTACompileNotifier)
  protected
    procedure ProjectCompileStarted(const Project: IOTAProject; Mode: TOTACompileMode);
    procedure ProjectCompileFinished(const Project: IOTAProject; Result: TOTACompileResult);
    procedure ProjectGroupCompileStarted(Mode: TOTACompileMode);
    procedure ProjectGroupCompileFinished(Result: TOTACompileResult);
  end;

var
  CompileNotifier: Integer;

procedure TCompileNotifier.ProjectCompileStarted(const Project: IOTAProject; Mode: TOTACompileMode);
var
  S, S2: String;
  N: TOTAOptionName;
begin
  S := '';
  for N in Project.ProjectOptions.GetOptionNames do begin
    try
      S2 := '"' + String(Project.ProjectOptions.Values[N.Name]) + '"';
    except
      S2 := 'error';
    end;
    S := S + N.Name + ' = ' + S2 + sLineBreak;
  end;
  ShowMessage(S + '"' + Project.ProjectType + '"');
end;

procedure TCompileNotifier.ProjectCompileFinished(const Project: IOTAProject; Result: TOTACompileResult);
begin
end;

procedure TCompileNotifier.ProjectGroupCompileStarted(Mode: TOTACompileMode);
begin
end;

procedure TCompileNotifier.ProjectGroupCompileFinished(Result: TOTACompileResult);
begin
end;

initialization
  CompileNotifier := (BorlandIDEServices as IOTACompileServices).AddNotifier(TCompileNotifier.Create);

finalization
  (BorlandIDEServices as IOTACompileServices).RemoveNotifier(CompileNotifier);

end.

Witzig finde ich die neue MessageBox der XE-IDE ... so cool mit ScrollBar, wenn zuviel Text angezeigt werden soll.



Im Prinzip hätte ich gerne ein Tool, welches die Projektoptionen prüft und falls da etwas nicht stimmt, fragt es einen, so daß man eventuell aus einem Set von vorgefertigten Optionen eoine auswählen kann.

Damit endlich mal das Chaos, mit den unzähligen Speicher- und Suchpfaden, ein Ende findet.


Wenn ich es mir jetzt recht überlege, ist es vor dem Kompilieren eh schöner, da dann nicht gleich jedes Projekt angemeckert wird, sondern erst wenn man kompiliert, also da wo es wichtig wird.
Die Pfade der IDE-Optionen laß ich nun schon über den FinalBuilder abgleichen, also mit dessen aktuellen Pfaden.

[USchuster]

Zitat von himitsu:

Ist zufällig jemand da, der sich mit der OTA auskennt?

Auskennen wer übertrieben

Zitat von himitsu:

Im Prinzip brauch ich nur recht "schnell" ein paar Tipps, wo man eine Notification herbekommt, wenn ein Projekt geladen wird und wie man an die Projekteinstellungen (Pfade) rankommt.

Nach dem Öffnen eines Projektes landet der Suchpfad der Basiskonfiguration im Meldungsfenster.

Delphi-Quellcode:

unit SimpleNotifierUnit;

interface

procedure Register;

implementation

uses
  SysUtils, ToolsAPI, DCCStrs;

type
  TSimpleNotifier = class(TNotifierObject, IOTAIDENotifier)
  public
    procedure AfterCompile(Succeeded: Boolean);
    procedure BeforeCompile(const Project: IOTAProject; var Cancel: Boolean);
    procedure FileNotification(NotifyCode: TOTAFileNotification;
      const FileName: string; var Cancel: Boolean);
  end;

var
  NotifierIndex: Integer = -1;

procedure Register;
begin
  NotifierIndex := (BorlandIDEServices as IOTAServices).AddNotifier(TSimpleNotifier.Create);
end;

{ TSimpleNotifier }

procedure TSimpleNotifier.AfterCompile(Succeeded: Boolean);
begin
//
end;

procedure TSimpleNotifier.BeforeCompile(const Project: IOTAProject;
  var Cancel: Boolean);
begin
//
end;

procedure TSimpleNotifier.FileNotification(NotifyCode: TOTAFileNotification;
  const FileName: string; var Cancel: Boolean);
var
  ProjModule: IOTAModule;
  Project: IOTAProject;
  BuildConfigs: IOTAProjectOptionsConfigurations;
  EnvOptions: IOTAEnvironmentOptions;
  Config: IOTABuildConfiguration;
  SearchPath, SearchPathConfig, SearchPathLib: string;
begin
  if (NotifyCode = ofnFileOpened) and
    {$IF COMPILERVERSION >= 22.0}
    (BorlandIDEServices as IOTAServices).IsProject(FileName)
    {$ELSE}
    SameText('.dproj', ExtractFileExt(FileName))
    {$IFEND}
  then
  begin
    ProjModule := (BorlandIDEServices as IOTAModuleServices).FindModule(FileName);
    if Supports(ProjModule, IOTAProject, Project) and
      Supports(Project.ProjectOptions, IOTAProjectOptionsConfigurations, BuildConfigs) then
    begin
      Config := BuildConfigs.BaseConfiguration;
      (BorlandIDEServices as IOTAMessageServices).AddTitleMessage(Format('Opened Project %s', [FileName]));
      SearchPathConfig := Config.Value[sUnitSearchPath];
      (BorlandIDEServices as IOTAMessageServices).AddTitleMessage(Format('  Base.SearchPath = %s', [SearchPathConfig]));
      EnvOptions := (BorlandIDEServices as IOTAServices).GetEnvironmentOptions;
      SearchPathLib := EnvOptions.Values['LibraryPath'];
      (BorlandIDEServices as IOTAMessageServices).AddTitleMessage(Format('  EnvironmentOptions.LibraryPath = %s', [SearchPathLib]));
      SearchPath := SearchPathConfig;
      if SearchPathLib <> '' then
      begin
        if SearchPath <> '' then
          SearchPath := SearchPath + ';';
        SearchPath := SearchPath + SearchPathLib;
      end;
      (BorlandIDEServices as IOTAMessageServices).AddTitleMessage(Format('  SearchPath = %s', [SearchPath]));
    end;
  end;
end;

initialization

finalization
  if NotifierIndex <> -1 then
    (BorlandIDEServices as IOTAServices).RemoveNotifier(NotifierIndex);

end.

Zitat von himitsu:

Schön wäre es auch, wenn man die ToolsAPI.pas wieder kompilieren könnte, ohne rumgeeiere, wie fehlende Suchpfade und die blöde immernoch fehlende Unit DockForm.

Package Designide einbinden und spätestens wenn Du INTA Interfaces benutzen willst musst Du ohnehin mit Packages compilieren.

Zitat von himitsu:

Ich glaub Emba will um jeden Preis verhindern, daß man Schwächen in der IDE selber ausbessert oder sonstwas darin veranstaltet.

Das schließt Du nochmal wo heraus?

[himitsu]

Zitat von USchuster:

Das schließt Du nochmal wo heraus?

Weil ich das ständig vergesse und man doch schon ein kleines Weilchen nach dieser info suchen muß.

Warum fehlen diese Units überhaupt?
Und weshalb steht nirgends in den ToolsAPI-Units, daß man diese nicht direkt nutzen kann, sonstern dieses Package einbinden muß?
und weil es von Emba doch eigentlich keine ordentliche Doku dazu gibt? (mir kommt es so vor, als wenn die meisten Infos von irgendwelchen Läuten durch Probieren rausgefunden wurden)

[Stevie]

Zitat von himitsu:

Zitat von USchuster:

Das schließt Du nochmal wo heraus?

Weil ich das ständig vergesse und man doch schon ein kleines Weilchen nach dieser info suchen muß.

Warum fehlen diese Units überhaupt?
Und weshalb steht nirgends in den ToolsAPI-Units, daß man diese nicht direkt nutzen kann, sonstern dieses Package einbinden muß?
und weil es von Emba doch eigentlich keine ordentliche Doku dazu gibt? (mir kommt es so vor, als wenn die meisten Infos von irgendwelchen Läuten durch Probieren rausgefunden wurden)

Wer lesen kann, ist klar im Vorteil - aber einfach mal rummaulen und auf Emba schimpfen ist einfacher, gell? Und nein, ich bin auch nicht immer mit allem einverstanden, was die machen.

[USchuster]

Zitat von himitsu:

Zitat von USchuster:

Das schließt Du nochmal wo heraus?

Weil ich das ständig vergesse und man doch schon ein kleines Weilchen nach dieser info suchen muß.

Gut. Ich dachte nämlich an meiner Denke - das AddOns die IDE aufwerten und Embarcadero froh darüber sein kann - ist was falsch.

Zitat von himitsu:

Warum fehlen diese Units überhaupt?

Weil die Units im Verzeichnis $(BDS)\source\ToolsAPI nur zur Dokumentation gedacht sind und sich einige Units aus Designgründen im DesignIDE Package befinden, aber Embarcadero diese nicht unbedingt zur Verwendung freigeben möchte. Mit Hilfe eines DockForm Stubbs konnte und kann man dockbare Fenster für die IDE erzeugen, jedoch gibt es seit Delphi 2010 für diesen Anwendungsfall INTACustomDockableForm in ToolsAPI.

Zitat von himitsu:

Und weshalb steht nirgends in den ToolsAPI-Units, daß man diese nicht direkt nutzen kann, sonstern dieses Package einbinden muß?

Info steht unter dem schon von Stevie angegebenen Link

Zitat von himitsu:

und weil es von Emba doch eigentlich keine ordentliche Doku dazu gibt? (mir kommt es so vor, als wenn die meisten Infos von irgendwelchen Läuten durch Probieren rausgefunden wurden)

Eine sehr beschränke Doku gibt es unter o.g. Link. Eine OTA Doku war mal im Rahmen des Projekts Chromium geplant, jedoch steht die Doku aktuell nicht mehr in der Roadmap. Die beste Doku ist die ToolsAPI Unit selbst. Die neueren Sachen sind ausreichend dokumentiert. Wenn man das Prinzip einmal verstanden hat, dann gehts eigentlich auch ohne Doku und finden tue ich eigentlich nicht die Infos, sondern die Bugs. Selbst wenn die OTA komplett dokumentiert würde, dann wäre die Hilfe noch lange kein Expertensystem, welches Dir sagt welches Interfaces und deren Methoden Du wie verwenden musst, damit genau das herauskommt was Du willst.