Grundlegendes Verständnis - Actions und deren Registrierung

[Hausmarke]

Hallo Leute,

ich versuche mich gerade in actions und deren Registrierung in ActionsLists zur Laufzeit einzuarbeiten.

Allerdings komme ich nur schwer voran.
Was Actions sind habe ich soweit verstanden und auch für was ActionLists gut sind.

und dann hörts auf :)
Wie kann ich die actions in der actionlist registrieren?
Bei "RegisterActions" komm ich nicht mit den AktionKlasseNamen zu recht.
Wie ich es verstehe gibt man dort die Namen der Actions an, die man jedoch wo und wie deklariert?

Gibt es hierfür ein gutes Tutorial was Ihr empfehlen könnt, oder kann mir es jemand kurz und prägnant erläutern?

ich danke schon mal im voraus

[Uwe Raabe]

RegisterActions ist nur für neue, von dir geschriebene Action-Klassen notwendig. Normalerweise brauchst du das nicht.

Eigentlich solltest du deine Actions in der IDE zur Designzeit anlegen. Dazu legst du eine ActionList auf das Formular oder Datenmodul und machst einen Doppelclick drauf. Dann kannst du deine Actions einfach anlegen und sie sind auch gleich in der passenden ActionList.

Solltest du auf irgendeine Art erst zur Laufzeit eine Action erzeugt haben, dann weise deren ActionList-Property einfach die gewünschte ActionList zu.

[sx2008]

Im Anhang ein Beispiel für eine Action-Klasse und wie diese mit

Delphi-Quellcode:

RegisterActions()

verankert wird.
Wenn du die Unit in ein Designtime-Package aufnimmst *), dann steht die neue Action für jede Anwendung zur Verfügung.

*) Eigentlich sollte der Code der Klasse in ein Runtime-Package und nur der

Delphi-Quellcode:

RegisterActions()

Aufruf in eine Designtime-Package.

[Uwe Raabe]

Zitat:

Zitat von Hausmarke (Beitrag 1219938)

ich versuche mich gerade in actions und deren Registrierung in ActionsLists zur Laufzeit einzuarbeiten.

Wie schon gesagt: Actions werden nicht in ActionLists registriert (im Sinne von RegisterActions).

Also nochmal die Frage: Willst du einfach nur zur Laufzeit eine Action erzeugen und in eine ActionList hinzufügen?

[Hausmarke]

@sx2008: besten Dank für das Beispiel :thumb: 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:

Zitat von Hausmarke (Beitrag 1220204)

@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:

Zitat von Hausmarke (Beitrag 1220223)

@ 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:

Zitat von Hausmarke (Beitrag 1220234)

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.