GUI mit Commandline Parametern

[hubblec4]

Hallo an alle

Ich habe eine GUI geschrieben und würde dieser zusätzlich gerne noch Commandline Optionen hinzufügen.

Ist das machbar das eine GUI auch ein CLI-teilbesitzt und je nachdemwieman die MYGUI.exe aufruft eben die normale GUIstartet oder eben das Konsolenfenster?

Was genau muss ich im Quellcode da einrichten?

Wenn ich ein neues Projekt erstelle kann ich anfangs ja auswählen obs ne GUI oder ein Konsolenprogramm wird.

Ich habe zum testen mal ein Kosolenprogramm erstellt und angefangen etwas "rumzuspielen". Ich bin da noch etwas neuling auf dem gebiet.

LG
Hubble

[Philos]

Der Teil mit der GUI passiert in der .lpr-Datei. Wenn du weißt oder herausfindest, wie du die Kommandozeilenparameter auswertest,
sollte das für dich der richtige Ansatzpunkt sein

[hubblec4]

hi Philos

der tipp mit der .lpr ist schonmal gut. jetzt weis ich wo der quellcode hinkommt.

allerdings fehlt mir da noch einiges an wissen.

meine .lpr sieht wie folgt aus:

Code: Alles auswählen

program chapterEditor;
 
{$mode objfpc}{$H+}
 
uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Interfaces, // this includes the LCL widgetset
  Forms, Unit1, runtimetypeinfocontrols, Unit2, bluray_mpls, dreiGPP_TTXT, 
Sprache_Hilfe, multiAVCHD, OGG, XML, Multi_Kapitel, 
Multi_Versionen
  { you can add units after this };
 
{$R *.res}
 
begin
  Application.Title:='chapterEditor';
  RequireDerivedFormResource := True;
  Application.Initialize;
  Application.CreateForm(TForm1, Form1);
  Application.CreateForm(TForm2, Form2);
  Application.CreateForm(TForm3, Form3);
  Application.CreateForm(TF_MultiKap, F_MultiKap);
  Application.Run;
end.

in einem neuen/leeren Konsolenprogramm steht folgendes drin:

Code: Alles auswählen

program test;
 
{$mode objfpc}{$H+}
 
uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Classes, SysUtils, CustApp
  { you can add units after this };
 
type
 
  { TMyApplication }
 
  TMyApplication = class(TCustomApplication)
  protected
    procedure DoRun; override;
  public
    constructor Create(TheOwner: TComponent); override;
    destructor Destroy; override;
    procedure WriteHelp; virtual;
  end;
 
{ TMyApplication }
 
procedure TMyApplication.DoRun;
var
  ErrorMsg: String;
begin
  // quick check parameters
  ErrorMsg:=CheckOptions('h','help');
  if ErrorMsg<>'' then begin
    ShowException(Exception.Create(ErrorMsg));
    Terminate;
    Exit;
  end;
 
  // parse parameters
  if HasOption('h','help') then begin
    WriteHelp;
    Terminate;
    Exit;
  end;
 
  { add your program here }
 
  // stop program loop
  Terminate;
end;
 
constructor TMyApplication.Create(TheOwner: TComponent);
begin
  inherited Create(TheOwner);
  StopOnException:=True;
end;
 
destructor TMyApplication.Destroy;
begin
  inherited Destroy;
end;
 
procedure TMyApplication.WriteHelp;
begin
  { add your help code here }
  writeln('Usage: ',ExeName,' -h');
end;
 
var
  Application: TMyApplication;
begin
  Application:=TMyApplication.Create(nil);
  Application.Title:='My Application';
  Application.Run;
  Application.Free;
end.

ich habe es geschafft einen weiteren parameter zu "generieren" in dem ich bei

Code: Alles auswählen

 
CheckOptions('h','help');

das ganze mit einem "t" erweiter habe:

Code: Alles auswählen

CheckOptions('h:t','help');

mit HasOption konnte ich dann draufzugreifen auf "t".

hinter das "help" hatte ich auch mal "test" geschrieben. beide varianten funktionierten.

