Einzelnen Beitrag anzeigen

nahpets
(Gast)

n/a Beiträge
 

Before- und Aftercompileexperte

  Alt 24. Mär 2009, 11:43
Hallo,

hier Aufbau & ToDo's für ein PlugIn-Setup für Delphi IDE und hier Post compile batch starten aus IDE? gabe es mal Fragen zu Delphi, die sich mit einem eigenen Experten lösen lassen könnten. Habe mich mal hingesetzt und mir einen Spielexperten für Before- und Aftercompile gebaut.

Das Grundgerüst des Experten habe ich mal, zur eigenen Erweiterung, reingestellt.

Das Grundgerüst enthält viele ShowMessage, um zu sehen, welche Methode des Experten wann aufgerufen wird. Dies macht die Arbeit mit der IDE nicht so ganz einfach, da auch beim CodeInsight die entsprechenden Methoden des Experten aufgerufen werden. Dies läßt sich aber durch entfernen des {$DEFINE Meckermodus} beheben.

Das Teil ist nicht perfekt, sondern soll nur zur Entwicklung eigener Ideen anregen.

Delphi-Quellcode:
{$DEFINE Meckermodus}
unit BeforeAfterCompileExperteUnit1;

interface

{$I-}

uses
  ToolsAPI;

Type
  TBeforeCompile = class(TNotifierObject, IOTAIDENotifier, IOTAIDENotifier50, IOTAWizard, IOTAMenuWizard)
  protected
    procedure AfterCompile(Succeeded: Boolean); overload;
    procedure AfterCompile(Succeeded: Boolean; IsCodeInsight: Boolean); overload;
    procedure BeforeCompile(const Project: IOTAProject; var Cancel: Boolean); overload;
    procedure BeforeCompile(const Project: IOTAProject; IsCodeInsight: Boolean; var Cancel: Boolean); overload;
    procedure FileNotification(NotifyCode: TOTAFileNotification; const FileName: string; var Cancel: Boolean);
  public
    function GetMenuText : string;
    function GetIDString : string;
    function GetName : string;
    function GetState : TWizardState;
    procedure Execute;
    constructor Create;
    function AddNotifier(const Notifier: IOTAIDENotifier50) : Integer;
    procedure RemoveNotifier(Index: Integer);
  end;

procedure Register;

implementation

uses
  SysUtils,
  Dialogs,
  Classes,
  ShellAPI;

Var
  // Die werden nicht alle gebraucht, sind nur hier, um zu sehen,
  // was es so gibt.
  MainServices : INTAServices;
  ActionServices : IOTAActionServices;
  CodeInsideServices : IOTACodeInsightServices;
  DebuggerServices : IOTADebuggerServices;
  EditorServices : IOTAEditorServices;
  KeyBindingServices : IOTAKeyBindingServices;
  KeyboardDiagnostics : IOTAKeyboardDiagnostics;
  KeyboardServices : IOTAKeyboardServices;
  MessageServices : IOTAMessageServices;
  ModuleServices : IOTAModuleServices;
  PackageServices : IOTAPackageServices;
  Services : IOTAServices;
  WizardServices : IOTAWizardServices;

  Index : Integer;

procedure Register;
begin
  RegisterPackageWizard(TBeforeCompile.create as IOTAWizard);
end;

procedure InitExpert;
begin
  MainServices := (BorlandIDEServices as INTAServices);
  ActionServices := (BorlandIDEServices as IOTAActionServices);
  CodeInsideServices := (BorlandIDEServices as IOTACodeInsightServices);
  DebuggerServices := (BorlandIDEServices as IOTADebuggerServices);
  EditorServices := (BorlandIDEServices as IOTAEditorServices);
  KeyBindingServices := (BorlandIDEServices as IOTAKeyBindingServices);
  KeyboardDiagnostics := (BorlandIDEServices as IOTAKeyboardDiagnostics);
  KeyboardServices := (BorlandIDEServices as IOTAKeyboardServices);
  MessageServices := (BorlandIDEServices as IOTAMessageServices);
  ModuleServices := (BorlandIDEServices as IOTAModuleServices);
  PackageServices := (BorlandIDEServices as IOTAPackageServices);
  Services := (BorlandIDEServices as IOTAServices);
  WizardServices := (BorlandIDEServices as IOTAWizardServices);
  Index := (BorlandIDEServices as IOTAServices).AddNotifier(TBeforeCompile.create);
end;

procedure DoneExpert;
begin
 (BorlandIDEServices as IOTAServices).RemoveNotifier(Index);
end;

procedure TBeforeCompile.AfterCompile(Succeeded: Boolean);
begin
{$IFDEF Meckermodus}
  ShowMessage('AfterCompile(Succeeded: Boolean) - AfterCompile(' + BoolToStr(Succeeded) + ')');
{$ENDIF}
end;

