`InputActionLabel` is a drag-and-drop `Class.GuiObject` that automatically
shows the appropriate key or icon for an `Class.InputAction` based on the
player's current input device (keyboard/mouse, gamepad, touch, VR). When the
player switches devices or the binding is rebound, the label updates instantly
without scripting.

Rendering of the `InputActionLabel` depends on the `Class.InputAction` (linked
through `Class.InputActionLabel.InputAction`) and that action's child
`Class.InputBinding|InputBindings`. As the label resolves what to show, it
follows this order:

1. **Custom Images** — If child `Class.InputBinding|InputBindings` have their
   `Class.InputBinding.DisplayImage|DisplayImage` property set, the label
   renders those images directly, optionally modified by
   `Class.InputActionLabel.ImageColor3|ImageColor3` and
   `Class.InputActionLabel.ImageTransparency|ImageTransparency`.

2. **Platform Key Images** — Lacking custom images, the label renders
   platform-provided images for child `Class.InputBinding|InputBindings`
   through `Class.UserInputService:GetImageForKeyCode()`, if such images are
   available. Composite bindings with modifiers show multiple icons with `+`
   separators.

3. **Custom Names** — Lacking available images, if child
   `Class.InputBinding|InputBindings` have their
   `Class.InputBinding.DisplayName|DisplayName` property set, the label
   renders that text in a style defined by
   `Class.InputActionLabel.FontFace|FontFace`,
   `Class.InputActionLabel.TextColor3|TextColor3`,
   `Class.InputActionLabel.TextSize|TextSize`,
   `Class.InputActionLabel.TextTransparency|TextTransparency`,
   `Class.InputActionLabel.TextWrapped|TextWrapped`,
   `Class.InputActionLabel.TextXAlignment|TextXAlignment`, and
   `Class.InputActionLabel.TextYAlignment|TextYAlignment`.

4. **Platform Key Strings** — Lacking all of the above, the label renders
   platform-provided strings through
   `Class.UserInputService:GetStringForKeyCode()`.

5. If no `Class.InputAction` is assigned or no child `Class.InputBinding`
   exists, the label renders a placeholder icon.


InputActionLabel

This property is similar to `Class.TextLabel.FontFace` and determines the
font family, weight, and style used when the label renders in a text mode.


InputActionLabel.FontFace

Determines the font used to render text.


This property determines how label images are colorized. When set to
white, no colorization occurs. This property is useful for reusing image
assets; if the source images are completely white with transparency, you
can set the entire label color at once with this property.


InputActionLabel.ImageColor3

Determines how rendered label images will be colorized.


This property determines the alpha of rendered label images. A value of
`0` is completely opaque and a value of `1` is completely transparent
(invisible).


InputActionLabel.ImageTransparency

Determines the transparency of rendered label images.


The `Class.InputAction` instance for which to have the label automatically
resolve and display its preferred binding. When the binding changes (due
to rebinding or input device switching), the label updates automatically.

Setting this to `nil` clears the display and shows the placeholder.


InputActionLabel.InputAction

The `Class.InputAction` whose preferred binding this label displays.


Contains the `Datatype.Content` of the first resolved image when the label
renders in an image mode. Empty when in text or placeholder mode. This is
a read-only property set by the engine when the binding resolves.


InputActionLabel.ResolvedImageContent

Read-only. The resolved image content currently being displayed.


Contains the composed key name string such as `Ctrl + Shift + Space` when
the label renders in text mode. Empty when the label renders in image or
placeholder mode. This is a read-only property set by the engine when the
binding resolves.


InputActionLabel.ResolvedText

The resolved key name string currently being displayed.


This property determines the color of all text rendered by the label.


InputActionLabel.TextColor3

Controls the font size in pixels for text mode rendering. Value is clamped
between `1` and `200`.


InputActionLabel.TextSize

Determines the line height of text in offsets.


This property determines the transparency of all text rendered by the
label.


InputActionLabel.TextTransparency

Determines the transparency of rendered text.


When `true`, text renders on multiple lines within the label's space so
that `Class.InputActionLabel.TextSize|TextSize` lines never exceed the
`Class.GuiBase2d.AbsoluteSize` of the object. This is achieved by breaking
long lines of text into multiple lines.


InputActionLabel.TextWrapped

Determines if text wraps to multiple lines within the label's space.


This property determines the horizontal alignment of text rendered within
the label's space.


InputActionLabel.TextXAlignment

Determines the horizontal alignment of rendered text.


This property determines the vertical alignment of text rendered within
the label's space.


InputActionLabel.TextYAlignment

Determines the vertical alignment of rendered text.


A `Class.GuiObject` that automatically displays the keybinding for an action
as text or an image.


`Class.GuiObject` ist eine abstrakte Klasse (ähnlich wie `Class.BasePart`) für ein 2D
Benutzeroberflächenobjekt. Sie definiert alle Eigenschaften, die mit der Anzeige
 eines grafischen Benutzeroberflächenobjekts (GUI) verbunden sind, wie `Class.GuiObject.Size|Size`
 und `Class.GuiObject.Position|Position`. Sie hat auch einige nützliche schreibgeschützte
Eigenschaften wie `Class.GuiObject.AbsolutePosition|AbsolutePosition`,
`Class.GuiObject.AbsoluteSize|AbsoluteSize` und
`Class.GuiObject.AbsoluteRotation|AbsoluteRotation`.

