`Class.TextChannelWindow` ist ein `Class.GuiObject`, das in-Erlebnis
Textnachrichten aus einem verknüpften `Class.TextChannel` rendert. Platziere es unter einem
`Class.ScreenGui` oder einem anderen Nachkommen von `Class.LayerCollector`, um den Chat
an einem benutzerdefinierten Ort und Layout anzuzeigen.

Setze `Class.TextChannelWindow.Target|Target` auf einen `Class.TextChannel`, um zu wählen,
welche Nachrichten des Kanals im Fenster angezeigt werden. Das Fenster registriert sich bei
`Class.TextChatService`, wenn es dem Datenmodell hinzugefügt wird.

Eigenschaften, die auf `Class.ChatWindowConfiguration` gesetzt sind, gelten nicht für dieses Fenster.

Akzeptierte Kinder: `Class.UICorner`, `Class.UIAspectRatioConstraint`,
`Class.UISizeConstraint` und Skripte (`Class.LocalScript`, `Class.Script`,
`Class.ModuleScript`); andere Kindtypen werden abgelehnt.


TextChannelWindow

Eine Referenz zu dem `Class.TextChannel`, dessen Nachrichten dieses Fenster rendert.
Wenn gesetzt, zeigt das Fenster Nachrichten aus dem angegebenen Kanal an. Das Setzen
dieser Eigenschaft auf `nil` trennt das Fenster von einem Kanal, sodass es
keine Nachrichten anzeigt.

Der Standardwert ist `nil` (kein Kanal verknüpft).

TextChannelWindow.Target

Zeigt den RBXGeneral-Kanal in einem benutzerdefinierten Fenster mit einer nicht standardmäßigen Schriftart an. Fügen Sie
es in ein LocalScript ein.


Schriftart, die verwendet wird, um die Nachrichten dieses Fensters und seine Eingabeleiste darzustellen. Wird nur angewendet,
wenn `Class.TextChannelWindow.UseDefaultFont` `false` ist.


TextChannelWindow.FontFace

Schriftart, die verwendet wird, um Text in diesem Fenster darzustellen.


Wenn `true` (Standard), verwendet das Fenster die Standard-Schriftart der Live-Plattform.
Wenn `false`, verwendet das Fenster `Class.TextChannelWindow.FontFace|FontFace`.


TextChannelWindow.UseDefaultFont

Ob dieses Fenster die Standard-Schriftart der Live-Plattform verwendet.


`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ächen (GUI) Objekts wie `Class.GuiObject.Size|Size`
und `Class.GuiObject.Position|Position` zusammenhängen. 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 spezielle Weise zu manipulieren, können Sie eine Layoutstruktur
wie [list/flex](/ui/list-flex-layouts) oder
[grid](/ui/grid-table-layouts) verwenden, und Sie können sie über ihre
Kerneigenschaften hinaus durch
[appearance modifiers](/ui/appearance-modifiers) gestalten.

Obwohl es möglich ist, Maustastenereignisse auf jedem GUI-Objekt mit
`Class.GuiObject.InputBegan|InputBegan` und
`Class.GuiObject.InputEnded|InputEnded` zu erkennen, haben nur `Class.ImageButton` und
`Class.TextButton` bequeme, 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 beginnt, das Objekt zu ziehen.

Siehe auch `Class.GuiObject.DragStopped`.

GuiObject.DragBegin

initialPosition

Ein `Datatype.UDim2`-Wert der Position des `Class.GuiObject`
vor Beginn einer Ziehoperation.

Wird ausgelöst, wenn ein Spieler beginnt, das Objekt zu ziehen.

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 X- und Y-Position drucken,
 wo der Spieler aufgehört hat, die GUI zu ziehen. Wenn der Spieler beispielsweise das Objekt bei 189, 180 loslässt,
 würde das Folgendes drucken: Der Spieler hat das Ziehen des GuiObject bei (189, 180) gestoppt.


Dieses Ereignis wird ausgelöst, wenn ein Spieler aufhört, das Objekt zu ziehen.

Siehe auch `Class.GuiObject.DragBegin`.

GuiObject.DragStopped

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

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

Wird ausgelöst, wenn ein Spieler aufhört, das Objekt zu ziehen.

Das folgende Beispiel demonstriert eines von vielen Anwendungsbeispielen zur Handhabung von Benutzer
Eingaben von InputBegan, abhängig von ihrem Typ.

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


Dieses Ereignis wird ausgelöst, wenn ein Benutzer mit dem `Class.GuiObject`
über ein Human-Computer-Interface-Gerät (Maus-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.InputBegan`.

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

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

