TControl — die gemeinsame Grundlage

Jedes Steuerelement in Vega erbt von TControl. Was hier steht, gilt deshalb für alle — die Detailseiten der einzelnen Controls führen nur noch auf, was dazukommt.

→ Alle Steuerelemente · Guide: Eigenschaften · Guide: Ereignisse

Unit: Vega.Control · Basis: TComponent

Einordnung

TControl ist gleichzeitig Basisklasse und Container: Es hält Kinder, kennt seine Geometrie, zeichnet sich und verteilt Ereignisse. Ein Element ohne eigene Darstellung (new TControl()) taugt als reiner Container — genau so werden Leisten und Spalten gebaut.

Darüber liegt seit dem Komponenten-Split TComponent: von dort kommen Owner, Name, Tag, ComponentState und die Besitzverwaltung. Die Trennlinie verläuft am Zeichnen — was nie malt, sondern nur hält oder tickt (TTimer, TImageList), hängt direkt an TComponent.

Verwendung

var c: TControl := new TControl();     // roher Container
c.Height := 32;
c.Align := AL_BOTTOM;
c.SetParent(f);

var b: TButton := new TButton("OK");   // jedes Control kann dasselbe
b.SetBounds(8, 4, 100, 24);
b.Tag := 1;
b.SetHint("Übernimmt die Eingabe");
b.OnClick := OnOk;
b.SetParent(c);

Besonderheiten

Setter zeichnen neu, Felder nicht. c.Left := 20 verschiebt ohne Neuzeichnen, c.SetLeft(20) zeichnet neu. Die Felder bleiben öffentlich lesbar — für Berechnungen ist der direkte Zugriff richtig.
BeginUpdate()/EndUpdate() fasst mehrere Änderungen zu einem Neuzeichnen zusammen.
Parent ist die zeichnerische Verschachtelung, Owner die logische Zugehörigkeit (meist das Formular) — bei Handlern der Weg zurück zum Fenster. Owner ist seit dem Komponenten-Split ein TComponent; OwnerControl() liefert ihn ohne Umwandlung von Hand als TControl. AddChild reicht den Besitzer nach unten durch, trägt das Kind aber nicht in OwnedComponents ein — siehe TComponent.
Align schlägt Left/Top/Width/Height. Ein ausgerichtetes Kind bekommt seine Geometrie vom Layout.
Font ist ein Zeiger, keine Kopie: mehrere Controls teilen sich dieselbe Schrift. 0 heißt „die des Elternteils„.

Eigenschaften

Alle Eigenschaften, auch die geerbten.