Um das Layout von GUI-Objekten auf besondere Weise zu manipulieren, können Sie eine Layout-
struktur wie [list/flex](/ui/list-flex-layouts) oder
[grid](/ui/grid-table-layouts) verwenden, und Sie können sie über ihre
Kerneigenschaften hinaus mit
[Appearance Modifiers](/ui/appearance-modifiers) gestalten.

Obwohl es möglich ist, Mausklickereignisse für jedes GUI-Objekt mit
`Class.GuiObject.InputBegan|InputBegan` und
`Class.GuiObject.InputEnded|InputEnded` zu erkennen, haben nur `Class.ImageButton` und
`Class.TextButton` praktische dedizierte Ereignisse wie
`Class.TextButton.Activated|Activated`, um Klicks/Drücke zu erkennen.

Das folgende Beispiel geht davon aus, dass es sich innerhalb eines GuiObject wie einem `TextButton` befindet, und
 dass die `Class.GuiObject.Draggable`-Eigenschaft auf true gesetzt ist. Es wird die UDim2 ausgegeben,
von wo der Spieler angefangen hat, das Objekt zu ziehen.

Dieses Ereignis wird ausgelöst, wenn ein Spieler mit dem Ziehen des Objekts beginnt.

Siehe auch `Class.GuiObject.DragStopped`.

GuiObject.DragBegin

initialPosition

Ein `Datatype.UDim2`-Wert der Position des `Class.GuiObject`,
bevor eine Ziehoperation begonnen hat.

Wird ausgelöst, wenn ein Spieler mit dem Ziehen des Objekts beginnt.

Das folgende Beispiel geht davon aus, dass es sich um ein GuiObject wie einen `TextButton` handelt und
 dass die `Class.GuiObject.Draggable`-Eigenschaft auf true gesetzt ist. Es wird die
 X- und Y-Position drucken, an der der Spieler aufgehört hat, das GUI zu ziehen. Wenn der
 Spieler das Objekt beispielsweise bei 189, 180 loslässt, würde das Folgendes drucken: Der
 Spieler hat aufgehört, das GuiObject bei (189, 180) zu ziehen.

Dieses Ereignis wird ausgelöst, wenn ein Spieler das Ziehen des Objekts stoppt.

Siehe auch `Class.GuiObject.DragBegin`.

GuiObject.DragStopped

Die **X**-Position des Mauszeigers auf dem Bildschirm in Pixeln, relativ zur oberen linken
Ecke des Bildschirms.

Die **Y**-Position des Mauszeigers auf dem Bildschirm in Pixeln, relativ zur oberen linken
Ecke des Bildschirms.

Wird ausgelöst, wenn ein Spieler das Ziehen des Objekts stoppt.

Das folgende Beispiel zeigt eines von vielen Anwendungsszenarien zur Handhabung von Benutzer
 eingaben aus InputBegan, abhängig von deren Typ.

Damit dies wie erwartet funktioniert, muss es in einem `LocalScript`
 und einem Kind von _gui_ platziert werden.

Dieses Ereignis wird ausgelöst, wenn ein Benutzer beginnt, mit dem `Class.GuiObject`
über ein Schnittstelle-Human-Computer-Gerät (Links-Taste gedrückt, Berührung beginnt,
Tastaturtaste gedrückt usw.) zu interagieren.

Der `Class.UserInputService` hat ein ähnlich benanntes Ereignis, das nicht auf ein bestimmtes
UI-Element beschränkt ist: `Class.UserInputService.InputBegan`.

Dieses Ereignis wird unabhängig vom Spielzustand immer ausgelöst.

Siehe auch `Class.GuiObject.InputEnded` und `Class.GuiObject.InputChanged`.

GuiObject.InputBegan

input

Ein `Class.InputObject`, das nützliche Daten zur Abfrage von Benutzer
Eingaben enthält, wie z. B. den `Enum.UserInputType|Art der Eingabe`,
den `Enum.UserInputState|Zustand der Eingabe` und
`Class.InputObject.Position|Bildschirmkoordinaten der Eingabe`.

Wird ausgelöst, wenn ein Benutzer beginnt, mit einem Schnittstelle-Human-Computer-Gerät
(Links-Taste gedrückt, Berührung beginnt, Tastaturtaste gedrückt usw.) zu interagieren.

Das folgende Beispiel demonstriert eines von vielen Anwendungsbeispielen für den Umgang mit Benutzer
 eingaben durch InputChanged, abhängig von ihrem Typ.

Damit dies wie erwartet funktioniert, muss es in einem `LocalScript`
 und ein Kind von _gui_ sein.

Dieses Ereignis wird ausgelöst, wenn ein Benutzer die Art und Weise ändert, wie er
über ein Schnittstelle-Human-Computer-Gerät (Links-Taste gedrückt, Berührung beginnt, Tastaturtaste
 gedrückt usw.) interagiert.

Der `Class.UserInputService` hat ein ähnlich benanntes Ereignis, das nicht auf ein bestimmtes UI-Element
beschränkt ist: `Class.UserInputService.InputChanged`.

Dieses Ereignis wird unabhängig vom Spielzustand immer ausgelöst.

Siehe auch `Class.GuiObject.InputBegan` und `Class.GuiObject.InputEnded`.

GuiObject.InputChanged

Wird ausgelöst, wenn ein Benutzer die Art und Weise ändert, wie er über ein Human-Computer-
Interface-Gerät (Links-Taste gedrückt, Berührung beginnt, Tastaturtaste gedrückt usw.) interagiert.

