`Class.Frame` ist ein `Class.GuiObject`, das als Container für andere
`Class.GuiObject|GuiObjects` fungiert. Sie können es für die UI verwenden, die entweder auf einem
Benutzerbildschirm [screen](/ui/on-screen-containers) oder auf einer
[oberfläche](/ui/in-experience-containers) innerhalb der Erfahrung angezeigt wird.

<img src="/assets/ui/ui-objects/Frame-Example.jpg" width="840" />

`Class.Frame|Frames` sind ideal für responsive Layouts wie
[list and flex layouts](/ui/list-flex-layouts), die es Ihnen ermöglichen,
die Größe des Frames zu ändern und dynamisch anzupassen, wie Layout-Elemente darin passen.
`Class.Frame|Frames` sind auch Kernbestandteile von `Class.GuiObject|GuiObjects`, sodass
Sie Eigenschaften wie
`Class.GuiObject.BackgroundColor3|BackgroundColor3`,
`Class.GuiObject.Transparency|Transparency` anpassen, einen
[Hintergrundverlauf](/ui/appearance-modifiers#gradient) oder
[Rand](/ui/appearance-modifiers#stroke) anwenden und mehr.


Frame

Bestimmt, wie der Frame aus einer Auswahl vordefinierter Stile aussieht.
Siehe `Enum.FrameStyle` für eine Beschreibung jedes Stils.


Frame.Style

Bestimmt, wie der Frame aus einer Auswahl vordefinierter Stile aussieht.


Ein `Class.GuiObject`, das als einfaches Rechteck gerendert wird, und allgemein als ein
Container verwendet wird.


`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`.

Diese Eigenschaft bestimmt, ob das `Class.GuiObject` einen Teil von Nachfahren-GUI-Elementen zugeschnitten wird
, die andernfalls außerhalb der Grenzen des Rechtecks gerendert werden.

Hinweis: `Class.GuiObject.Rotation|Rotation` wird von dieser Eigenschaften nicht unterstützt.
Wenn diese oder ein übergeordnetes GUI eine **nicht null**
`Class.GuiObject.Rotation|Rotation` hat, wird diese Eigenschaft **ignoriert** und
Nachfahren-GUI-Elemente werden unabhängig von ihrem Wert gerendert.

GuiObject.ClipsDescendants

Bestimmt, ob Nachkommen `Class.GuiObject|GuiObjects`, die außerhalb der
Grenzen eines übergeordneten GUI-Elements liegen, gerendert werden sollen.

Dies zeigt an, ob ein `Class.GuiObject` (und seine Nachkommen) über den Bildschirm gezogen werden kann.

GuiObject.Draggable

Bestimmt, ob ein `Class.GuiObject` (und seine Nachkommen) über den Bildschirm gezogen werden können.

Wenn der Finger des Spielers auf dem
`Class.GuiObject` gedrückt wird und gehalten wird, wird der `Class.GuiObject.GuiState|GuiState` von 
`Class.GuiObject` auf `Enum.GuiState.Press|Press` gesetzt. Ebenso,
wenn der Finger des Spielers vom `Class.GuiObject` losgelassen wird, wird der
`Class.GuiObject.GuiState|GuiState` von `Class.GuiObject` auf
`Enum.GuiState.Idle|Idle` gesetzt, und wenn
`Class.GuiObject.Interactable|Interactable` im `Class.GuiObject` deaktiviert wird, wird der
`Class.GuiState` von `Class.GuiObject` auf
`Enum.GuiState.NonInteractable|NonInteractable` gesetzt.

GuiObject.GuiState

Bestimmt, ob die Maus des Spielers aktiv auf dem `Class.GuiObject` gedrückt wird oder nicht.

GuiObject.InputSink

Bestimmt, ob der `Class.GuiButton` interaktiv ist oder nicht, oder
ob sich der `Enum.GuiState|GuiState` des `Class.GuiObject` ändert oder
nicht.

Bei einem `Class.GuiButton`:

- Wenn die Einstellung `Class.GuiObject.Interactable|Interactable` auf dem
  `Class.GuiButton` auf `false` gesetzt ist, kann der `Class.GuiButton` nicht
  mehr gedrückt oder angeklickt werden, und der
  `Class.GuiObject.GuiState|GuiState` wird ständig auf
  `Enum.GuiState.NonInteractable|NonInteractable` gesetzt.
- Wenn die Einstellung `Class.GuiObject.Interactable|Interactable` auf dem
  `Class.GuiButton` auf `true` gesetzt ist, verhält sich der `Class.GuiButton`
  wieder normal und der `Class.GuiObject.GuiState|GuiState` funktioniert
  normal.

Bei einem `Class.GuiObject`:

- Wenn die Einstellung `Class.GuiObject.Interactable|Interactable` auf dem
  `Class.GuiButton` auf `false` gesetzt ist, wird der
  `Class.GuiObject.GuiState|GuiState` ständig auf
  `Enum.GuiState.NonInteractable|NonInteractable` gesetzt.
- Wenn die Einstellung `Class.GuiObject.Interactable|Interactable` auf dem
  `Class.GuiButton` auf `true` gesetzt ist, verhält sich der
  `Class.GuiObject.GuiState|GuiState` wieder normal.


GuiObject.Interactable

Bestimmt, ob der `Class.GuiButton` interaktiv ist oder nicht, oder
ob sich der `Enum.GuiState|GuiState` des `Class.GuiObject` ändert oder
nicht.


Diese Eigenschaft kontrolliert die Sortierreihenfolge des `Class.GuiObject`, wenn
mit einem `Class.UIGridStyleLayout` (wie `Class.UIListLayout` oder
`Class.UIPageLayout`) verwendet, wobei `Class.UIGridStyleLayout.SortOrder|SortOrder`
auf `Enum.SortOrder.LayoutOrder` gesetzt ist. Sie hat keine Funktionalität, wenn das Objekt
keine Geschwister-UI-Layout-Struktur hat.

`Class.GuiObject|GuiObjects` werden in aufsteigender Reihenfolge sortiert, wobei niedrigere
Werte höheren Werten Vorrang haben. Objekte mit gleichen Werten fallen
auf die Reihenfolge zurück, in der sie hinzugefügt wurden.

Wenn Sie sich nicht sicher sind, ob Sie in Zukunft ein Element zwischen zwei bestehenden
elementen hinzufügen müssen, ist es eine gute Praxis, Vielfache von `100`
(`0`, `100`, `200`, usw.) zu verwenden. Dies gewährleistet eine große Lücke von Sortierreihenfolgen,
die Sie für zwischen anderen Elementen sortierte Elemente verwenden können.

Siehe auch `Class.GuiObject.ZIndex|ZIndex`, welches die **Darstellungs**reihenfolge des Objekts anstelle der Sortierreihenfolge bestimmt.


GuiObject.LayoutOrder

Kontrolliert die Sortierreihenfolge des `Class.GuiObject`, wenn es mit einem
`Class.UIGridStyleLayout` verwendet wird.


Dieses Beispiel zeigt, wie man die Gamepad-Navigation durch ein Raster von
`GuiObject|GUI`-Elementen ermöglichen kann, ohne manuell die
`Class.GuiObject.NextSelectionUp`, `Class.GuiObject.NextSelectionDown` und
`GuiObject|NextSelectionRight` sowie `Class.GuiObject.NextSelectionLeft`
Eigenschaften für jedes Element im Raster zu verbinden.

Beachten Sie, dass dieses Codebeispiel davon ausgeht, dass Ihr `UIGridLayout`
nach `Class.UIGridLayout.SortOrder|name` sortiert ist, wobei die Elemente in
aufeinanderfolgender numerischer Reihenfolge benannt sind.

Der Code verlässt sich darauf, die NextSelection-Eigenschaften für alle
`GuiObjects` auf derselben Ebene wie das UIGridLayout festzulegen. In unserem
Beispiel sind das UIGridLayoutObject und die GUI-Elemente innerhalb des Rasters
alle Kinder eines `Frame` mit dem Namen _"Container"_. Der Code
`Class.Instance:GetChildren()|holt die Kinder` von _"Container"_ und durchläuft
jedes Kind. Kinder, die keine GuiObjects sind, werden ignoriert. Für jedes GUI-
Element versucht der Code, die NextSelection-Eigenschaften mit der folgenden
Logik zuzuweisen:

1. Beginnend mit 1, stimmt der Name aller GUI-Elemente mit ihrer Position im
   Raster überein.
2. Links: Das Element links wird immer um 1 kleiner nummeriert als das aktuelle
   Element.
3. Rechts: Das Element rechts wird immer um 1 größer nummeriert als das aktuelle
   Element.
4. Oben: Das Element oben (nach oben) wird immer die Anzahl der GUIs in einer
   Reihe um 1 kleiner sein als das aktuelle Element.
5. Unten: Das Element unten (nach unten) wird immer die Anzahl der GUIs in einer
   Reihe um mehr als das aktuelle Element sein. Diese Logik ermöglicht es auch,
   dass die GUI-Elemente am Anfang und Ende von Reihen (außer dem ersten und
   letzten Element) zu den nächsten und vorherigen Reihen zurückkehren. Wenn kein
   Element links, rechts, oben oder unten existiert, bleibt die NextSelection nil,
   und das Bewegen des Gamepad-Auswählers in diese Richtung ändert nicht das
   ausgewählte GUI.

Dieses Beispiel enthält auch Code, um das Raster mit den Pfeiltasten (Hoch,
Runter, Links, Rechts) Ihrer Tastatur anstelle eines Gamepads zu testen, falls Sie
kein Gamepad zum Testen haben. Dieser Teil des Codes wählt anfänglich das
element mit dem Namen _"1"_ aus, indem es ihm die Eigenschaft
`Class.GuiService.SelectedObject` zuweist.


Diese Eigenschaft setzt das `Class.GuiObject`, das ausgewählt wird, wenn der Benutzer den
[Gamepad](/input/gamepad) Wähler nach unten bewegt. Wenn diese Eigenschaft
leer ist, ändert sich das ausgewählte GUI nicht, wenn das Gamepad nach unten bewegt wird.

Das Bewegen des Gamepad-Wählern nach unten setzt das
`Class.GuiService.SelectedObject` auf dieses Objekt, es sei denn, das GUI ist nicht
`Class.GuiObject.Selectable|Selectable`. Beachten Sie, dass diese Eigenschaft auf ein GUI-Element gesetzt werden kann,
auch wenn es nicht `Class.GuiObject.Selectable|Selectable` ist, sodass Sie sicherstellen sollten, dass der
Wert der wählbaren Eigenschaft eines GUIs Ihrem erwarteten Verhalten entspricht.

Siehe auch `Class.GuiObject.NextSelectionUp|NextSelectionUp`,
`Class.GuiObject.NextSelectionLeft|NextSelectionLeft` und
`Class.GuiObject.NextSelectionRight|NextSelectionRight`.


GuiObject.NextSelectionDown

Setzt das `Class.GuiObject`, das ausgewählt wird, wenn der
Gamepad-Wähler nach unten bewegt wird.


Diese Eigenschaft setzt das `Class.GuiObject`, das ausgewählt wird, wenn der Benutzer den
[Gamepad](/input/gamepad) Wähler nach links bewegt. Wenn diese
Eigenschaft leer ist, ändert sich das ausgewählte GUI nicht, wenn das Gamepad nach links bewegt wird.

Das Bewegen des Gamepad-Wählers nach links setzt das
`Class.GuiService.SelectedObject` auf dieses Objekt, es sei denn, das GUI ist nicht
`Class.GuiObject.Selectable|Selectable`. Beachten Sie, dass diese Eigenschaft auf ein GUI-Element gesetzt werden kann,
auch wenn es nicht `Class.GuiObject.Selectable|Selectable` ist, sodass Sie sicherstellen sollten, dass der
Wert der wählbaren Eigenschaft eines GUIs Ihrem erwarteten Verhalten entspricht.

Siehe auch `Class.GuiObject.NextSelectionUp|NextSelectionUp`,
`Class.GuiObject.NextSelectionDown|NextSelectionDown` und
`Class.GuiObject.NextSelectionRight|NextSelectionRight`.


GuiObject.NextSelectionLeft

Setzt das `Class.GuiObject`, das ausgewählt wird, wenn der
Gamepad-Wähler nach links bewegt wird.


Diese Eigenschaft setzt das `Class.GuiObject`, das ausgewählt wird, wenn der Benutzer den
[Gamepad](/input/gamepad) Wähler nach rechts bewegt. Wenn diese
Eigenschaft leer ist, ändert sich das ausgewählte GUI nicht, wenn das Gamepad nach rechts bewegt wird.

Das Bewegen des Gamepad-Wählers nach rechts setzt das
`Class.GuiService.SelectedObject` auf dieses Objekt, es sei denn, das GUI ist nicht
`Class.GuiObject.Selectable|Selectable`. Beachten Sie, dass diese Eigenschaft auf ein GUI-Element gesetzt werden kann,
auch wenn es nicht `Class.GuiObject.Selectable|Selectable` ist, sodass Sie sicherstellen sollten, dass der
Wert der wählbaren Eigenschaft eines GUIs Ihrem erwarteten Verhalten entspricht.

Siehe auch `Class.GuiObject.NextSelectionUp|NextSelectionUp`,
`Class.GuiObject.NextSelectionDown|NextSelectionDown` und
`Class.GuiObject.NextSelectionLeft|NextSelectionLeft`.


GuiObject.NextSelectionRight

Setzt das `Class.GuiObject`, das ausgewählt wird, wenn der
Gamepad-Wähler nach rechts bewegt wird.


Diese Eigenschaft setzt das `Class.GuiObject`, das ausgewählt wird, wenn der Benutzer den
[Gamepad](/input/gamepad) Wähler nach oben bewegt. Wenn diese Eigenschaft ist
leer, ändert sich das ausgewählte GUI nicht, wenn das Gamepad nach oben bewegt wird.

Das Bewegen des Gamepad-Wählers nach oben setzt das
`Class.GuiService.SelectedObject` auf dieses Objekt, es sei denn, das GUI ist nicht
`Class.GuiObject.Selectable|Selectable`. Beachten Sie, dass diese Eigenschaft auf ein GUI-Element gesetzt werden kann,
auch wenn es nicht `Class.GuiObject.Selectable|Selectable` ist, sodass Sie sicherstellen sollten, dass der
Wert der wählbaren Eigenschaft eines GUIs Ihrem erwarteten Verhalten entspricht.

Siehe auch `Class.GuiObject.NextSelectionDown|NextSelectionDown`,
`Class.GuiObject.NextSelectionLeft|NextSelectionLeft`,
`Class.GuiObject.NextSelectionRight|NextSelectionRight`.


GuiObject.NextSelectionUp

Setzt das `Class.GuiObject`, das ausgewählt wird, wenn der
Gamepad-Wähler nach oben bewegt wird.


Diese Eigenschaft bestimmt die Pixel- und Skalierungsposition des `Class.GuiObject`
unter Verwendung eines `Datatype.UDim2`. Die Position ist um den `Class.GuiObject.AnchorPoint`
zentriert.

Die Skalierungsposition ist relativ zur Größe des übergeordneten GUI-Elements, falls vorhanden.

Die Pixelanteile des Wertes `Datatype.UDim2` sind unabhängig von der Größe des übergeordneten GUIs gleich.
Die Werte repräsentieren die Position des Objekts in Pixeln. Die tatsächliche Pixelposition eines Objekts kann aus der
`Class.GuiBase2d.AbsolutePosition`-Eigenschaft gelesen werden.


GuiObject.Position

Bestimmt die Pixel- und Skalierungsposition des `Class.GuiObject`.


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