Name	Typ	Bedeutung	Herkunft
`Parent`	TControl	Zeichnerisches Elternteil	eigen
`Children`	TObjectList	Kinder	eigen
`ChildCount`	int64	Anzahl der Kinder	eigen
`Left`	int64	Position relativ zum Elternteil	eigen
`Top`	int64	Position relativ zum Elternteil	eigen
`Width`	int64	Breite	eigen
`Height`	int64	Höhe	eigen
`Visible`	bool	Wird gezeichnet und nimmt am Layout teil	eigen
`Enabled`	bool	Nimmt Eingaben an	eigen
`Focused`	bool	Hat den Tastaturfokus (nur lesen)	eigen
`Hovered`	bool	Zeiger steht darüber	eigen
`Pressed`	bool	Maustaste ist gedrückt	eigen
`CanFocus`	bool	Kann den Fokus überhaupt bekommen	eigen
`Align`	int64	Ausrichtung: `AL_NONE` (0), `AL_TOP` (1), `AL_BOTTOM` (2), `AL_LEFT` (3), `AL_RIGHT` (4), `AL_CLIENT` (5)	eigen
`Anchors`	int64	Bitmaske: `ANCHOR_LEFT` (1), `ANCHOR_TOP` (2), `ANCHOR_RIGHT` (4), `ANCHOR_BOTTOM` (8)	eigen
`Font`	TFont	Eigene Schrift oder `0` = die des Elternteils (Zeiger, keine Kopie)	eigen
`Cursor`	int64	Mauszeiger (`CUR_*`); `CUR_DEFAULT` erbt vom Elternteil	eigen
`TabStop`	bool	Wird per Tabulator angesteuert	eigen
`TabOrder`	int64	Reihenfolge beim Tabulator	eigen
`HelpType`	int64	Art der Hilfeanbindung	eigen
`HelpContext`	int64	Hilfekennung	eigen
`HelpKeyword`	pchar	Hilfestichwort	eigen
`BorderWidth`	int64	Abstand zwischen Rand und Kindern	eigen
`AutoSize`	bool	Größe aus dem Inhalt ableiten	eigen
`MinWidth`	int64	Kleinste Breite; `0` = keine Grenze	eigen
`MinHeight`	int64	Kleinste Höhe; `0` = keine Grenze	eigen
`MaxWidth`	int64	Größte Breite; `0` = keine Grenze	eigen
`MaxHeight`	int64	Größte Höhe; `0` = keine Grenze	eigen
`DragMode`	int64	`DM_MANUAL` (0), `DM_AUTOMATIC` (1)	eigen
`PopupMenuPtr`	int64	Kontextmenü (`TPopupMenu` als Zahl)	eigen
`ActionPtr`	int64	Verknüpfter Befehl (`TAction`)	eigen
`Hint`	pchar	Kurztext	eigen
`ShowHint`	bool	Kurztext anzeigen — wirkt auch auf Kinder	eigen
`Caption`	pchar	Beschriftung — hält nur den Zeiger, keine Kopie	eigen
`Dirty`	bool	Neuzeichnen steht aus	eigen
`AutoRepaint`	bool	Nach Änderungen selbst neu zeichnen	eigen
`PendingRepaint`	bool	Neuzeichnen ist angefordert	eigen
`Color`	TColor	Grundfarbe, sofern das Theme nichts vorgibt	eigen
`Theme`	TTheme	Eigenes Theme statt des voreingestellten	eigen
`StyleType`	int64	Typnummer im Stylesheet	eigen
`StyleRole`	int64	Rolle im Stylesheet (`SetRole`)	eigen
`StyleClasses`	TIntArray	Stilklassen	eigen
`StyleClassCount`	int64	Zahl der Stilklassen	eigen
`ExplicitStyle`	TStyleSet	Werte, die den Themewechsel überleben	eigen
`ScopeStyle`	TStyleSheet	Stylesheet für diesen Teilbaum	eigen
`Owner`	TComponent	Wer diese Komponente wegräumt — nicht das Elternteil im Zeichenbaum	TComponent
`OwnedComponents`	TObjectList	Die Komponenten, die dieser gehören (Delphis `Components[]`)	TComponent
`Name`	pchar	Name der Komponente, für `FindComponent` und Formulardateien	TComponent
`Tag`	int64	Freier Wert für die Anwendung	TComponent
`ComponentState`	int64	Zustand als Bitmaske: `csLoading`, `csDestroying`, `csDesigning` …	TComponent
`ComponentStyle`	int64	Stil als Bitmaske; Vorgabe `csInheritable`	TComponent

Methoden

Alle Methoden, auch die geerbten.