Das folgende Beispiel zeigt eines von vielen Anwendungsbeispielen zur Verarbeitung von Benutzer
Eingaben aus InputEnded, abhängig von deren Typ.

Um dies erwartungsgemäß zum Laufen zu bringen, muss es in einem `LocalScript`
ein Kind von _gui_ sein.

Das InputEnded-Ereignis wird ausgelöst, wenn ein Benutzer aufhört, über ein human-computer-Interface-Gerät zu interagieren
(Links-Taste gedrückt, Berührung beginnt, Tastaturtaste gedrückt usw.).

Der `Class.UserInputService` hat ein ähnlich benanntes Ereignis, das nicht auf ein bestimmtes UI-Element beschränkt ist: `Class.UserInputService.InputEnded`.

Dieses Ereignis wird unabhängig vom Spielzustand immer ausgelöst.

Siehe auch `Class.GuiObject.InputBegan` und `Class.GuiObject.InputChanged`.

GuiObject.InputEnded

Ein `Class.InputObject`, das nützliche Daten zur Abfrage von Benutzer
Eingaben enthält, wie z. B. den `Enum.UserInputType`, `Enum.UserInputState` und
`Class.InputObject.Position`.

Wird ausgelöst, wenn ein Benutzer aufhört, über ein Human-Computer-Interface-Gerät zu interagieren
(Links-Taste gedrückt, Berührung beginnt, Tastaturtaste gedrückt usw.).

Das folgende Beispiel druckt die Mausposition in Pixeln, wenn sie ein GUI-Element betritt.

Das MouseEnter-Ereignis wird ausgelöst, wenn ein Benutzer die Maus in ein
`Class.GuiObject`-Element bewegt.

Bitte verlassen Sie sich nicht auf die `x`- und `y`-Argumente, die durch dieses Ereignis übergeben werden, als sicheres Mittel, um zu bestimmen, wo sich die Maus des Benutzers befindet, wenn sie in ein GUI eintritt. Diese Koordinaten können variieren, selbst wenn die Maus durch denselben Rand in das GUI eintritt - insbesondere, wenn die Maus schnell in das Element eintritt. Dies liegt daran, dass die Koordinaten die Position der Maus angeben, als das Ereignis ausgelöst wird, anstatt den genauen Moment, in dem die Maus in das GUI eintritt.

Dieses Ereignis wird sogar ausgelöst, wenn das GUI-Element unter einem anderen Element rendert.

Wenn Sie verfolgen möchten, wann die Maus eines Benutzers ein GUI-Element verlässt, können Sie das `Class.GuiObject.MouseLeave`-Ereignis verwenden.

##### Siehe Auch

- `Class.GuiObject.MouseLeave`
- `Class.GuiObject.MouseMoved`
- `Class.GuiObject.MouseWheelForward`
- `Class.GuiObject.MouseWheelBackward`

GuiObject.MouseEnter

Die **X**-Bildschirmkoordinate der Maus in Pixeln, relativ zur oberen linken
Ecke des Bildschirms.

Die **Y**-Bildschirmkoordinate der Maus in Pixeln, relativ zur oberen linken
Ecke des Bildschirms.

Wird ausgelöst, wenn ein Benutzer die Maus in ein GUI-Element bewegt.

Das MouseLeave-Ereignis wird ausgelöst, wenn ein Benutzer die Maus aus einem
`Class.GuiObject`-Element bewegt.

Bitte verlassen Sie sich nicht auf die `x`- und `y`-Argumente, die durch dieses Ereignis übergeben werden, als sicheres Mittel, um zu bestimmen, wo sich die Maus des Benutzers befindet, wenn sie ein GUI verlässt. Diese Koordinaten können variieren, selbst wenn die Maus das GUI über denselben Rand verlässt - insbesondere, wenn die Maus schnell das Element verlässt. Dies liegt daran, dass die Koordinaten die Position der Maus angeben, als das Ereignis ausgelöst wird, anstatt den genauen Moment, in dem die Maus das GUI verlässt.

Dieses Ereignis wird sogar ausgelöst, wenn das GUI-Element unter einem anderen Element rendert.

##### Siehe Auch

- `Class.GuiObject.MouseEnter`
- `Class.GuiObject.MouseMoved`
- `Class.GuiObject.MouseWheelForward`
- `Class.GuiObject.MouseWheelBackward`

GuiObject.MouseLeave

Wird ausgelöst, wenn ein Benutzer die Maus aus einem GUI-Element bewegt.

Wird ausgelöst, wenn ein Benutzer die Maus bewegt, während sie sich in einem
`Class.GuiObject`-Element befindet. Es ist ähnlich wie `Class.Mouse.Move`, das
unabhängig davon, ob die Maus des Benutzers über einem GUI-Element ist, ausgelöst wird.

Hinweis: Dieses Ereignis wird ausgelöst, wenn die Position der Maus aktualisiert wird; daher wird es
während der Bewegung mehrmals ausgelöst.

Die Argumente `x` und `y` geben die aktualisierten Bildschirmkoordinaten der
Maus des Benutzers in Pixeln an. Diese können nützlich sein, um die Position der Maus im GUI, Bildschirm und die Delta zu bestimmen, seit der vorherige Position der Maus, wenn sie in einer globalen Variablen verfolgt wird.

Der folgende Code demonstriert, wie man die `Datatype.Vector2`-Verschiebung
des Benutzers relative zu einem GUI-Element bestimmen kann:

