TAction — ein Befehl für mehrere Bedienelemente

Ein Befehl: Beschriftung, Hinweis, Tastenkürzel, Zustand und Handler an einer Stelle — und beliebig viele Bedienelemente, die ihn auslösen. Menüeintrag, Knopf und Werkzeugknopf zeigen dann dieselbe Sache und werden gemeinsam gesperrt.

Unit: vega.actions · Basis: keine — eigene Wurzel

→ Alle Steuerelemente · Klassenbaum · Guide: Komponenten

Vererbung

Kette: TAction — eigene Wurzel, kein Vorfahr. Was diese Klasse kann, steht vollständig auf dieser Seite.

Direkte Nachfahren: keine — diese Klasse wird nicht weiter abgeleitet.

Quelle: vega/actions.lyx

Verwendung

Ein Befehl wird an einer TActionList angelegt und dann mit den Bedienelementen verknüpft, die ihn auslösen:

var al: TActionList := new TActionList();

var a: TAction := al.Add("Speichern");
a.SetHint("Schreibt die Datei");
a.SetShortcut(KEY_S, MOD_CTRL);
a.OnExecute := Speichern;
a.OnUpdate  := SpeichernPruefen;

a.LinkMenuItem(miSpeichern);     // Menueeintrag
a.LinkControl(btnSpeichern);     // Knopf
a.LinkControl(tbSpeichern);      // Werkzeugknopf

// Im Update-Handler nur den Zustand setzen, nichts tun:
fn SpeichernPruefen(sender: TAction): void {
    sender.SetEnabled(g_geaendert);
}

Ab hier schlägt jede Änderung am Befehl auf alle verknüpften Elemente durch, und ein Klick — gleich wo — führt denselben Handler aus.

Besonderheiten

Das Problem, das TAction löst: Sobald „Speichern„ im Menü, in der Werkzeugleiste und auf einem Knopf angeboten wird, steht dieselbe Sache dreimal im Code — dreimal die Beschriftung, dreimal der Hinweis, dreimal das Sperren. Beim vierten Mal vergisst man eine Stelle. Mit einem Befehl gibt es die Sache einmal, die Bedienelemente sind nur noch Ansichten darauf.
OnUpdate läuft im Leerlauf, wie in Delphi: TApplication ruft UpdateActions in jedem Schleifendurchlauf. Der Handler gehört deshalb schlank gehalten — er setzt Zustand (SetEnabled, SetChecked), er arbeitet nicht.
Apply zieht den Zustand sofort nach, wenn man nicht bis zum nächsten Leerlauf warten will.
Tastenkürzel werden durchgereicht an verknüpfte Menüeinträge — die Menüleiste prüft sie ohnehin.
Verknüpfen ist zweiseitig: LinkControl / UnlinkControl für Steuerelemente, LinkMenuItem / UnlinkMenuItem für Menüeinträge. Wer ein Element zerstört, löst die Verknüpfung vorher.

Eigenschaften

Alle Eigenschaften, auch die geerbten.

Name	Typ	Bedeutung	Herkunft
`Caption`	TTextBuffer	Beschriftung	eigen
`Checked`	bool	Angehakt	eigen
`Enabled`	bool	Nimmt Eingaben an	eigen
`Hint`	TTextBuffer	Hinweistext	eigen
`ImageIndex`	int64	Fuer später: die Nummer im Symbolsatz. Wird schon jetzt an Clients weitergegeben, sobald diese ein solches Feld haben	eigen
`Name`	TTextBuffer	Name der Komponente — für `FindComponent` und beim Laden aus LFM	eigen
`ShortcutKey`	int64	Tastenkuerzel. Wird an verknuepfte Menueeintraege durchgereicht — die Menueleiste prüft sie ohnehin schon	eigen
`ShortcutMods`	int64	Umschalter des Tastenkürzels	eigen
`Tag`	int64	Freier Wert für eigene Zwecke; die Bibliothek fasst ihn nicht an	eigen
`Visible`	bool	Wird gezeichnet	eigen

Methoden

Alle Methoden, auch die geerbten.

Signatur	Zweck	Herkunft
`Apply(): void`	Überträgt Beschriftung, Hinweis und Zustand sofort auf alle verknüpften Elemente	eigen
`ControlAt(i: int64): TControl`	Verknüpftes Steuerelement Nummer `i`	eigen
`ControlCount(): int64`	Zahl der verknüpften Steuerelemente	eigen
`Create(caption: pchar): void`	Anlegen; `new TAction()`	eigen
`Destroy(): void`	Gibt eigene Ressourcen frei	eigen
`Execute(): bool`	Liefert false, wenn der Befehl gesperrt ist oder gar keinen Handler hat — dann ist nichts passiert, und der Aufrufer weiß es	eigen
`ItemAt(i: int64): TMenuItem`	Verknüpfter Menüeintrag Nummer `i`	eigen
`ItemCount(): int64`	Zahl der verknüpften Menüeinträge	eigen
`LinkControl(c: TControl): void`	Ein Bedienelement anhaengen. Es bekommt sofort den aktuellen Zustand und ab da jede Änderung. Der Klick laeuft über OnClick — ein vorher gesetzter eigener Handler wird dabei ersetzt. Das …	eigen
`LinkMenuItem(m: TMenuItem): void`	Verknüpft einen Menüeintrag	eigen
`SetCaption(s: pchar): void`	Setzt `Caption`	eigen
`SetChecked(v: bool): void`	Setzt `Checked`	eigen
`SetEnabled(v: bool): void`	Setzt `Enabled`	eigen
`SetHint(s: pchar): void`	Setzt `Hint`	eigen
`SetImageIndex(i: int64): void`	Setzt `ImageIndex`	eigen
`SetName(s: pchar): void`	Setzt `Name`	eigen
`SetShortcut(key: int64, mods: int64): void`	Setzt Taste und Umschalter des Kürzels	eigen
`SetVisible(v: bool): void`	Setzt `Visible`	eigen
`ToggleChecked(): void`	Kippt `Checked`	eigen
`UnlinkControl(c: TControl): void`	Löst die Verknüpfung	eigen
`UnlinkMenuItem(m: TMenuItem): void`	Löst die Verknüpfung	eigen
`Update(): void`	Den Zustand prüfen lassen und danach verteilen. Ruft TActionList	eigen

Ereignisse

Name	Typ	Wann	Herkunft
`OnExecute`	TActionEvent	Der Befehl wurde ausgelöst — hier steht die eigentliche Arbeit	eigen
`OnUpdate`	TActionEvent	Im Leerlauf, um den Zustand nachzuziehen — hier nur `SetEnabled` und Verwandtes	eigen

Letzte Aktualisierung: 2026-09-05 — Seite neu angelegt; erhoben aus vega/actions.lyx im Repo lyx-vcl.