ApplicationModeController – Programme mit Benutzeroberfläche und Konsole anzeigen

Es ist möglich ein Programm so zu gestalten das es in drei „Darstellungen“ angezeigt bzw. verwendet werden kann. Benutzeroberfläche, Konsole oder beides. Dafür hab ich die Klasse TApplicationModeController geschrieben.

Download UnitDownload Demo-ProgrammDownload Code vom Demo-Programm

Die Anwendung ist ganz einfach. Einfach die Unit einem Delphi-Projekt hinzufügen und dann die DPR-Datei wie folgt abändern:

program SampleProgram;
{ --------------------------------------------------------------------------
  Die Units SysUtils, Classes, Forms und
  ApplicationModeController müssen immer eingebunden werden!
  ---------------------------------------------------------------------------}
 
uses
  SysUtils,
  Classes,
  Forms,
  Main in 'Main.pas' {frmMain},
  Second in 'Second.pas' {frmSecond},
  ApplicationModeController in 'ApplicationModeController.pas';
 
{ --------------------------------------------------------------------------
  Stellen Sie sicher das dieser Compiler-Schalter
  immer definiert ist!
  ---------------------------------------------------------------------------}
 
{$Apptype Console}
 
{$R *.res}
 
procedure DoRunGUI(Self, Sender: TObject);
begin
  Application.MainFormOnTaskbar := True;
  Application.CreateForm(TfrmMain, frmMain);
  Application.CreateForm(TfrmSecond, frmSecond);
end;
 
procedure DoRunConsole(Self, Sender: TObject);
begin
  // Irgendetwas machen...
end;
 
procedure DoRunBoth(Self, Sender: TObject);
begin
  // Beide Codes ausführen
  DoRunGUI(Self, Sender);
  DoRunConsole(Self, Sender);
end;
 
var
  ApplicationModeController: TApplicationModeController;
  RunCodeMethod: TMethod;
begin
  // Klasse erstellen
  ApplicationModeController := TApplicationModeController.Create;
  try
    { --------------------------------------------------------------------------
      Nach folgend muss definiert werden wie das Programm gestartet werden soll.
      Sie müssen der Eigenschaft "ApplicationMode" einen Wert zuweisen.
 
      Es gibt folgende Optionen:
        - Benutzeroberfläche:       amGUI
        - Kommandozeile:            amConsole
        - Kombination aus Beiden:   amBoth
 
      Der Standard ist die Benutzeroberfläche bzw. "amGUI".
      Wenn Sie eine GUI-Anwendung haben möchten müssen sie der Eigenschaft nichts
      zuweisen. Als Beispiel wird hier trotzdem der Wert zugewiesen.
    ---------------------------------------------------------------------------}
 
    ApplicationModeController.ApplicationMode := amGUI;
 
    { --------------------------------------------------------------------------
      Nun werden die Parameter ausgewertet (die der Anwendung übergeben wurden)
      um den App-Modus festzulegen (Konsole oder Beides). Wird keiner dieser
      Parameter übergeben wird der Standard-Wert (siehe oben) verwendet.
    ---------------------------------------------------------------------------}
 
    if ParamStr(1) = '/console' then
      ApplicationModeController.ApplicationMode := amConsole
    else if ParamStr(1) = '/both' then
      ApplicationModeController.ApplicationMode := amBoth;
 
    { --------------------------------------------------------------------------
      Jetzt muss der Code festgelegt werden der je nach festgelegten Modus
      ausgeführt wird. Man deiniert eine lokale Procedure (siehe oben) und
      weißt sie mittels TMethod und einem Hard-Cast auf TNotifyEvent zu.
    ---------------------------------------------------------------------------}
 
    // Benutzeroberfläche
    RunCodeMethod.Data := nil;
    RunCodeMethod.Code := @DoRunGUI;
    ApplicationModeController.OnRunGUI := TNotifyEvent(RunCodeMethod);
 
    // Konsole
    RunCodeMethod.Data := nil;
    RunCodeMethod.Code := @DoRunConsole;
    ApplicationModeController.OnRunConsole := TNotifyEvent(RunCodeMethod);
 
    // Konsole + Benutzeroberfläche
    RunCodeMethod.Data := nil;
    RunCodeMethod.Code := @DoRunBoth;
    ApplicationModeController.OnRunBoth := TNotifyEvent(RunCodeMethod);
 
    // Jetzt muss das Programm nur noch gestartet werden
    ApplicationModeController.Run;
 
    // z. B. abschließende arbeiten durchfühern
    if (ApplicationModeController.ApplicationMode = amConsole) or (ApplicationModeController.ApplicationMode = amBoth) then
      Writeln('Ende!');
  finally
    // Zu guter letzt wird noch der Speicher freigegeben und fertig
    FreeAndNil(ApplicationModeController);
  end;
end.

Das war es schon. Jetzt kann man innerhalb des Programms z. B. „Writeln“ ausführen (geht aber nur bei „ApplicationMode := amBoth bzw. amConsole“.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.