```lua
local Players = game:GetService("Players")

local CustomScrollingFrame = script.Parent
local SubFrame = CustomScrollingFrame:FindFirstChild("SubFrame")

local mouse = Players.LocalPlayer:GetMouse()

local function getPosition(X, Y)
	local gui_X = CustomScrollingFrame.AbsolutePosition.X
	local gui_Y = CustomScrollingFrame.AbsolutePosition.Y

	local pos = Vector2.new(math.abs(X - gui_X), math.abs(Y - gui_Y - 36))
	print(pos)
end

CustomScrollingFrame.MouseMoved:Connect(getPosition)
```
Beachten Sie, dass dieses Ereignis möglicherweise nicht genau ausgelöst wird, wenn die Maus des Benutzers ein GUI-Element betritt oder verlässt. Daher stimmen die `x`- und `y`-Argumente möglicherweise nicht perfekt mit den Koordinaten der GUI-Ränder überein.

##### Siehe Auch

- `Class.GuiObject.MouseEnter`
- `Class.GuiObject.MouseLeave`
- `Class.GuiObject.MouseWheelForward`
- `Class.GuiObject.MouseWheelBackward`

GuiObject.MouseMoved

Wird ausgelöst, wenn ein Benutzer die Maus bewegt, während sie in einem GUI-Element ist.

Das WheelBackward-Ereignis wird ausgelöst, wenn ein Benutzer das Mausrad zurückscrollt,
während die Maus über einem `Class.GuiObject`-Element ist. Es ist ähnlich zu
`Class.Mouse.WheelBackward`, das unabhängig davon, ob die Maus des Benutzers über einem GUI-Element ist, ausgelöst wird.

Dieses Ereignis wird lediglich als Indikator für die Rückwärtsbewegung des Rades ausgelöst.
Das bedeutet, dass die `x`- und `y`-Mauskoordinaten-Argumente sich nicht als Ergebnis dieses Ereignisses ändern. Diese Koordinaten ändern sich nur, wenn die Maus
bewegt wird, was durch das Ereignis `Class.GuiObject.MouseMoved` verfolgt werden kann.

##### Siehe Auch

- `Class.GuiObject.MouseEnter`
- `Class.GuiObject.MouseLeave`
- `Class.GuiObject.MouseMoved`
- `Class.GuiObject.MouseWheelForward`

GuiObject.MouseWheelBackward

Wird ausgelöst, wenn ein Benutzer das Mausrad zurückscrollt, während die Maus über einem
GUI-Element ist.

Das WheelForward-Ereignis wird ausgelöst, wenn ein Benutzer das Mausrad nach vorne scrollt,
während die Maus über einem `Class.GuiObject`-Element ist. Es ist ähnlich zu
`Class.Mouse.WheelForward`, das unabhängig davon, ob die Maus des Benutzers über einem GUI-Element ist, ausgelöst wird.

Dieses Ereignis wird lediglich als Indikator für die Vorwärtsbewegung des Rades ausgelöst.
Das bedeutet, dass die **X**- und **Y**-Mauskoordinaten-Argumente sich nicht als Ergebnis dieses Ereignisses ändern. Diese Koordinaten ändern sich nur, wenn die
Maus bewegt wird, was durch das Ereignis `Class.GuiObject.MouseMoved`
verfolgt werden kann.

##### Siehe Auch

- `Class.GuiObject.MouseEnter`
- `Class.GuiObject.MouseLeave`
- `Class.GuiObject.MouseMoved`
- `Class.GuiObject.MouseWheelBackward`

GuiObject.MouseWheelForward

Die **Y**-Koordinate der Maus des Benutzers.

Wird ausgelöst, wenn ein Benutzer das Mausrad nach vorne scrollt, während die Maus über
einem GUI-Element ist.

Das folgende Beispiel druckt eine Nachricht, wenn der Benutzer das Objekt mit einem
Gamepad auswählt.

Damit dies wie erwartet funktioniert, muss es in einem `LocalScript`
und ein Kind von _gui_ platziert werden.

Dieses Ereignis wird ausgelöst, wenn der Gamepad-Selector beginnt, sich auf das
`Class.GuiObject` zu konzentrieren.

Wenn Sie überprüfen möchten, wann der Gamepad-Selektor auf dem GUI-Element nicht mehr fokussiert, können Sie das `Class.GuiObject.SelectionLost`-Ereignis verwenden.

Wenn ein GUI den Auswahlfokus erhält, ändert sich auch der Wert der
`Class.GuiService.SelectedObject|SelectedObject`-Eigenschaft auf das, das den Fokus erhält. Um zu überprüfen, welches GUI den Fokus erhalten hat, überprüfen Sie den Wert dieser Eigenschaft.

GuiObject.SelectionGained

Wird ausgelöst, wenn das GuiObject mit dem Gamepad-Selector fokussiert wird.

Das folgende Beispiel gibt eine Nachricht aus, wenn das Element den Fokus auf
einem Gamepad verliert.

Damit dies wie erwartet funktioniert, muss es in einem `LocalScript`
und ein Kind von _gui_ platziert werden.

Dieses Ereignis wird ausgelöst, wenn der Gamepad-Selector aufhört, sich auf das
`Class.GuiObject` zu konzentrieren.

Wenn Sie überprüfen möchten, wann der Gamepad-Selektor beginnt, sich auf das GUI-Element zu fokussieren, können Sie das `Class.GuiObject.SelectionGained`-Ereignis verwenden.