GuiObject.InputBegan

input

Ein `Class.InputObject`, das nützliche Daten zum Abfragen von Benutzer
Eingaben enthält, wie den `Enum.UserInputType|Eingabetyp`,
`Enum.UserInputState|Eingabestatus` und
`Class.InputObject.Position|Bildschirmkoordinaten der Eingabe`.

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

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 ändert, wie er über ein
Human-Computer-Interface-Gerät (Maus-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 immer ausgelöst, unabhängig vom Spielstatus.

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

GuiObject.InputChanged

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

Das folgende Beispiel demonstriert eines von vielen Anwendungsbeispielen zur Handhabung von Benutzer
Eingaben aus InputEnded, abhängig von ihrem Typ.

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


Das InputEnded-Ereignis wird ausgelöst, wenn ein Benutzer aufhört, über ein
Human-Computer-Interface-Gerät (Maus-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.InputEnded`.

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

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

GuiObject.InputEnded

Ein `Class.InputObject`, das nützliche Daten zum Abfragen von Benutzer
Eingaben enthält, wie 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 (Maus-Taste gedrückt, Berührung beginnt, Tastaturtaste gedrückt usw.).

Das folgende Beispiel druckt die Mausposition in Pixeln, wenn sie in das GUI-Element eintritt.


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 von diesem Ereignis übergeben werden, als
sichere Möglichkeit, zu bestimmen, wo sich die Maus des Benutzers befindet, wenn sie in ein
GUI eintritt. Diese Koordinaten können variieren, selbst wenn die Maus über die
selbe Kante in die GUI eintritt - insbesondere, wenn die Maus schnell in das Element eintritt. Dies
liegt daran, dass die Koordinaten die Position der Maus angeben, wenn das Ereignis ausgelöst wird, anstatt den genauen Moment, in dem die Maus in die GUI eintritt.

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

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 von diesem Ereignis übergeben werden, als
sichere Möglichkeit, zu bestimmen, wo sich die Maus des Benutzers befindet, wenn sie ein GUI verlässt. Diese Koordinaten können variieren, selbst wenn die Maus über die
selbe Kante das GUI verlässt - insbesondere, wenn die Maus schnell das Element verlässt. Dies
liegt daran, dass die Koordinaten die Position der Maus angeben, wenn das Ereignis ausgelöst wird, anstatt den genauen Moment, in dem die Maus das GUI verlässt.

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

##### 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 seine Maus bewegt, während sie sich innerhalb eines
`Class.GuiObject`-Elements befindet. Es ist ähnlich wie `Class.Mouse.Move`, das
unabhängig davon ausgelöst wird, ob die Maus des Benutzers über einem GUI-Element ist.

Beachten Sie, dass dieses Ereignis ausgelöst wird, wenn die Position der Maus aktualisiert wird, daher
wird es wiederholt ausgelöst, während sie bewegt wird.

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
auf der GUI, dem Bildschirm und die Differenz zur vorherigen Position der Maus zu bestimmen,
wenn sie in einer globalen Variablen verfolgt wird.

Der folgende Code zeigt, wie man den `Datatype.Vector2`-Offset
der Maus des Benutzers relativ zu einem GUI-Element bestimmt.
`Class.GuiObject.AbsolutePosition|AbsolutePosition` wird innerhalb des
GUI-Abstands des Bildschirms gemessen, während die `x`- und `y`-Argumente dieses Ereignisses
Bildschirmkoordinaten sind, die ihn einschließen, sodass der Beispielaufruf
`Class.GuiService:GetGuiInset()|GetGuiInset()` die beiden Bereiche
abgleicht, anstatt von einer festen Abstandsgröße auszugehen.

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

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

local mouse = Players.LocalPlayer:GetMouse()

local function getPosition(X, Y)
	local topLeftInset = GuiService:GetGuiInset()

	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 - topLeftInset.Y))
	print(pos)
end

CustomScrollingFrame.MouseMoved:Connect(getPosition)
```
Beachten Sie, dass dieses Ereignis möglicherweise nicht genau ausgelöst wird, wenn die Maus des Benutzers in ein GUI-Element eintritt oder es verlässt. Daher stimmen die Argumente `x` und `y` möglicherweise nicht perfekt mit den Koordinaten der Ränder der GUI ü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 sich in einem GUI-Element befindet.

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 wie
`Class.Mouse.WheelBackward`, das unabhängig davon ausgelöst wird, ob sich die Maus des Benutzers über einem GUI-Element befindet.

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 `Class.GuiObject.MouseMoved`-Ereignis 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 wie
`Class.Mouse.WheelForward`, das unabhängig davon ausgelöst wird, ob sich die Maus des Benutzers über einem GUI-Element befindet.

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 `Class.GuiObject.MouseMoved`
Ereignis 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-Selector auf das GUI-Element aufhört zu fokussieren,
können Sie das `Class.GuiObject.SelectionLost`-Ereignis verwenden.

Wenn eine GUI den Auswahlfokus erhält, ändert sich der Wert der
`Class.GuiService.SelectedObject|SelectedObject`-Eigenschaft ebenfalls auf das, das die Auswahl erhält. Um zu bestimmen, welches GUI die Auswahl 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-Selector beginnt, sich auf das GUI-Element zu konzentrieren,
können Sie das `Class.GuiObject.SelectionGained`-Ereignis verwenden.

Wenn eine GUI den Auswahlfokus verliert, ändert sich der Wert der
`Class.GuiService.SelectionObject|SelectionObject`-Eigenschaft entweder auf `nil` oder auf das GUI-Element, das den Auswahlfokus erhält. Um zu bestimmen, welches GUI die Auswahl 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 aufhört, sich auf das GuiObject zu konzentrieren.

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 gefärbt.


Dieses Ereignis wird nach einem kurzen Moment ausgelöst, wenn der Spieler seinen Finger
auf dem UI-Element mit einem berührungsempfindlichen Gerät hält. 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 plattformabhängig; im 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`, das den Zustand der Geste beschreibt:

- Begin wird einmal zu Beginn der Geste (nach der kurzen
  Verzögerung) ausgelöst.
- Change wird ausgelöst, wenn der Spieler seinen Finger bewegt, während er gedrückt hält.
- 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 lange zu drücken.

Dieses Codebeispiel soll in einem `LocalScript` innerhalb eines inneren
`Frame` platziert werden, der sich innerhalb eines äußeren `Frame` oder eines 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 vor
`Class.GuiObject.TouchSwipe` ausgelöst und wird nicht mit
`Class.GuiObject.TouchTap` ausgelöst. 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 beschreiben, die an der Geste beteiligt sind.

totalTranslation

Gibt an, wie weit die Schwenkbewegung 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 auf dem UI-Element bewegt.

Dieses Codebeispiel ist für ein `LocalScript` innerhalb eines inneren `Frame`, der
innerhalb eines äußeren `Frame` oder eines anderen `GuiObject` ist. Es ermöglicht dem Spieler, den inneren Frame zu skalieren,
indem er eine `Class.GuiObject.TouchPinch` 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 mit einem berührungsempfindlichen Gerät 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 zusammen mit `Class.GuiObject.TouchPan` ausgelöst. Dieses Ereignis ist nützlich, um dem Spieler zu ermöglichen, die Skalierung (Größe) von UI-Elementen auf dem Bildschirm zu manipulieren, und wird am häufigsten für Zoom-Funktionen verwendet.

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

GuiObject.TouchPinch

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

scale

Ein Float, der den Unterschied vom Beginn der Pinch-Geste angibt.

Ein Float, der angibt, wie schnell die Pinch-Geste erfolgt.

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

Dieses Codebeispiel ist für ein `LocalScript` innerhalb eines inneren `Frame`, der
innerhalb eines äußeren `Frame` oder eines anderen `GuiObject` ist. Es ermöglicht dem Spieler, den inneren
Frame zu drehen, 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 Rotationsgeste auf dem UI-Element mit einem berührungsempfindlichen Gerät auszuführen. Die Rotation tritt auf, wenn sich der Winkel der Linie zwischen zwei Fingern ändert. Dieses Ereignis wird zusammen mit `Class.GuiObject.TouchPan` ausgelöst. Dieses Ereignis ist nützlich, um dem Spieler zu ermöglichen, die Rotation von UI-Elementen auf dem Bildschirm zu manipulieren.

Dieses Ereignis wird mit einer Tabelle von `Datatype.Vector2` ausgelöst, die die relativen Bildschirmpositionen der an der Geste beteiligten Finger beschreibt. Darüber hinaus wird es mehrmals ausgelöst: `Enum.UserInputState.Begin` nach einer kurzen Verzögerung, `Enum.UserInputState.Change`, wenn der Spieler während der Geste einen Finger 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 anzeigen.

rotation

Ein Float, der angibt, wie viel die Rotation seit 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 Tabs in mobilen UIs zu wechseln.

GuiObject.TouchSwipe

swipeDirection

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

numberOfTouches

Die Anzahl der an der Geste beteiligten Berührungspunkte (normalerweise 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 Einzelberührung ohne jegliche Bewegung (ein längerer Druck würde `Class.GuiObject.TouchLongPress` auslösen, und eine 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 an der Geste beteiligten Finger beschreiben.

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 Tippgeste auf dem UI-Element ausführt.

Dieses Codebeispiel demonstriert eine umfangreichere Verwendung von TweenPosition, indem es erkennt, wann der Tween abgeschlossen oder abgebrochen wird, indem eine Callback-Funktion definiert wird. Es wird auch ausgegeben, ob der 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 Methode löst einen Fehler aus, wenn `easingStyle` `Enum.EasingStyle.Bezier`
oder `Enum.EasingStyle.Spring` ist.

Diese Funktion gibt zurück, ob der Tween abgespielt wird. Er wird nicht abgespielt, wenn
ein anderer Tween auf das `Class.GuiObject` wirkt und der Override
Parameter `false` ist.

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


GuiObject:TweenPosition

endPosition

easingDirection

Die Richtung, in die die GUI zur _endPosition_ eased werden soll.

easingStyle

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

time

Wie lange, in Sekunden, die Tween-Animation dauern soll.

override

Ob die Tween-Animation eine laufende Tween-Animation überschreiben wird.

callback

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

Bewegt eine GUI sanft zu einer 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 auf ein neues `Datatype.UDim2` in der
angegebenen Zeit unter Verwendung der angegebenen `Enum.EasingDirection` und
`Enum.EasingStyle`. Diese Methode löst einen Fehler aus, wenn `easingStyle` ist
`Enum.EasingStyle.Bezier` oder `Enum.EasingStyle.Spring`.

Diese Funktion gibt zurück, ob der Tween abgespielt wird. Normalerweise wird dies
immer `true` zurückgeben, aber es wird `false` zurückgeben, wenn ein anderer Tween aktiv ist
und der 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 zur _endSize_ eased werden soll.

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

Ändert die Größe eines `Class.GuiObject` sanft auf eine neue `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 Methode löst einen Fehler aus, wenn `easingStyle` ist
`Enum.EasingStyle.Bezier` oder `Enum.EasingStyle.Spring`.

Diese Funktion gibt zurück, ob der Tween abgespielt wird. Normalerweise wird dies
immer `true` zurückgeben, aber es wird `false` zurückgeben, wenn ein anderer Tween aktiv ist
und der Override auf `false` gesetzt ist.

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


GuiObject:TweenSizeAndPosition

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

Der Stil, in dem die GUI zur _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 zugrunde liegende Modelle mit einer `Class.ClickDetector`-Klasse
wie `Class.DragDetector`, annimmt.

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 auch für
 diese). 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 annimmt.

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 ist (durch `Class.GuiObject.Position`) und von wo die
gerenderte `Class.GuiObject.Size` sich ausdehnt.

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 einen automatisch dimensionierten übergeordneten Rahmen mit
einem `UIListLayout`, dann fügt es mehrere automatisch dimensionierte `TextLabel`
Objekte ein. Beachten Sie, wie sich das übergeordnete `UIListLayout` automatisch anpasst, um seinen
Kindinhalt aufzunehmen, und die Labels sich automatisch an ihren Textinhalt anpassen.
Dieses Skript kann einem `ScreenGui` zugewiesen werden.


Diese Eigenschaft wird verwendet, um übergeordnete UI-Objekte automatisch basierend auf 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 diesen Inhalt zu passen.

Wenn `Class.GuiObject.AutomaticSize|AutomaticSize` auf einen
`Enum.AutomaticSize`-Wert gesetzt ist, der etwas anderes als
`Enum.AutomaticSize|None` ist, kann dieses UI-Objekt je nach Inhalt seiner
Kinder die 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 des Hintergrunds eines `Class.GuiObject` (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 Textfarbe steht.

Eine weitere Eigenschaft, die die visuellen Eigenschaften des Hintergrunds bestimmt,
ist `Class.GuiObject.BackgroundTransparency`; wenn dies auf `1` gesetzt ist,
werden 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 Hintergrunds und des Randes des `Class.GuiObject`.
Sie bestimmt jedoch nicht die Transparenz des Textes, wenn die GUI ein `Class.TextBox`, `Class.TextButton` oder
`Class.TextLabel` ist; die Texttransparenz wird durch
`Class.TextBox.TextTransparency`, `Class.TextButton.TextTransparency` und
`Class.TextLabel.TextTransparency` jeweils bestimmt.

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

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 sorgt dafür, dass der Rand eines übergeordneten GuiObject hervorgehoben wird, 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 getrennt von der Hintergrundfarbe des Objekts
`Class.GuiObject.BackgroundColor3`. Sie können den Rand des Objekts nicht sehen,
wenn die Eigenschaft `Class.GuiObject.BorderSizePixel` auf `0` gesetzt ist.

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

GuiObject.BorderColor3

Diese Eigenschaft bestimmt, in welcher Weise der Rand des `Class.GuiObject` relativ zu seinen Dimensionen angeordnet ist, unter Verwendung des gleichnamigen Enums,
`Enum.BorderMode`.

Beachten Sie, dass `Class.UIStroke` diese Eigenschaft überschreiben kann und erweiterte Randwirkungen ermöglicht.

GuiObject.BorderMode

Bestimmt, in welcher Weise der Rand des `Class.GuiObject` relativ zu seinen Dimensionen angeordnet ist.

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

Beachten Sie, dass `Class.UIStroke` diese Eigenschaft überschreiben kann und erweiterte Randwirkungen ermöglicht.

GuiObject.BorderSizePixel

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

Diese Eigenschaft bestimmt, ob das `Class.GuiObject` Teile von nachfolgenden GUI-Elementen, die andernfalls außerhalb der Grenzen des Rechtecks gerendert werden würden, zuschneiden (unsichtbar machen) wird.

#### Rotationsverhalten

Wenn `Class.StarterGui.ClipsDescendantsSupportsRotation` aktiviert ist,
funktioniert das Zuschneiden korrekt für rotierte Formen. Das Zuschneiden **durch**
rotierte Formen (wenn der Zuschneide-Elternteil selbst rotiert ist) oder durch abgerundete
Ecken (`Class.UICorner`) wird jedoch nicht unterstützt.

Wenn `Class.StarterGui.ClipsDescendantsSupportsRotation` **nicht** aktiviert ist und dieses `Class.GuiObject` oder ein beliebiger Vorfahr `Class.GuiObject` eine **nicht-null** `Class.GuiObject.Rotation|Rotation` hat, wird diese Eigenschaft
**ignoriert** und nachfolgende GUI-Elemente werden unabhängig vom Wert dieser
Eigenschaft gerendert.

GuiObject.ClipsDescendants

Bestimmt, ob Nachkommen von `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 und gehalten wird, wird der `Class.GuiObject.GuiState|GuiState` des
`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` des `Class.GuiObject` auf
`Enum.GuiState.Idle|Idle` gesetzt, und wenn
`Class.GuiObject.Interactable|Interactable` auf dem
`Class.GuiObject` deaktiviert ist, wird der `Class.GuiState` des `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.

Steuert, ob und in welchem Maße das `Class.GuiObject` Eingaben annimmt,
 die über ihm erfolgen, unter Verwendung von `Enum.InputSink`. Das Annahme von Eingaben verhindert, dass sie
an Objekte hinter dem Element weitergegeben werden, einschließlich 3D-Objekten
in der Welt, wie denen mit einem `Class.ClickDetector` oder
`Class.DragDetector`. Es hat standardmäßig den Wert `Enum.InputSink.None`, außer bei
`Class.GuiButton`-Objekten (`Class.ImageButton` und `Class.TextButton`),
wo es standardmäßig `Enum.InputSink.Activate` ist.

- `Enum.InputSink.None` — das Objekt nimmt keine Eingaben von sich aus an.
- `Enum.InputSink.Activate` — das Objekt nimmt die Maus-Taste und Berührungs-
  Drücken/Loslassen-Eingaben an, die zur Aktivierung verwendet werden, lässt jedoch andere Eingaben (wie
  Mausbewegungen) durch.
- `Enum.InputSink.All` — das Objekt nimmt alle Eingaben an, die über ihm erfolgen.

Diese Eigenschaft ist ein granularer Nachfolger der booleschen
`Class.GuiObject.Active|Active`-Eigenschaft, die nur alle Eingaben oder
keine annehmen kann. Die Ereignisse `Class.GuiObject.InputBegan|InputBegan`,
`Class.GuiObject.InputChanged|InputChanged` und
`Class.GuiObject.InputEnded|InputEnded` werden unabhängig vom Wert dieser
Eigenschaft ausgelöst.

GuiObject.InputSink

Steuert, ob und wie das `Class.GuiObject` Eingaben annimmt, die über ihm erfolgen.

Bestimmt, ob der `Class.GuiButton` interagiert werden kann 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` verhält sich
  wieder 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` interagiert werden kann oder nicht, oder
ob sich der `Enum.GuiState|GuiState` des `Class.GuiObject` ändert oder nicht.

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

`Class.GuiObject|GuiObjects` werden in aufsteigender Reihenfolge sortiert, wobei niedrigere
Werte höhere Priorität als höhere Werte 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 Layoutreihenfolgewerten,
 die Sie für Elemente verwenden können, die zwischen anderen Elementen angeordnet sind.

Siehe auch `Class.GuiObject.ZIndex|ZIndex`, das die **Rendering**-Reihenfolge des Objekts bestimmt, anstatt die Sortierreihenfolge.

GuiObject.LayoutOrder

Steuert 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 aktiviert, 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 im Raster alle
Kinder eines `Frame`, das _"Container"_ genannt wird. 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, entspricht der Name aller GUI-Elemente ihrer Position im
   Raster
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 (hoch) wird immer die Anzahl der GUIs in einer
   Reihe um 1 kleiner als das aktuelle Element sein
5. Unten: Das Element unten (runter) wird immer die Anzahl der GUIs in einer
   Reihe größer als das aktuelle Element sein. Diese Logik ermöglicht es auch,
   dass die GUI-Elemente am Anfang und Ende der Reihen (außer dem ersten und
   letzten Element) zu den nächsten und vorherigen Reihen umschalten. Wenn ein
   Element links, rechts, oben oder unten nicht existiert, bleibt die
   NextSelection nil und das Bewegen des Gamepad-Auswahlwerkzeugs in die
   Richtung ändert das ausgewählte GUI nicht.

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 Codeabschnitt wählt zunächst das
Element mit dem Namen _"1"_ aus, indem es ihm die `Class.GuiService.SelectedObject`
Eigenschaft zuweist.


Diese Eigenschaft setzt das `Class.GuiObject`, das ausgewählt wird, wenn der Benutzer den
[Gamepad](/input/gamepad) -Selector nach unten bewegt. Wenn diese Eigenschaft
leer ist, wird das Bewegen des Gamepads nach unten die ausgewählte GUI nicht ändern.

Das Bewegen des Gamepad-Selectors nach unten setzt das
`Class.GuiService.SelectedObject` auf dieses Objekt, es sei denn, die 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 auswählbaren Eigenschaft einer GUI 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-
Selector nach unten bewegt wird.

Diese Eigenschaft setzt das `Class.GuiObject`, das ausgewählt wird, wenn der Benutzer den
[Gamepad](/input/gamepad) -Selector nach links bewegt. Wenn diese
Eigenschaft leer ist, wird das Bewegen des Gamepads nach links die ausgewählte GUI nicht ändern.

Das Bewegen des Gamepad-Selectors nach links setzt das
`Class.GuiService.SelectedObject` auf dieses Objekt, es sei denn, die 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 auswählbaren Eigenschaft einer GUI 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-
Selector nach links bewegt wird.

Diese Eigenschaft setzt das `Class.GuiObject`, das ausgewählt wird, wenn der Benutzer den
[Gamepad](/input/gamepad) -Selector nach rechts bewegt. Wenn diese
Eigenschaft leer ist, wird das Bewegen des Gamepads nach rechts die ausgewählte GUI nicht ändern.

Das Bewegen des Gamepad-Selectors nach rechts setzt das
`Class.GuiService.SelectedObject` auf dieses Objekt, es sei denn, die 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 auswählbaren Eigenschaft einer GUI 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-
Selector nach rechts bewegt wird.

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

/reference/engine/classes/TextChannelWindow.yaml

Zusammenfassung