Signatur	Zweck	Herkunft
`Create(): void`	Konstruktor	eigen
`Init(): void`	Vorgaben von `TControl` setzen — in eigenen Klassen als erste Zeile im `Create`	eigen
`SetLeft(v: int64): void`	Position setzen und neu zeichnen	eigen
`GetLeft(): int64`	Position lesen	eigen
`SetTop(v: int64): void`	Position setzen und neu zeichnen	eigen
`GetTop(): int64`	Position lesen	eigen
`SetWidth(v: int64): void`	Breite setzen und neu zeichnen	eigen
`GetWidth(): int64`	Breite lesen	eigen
`SetHeight(v: int64): void`	Höhe setzen und neu zeichnen	eigen
`GetHeight(): int64`	Höhe lesen	eigen
`SetVisible(v: bool): void`	Sichtbarkeit setzen	eigen
`GetVisible(): bool`	Sichtbarkeit lesen	eigen
`SetEnabled(v: bool): void`	Bedienbarkeit	eigen
`GetEnabled(): bool`	Bedienbarkeit lesen	eigen
`SetCaption(v: pchar): void`	Beschriftung setzen und neu zeichnen	eigen
`GetCaption(): pchar`	Beschriftung lesen	eigen
`SetHint(v: pchar): void`	Kurztext setzen	eigen
`GetHint(): pchar`	Kurztext lesen	eigen
`SetName(v: pchar): void`	Bezeichner setzen	eigen
`IsClass(name: pchar): bool`	Ist von dieser Klasse	eigen
`FindByName(name: pchar): TControl`	Kind über `Name` finden	eigen
`FindTyped(name: pchar, klasse: pchar): TControl`	dasselbe mit Klassenprüfung	eigen
`CountClass(klasse: pchar): int64`	Kinder dieser Klasse zählen	eigen
`GetName(): pchar`	Bezeichner lesen	eigen
`OwnerControl(): TControl`	Der Besitzer als `TControl` — der kurze Weg zum Formular	eigen
`GetParentComponent(): TComponent`	Übergeordnete Komponente im Baum	eigen
`EffectiveFont(): TFont`	Tatsächlich geltende Schrift	eigen
`SetFont(f: TFont): void`	Schrift setzen	eigen
`HasOwnFont(): bool`	Eigene Schrift gesetzt	eigen
`SetCursor(v: int64): void`	Mauszeiger setzen	eigen
`GetCursor(): int64`	Mauszeiger lesen	eigen
`EffectiveCursor(): int64`	Tatsächlich geltender Zeiger	eigen
`SetConstraints(minW: int64, minH: int64, maxW: int64, maxH: int64): void`	Grenzen setzen	eigen
`ClampWidth(w: int64): int64`	Breite auf die Grenzen bringen	eigen
`ClampHeight(h: int64): int64`	Höhe auf die Grenzen bringen	eigen
`HasHint(): bool`	Hat einen Kurztext	eigen
`HintsAllowed(): bool`	Kurztexte hier erlaubt	eigen
`SetColor(v: TColor): void`	Farbe setzen	eigen
`GetColor(): TColor`	Farbe lesen	eigen
`SetAlign(v: int64): void`	Ausrichtung setzen	eigen
`GetAlign(): int64`	Ausrichtung lesen	eigen
`SetAnchors(v: int64): void`	Anker setzen	eigen
`GetAnchors(): int64`	Anker lesen	eigen
`SetTag(v: int64): void`	Freien Wert setzen	eigen
`GetTag(): int64`	Freien Wert lesen	eigen
`SetCanFocus(v: bool): void`	Fokusfähigkeit setzen	eigen
`GetCanFocus(): bool`	Fokusfähigkeit lesen	eigen
`SetPosition(x: int64, y: int64): void`	Position in einem Zug	eigen
`SetSize(w: int64, h: int64): void`	Größe in einem Zug	eigen
`SetBounds(x: int64, y: int64, w: int64, h: int64): void`	Position und Größe in einem Zug	eigen
`SetRole(name: pchar): void`	Semantische Rolle fürs Theme (`„primary“`, `„danger“` …)	eigen
`AddStyleClass(name: pchar): void`	Stilklasse hinzufügen	eigen
`ClearStyleClasses(): void`	Stilklassen leeren	eigen
`SetStyle(prop: int64, value: int64): void`	Ausdrückliche Stilwerte setzen	eigen
`ResetStyle(prop: int64): void`	Ausdrückliche Stilwerte verwerfen	eigen
`HasExplicitStyle(prop: int64): bool`	Hat ausdrückliche Stilwerte	eigen
`StyleStates(): int64`	Zustände fürs Theme (`ST_*`)	eigen
`StyleQueryFor(scale: int64): TStyleQuery`	Stilabfrage aufbauen	eigen
`ResolvedPartStyle(partName: pchar, partStates: int64): TStyleSet`	Aufgelöste Stilwerte eines Teils	eigen
`ResolvedStyle(): TStyleSet`	Aufgelöste Stilwerte (nach Gebrauch `Destroy()`)	eigen
`ClientRect(): TRect`	Fläche ohne Rahmen — die Zeichenfläche	eigen
`SetBorderWidth(v: int64): void`	Abstand zwischen Rand und Kindern setzen	eigen
`BoundsRect(): TRect`	Fläche einschließlich Rahmen	eigen
`AddChild(c: TControl): void`	Kind einhängen	eigen
`ChildAt(i: int64): TControl`	Kind über den Index	eigen
`RemoveChild(c: TControl): void`	Aushängen	eigen
`Root(): TControl`	Wurzel des Baums	eigen
`IsVisible(): bool`	Tatsächlich sichtbar (auch die Eltern)	eigen
`IsEnabled(): bool`	Tatsächlich bedienbar	eigen
`Show(): void`	Sichtbar machen	eigen
`Hide(): void`	Verbergen	eigen
`BringToFront(): void`	Nach vorn	eigen
`SendToBack(): void`	Nach hinten	eigen
`CanSetFocus(): bool`	Kann den Fokus jetzt bekommen	eigen
`SetFocus(): bool`	Fokus holen	eigen
`Update(): void`	Sofort zeichnen	eigen
`Refresh(): void`	Neu zeichnen	eigen
`ClientWidth(): int64`	Breite der Zeichenfläche	eigen
`ClientHeight(): int64`	Höhe der Zeichenfläche	eigen
`ClientOrigin(): TPoint`	Ursprung der Zeichenfläche auf dem Bildschirm	eigen
`ClientToScreen(x: int64, y: int64): TPoint`	Punkt in Bildschirmkoordinaten	eigen
`ScreenToClient(x: int64, y: int64): TPoint`	Punkt in Elementkoordinaten	eigen
`ControlCount(): int64`	Zahl der Kinder	eigen
`Controls(i: int64): TControl`	Kind über den Index	eigen
`HasParent(): bool`	Hat ein Elternteil	eigen
`GetTopParent(): TControl`	Oberstes Elternteil	eigen
`IsParentOf(c: TControl): bool`	Ist Vorfahr von	eigen
`ContainsControl(c: TControl): bool`	Enthält dieses Element	eigen
`ControlAtPos(x: int64, y: int64): TControl`	Element an einer Position	eigen
`FindChildControl(name: pchar): TControl`	Nur direkte Kinder	eigen
`GetTextLen(): int64`	Länge der Beschriftung	eigen
`GetTextBuf(dst: TTextBuffer): int64`	Beschriftung in einen Puffer	eigen
`SetTextBuf(src: pchar): void`	Beschriftung aus einem Puffer	eigen
`SetTabOrder(v: int64): void`	Tabulatorreihenfolge setzen	eigen
`GetTabOrder(): int64`	Tabulatorreihenfolge lesen	eigen
`PreferredWidth(): int64`	Wunschbreite aus dem Inhalt	eigen
`PreferredHeight(): int64`	Wunschhöhe aus dem Inhalt	eigen
`SetAutoSize(v: bool): void`	Automatische Größe schalten	eigen
`ApplyAutoSize(): void`	Größe an den Inhalt anpassen	eigen
`Showing(): bool`	Tatsächlich zu sehen: selbst sichtbar und jeder Vorfahr sichtbar	eigen
`DoubleBuffered(): bool`	Auskunft, ob doppelt gepuffert gezeichnet wird — in Vega immer `true` und nicht einstellbar	eigen
`InsertControl(c: TControl): void`	Kind aufnehmen (Delphi-Name für `SetParent`)	eigen
`RemoveControl(c: TControl): void`	Kind aushängen	eigen
`GetControlIndex(c: TControl): int64`	Stelle eines Kindes in der Liste — zugleich die Z-Ordnung	eigen
`SetControlIndex(c: TControl, index: int64): void`	Kind an eine andere Stelle schieben; `BringToFront` und `SendToBack` sind die Sonderfälle	eigen
`DisableAlign(): void`	Layout anhalten (Delphi-Name für `BeginUpdate`)	eigen
`EnableAlign(): void`	Layout wieder zulassen (Delphi-Name für `EndUpdate`)	eigen
`ReAlign(): void`	Kinder neu ausrichten	eigen
`PaintTo(canvas: TCanvas, x: int64, y: int64): void`	Ganzen Teilbaum an eine Stelle einer beliebigen Zeichenfläche malen — für Vorschaubilder und Ausdrucke	eigen
`GetChildrenRect(): TRect`	Umschließendes Rechteck aller sichtbaren Kinder, in eigenen Koordinaten; leer, wenn es keine gibt	eigen
`ScrollBy(dx: int64, dy: int64): void`	Alle Kinder um `dx`,`dy` verschieben	eigen
`ScaleBy(m: int64, d: int64): void`	Größe und Lage im Verhältnis `m`/`d` ändern, samt aller Kinder — der Weg zu anderer Pixeldichte	eigen
`GetTabOrderList(dst: TObjectList): void`	Fokussierbare Controls in Tabulator-Reihenfolge sammeln; steigt in Kinder ab	eigen
`ToAbsolute(x: int64, y: int64): TPoint`	Punkt in absolute Koordinaten	eigen
`HitTest(x: int64, y: int64): TControl`	Welches Element liegt dort (überschreibbar)	eigen
`Invalidate(): void`	Neuzeichnen anfordern	eigen
`Repaint(): void`	Sofort neu zeichnen	eigen
`SetParent(v: TControl): void`	In einen Container einhängen	eigen
`GetParent(): TControl`	Elternteil lesen	eigen
`SetAutoRepaint(v: bool): void`	Selbsttätiges Neuzeichnen schalten	eigen
`GetAutoRepaint(): bool`	Einstellung lesen	eigen
`BeginUpdate(): void`	Änderungen bündeln (kein Neuzeichnen bis `EndUpdate`)	eigen
`EndUpdate(): void`	Bündelung beenden und neu zeichnen	eigen
`EffectiveTheme(): TTheme`	Tatsächlich geltendes Theme	eigen
`Paint(canvas: TCanvas): void`	Darstellung (überschreibbar)	eigen
`PaintTree(canvas: TCanvas): void`	Sich und die Kinder zeichnen	eigen
`PaintChildren(canvas: TCanvas): void`	Kinder zeichnen (überschreibbar)	eigen
`DoClick(): void`	Klick behandeln (überschreibbar)	eigen
`DoMouseDown(x: int64, y: int64, button: int64): void`	Maustaste behandeln (überschreibbar)	eigen
`DoDblClick(): void`	Doppelklick behandeln (überschreibbar)	eigen
`DoStartDrag(): void`	Ziehgeste beginnen (überschreibbar)	eigen
`DoDragOver(source: TControl, x: int64, y: int64): bool`	Annahme prüfen (überschreibbar)	eigen
`DoDragDrop(source: TControl, x: int64, y: int64): void`	Ablegen behandeln (überschreibbar)	eigen
`DoEndDrag(target: TControl, x: int64, y: int64): void`	Geste beenden (überschreibbar)	eigen
`DoKeyUp(key: int64, modifiers: int64): void`	Loslassen behandeln (überschreibbar)	eigen
`DoContextPopup(x: int64, y: int64): bool`	Kontextmenü anfordern (überschreibbar)	eigen
`DoMouseUp(x: int64, y: int64, button: int64): void`	Loslassen behandeln (überschreibbar)	eigen
`DoMouseMove(x: int64, y: int64, button: int64): void`	Bewegung behandeln (überschreibbar)	eigen
`SetBackendRef(b: int64): void`	Backend bekannt machen	eigen
`DoMouseWheel(delta: int64): void`	Mausrad behandeln (überschreibbar)	eigen
`DoMouseEnter(): void`	Betreten behandeln (überschreibbar)	eigen
`DoMouseLeave(): void`	Verlassen behandeln (überschreibbar)	eigen
`DoKeyDown(key: int64, modifiers: int64): void`	Taste behandeln (überschreibbar)	eigen
`DoChar(cp: int64): void`	Zeichen behandeln (überschreibbar)	eigen
`DoFocusIn(): void`	Fokus erhalten (überschreibbar)	eigen
`DoFocusOut(): void`	Fokus verloren (überschreibbar)	eigen
`DoResize(): void`	Größenänderung behandeln (überschreibbar)	eigen
`ApplyLayout(): void`	Kinder ausrichten — eine Ebene tief	eigen
`InitComponent(): void`	Grundzustand herstellen — von jeder Ableitung im `Create` zu rufen, da Lyx Konstruktoren nicht vererbt	TComponent
`Destroy(): void`	Gibt eigene Ressourcen frei	TComponent
`ComponentCount(): int64`	Anzahl der eigenen Komponenten	TComponent
`Components(index: int64): TComponent`	Eigene Komponente an dieser Stelle	TComponent
`ComponentIndex(): int64`	Eigener Platz in der Liste des Besitzers, `-1` ohne Besitzer	TComponent
`InsertComponent(c: TComponent): void`	Komponente in Besitz nehmen; ein bisheriger Besitzer gibt sie ab	TComponent
`RemoveComponent(c: TComponent): void`	Komponente aus dem Besitz nehmen	TComponent
`FindComponent(name: pchar): TComponent`	Eigene Komponente über ihren `Name` suchen — eine Ebene tief	TComponent
`DestroyComponents(): void`	Alle Besitztümer abbauen, von hinten nach vorn	TComponent
`HasState(bits: int64): bool`	Sind diese Zustandsbits gesetzt	TComponent
`SetState(bits: int64): void`	Zustandsbits setzen	TComponent
`ClearState(bits: int64): void`	Zustandsbits löschen	TComponent
`GetNamePath(): pchar`	Voller Name für Formulardateien; in Vega der Name selbst	TComponent
`Tick(now: int64): bool`	Einmal je Bild aus der Fensterschleife; `true` = es hat sich etwas getan, also neu zeichnen	TComponent
`NextDueIn(now: int64): int64`	Wie lange die Schleife höchstens schlafen darf, bis diese Komponente wieder dran ist; `-1` = nie von selbst	TComponent