Wenn ein GUI den Auswahlfokus verliert, ändert sich der Wert der
`Class.GuiService.SelectionObject|SelectionObject`-Eigenschaft entweder
auf `nil` oder auf das GUI-Element, das den Fokus erhält. Um zu überprüfen, welches GUI den Fokus erhalten hat, oder ob kein GUI ausgewählt ist, überprüfen Sie den Wert dieser Eigenschaft.

GuiObject.SelectionLost

Wird ausgelöst, wenn der Gamepad-Selector auf dem GuiObject aufhört, sich zu fokussieren.

Dieses Codebeispiel ermöglicht es dem Spieler, die Bildschirmposition eines
UI-Elements, wie einem `Frame`, zu manipulieren, indem er das UI-Element für einen kurzen
Moment gedrückt hält. Dann bewegt der Spieler seinen Finger und lässt los. Während der Geste
wird der Frame blau mit einem weißen Rand eingefärbt.

Dieses Ereignis wird ausgelöst, nachdem der Spieler einen kurzen Moment lang seinen Finger
auf dem UI-Element eines berührungsempfindlichen Geräts gehalten hat. Es wird mit einer Tabelle von
`Datatype.Vector2` ausgelöst, die die relativen Bildschirmpositionen der
Finger beschreibt, die an der Geste beteiligt sind. Darüber hinaus wird es mehrmals ausgelöst:
`Enum.UserInputState.Begin` nach einer kurzen Verzögerung,
`Enum.UserInputState.Change`, wenn der Spieler seinen Finger während der
Geste bewegt, und schließlich `Enum.UserInputState.End`. Die Verzögerung ist plattformspezifisch;
in Studio ist sie etwas länger als eine Sekunde.

GuiObject.TouchLongPress

touchPositions

Ein Array von `Datatype.Vector2`, das die **relativen**
Positionen der Finger beschreibt, die an der Geste beteiligt sind.

state

Ein `Enum.UserInputState`, der den Status der Geste beschreibt:

- Begin wird einmal zu Beginn der Geste ausgelöst (nach der kurzen Verzögerung)
- Change wird ausgelöst, wenn der Spieler seinen Finger bewegt, während er drückt
- End wird einmal am Ende der Geste ausgelöst, wenn er seinen Finger loslässt.

Wird ausgelöst, wenn der Spieler beginnt, weiterhin und aufhört, das UI-Element lang zu drücken.

Dieses Codebeispiel soll in einem `LocalScript` innerhalb eines inneren
`Frame` platziert werden, der sich in einem äußeren `Frame` oder einem anderen `GuiObject` befindet. Es ermöglicht dem
Spieler, die Position des inneren Frames zu manipulieren, indem er seinen Finger auf
dem äußeren Frame bewegt.

Dieses Ereignis wird ausgelöst, wenn der Spieler seinen Finger auf dem UI-Element
mit einem berührungsempfindlichen Gerät bewegt. Es wird kurz bevor
`Class.GuiObject.TouchSwipe` ausgelöst würde, und nicht mit
`Class.GuiObject.TouchTap`. Dieses Ereignis ist nützlich, um dem Spieler
zu ermöglichen, die Position von UI-Elementen auf dem Bildschirm zu manipulieren.

Dieses Ereignis wird mit einer Tabelle von `Datatype.Vector2` ausgelöst, die die
relativen Bildschirmpositionen der Finger beschreibt, die an der Geste beteiligt sind. Darüber hinaus
wird es mehrmals ausgelöst: `Enum.UserInputState.Begin` nach einer
kurzen Verzögerung, `Enum.UserInputState.Change`, wenn der Spieler seinen
Finger während der Geste bewegt, und schließlich mit `Enum.UserInputState.End`.

GuiObject.TouchPan

Ein Luau-Array von `Datatype.Vector2`-Objekten, die jeweils die
Position aller Finger, die an der Geste beteiligt sind, anzeigt.

totalTranslation

Gibt an, wie weit die Schiebegeste von ihrem Ausgangspunkt entfernt ist.

velocity

Gibt an, wie schnell die Geste in jeder Dimension ausgeführt wird.

Gibt den `Enum.UserInputState` der Geste an.

Wird ausgelöst, wenn der Spieler seinen Finger über das UI-Element bewegt.

Dieses Codesample ist für ein `LocalScript` innerhalb eines inneren `Frame`, der
in einem äußeren `Frame` oder einem anderen `GuiObject` enthalten ist. Es ermöglicht dem Spieler, den inneren Frame zu skalieren,
durch die Ausführung einer `Class.GuiObject.TouchPinch` Geste auf dem äußeren Frame.

Dieses Ereignis wird ausgelöst, wenn der Spieler zwei Finger verwendet, um eine Pinch- oder Pull-Geste
auf dem UI-Element eines berührungsempfindlichen Geräts auszuführen. Ein **Pinch**
tritt auf, wenn zwei oder mehr Finger näher zusammen bewegt werden, und ein **Pull**
tritt auf, wenn sie sich auseinander bewegen. Dieses Ereignis wird in Verbindung mit
`Class.GuiObject.TouchPan` ausgelöst. Dieses Ereignis ist nützlich, um dem Spieler
den Maßstab (Größe) von UI-Elementen auf dem Bildschirm zu manipulieren, und wird am häufigsten
dafür verwendet, Zoomfunktionen bereitzustellen.