exakt verstehe ich das verhalten von den beiden worten/werten noch nicht.
hat das irgendwas mit "kurz" und "lang" variable zu tun??


was ich jetzt nicht weis ist, wie ich den "neuen/leeren" code sinnvoll in meiner .lpr einbinde. also welche teile davon. einiges steht ja schon da.

LG
hubble

[Philos]

ja hat es Hier ist es ganz gut beschrieben: http://wiki.freepascal.org/Command_line ... _variables. Du kannst einer Option also sowohl eine kurze als auch eine lange Schreibweise zuordnen oder auch nicht, ganz wie du willst
Letztendlich musst du jetzt nur noch Codebeispiel 1 und 2 verbinden. Du fragst über HasOption ab, ob das Prog. in der Kommandozeile laufen soll und startest dann entweder das KZ-Prog wie in Beispiel 2, andernfalls erstellst du die Application mit all den Forms wie im ersten Beispiel. Vom Prinzip klar geworden? Gemacht hab ich das auch noch nicht, hab also kein Beispiel da, das ich herzaubern kann

MfG, Philos

[Mathias]

Am einfachsten geht es so:

Code: Alles auswählen

procedure TForm1.Button1Click(Sender: TObject);
var
  s: string;
  i: integer;
begin
  s := '';
  for i := 0 to ParamCount do begin
    s := s + 'Parameter ' + IntToStr(i) + ': ' + ParamStr(i) + #10;
  end;
  ShowMessage( s);
end;           

Wobei ParamStr(0) den Pfad und Name der Exe zurückgibt.
ParamCount ist die Anzahl der Parameter.

[hubblec4]

danke für den link Philos,
jedes bissl text was ich dazu lesen kann hilft mir weiter.

also das grundprinzip ist mir klar, wenn auch noch nicht in vollem umfang.

mit HasOption abfragen ob die GUI.exe mit paramtern gestartet wurde: was ja fast nur sein kann wenn es von einer bat-datei oder der konsole selbst aus gestartet wurde.

ein doppelklick würde die GUI.exe starten aber keine parameter mitgeben.

ist das so richtig erkannt?

wenn dann HasOption parameter findet nur die konsole starten (oder kann man die dann auch unsichtbar starten?).

wo genau müsste das denn in meine .lpr rein kommen?

ich muss doch sicher auch noch die uses: CustApp einbinden oder?

Leider bietet das Lazarus Buch nicht viel hilfe zu diesem thema.

In den Projekteinstellungen habe ich den haken für die win32 Gui (-WG) mal testhalber entfernt. ok da geht dann gleich ein konsolenfenster mit auf.
weiter gebracht hat es mich aber noch nicht.

[Mathias]

wenn dann HasOption parameter findet nur die konsole starten (oder kann man die dann auch unsichtbar starten?).

Habe ich es richtig verstanden, du brauchst keine Konsolen-Ausgabe ? Unsichtbar währe einfacher.

was ja fast nur sein kann wenn es von einer bat-datei oder der konsole selbst aus gestartet wurde.

Du kannst bei Verküpfungen auf deine Exe auch Parameter mitgeben.

ich muss doch sicher auch noch die uses: CustApp einbinden oder?

Wen du mit Paramstr und ParamCount arbeitest brauchst das nicht.


Was willst du für Parameter übergeben ?

[hubblec4]

im prinzip müsste nicht unbedingt eine konsole angezeigt werden. würde das aber gerne als option (parameter) versehen wollen.

das mit der verknüpfung und den dortigen paramtern hatte ich übersehen. sollte aber nicht weiter ins gewicht fallen.

also nur HasOption braucht die CustApp uses?

Es werden sicher einige parameter werden. input, output, output-format, fps, (vll noch: namen), ein "versteckt-modus"(hide)
bin mir da noch nicht im klaren.

[hubblec4]

short options sind immer mit einem buchstaben (character) versehen.

wenn ich also bei HasOption(hf, help file) eingeben kann ich h oder f als parameter nutzen.