Ereignisse

Name	Typ	Wann	Herkunft
`OnClick`	TNotifyEvent	Klick	eigen
`OnDblClick`	TNotifyEvent	Doppelklick	eigen
`OnMouseDown`	TMouseEvent	Maustaste gedrückt; Koordinaten relativ zum Control	eigen
`OnMouseUp`	TMouseEvent	Maustaste losgelassen	eigen
`OnMouseMove`	TMouseEvent	Zeiger bewegt sich über dem Control	eigen
`OnMouseEnter`	TNotifyEvent	Zeiger betritt die Fläche	eigen
`OnMouseLeave`	TNotifyEvent	Zeiger verlässt die Fläche	eigen
`OnKeyDown`	TKeyEvent	Taste gedrückt (`KEY_`, `MOD_`)	eigen
`OnKeyUp`	TKeyEvent	Taste losgelassen	eigen
`OnChar`	TCharEvent	Eingegebenes Zeichen (Unicode-Codepoint)	eigen
`OnMouseWheel`	TWheelEvent	Mausrad; `delta` ist `+1` oder `-1`	eigen
`OnPaint`	TPaintEvent	Zeichnen	eigen
`OnResize`	TNotifyEvent	Größe geändert	eigen
`OnFocusIn`	TNotifyEvent	Fokus erhalten	eigen
`OnFocusOut`	TNotifyEvent	Fokus verloren	eigen
`OnEnter`	TNotifyEvent	Element betreten	eigen
`OnExit`	TNotifyEvent	Element verlassen	eigen
`OnKeyPress`	TCharEvent	Wie `OnChar`	eigen
`OnChangeBounds`	TNotifyEvent	Geometrie geändert	eigen
`OnShowHint`	TNotifyEvent	Kurztext erscheint	eigen
`OnContextPopup`	TMouseEvent	Kontextmenü angefordert	eigen
`OnStartDrag`	TNotifyEvent	Ziehgeste beginnt	eigen
`OnDragOver`	TDragOverEvent	Über einem möglichen Ziel; Rückgabe `true` = annehmen	eigen
`OnDragDrop`	TDragDropEvent	Abgelegt	eigen
`OnEndDrag`	TDragEndEvent	Geste beendet; `target` ist `0` bei Abbruch	eigen

Letzte Aktualisierung: 2026-08-20 — API maschinell aus Vega/Control.lyx und Vega/Component.lyx erhoben; Komponenten-Split (TComponent als neue Basis) mit lyxc 1.1.4A nachgemessen.