Dieses Ereignis wird mit einer Tabelle von `Datatype.Vector2` ausgelöst, die die
relativen Bildschirmpositionen der Finger beschreibt, die an der Geste beteiligt sind. Darüber hinaus
wird es mehrmals ausgelöst: `Enum.UserInputState.Begin` nach einer
kurzen Verzögerung, `Enum.UserInputState.Change`, wenn der Spieler einen Finger
during der Geste bewegt, und schließlich mit `Enum.UserInputState.End`. Es sollte
beachtet werden, dass der Maßstab **multiplikativ** verwendet werden sollte.

GuiObject.TouchPinch

Ein Luau-Array von `Datatype.Vector2`-Objekten, die jeweils die
Position aller Finger, die an der Kneifgeste beteiligt sind, anzeigt.

scale

Ein Float, der den Unterschied vom Anfang der Kneifgeste angibt.

Ein Float, der angibt, wie schnell die Kneifgeste ausgeführt wird.

Wird ausgelöst, wenn der Spieler eine Kneif- oder Ziehgestik mit zwei Fingern
auf dem UI-Element ausführt.

Dieses Codebeispiel ist für ein `LocalScript` innerhalb eines inneren `Frame`, das
sich in einem äußeren `Frame` oder einem anderen `GuiObject` befindet. Es ermöglicht dem Spieler,
das innere Frame zu rotieren, indem er eine `Class.GuiObject.TouchRotate` Geste auf dem
äußeren Frame ausführt.

Dieses Ereignis wird ausgelöst, wenn der Spieler zwei Finger verwendet, um eine Pinch- oder Pull-Geste
auf dem UI-Element eines berührungsempfindlichen Geräts auszuführen. Eine Drehung erfolgt,
wenn sich der Winkel der Linie zwischen zwei Fingern ändert. Dieses Ereignis wird
in Verbindung mit `Class.GuiObject.TouchPan` ausgelöst. Dieses Ereignis ist nützlich,
um dem Spieler zu ermöglichen, die Drehung von UI-Elementen auf dem
Bildschirm zu manipulieren.

Dieses Ereignis wird mit einer Tabelle von `Datatype.Vector2` ausgelöst, die die
relativen Bildschirmpositionen der Finger beschreibt, die an der Geste beteiligt sind. Darüber hinaus
wird es mehrmals ausgelöst: `Enum.UserInputState.Begin` nach einer
kurzen Verzögerung, `Enum.UserInputState.Change`, wenn der Spieler einen Finger
during der Geste bewegt, und schließlich mit `Enum.UserInputState.End`.

GuiObject.TouchRotate

Ein Luau-Array von `Datatype.Vector2`-Objekten, die jeweils die
Position aller an der Geste beteiligten Finger angeben.

rotation

Ein Float, der angibt, wie weit die Rotation seit dem Beginn der
Geste erfolgt ist.

Ein Float, der angibt, wie schnell die Geste ausgeführt wird.

Wird ausgelöst, wenn der Spieler eine Rotationsgeste mit zwei Fingern auf dem
UI-Element ausführt.

Dieses Codesample bewirkt, dass ein `Frame` (oder ein anderer `GuiObject`) springt, wenn eine
Wischgeste auf einem touchscreen-fähigen Gerät (oder dem Emulator von Studio) ausgeführt wird.
Horizontale Wischbewegungen ändern den Farbton der
`Class.GuiObject.BackgroundColor3`, während vertikale Wischbewegungen die
Sättigung ändern.

Dieses Ereignis wird ausgelöst, wenn der Spieler eine Wischgeste auf dem UI-Element
mit einem berührungsempfindlichen Gerät ausführt. Es wird mit der Richtung der
Geste (Oben, Unten, Links oder Rechts) und der Anzahl der an der Geste beteiligten
Berührungspunkte ausgelöst. Wischgesten werden häufig verwendet, um Registerkarten in mobilen
UIs zu wechseln.

GuiObject.TouchSwipe

swipeDirection

Ein `Enum.SwipeDirection`, der die Richtung der Wischgeste
(Oben, Unten, Links oder Rechts) angibt.

numberOfTouches

Die Anzahl der an der Geste beteiligten Berührungspunkte (in der Regel 1).

Wird ausgelöst, wenn der Spieler eine Wischgeste auf dem UI-Element ausführt.

Dieses Codebeispiel schaltet die `Class.GuiObject.BackgroundTransparency` eines
UI-Elements, wie eines `Frame`, um, wenn es auf einem touchfähigen Gerät angetippt wird.

Dieses Ereignis wird ausgelöst, wenn der Spieler eine Tippgeste auf dem UI-Element
mit einem berührungsempfindlichen Gerät ausführt. Ein Tipp ist eine schnelle, einzelne Berührung ohne
bewegung (ein längerer Druck würde
`Class.GuiObject.TouchLongPress` auslösen, und Bewegung während der Berührung würde
`Class.GuiObject.TouchPan` und/oder `Class.GuiObject.TouchSwipe` auslösen). Es wird
mit einer Tabelle von `Datatype.Vector2`-Objekten ausgelöst, die die relativen
Positionen der Finger beschreibt, die an der Geste beteiligt sind.

GuiObject.TouchTap

Ein Array von `Datatype.Vector2`, das die **relativen**
Positionen der an der Geste beteiligten Finger beschreibt.

Wird ausgelöst, wenn der Spieler eine Tippen-Geste auf dem UI-Element ausführt.

Dieses Codebeispiel zeigt eine umfangreichere Verwendung von TweenPosition, indem
detektiert wird, wann das Tween abgeschlossen/abgebrochen wird, indem eine Callback-Funktion definiert wird. Es
wird auch ausgegeben, ob das Tween abgespielt wird.

