Grundlegendes Verständnis - Actions und deren Registrierung

[Hausmarke]

@sx2008: besten Dank für das Beispiel so in etwa hatte ich es mir schon gedacht, aber leider kein konkretes Beispiel gefunden.

@U.Raabe:
mein Ziel ist es die Actions zur Laufzeit und damit dynamisch zur Actionlist hinzuzufügen.
Ich dachte dies nennt man registrieren.
Wie darf man das RegisterAction sonst verstehen? Wo werden die Actions Registriert wenn nicht in der ActionList?

[Uwe Raabe]

Zitat von Hausmarke:

@U.Raabe:
mein Ziel ist es die Actions zur Laufzeit und damit dynamisch zur Actionlist hinzuzufügen.
Ich dachte dies nennt man registrieren.
Wie darf man das RegisterAction sonst verstehen? Wo werden die Actions Registriert wenn nicht in der ActionList?

Man unterscheidet grundsätzlich zwischen einer TAction, bei der das OnUpdate und OnExecute als Event ausgeführt sind, die du in deinem Code wie bei einem OnClick-Event behandelts, und speziellen Actions, von denen man einige in StdActns.pas finden kann (z.B. TFileExit) und die für bestimmte Fälle ein vordefiniertes Verhalten implementieren. Alle diese Actions können zu ActionLists hinzugefügt werden. Das geschieht einfach durch Zuweisung der ActionList auf das entsprechende Property der Action.

Damit diese Actions aber im ActionListEditor der IDE auftauchen (das was aufgeht, wenn man in der IDE einen Doppelcklick auf die ActionList macht), müssen sie in der IDE mit RegisterActions registriert werden. RegisterActions brauchst du also nur, wenn du in einem DesignTime-Package für die IDE eine neue ActionKlasse registrieren willst. Zur Runtime brauchst du diese Funktion nicht.

Die Actions aus StdActions werden von den Delphi-Packages bereits registriert. Wenn du mal in der IDE auf eine ActionList doppelclickst und dann den DropDown-Pfeil beim "Neue Action"-Button anklickst, dann siehst du einen Menüpunkt "Neue Standardaktion". Dahinter verbirgt sich die Liste aller registrierten Standard-Aktionen. Je nach installierten Fremd-Komponenten sind das auch mal durchaus mehr als die Delphi-Standard-Actions.

Also: RegisterActions dient zum Registrieren neuer Aktions-Klassen in der IDE und ist nur zur Designzeit relevant. Das Hinzufügen einer TAction-Instanz zu einer ActionList geschieht durch Zuweisung des ActionList.Properties der TAction und wird zur Runtime durchgeführt, wenn die ActionList nicht (oder nur teilweise) schon im Designer gefüllt wurde.

[Hausmarke]

@ U. Raabe: ich denke ich habe es soweit verstanden.
Man registriert die Actions und findet diese dann zur Entwurfszeit im Dialog der ActionList wieder.
Dazu ein paar fragen: was ist wenn die ActionList auf einem anderen Formular bzw. in einer anderen Unit verankert ist?
Wie teile ich dies dem RegisterActions Aufruf mit?

Ich habe aktuell folgendes:

Delphi-Quellcode:

type
  TMyBaseAction = class (TCustomAction)
    private
      FCaption: string;
      procedure SetCaption(const Value: string);

    public
      property Caption: string read FCaption write SetCaption;
      constructor Create(AOwner: TComponent); virtual;
      procedure ExecuteTarget(Target: TObject); override;
      procedure UpdateTarget(Target: TObject); override;

  end;

  TBrowseAction = class(TMyBaseAction)
    private

    public
      constructor Create(AOwner: TComponent); override;
      procedure ExecuteTarget(Target: TObject); override;
      procedure UpdateTarget(Target: TObject); override;

  end;


implementation

uses MainFrm;


{ TMyBaseAction }

constructor TMyBaseAction.Create(AOwner: TComponent);
begin
  inherited;
  Caption := 'New Action';
end;


procedure TMyBaseAction.ExecuteTarget(Target: TObject);
begin
  inherited;

end;

procedure TMyBaseAction.SetCaption(const Value: string);
begin
  FCaption := Value;
end;


procedure TMyBaseAction.UpdateTarget(Target: TObject);
begin
  inherited;

end;


{ TBrowseAction }

constructor TBrowseAction.Create(AOwner: TComponent);
begin
  inherited;
end;

procedure TBrowseAction.ExecuteTarget(Target: TObject);
begin
  inherited;
  showmessage('Execute');
end;

procedure TBrowseAction.UpdateTarget(Target: TObject);
begin
  inherited;
  showmessage('update');
end;

initialization
  RegisterActions('Datei', [TMyBaseAction], nil);

end.

,

Beim Ausführen schmeißt es mir die Exception 'Ungültige Aktionsregistrierung' entgegen.

Was mache ich falsch?

[Uwe Raabe]

Zitat von Hausmarke:

@ U. Raabe: ich denke ich habe es soweit verstanden.
Man registriert die Actions und findet diese dann zur Entwurfszeit im Dialog der ActionList wieder.
Dazu ein paar fragen: was ist wenn die ActionList auf einem anderen Formular bzw. in einer anderen Unit verankert ist?
Wie teile ich dies dem RegisterActions Aufruf mit?

Deine Frage macht für mich keinen Sinn. Vielleicht beschreibst du einfach mal was du genau erreichen willst.

[Hausmarke]

Mein Ziel ist es, eigene Actions in der ActionList zu registrieren.
Mir ist bekannt das ich diese zur Laufzeit mit der property "ActionList" meiner gewünschten ActionList hinzufügen kann.