wenn ich aber einen parameter haben will der "fps" heist wie müsste ich das anstellen. also es soll nicht als lang-option verwendet werden.

[Philos]

short options sind immer mit einem buchstaben (character) versehen.

wenn ich also bei HasOption(hf, help file) eingeben kann ich h oder f also parameter nutzen.

wenn ich aber einen parameter haben will der "fps" heist wie müsste ich das anstellen. also es soll nicht als lang-option verwendet werden.

So wie ich das sehe so:

Code: Alles auswählen

if HasOption('' , 'fps') then ...

Oder wie stellst du dir das anders vor?

[hubblec4]

hi Philos

also hier würde ich sagen hat man einen parameter (oder eben keinen) "kurzen" parameter, dafür aber einen lang-paramter welcher dann mit
--fps
aufgerufen werden müsste.

Code: Alles auswählen

if HasOption('' , 'fps') then ...

aber es soll ein kurz-paramter sein der mit dem einfachen "-" eingeleitet wird.

als beispiel: ich nutze viel und oft eac3to. dort kann man ja auch verschieden lange "kurz-parameter" eingeben. zum beispiel: -10mb oder -core


oder sind das alles lang-parameter? aber warum haben sie nur ein "-" am anfang?

LG
Hubble

[Mathias]

als beispiel: ich nutze viel und oft eac3to. dort kann man ja auch verschieden lange "kurz-parameter" eingeben. zum beispiel: -10mb oder -core

oder sind das alles lang-parameter? aber warum haben sie nur ein "-" am anfang?

Das kommt darauf wie der Programmierer die Parameter bestimmt.

Unter linux gibt es meistens kurze und lange Parameter, das sieht man hier gut.

[Philos]

als Workaround könntest du ja auch einfach beim Lang-Parameter "-fps" eingeben.
Dann solltest du, so wie du es erzählt hast, ja am Ende "--fps" als Parameter erhalten.
Und wenn man den Strich weglässt, hast du halt '-fps'. Damit sollte doch jetzt alles funktionieren
( ohne dass ich es jemals ausprobiert hätte )

MfG, Philos

[hubblec4]

als Workaround könntest du ja auch einfach beim Lang-Parameter "-fps" eingeben.
Dann solltest du, so wie du es erzählt hast, ja am Ende "--fps" als Parameter erhalten.
Und wenn man den Strich weglässt, hast du halt '-fps'. Damit sollte doch jetzt alles funktionieren
( ohne dass ich es jemals ausprobiert hätte )

MfG, Philos

mmh würde ich jetzt als nicht richtig ansehen. als "lang-parameter" fps erzeugt doch schon --fps

dann hätte ich ja bei "-fps" dann ---fps.

oder liege ich da jetzt voll daneben.

[Michl]

Freepascal stellt mit Application.HasOption einen KurzOption ( -Char OptionWert ) und eine LangOption ( --String=OptionWert ) zur Verfügung.
Siehe Link von Philos: http://wiki.freepascal.org/Command_line ... _variables
oder http://www.freepascal.org/docs-html/fcl ... ption.html

Wenn Du etwas entgegen der Methodik von Application.HasOption machen willst, kannst Du Deine Parameter selber parsen (was anderes macht FPC mit HasOption im Prinzip auch nicht), siehe http://www.lazarusforum.de/viewtopic.php?p=70236#p70236

als beispiel: ich nutze viel und oft eac3to. dort kann man ja auch verschieden lange "kurz-parameter" eingeben. zum beispiel: -10mb oder -core

z.B.:

Code: Alles auswählen

procedure TForm1.FormCreate(Sender: TObject);
var
  i: Int32;
  s: String;
begin
  s:='';
  for i:=1 to Application.ParamCount do begin
    if Application.Params[i]='-10mb' then s:=s + 'Option: -10mb übergeben' + LineEnding;
    if Application.Params[i]='-core' then s:=s + 'Option: -core übergeben' + LineEnding;
  end;
  if Length(s) > 0 then ShowMessage(s);
end;