Bewegt eine GUI sanft zu einer neuen `Datatype.UDim2`-Position in der angegebenen
Zeit unter Verwendung der angegebenen `Enum.EasingDirection`- und `Enum.EasingStyle`.

Diese Funktion gibt zurück, ob das Tween abgespielt wird oder nicht. Es wird nicht abgespielt, wenn
 ein anderes Tween auf dem `Class.GuiObject` aktiv ist und der Übersteuerungsparameter `false` ist.

Siehe auch `Class.GuiObject:TweenSize()` und
`Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenPosition

endPosition

easingDirection

Die Richtung, in die die GUI zu der _endPosition_ eased werden soll.

easingStyle

Der Stil, in dem die GUI zu der _endPosition_ eased werden soll.

time

Wie lange, in Sekunden, das Tween zur Vollziehung benötigt.

override

Ob das Tween ein in Bearbeitung befindliches Tween überschreibt.

callback

Eine Callback-Funktion, die ausgeführt wird, wenn das Tween abgeschlossen ist.

Bewegt eine GUI sanft zu einem neuen `Datatype.UDim2`.

Dieses Codebeispiel demonstriert die Verwendung der `Class.GuiObject:TweenSize()`
Funktion. Es initiiert eine Animation auf der `Class.GuiObject.Size`
Eigenschaft des Elternteils zu `UDim2.new(0.5, 0, 0.5, 0)`, was die Hälfte der Größe des `GuiObject`
Elternteils in beiden Achsen ist.

Zusätzlich wird demonstriert, wie der Callback-Parameter verwendet werden kann, um zu erkennen,
wann der Tween stoppt (ob er von einem anderen Tween abgebrochen wurde oder abgeschlossen wurde).

Ändert die Größe eines `Class.GuiObject` sanft zu einem neuen `Datatype.UDim2` in der
angegebenen Zeit unter Verwendung der angegebenen `Enum.EasingDirection`- und
`Enum.EasingStyle`.

Diese Funktion gibt zurück, ob das Tween abgespielt wird oder nicht. Normalerweise gibt dies
immer `true` zurück, jedoch wird es `false` zurückgeben, wenn ein anderes Tween
aktiv ist und `override` auf `false` gesetzt ist.

Siehe auch `Class.GuiObject:TweenSize()` und
`Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenSize

endSize

Die Größe, auf die die GUI geändert werden soll.

Die Richtung, in die die GUI zu der _endSize_ eased werden soll.

Der Stil, in dem die GUI zu der _endSize_ eased werden soll.

Ändert die Größe eines `Class.GuiObject` sanft zu einem neuen `Datatype.UDim2`.

Das folgende Beispiel würde ein `Class.Frame` in die obere linke Ecke der Größe des Elternteils tweenen
und es auf 0 verkleinern.

Ändert die Größe und bewegt eine GUI sanft zu einer neuen `Datatype.UDim2`-Größe und
Position in der angegebenen Zeit unter Verwendung der angegebenen `Enum.EasingDirection`
und `Enum.EasingStyle`.

Diese Funktion gibt zurück, ob das Tween abgespielt wird oder nicht. Normalerweise gibt dies
immer `true` zurück, jedoch wird es `false` zurückgeben, wenn ein anderes Tween
aktiv ist und `override` auf `false` gesetzt ist.