Dies gehört zu einer Aufgabenstellung, welche als Ziel die Registrierung der Action in einer ActionList beinhaltet.


Meine zuletzt gestellten fragen beziehen sich dabei auf meine Beobachtung.
Die Registrierung der Action schlug fehl. Anschließend stellte sich mir die Frage in welche ActionList die Registrierung erfolgt bzw. woher der Compiler wissen soll welche ActionList gemeint ist.
Das sind für wissende möglicherweise nicht nachvollziehbare fragen. Ich würde mich dennoch freuen wenn jemand den Nerv hat mir dies zu erklären.

Vielen Dank

[Uwe Raabe]

Zitat von Hausmarke:

Mein Ziel ist es, eigene Actions in der ActionList zu registrieren.
Mir ist bekannt das ich diese zur Laufzeit mit der property "ActionList" meiner gewünschten ActionList hinzufügen kann.

Dies gehört zu einer Aufgabenstellung, welche als Ziel die Registrierung der Action in einer ActionList beinhaltet.


Meine zuletzt gestellten fragen beziehen sich dabei auf meine Beobachtung.
Die Registrierung der Action schlug fehl. Anschließend stellte sich mir die Frage in welche ActionList die Registrierung erfolgt bzw. woher der Compiler wissen soll welche ActionList gemeint ist.
Das sind für wissende möglicherweise nicht nachvollziehbare fragen. Ich würde mich dennoch freuen wenn jemand den Nerv hat mir dies zu erklären.

Vielen Dank

Tut mir Leid das sagen zu müssen, aber du hast es offenbar doch noch nicht ganz verstanden. Ich habe auch langsam den Eindruck, daß das sicher gut gemeinte Beispiel von sx2008 dich eher in die falsche Richtung gelockt hat. Dort wird nämlich keine Action in einer ActionList registriert, sondern vielmehr eine neuartige Action in der IDE registriert (wobei die Funktionalität erstmal egal ist).

Verabschieden wir uns doch bitte mal von der Formulierung eine Action in einer ActionList registrieren, da der Begriff eine Action registrieren schon für einen anderen Vorgang reserviert ist. Eine ActionList enthält getreu ihres Namens eine Liste von Actions. Man kann nun Actions zu dieser ActionList hinzufügen oder daraus entfernen.

Ich kann anhand deiner Beispiele leider auch nicht nachvollziehen, warum du überhaupt eigene Action-Klassen schreibst anstatt einfach eine normale TAction zu verwenden. Zwar ist der gängig Weg eine Action zu erzeugen der, diese in der IDE über den ActionList-Editor anzulegen, aber es geht natürlich auch zur Laufzeit über TAction.Create und anschließendes Setzen des ActionList-Properties.

Hier mal etwas Code:

Delphi-Quellcode:

var
  act: TAction;
begin
  act := TAction.Create(Self);        // oder ein anderer geeigneter Owner
  act.Caption := 'Beispiel';
  act.Hint := 'Dies ist ein Beispiel';
  act.ImageIndex := 42;               // Diese drei Properties lassen sich auch im OnUpdate dynamisch ändern
  act.OnExecute := MyActionExecute;   // hier den passenden Exedcute-Event-Handler zuweisen
  act.OnUpdate := MyActionUpdate;     // und den Update-Event-Handler
  act.ActionList := MyActionList;     // und hier die passende ActionList
end;

Danach enthält MyActionList die so erzeugte Action, was ja dein eigentliches Ziel sein sollte, wenn ich dich nicht völlig falsch verstanden habe.

Das obige Beispiel kann natürlich auch für andere Action-Klassen als TAction angewandt werden, wobei dort eventuell die Event-Handler nicht gebraucht werden und womöglich andere Properties gesetzt werden müssen.

[Hausmarke]

ja ich denke die Aussage "eine Action in einer ActionList zu registrieren" hat mich auf eine falsche Fährte gelockt. Was ich mittlerweile verstanden habe.

Die Action einer Actionlist zuzuordnen ist wie erwähnt kein Problem, auch das erzeugen der Action zur Laufzeit ist nicht das Problem.
Aber wie ich erkenne, ist dies wohl auch nicht das Ziel...wäre ja auch zu einfach gewesen....
Mir wurde gesagt ich soll die Actions Registrieren, da ich bis dahin keine Ahnung von Actions hatte, ging ich davon aus, das dies die Verknüpfung mit einer ActionList bedeutet. Okay, das ist falsch.

Wie ich deiner Antwort entnehme, an dieser Stelle vielen dank für deine Geduld, registriert man eigene Actionen in der IDE.
Wobei ich den Vorteil bzw. den Zweck dahinter noch nicht verstehe.
Mein Beispiel bezog sich nur auf die reine Handhabung, und hatte keine tiefere Funktionalität.

Wenn ich das richtig verstanden habe:
Das Beispiel von sx2008 implementiert die Aktion "Print Windows", was quasi den Drucken Dialog aufruft. Das ganze ist auch via shortcut F3 auszuführen.
Wäre diese Action nicht auch ohne Registrierung lauffähig und wie folgt umsetzbar:

Delphi-Quellcode:

var
  act: TAction;
begin
  act := TAction.Create(Self); 
  act.Caption := 'Print Window';
  act.Hint := 'Drucken';
  act.ImageIndex := 42; 
  act.OnExecute := MyWindowPrintExecute; //    GetForm(Target).Print; - in OnExecute implementieren
  act.OnUpdate := MyWindowPrintUpdate; //  
  act.ActionList := MyActionList; // und hier die passende ActionList
end;