procedure TBeforeCompile.AfterCompile(Succeeded: Boolean; IsCodeInsight: Boolean);
var
   path : string;
   params : string;
begin
{$IFDEF Meckermodus}
  ShowMessage('AfterCompile(Succeeded: Boolean; IsCodeInsight: Boolean) - AfterCompile('
  + BoolToStr(Succeeded) + ';(' + BoolToStr(IsCodeInsight) + ')');
{$ENDIF}
  if not IsCodeInsight then begin
    // Hier kann man beliebige Aufgaben nach dem Kompilieren ausführen.
    path := 'cmd.exe'; // Die Konsole oder irgendein Programm aufrufen.
    params := '/C %temp%\AfterCompile.Bat'; // Die für das Programm erforderlichen Parameter.
    ShellAPI.ShellExecute(0,'open',PChar(path),PChar(params),nil,0);
  end;
end;

procedure TBeforeCompile.BeforeCompile(const Project: IOTAProject; var Cancel: Boolean);
begin
{$IFDEF Meckermodus}
  ShowMessage('BeforeCompile(const Project: IOTAProject; var Cancel: Boolean);'
  + #13 + 'BeforeCompile(' + Project.FileName + '; ' + BoolToStr(Cancel) + ');');
{$ENDIF}
end;

procedure TBeforeCompile.BeforeCompile(const Project: IOTAProject; IsCodeInsight: Boolean; var Cancel: Boolean);
Var
          sl : TStringList;
begin
{$IFDEF Meckermodus}
  ShowMessage('BeforeCompile(const Project: IOTAProject; IsCodeInsight: Boolean; var Cancel: Boolean);'
  + #13 + 'BeforeCompile(' + Project.FileName + '; ' + BoolToStr(IsCodeInsight) + '; ' + BoolToStr(Cancel) + ');');
{$ENDIF}
  if not IsCodeInsight then begin
    // Hier kann man beliebige Aufgaben vor dem Kompilieren ausführen.
    // Zum Beispiel eine Batchdatei erstellen, die von AfterCompile dann ausgeführt wird.
    sl := TStringList.Create;
    sl.Add('ECHO OFF');
    sl.Add('type ' + Project.FileName + ' > %temp%\type.txt');
    sl.SaveToFile(GetEnvironmentVariable('TEMP') + '\AfterCompile.Bat');
    sl.Free;
  End;
end;

procedure TBeforeCompile.FileNotification(NotifyCode: TOTAFileNotification; const FileName: string; var Cancel: Boolean);
begin
  //
end;

function TBeforeCompile.GetMenuText;
begin
  // Caption des Menüeintrages im Hilfemenü der IDE.
  result := 'TBeforeCompile';
end;

function TBeforeCompile.GetName;
begin
  result := 'TBeforeCompile';
end;

function TBeforeCompile.GetState;
begin
  result := [wsEnabled];
end;

function TBeforeCompile.GetIDString;
begin
  result := 'TBeforeCompile';
end;

Constructor TBeforeCompile.Create;
begin
  inherited;
end;

procedure TBeforeCompile.Execute;
begin
  ShowMessage('Das bekommen wir zu sehen, wenn wir im Hilfemenü auf TBefoeCompile klicken.');
end;

function TBeforeCompile.AddNotifier(const Notifier: IOTAIDENotifier50) : Integer;
begin
  Result := 0;
end;

procedure TBeforeCompile.RemoveNotifier(Index: Integer);
begin
  //
end;

initialization
  InitExpert;

finalization
  DoneExpert;

end.
Delphi-Quellcode:
package BeforeAfterCompileExperte;

{$R *.res}
{$ALIGN 8}
{$ASSERTIONS ON}
{$BOOLEVAL OFF}
{$DEBUGINFO ON}
{$EXTENDEDSYNTAX ON}
{$IMPORTEDDATA ON}
{$IOCHECKS ON}
{$LOCALSYMBOLS ON}
{$LONGSTRINGS ON}
{$OPENSTRINGS ON}
{$OPTIMIZATION ON}
{$OVERFLOWCHECKS OFF}
{$RANGECHECKS OFF}
{$REFERENCEINFO ON}
{$SAFEDIVIDE OFF}
{$STACKFRAMES OFF}
{$TYPEDADDRESS OFF}
{$VARSTRINGCHECKS ON}
{$WRITEABLECONST OFF}
{$MINENUMSIZE 1}
{$IMAGEBASE $400000}
{$DESCRIPTION 'Before- und Aftercompile-Experte'}
{$IMPLICITBUILD OFF}

requires
  rtl,
  vcl,
  designide,
  vclactnband,
  vclx;

contains
  BeforeAfterCompileExperteUnit1 in 'BeforeAfterCompileExperteUnit1.pas';

end.
  Mit Zitat antworten Zitat