Siehe auch `Class.GuiObject:TweenSize()` und `Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenSizeAndPosition

Die Richtung, in der die GUI zu der _endSize_ und
_endPosition_ eased werden soll.

Der Stil, in dem die GUI zu der _endSize_ und _endPosition_ eased werden soll.

Bewegt eine GUI sanft zu einer neuen Größe und Position.

GuiObject

Dieses Codebeispiel demonstriert die Verwendung der Active-Eigenschaft als Entprellung
für das Activated-Ereignis.

Diese Eigenschaft bestimmt, ob das `Class.GuiObject` Eingaben in den
3D-Raum, wie darunter liegende Modelle mit einer `Class.ClickDetector`-Klasse 
wie `Class.DragDetector`, absorbiert.

Für `Class.GuiButton`-Objekte (`Class.ImageButton` und
`Class.TextButton`) bestimmt diese Eigenschaft, ob
`Class.GuiButton.Activated|Activated` ausgelöst wird
(`Class.GuiButton.AutoButtonColor|AutoButtonColor` funktioniert dabei auch).
Die Ereignisse `Class.GuiObject.InputBegan|InputBegan`,
`Class.GuiObject.InputChanged|InputChanged` und
`Class.GuiObject.InputEnded|InputEnded` funktionieren normal, unabhängig vom Wert
 dieser Eigenschaft.

GuiObject.Active

Bestimmt, ob dieses UI-Element Eingaben absorbiert.

Dieses Codebeispiel bewegt ein UI-Element zu verschiedenen Seiten des Elternelements.
Es beginnt oben links und endet unten rechts. Fügen Sie es in ein
LocalScript in einem Frame innerhalb eines ScreenGui ein.

Diese Eigenschaft bestimmt den Ursprungspunkt eines `Class.GuiObject`, relativ
zu seiner absoluten Größe. Der Ursprungspunkt bestimmt, von wo das Element
(positioniert durch `Class.GuiObject.Position`) und von wo das
gerenderte `Class.GuiObject.Size` erweitert wird.

Siehe [hier](/ui/position-and-size#anchorpoint) für illustrierte
Diagramme und Details.

GuiObject.AnchorPoint

Bestimmt den Ursprungspunkt eines `Class.GuiObject`, relativ zu seiner
absoluten Größe.

Das folgende Skript erstellt ein automatisch größenanpassendes Elternelement mit
einem `UIListLayout`, dann fügt es mehrere automatisch größenanpassende `TextLabel`
Objekte ein. Beachte, wie das Elternelement `UIListLayout` automatisch angepasst wird, um
einzelne Inhalte zu passen, und die Labels automatisch angepasst werden, um ihren Textinhalt zu fassen.
Dieses Skript kann einem `ScreenGui` zugeordnet werden.

Diese Eigenschaft wird verwendet, um Eltern-UIs automatisch auf der Basis der
Größe ihrer Nachkommen zu dimensionieren. Sie können diese Eigenschaft verwenden, um dynamisch Text
und andere Inhalte zu einem UI-Objekt zur Bearbeitungs- oder Laufzeit hinzuzufügen, und die Größe wird
 angepasst, um diese Inhalte zu berücksichtigen.

Wenn `Class.GuiObject.AutomaticSize|AutomaticSize` auf einen
`Enum.AutomaticSize`-Wert gesetzt wird, der nichts anderes als `Enum.AutomaticSize|None` ist, kann 
dieses UI-Objekt je nachdem, was sich in den Kindinhalten befindet, seine Größe ändern.

Für weitere Informationen zur Verwendung dieser Eigenschaft und wie sie funktioniert, siehe
[hier](/ui/size-modifiers#automatic-sizing).

GuiObject.AutomaticSize

Bestimmt, ob die Größenänderung basierend auf dem Inhalt der Kinder erfolgt.

Bestimmt die Farbe des Hintergrunds des `Class.GuiObject`.

GuiObject.BackgroundColor

Dieses Codebeispiel lässt einen übergeordneten Rahmen durch alle Farben des
Regenbogens mit Color3.fromHSV schleifen.

Diese Eigenschaft bestimmt die Farbe eines `Class.GuiObject`-Hintergrunds (die
Füllfarbe). Wenn Ihr Element Text enthält, wie ein `Class.TextBox`,
`Class.TextButton` oder `Class.TextLabel`, stellen Sie sicher, dass die Farbe Ihres
Hintergrunds im Kontrast zur Farbe des Texts steht.

Eine weitere Eigenschaft, die die visuellen Eigenschaften des Hintergrunds bestimmt,
ist `Class.GuiObject.BackgroundTransparency`; wenn dies auf `1` gesetzt ist,
wird weder der Hintergrund noch der Rand gerendert.

Siehe auch `Class.GuiObject.BorderColor3|BorderColor3`.

GuiObject.BackgroundColor3

Bestimmt die Hintergrundfarbe des `Class.GuiObject`.

Diese Eigenschaft bestimmt die Transparenz des `Class.GuiObject`
Hintergrunds und Randes. Sie bestimmt jedoch nicht die Transparenz von
Text, wenn die GUI ein `Class.TextBox`, `Class.TextButton` oder
`Class.TextLabel` ist; die Texttransparenz wird bestimmt durch
`Class.TextBox.TextTransparency`, `Class.TextButton.TextTransparency` und
`Class.TextLabel.TextTransparency`.

Wenn diese Eigenschaft auf `1` gesetzt ist, wird weder der Hintergrund noch der Rand angezeigt,
und der GUI-Hintergrund ist vollständig transparent.

GuiObject.BackgroundTransparency

Bestimmt die Transparenz des Hintergrunds und des Randes des `Class.GuiObject`.

Bestimmt die Farbe des Randes des `Class.GuiObject`.

GuiObject.BorderColor

Dieses Codebeispiel lässt den Rand eines übergeordneten GuiObject hervorgehoben werden, wenn der
Benutzer mit der Maus über das Element fährt.

Bestimmt die Farbe des rechteckigen Randes des `Class.GuiObject` (auch
als Strichfarbe bekannt). Dies ist unabhängig von der
eigenschaften von `Class.GuiObject.BackgroundColor3`. Der Rand des Objekts ist nicht sichtbar,
wenn die `Class.GuiObject.BorderSizePixel`-Eigenschaft auf `0`
gesetzt ist.

Beachten Sie, dass die `Class.UIStroke`-Komponente erweiterte Rand-
effekte ermöglicht.

GuiObject.BorderColor3

Diese Eigenschaft bestimmt, wie der Rand des `Class.GuiObject` in Bezug auf seine Abmessungen angeordnet wird,
unter Verwendung des gleichnamigen Enums, `Enum.BorderMode`.

Hinweis: `Class.UIStroke` kann diese Eigenschaft überschreiben und ermöglicht erweiterte
Randeffekte.

GuiObject.BorderMode

Bestimmt, wie der Rand des `Class.GuiObject` in Bezug auf seine Abmessungen angeordnet wird.

Diese Eigenschaft bestimmt, wie breit der Rand des `Class.GuiObject` in
Pixeln gerendert wird. Wenn Sie dies auf `0` setzen, wird der Rand insgesamt deaktiviert.

Hinweis: `Class.UIStroke` kann diese Eigenschaft überschreiben und ermöglicht erweiterte
Randeffekte.

GuiObject.BorderSizePixel

Bestimmt die Pixelbreite des Randes des `Class.GuiObject`.

Eine abstrakte Klasse für alle 2D-Benutzeroberflächenobjekte.

/reference/engine/classes/InputActionLabel.yaml