TextBox
*Ce contenu est traduit en utilisant l'IA (Beta) et peut contenir des erreurs. Pour consulter cette page en anglais, clique ici.
Un TextBox permet au joueur de fournir une entrée de texte. Il fonctionne de manière similaire à un TextButton, excepté que vous ne pouvez mettre un seul Class.TextButton en lumière en cliquant, en tapant ou en sélectionnant un gamepad. Pendant qu'il est en lumière, le joueur peut utiliser un clavier pour modifier la propriété 2>Class.TextButton2>.
- Si il n'y a pas de texte, le PlaceholderText sera visible. Ceci est utile pour inviter les joueurs du type ou du format de données qu'ils devraient entrer.
- Par défaut, la propriété ClearTextOnFocus est activée et assure qu'il n'y a pas de texte existant lorsqu'une boîte de texte est concentrée. Cela peut ne pas être souhaitable pour le texte qui doit être modifié par le joueur.
- La propriété MultiLine permet aux joueurs d'entrer plusieurs lignes de texte avec des caractères de nouvelle ligne ( \n ).
Le ContextActionService honore les raccourcis de clavier TextBox et empêche automatiquement les événements de clé de presse d'être passés à des actions liées par ContextActionService:BindAction() . UserInputService.InputBegan et les événements liés seront toujours déclenchés pendant qu'un TextBox est en focus.
État de concentration
Il est possible de détecter et de modifier l'état de focus d'un TextBox :
- Vous pouvez utiliser CaptureFocus lorsqu'une boîte de dialogue apparaît afin que le joueur n'ait pas à cliquer sur un TextBox lorsqu'il est disponible ; vous pouvez utiliser ContextActionService:BindAction() pour lier un certain clé pour focaliser un TextBox en utilisant cette fonction. Lorsqu'un TextBox est en foco, l'évén
- Vous pouvez détecter si une certaine boîte de texte est en focus en utilisant IsFocused. Alternativement, UserInputService:GetFocusedTextBox() peut être utilisé pour vérifier si une boîte de texte est en focus.
- Lorsque le joueur a terminé d'entrer du texte, l'événement FocusLost se déclenche, indiquant si l'utilisateur a appuyé sur Entrer pour soumettre le texte avec le InputObject qui a causé la perte de focus. Lors de l'utilisation sur les claviers
- Si une affaire plus importante se présente pendant le partie, vous pouvez ReleaseFocus de la boîte de dialogue du texte pour que l'entrée du clavier d'un joueur soit renvoyée dans votre jeu.
Édition de texte
Un TextBox prend en charge la sélection du texte via ses propriétés CursorPosition et SelectionStart. En utilisant GetPropertyChangedSignal, vous pouvez détecter quand une sélection change. De plus, il est possible pour les joueurs de copier et coller le texte dans un TextBox, ce qui permet un assistancede presse de base.
Avis de filtrage du texte Les jeux qui facilitent la communication entre les joueurs en utilisant du texte, tels que le chat personnalisé ou les balises de nom, doivent filtrer correctement tel texte en utilisant TextService:FilterStringAsync() ou Chat:FilterStringAsync(). Si ceci n'est pas correctement fait, votre jeu peut recevoir une action de modération.
Échantillons de code
-- Place this code in a LocalScript inside a TextBox
local textBox = script.Parent
local secretWord = "roblox"
local colorNormal = Color3.new(1, 1, 1) -- white
local colorWrong = Color3.new(1, 0, 0) -- red
local colorCorrect = Color3.new(0, 1, 0) -- green
-- Initialize the state of the textBox
textBox.ClearTextOnFocus = true
textBox.Text = ""
textBox.Font = Enum.Font.Code
textBox.PlaceholderText = "What is the secret word?"
textBox.BackgroundColor3 = colorNormal
local function onFocused()
textBox.BackgroundColor3 = colorNormal
end
local function onFocusLost(enterPressed, _inputObject)
if enterPressed then
local guess = textBox.Text
if guess == secretWord then
textBox.Text = "ACCESS GRANTED"
textBox.BackgroundColor3 = colorCorrect
else
textBox.Text = "ACCESS DENIED"
textBox.BackgroundColor3 = colorWrong
end
else
-- The player stopped editing without pressing Enter
textBox.Text = ""
textBox.BackgroundColor3 = colorNormal
end
end
textBox.FocusLost:Connect(onFocusLost)
textBox.Focused:Connect(onFocused)
Résumé
Propriétés
Détermine si en cliquant sur la zone de texte, sa propriété TextBox.Text sera effacée.
Détermine l'Offset du curseur de texte en octets, ou -1 si il n'y a pas de curseur.
Détermine la police utilisée pour rendre le texte.
Détermine la police utilisée pour rendre le texte.
Échelle l'espacement entre les lignes de texte dans le TextBox .
Le nombre max de graphèmes que TextBox peut afficher.
Lorsqu'il est réglé sur vrai, le texte à l'intérieur d'une boîte de texte peut se déplacer sur plusieurs lignes. Cela permet également aux joueurs d'utiliser la touche Entrée pour se déplacer sur une nouvelle ligne.
Définit la couleur de texte qui est utilisée lorsque aucun texte n'a encore été entré dans la Boîte de texte.
Définit le texte qui s'affiche lorsque aucun texte n'a encore été saisi dans la Boîte de texte.
Détermine si la boîte de texte rend la chaîne TextBox.Text en utilisant une forme de texte riche.
Détermine la position de départ d'une sélection de texte, ou -1 si aucun texte n'est sélectionné.
Si réglé sur vrai, l'entrée native de la plate-forme est utilisée au lieu du clavier intégré de Roblox.
Détermine la chaîne rendue par l'élément UI.
La taille du texte d'un élément d'interface dans les décalages.
Détermine la couleur du texte rendu.
Détermine si l'utilisateur peut modifier le Text .
Whether the text fits within the constraints of the TextBox.
Change la taille du texte pour qu'elle soit à la hauteur de l'objet GUI qui le rend.
Déterminez la hauteur de ligne du texte dans les décalages.
Détermine la couleur du texte au pinceau (contours).
Détermine la transparence du trait de texte (contours).
Détermine la transparence du texte rendu.
Contrôle la coupure du texte affiché dans cette boîte de texte.
Détermine si le texte s'emboîte à plusieurs lignes dans l'espace d'élément GUI, ce qui coupe le texte en excès.
Détermine l'alignement horizontal du texte rendu.
Détermine l'alignement vertical du texte rendu.
Détermine si cet élément de l'interface utilisateur coule l'entrée.
Détermine le point d'origine d'un GuiObject , par rapport à sa taille absolue.
Détermine si la redimensionnement se produit en fonction du contenu de l'enfant.
Détermine la couleur de l'arrière-plan GuiObject.
Détermine la transparence de l'arrière-plan et de la frontière de GuiObject.
Détermine la couleur de la GuiObject bordure.
Détermine la manière dont la GuiObject bordure est distribuée par rapport à ses dimensions.
Détermine la largeur de pixel de la GuiObject bordure.
Détermine si le descendant GuiObjects en dehors des limites d'un élément GUI parent doit rendu.
Détermine si la souris du joueur est activement pressée sur le GuiObject ou non.
Détermine si le GuiButton peut être interagi ou non, ou si le GuiState du GuiObject change ou non.
Contrôle l'ordre de tri du GuiObject lorsqu'il est utilisé avec un UIGridStyleLayout .
Définit le GuiObject qui sera sélectionné lorsque le sélecteur de gamepad sera déplacé vers le bas.
Définit le GuiObject qui sera sélectionné lorsque le sélecteur de gamepad sera déplacé à gauche.
Définit le GuiObject qui sera sélectionné lorsque le sélecteur de gamepad sera déplacé à droite.
Définit le GuiObject qui sera sélectionné lorsque le sélecteur de gamepad sera déplacé vers le haut.
Détermine la position pixel et vectorielle de l' GuiObject .
Détermine le nombre de degrés par lesquels le GuiObject est pivoté.
Déterminez si le GUI peut être sélectionné par une manette de jeu.
Surclasse l'ornement de sélection par défaut utilisé pour les gamepads.
L'ordre de GuiObjects sélectionné par la sélection de l'interface de jeu.
Détermine la taille de pixel et de taille vectorielle de GuiObject .
Définit les Size axes sur lesquels le GuiObject sera basé, par rapport à la taille de son parent.
Une propriété mixte de BackgroundTransparency et TextTransparency .
Détermine si le GuiObject et ses descendants seront rendus.
Détermine l'ordre dans lequel un GuiObject rendu par rapport aux autres.
Décrivez la position d'écran réelle d'un élément UI, en pixels.
Décrivez la rotation de l'écran réelle d'un élément UI, en degrés.
Décrivez la taille réelle de l'interface utilisateur, en pixels.
Lorsqu'il est réglé sur vrai, la localisation sera appliquée à ce GuiBase2d et à ses descendants.
Une référence à un LocalizationTable pour être utilisé pour appliquer la localisation automatisée à ce GuiBase2d et à ses descendants.
Personnalise le comportement de sélection du gamepad dans la direction vers le bas.
Personnalise le comportement de sélection du gamepad dans la direction de gauche.
Personnalise le comportement de sélection du gamepad dans la bonne direction.
Personnalise le comportement de sélection du gamepad dans la direction vers le haut.
Permet la personnalisation de la sélection du gamepad.
Méthodes
Force le client à se concentrer sur la zone de texte.
Retourne vrai si la zone de texte est concentrée, ou faux s'il n'est pas.
Force le client à dé焦ser la boîte de texte.
- TweenPosition(endPosition : UDim2,easingDirection : Enum.EasingDirection,easingStyle : Enum.EasingStyle,time : number,override : bool,callback : function):bool
Déplace facilement une GUI vers un nouveau UDim2.
- TweenSize(endSize : UDim2,easingDirection : Enum.EasingDirection,easingStyle : Enum.EasingStyle,time : number,override : bool,callback : function):bool
Redimensionne facilement une GUI en une nouvelle UDim2 .
- TweenSizeAndPosition(endSize : UDim2,endPosition : UDim2,easingDirection : Enum.EasingDirection,easingStyle : Enum.EasingStyle,time : number,override : bool,callback : function):bool
Déplace facilement une GUI dans une nouvelle taille et position.
Évènements
Tire quand le client laisse leur focus quitter le TextBox.
Se déclenche lorsque le TextBox gagne en focus.
Activé lorsqu'un utilisateur commence à interagir via un appareil d'interface humain-ordinateur (bouton de souris, toucher de début, bouton de clavier, etc).
Activé lorsqu'un utilisateur change la façon dont ils interagissent via un appareil d'interface humain-ordinateur (bouton de souris, toucher le début, bouton de clavier, etc).
Activé lorsqu'un utilisateur arrête d'interagir via un appareil d'interface humain-ordinateur (bouton de souris, toucher début, bouton de clavier, etc).
Se déclenche lorsqu'un utilisateur déplace son curseur dans un élément GUI.
Se déclenche lorsqu'un utilisateur déplace sa souris à l'extérieur d'un élément GUI.
Se déclenche toujours lorsqu'un utilisateur déplace sa souris pendant qu'il est à l'intérieur d'un élément GUI.
Se déclenche lorsqu'un utilisateur fait glisser son roue de souris quand la souris est sur un élément de l'interface graphique.
Se déclenche lorsqu'un utilisateur fait glisser sa molette de souris vers l'avant lorsqu'il est au-dessus d'un élément GUI.
Activé lorsque l'objet Gui est focalisé avec le sélecteur Gamepad.
Activé lorsque le sélecteur Gamepad arrête de se concentrer sur GuiObject.
Démarre lorsque le joueur démarre, continue et s'arrête longuement sur la pression de l'API.
- TouchPan(touchPositions : Array,totalTranslation : Vector2,velocity : Vector2,state : Enum.UserInputState):RBXScriptSignal
Se déclenche lorsque le joueur déplace son doigt sur l'élément de l'interface utilisateur.
- TouchPinch(touchPositions : Array,scale : number,velocity : number,state : Enum.UserInputState):RBXScriptSignal
Se déclenche lorsque le joueur effectue un geste de pince ou de tir à l'aide de deux doigts sur l'élément de l'interface utilisateur.
- TouchRotate(touchPositions : Array,rotation : number,velocity : number,state : Enum.UserInputState):RBXScriptSignal
Se déclenche lorsque le joueur effectue une rotation à l'aide de deux doigts sur l'élément de l'interface utilisateur.
Se déclenche lorsque le joueur effectue un geste de ramassage sur l'élément de l'interface utilisateur.
Se déclenche lorsque le joueur effectue un geste de touche sur l'élément de l'interface.
- SelectionChanged(amISelected : bool,previousSelection : GuiObject,newSelection : GuiObject):RBXScriptSignal
Se déclenche lorsque la sélection du gamepad se déplace, quitte ou change dans la GuiBase2d ou tout descendant GuiObjects connecté.
Propriétés
ClearTextOnFocus
Détermine si en cliquant sur la zone de texte, vous effacerez sa propriété TextBox.Text
ContentText
CursorPosition
CursorPosition détermine l'Offset du curseur textuel en octets, ou -1 si la boîte de texte n'est pas actuellement modifiée. Une valeur de 1 représente le début, la position avant le premier octet dans la propriété Text. Lorsqu'il est utilisé conjointement avec la propriété SelectionStart, il est possible d'
Il doit être noté que les unités de cette propriété est octets et que de nombreux caractères unicode tels que les emojis sont plus longs que 1 octet . Par instance, si un joueur tape dans la Boîte de texte "Hello👋" – "Hello" immédiatement suivi du symbole de main dans la direction de la main – la position du curseur serait 10, non 7, car l'emoji utilise 4 octets.
Échantillons de code
local textBox = script.Parent
local function showSelection()
if textBox.CursorPosition == -1 or textBox.SelectionStart == -1 then
print("No selection")
else
local selectedText = string.sub(
textBox.Text,
math.min(textBox.CursorPosition, textBox.SelectionStart),
math.max(textBox.CursorPosition, textBox.SelectionStart)
)
print('The selection is:"', selectedText, '"')
end
end
textBox:GetPropertyChangedSignal("CursorPosition"):Connect(showSelection)
textBox:GetPropertyChangedSignal("SelectionStart"):Connect(showSelection)
Font
La propriété police sélectionne l'un des plusieurs fonts avec lesquels l'élément de l'interface utilisateur rendra son texte. Certaines polices ont des polices de caractère en majuscules et/ou en italique et/ou en police claire (comme il n'y a pas de propriétés de poids de police ou de style de police).
Avec l'exception de la police "Légacy", chaque police rendra du texte avec la hauteur de ligne égale à la propriété TextBox.TextSize. La police "Code" est la seule police monospace. Elle a la propriété unique que chaque personnage a le même largeur et hauteur de 1:2. La largeur de chaque personnage est environ la moitié de la propriété TextBox.TextSize.
Cette propriété est synchronisée avec la propriété TextBox.FontFace. Lorsque vous définissez la police, la police sera définie sur Font.fromEnum(value).
Échantillons de code
local textLabel = script.Parent
while true do
-- Iterate over all the different fonts
for _, font in pairs(Enum.Font:GetEnumItems()) do
textLabel.Font = font
textLabel.Text = font.Name
task.wait(1)
end
end
local frame = script.Parent
-- Create a TextLabel displaying each font
for _, font in pairs(Enum.Font:GetEnumItems()) do
local textLabel = Instance.new("TextLabel")
textLabel.Name = font.Name
-- Set the text properties
textLabel.Text = font.Name
textLabel.Font = font
-- Some rendering properties
textLabel.TextSize = 24
textLabel.TextXAlignment = Enum.TextXAlignment.Left
-- Size the frame equal to the height of the text
textLabel.Size = UDim2.new(1, 0, 0, textLabel.TextSize)
-- Add to the parent frame
textLabel.Parent = frame
end
-- Layout the frames in a list (if they aren't already)
if not frame:FindFirstChildOfClass("UIListLayout") then
local uiListLayout = Instance.new("UIListLayout")
uiListLayout.Parent = frame
end
FontFace
La propriété FontFace ressemble à la propriété Font, mais permet de définir des polices qui n'existent pas dans l'index des polices.
Cette propriété est gardée en synchronisation avec la propriété TextBox.Font. Lors de la configuration de la police de caractère, la police est réglée sur la valeur d'ensemble correspondante, ou sur Enum.Font.Unknown si il n'y a pas de correspondance.
LineHeight
Contrôle la hauteur des lignes, en plusieurs de la taille de police de la police, en augmentant la hauteur du spacing entre les lignes de texte dans le TextBox . Les valeurs valides varient de 1.0 à 3.0, la valeur par défaut étant 1.0.
MaxVisibleGraphemes
Cette propriété contrôle le nombre max de graphèmes (ou unités de texte) qui sont affichés sur le TextBox, qu'il s'agisse de montrer le TextBox.PlaceholderText ou le TextBox.Text.
Changer la propriété ne change pas la position ou la taille des graisses visibles - le layout sera calculé comme si toutes les graisses étaient visibles.
En définissant la propriété à -1, désactive la limite et montre l'entièreté du TextBox.Text .
MultiLine
Lorsqu'il est réglé sur vrai, le texte à l'intérieur d'une boîte de texte peut se déplacer sur plusieurs lignes. Cela permet également aux joueurs d'utiliser la touche Entrée pour se déplacer sur une nouvelle ligne.
OpenTypeFeatures
OpenTypeFeaturesError
PlaceholderColor3
Définit la couleur de texte qui est utilisée lorsque aucun texte n'a encore été entré dans la Boîte de texte.
PlaceholderText
Définit le texte qui s'affiche lorsque aucun texte n'a encore été saisi dans la Boîte de texte.
RichText
Cette propriété détermine si le TextBox rend la chaîne TextBox.Text en utilisant une formulation de texte riche. Le texte riche utilise des balises de marquage simples pour style les sections du texte en caractères forts, soulignés, de couleurs spécifiques et plus encore.
Pour utiliser le texte riche, incluez simplement des balises de mise en forme dans la TextBox.Text chaîne.
Notez que lorsque la propriété TextBox est activée et que la boîte gagne en focus, l'utilisateur pourra modifier et interagir avec la chaîne d'API complète, y compris tous les tags de forme. Lorsque le focus est perdu, le texte sera automatiquement transformé et rendu les balises en texte riche.
SelectionStart
Détermine la position de départ d'une sélection de texte, ou -1 si la boîte de texte n'a pas de portée de texte sélectionné. Si la valeur est -1 ou équivalente à CursorPosition, il n'y a pas de portée de texte sélectionnée. Cette propriété utilise la même logique de positionnement que CursorPosition. SelectionStart sera plus grand que CursorPosition si le curseur est au terminerd'une
Échantillons de code
local textBox = script.Parent
local function showSelection()
if textBox.CursorPosition == -1 or textBox.SelectionStart == -1 then
print("No selection")
else
local selectedText = string.sub(
textBox.Text,
math.min(textBox.CursorPosition, textBox.SelectionStart),
math.max(textBox.CursorPosition, textBox.SelectionStart)
)
print('The selection is:"', selectedText, '"')
end
end
textBox:GetPropertyChangedSignal("CursorPosition"):Connect(showSelection)
textBox:GetPropertyChangedSignal("SelectionStart"):Connect(showSelection)
ShowNativeInput
Si réglé sur vrai, l'entrée native de la plate-forme est utilisée au lieu du clavier intégré de Roblox.
Text
La propriété texte détermine le contenu rendu par l'élément UI. Les propriétés visuelles de la chaîne rendue sur l'écran sont déterminées par TextBox.TextColor3, Class
Il est possible de rendre des emojis (par exemple, 😃) et d'autres symboles. Ces symboles spéciaux ne sont pas affectés par la propriété TextBox.TextColor3. Ces derniers peuvent être collés dans Script et LocalScript objets, ainsi que dans la zone de texte dans la fenêtre propriétés.
Cette propriété peut contenir des caractères de nouvelle ligne, mais il n'est pas possible de taper des caractères de nouvelle ligne dans la fenêtre propriétés. De même, cette propriété peut contenir un caractère de rubrique, mais il sera rendu comme un espace à la place.
Échantillons de code
local TweenService = game:GetService("TweenService")
local textLabel = script.Parent
local content = {
"Welcome to my game!",
"Be sure to have fun!",
"Please give suggestions!",
"Be nice to other players!",
"Don't grief other players!",
"Check out the shop!",
"Tip: Don't die!",
}
local tweenInfo = TweenInfo.new(1, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)
local RNG = Random.new()
local fadeIn = TweenService:Create(textLabel, tweenInfo, {
TextTransparency = 0,
})
local fadeOut = TweenService:Create(textLabel, tweenInfo, {
TextTransparency = 1,
})
local lastIndex
while true do
-- Step 0: Fade out before doing anything
fadeOut:Play()
task.wait(tweenInfo.Time)
-- Step 1: pick content that wasn't the last displayed
local index
repeat
index = RNG:NextInteger(1, #content)
until lastIndex ~= index
-- Make sure we don't show the same thing next time
lastIndex = index
-- Step 2: show the content
textLabel.Text = content[index]
fadeIn:Play()
task.wait(tweenInfo.Time + 1)
end
local textLabel = script.Parent
textLabel.Text = "Kaboom!"
while true do
for size = 5, 100, 5 do
textLabel.TextSize = size
textLabel.TextTransparency = size / 100
task.wait()
end
task.wait(1)
end
local frame = script.Parent
-- Create a TextLabel displaying each font
for _, font in pairs(Enum.Font:GetEnumItems()) do
local textLabel = Instance.new("TextLabel")
textLabel.Name = font.Name
-- Set the text properties
textLabel.Text = font.Name
textLabel.Font = font
-- Some rendering properties
textLabel.TextSize = 24
textLabel.TextXAlignment = Enum.TextXAlignment.Left
-- Size the frame equal to the height of the text
textLabel.Size = UDim2.new(1, 0, 0, textLabel.TextSize)
-- Add to the parent frame
textLabel.Parent = frame
end
-- Layout the frames in a list (if they aren't already)
if not frame:FindFirstChildOfClass("UIListLayout") then
local uiListLayout = Instance.new("UIListLayout")
uiListLayout.Parent = frame
end
local textLabel = script.Parent
-- This text wrapping demo is best shown on a 200x50 px rectangle
textLabel.Size = UDim2.new(0, 200, 0, 50)
-- Some content to spell out
local content = "Here's a long string of words that will "
.. "eventually exceed the UI element's width "
.. "and form line breaks. Useful for paragraphs "
.. "that are really long."
-- A function that will spell text out two characters at a time
local function spellTheText()
-- Iterate from 1 to the length of our content
for i = 1, content:len() do
-- Get a substring of our content: 1 to i
textLabel.Text = content:sub(1, i)
-- Color the text if it doesn't fit in our box
if textLabel.TextFits then
textLabel.TextColor3 = Color3.new(0, 0, 0) -- Black
else
textLabel.TextColor3 = Color3.new(1, 0, 0) -- Red
end
-- Wait a brief moment on even lengths
if i % 2 == 0 then
task.wait()
end
end
end
while true do
-- Spell the text with scale/wrap off
textLabel.TextWrapped = false
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with wrap on
textLabel.TextWrapped = true
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with text scaling on
-- Note: Text turns red (TextFits = false) once text has to be
-- scaled down in order to fit within the UI element.
textLabel.TextScaled = true
-- Note: TextWrapped is enabled implicitly when TextScaled = true
--textLabel.TextWrapped = true
spellTheText()
task.wait(1)
end
local textLabel = script.Parent
local moods = {
["happy"] = "😃",
["sad"] = "😢",
["neutral"] = "😐",
["tired"] = "😫",
}
while true do
for mood, face in pairs(moods) do
textLabel.Text = "I am feeling " .. mood .. "! " .. face
task.wait(1)
end
end
TextBounds
La propriété Read-Only TextBounds reflète la taille absolue du texte rendu dans les décalages. En d'autres termes, si vous essayiez de faire tenir le texte dans un rectangle, cette propriété reflète les dimensions minimum du rectangle que vous auriez besoin pour faire tenir le texte.
En utilisant TextService:GetTextSize() , vous pouvez prédire quelles seront les limites de texte sur un TextLabel donné par une chaîne, TextBox.Font et TextBox.TextSize et la taille de la police.
Échantillons de code
local textBox = script.Parent
-- The smallest the TextBox will go
local minWidth, minHeight = 10, 10
-- Set alignment so our text doesn't wobble a bit while we type
textBox.TextXAlignment = Enum.TextXAlignment.Left
textBox.TextYAlignment = Enum.TextYAlignment.Top
local function updateSize()
textBox.Size = UDim2.new(0, math.max(minWidth, textBox.TextBounds.X), 0, math.max(minHeight, textBox.TextBounds.Y))
end
textBox:GetPropertyChangedSignal("TextBounds"):Connect(updateSize)
TextColor3
Cette propriété détermine la couleur de tout le texte rendu par un élément GUI. Cette propriété, ainsi que TextBox.Font, TextBox.TextSize et 2>Class.Toolbar.TextTransparency2>, déterminera les propriétés visuelles du texte. Le texte est rendu après le traitement du texte (
Il est important que le texte soit facilement lu par les joueurs ! Assurez-vous de choisir des couleurs avec une saturation minimale, comme la couleur blanche, grise ou noire. Assurez-vous que la couleur de votre texte est contrastée par le TextBox.BackgroundColor3 de l'élément de l'interface. Si l'élément a un fond transparent, essayez d'appliquer un no
Échantillons de code
local textBox = script.Parent
local function hasVowels(str)
return str:lower():find("[aeiou]")
end
local function onTextChanged()
local text = textBox.Text
-- Check for vowels
if hasVowels(text) then
textBox.TextColor3 = Color3.new(0, 0, 0) -- Black
else
textBox.TextColor3 = Color3.new(1, 0, 0) -- Red
end
end
textBox:GetPropertyChangedSignal("Text"):Connect(onTextChanged)
-- Place this code in a LocalScript inside a TextBox
local textBox = script.Parent
local secretWord = "roblox"
local colorNormal = Color3.new(1, 1, 1) -- white
local colorWrong = Color3.new(1, 0, 0) -- red
local colorCorrect = Color3.new(0, 1, 0) -- green
-- Initialize the state of the textBox
textBox.ClearTextOnFocus = true
textBox.Text = ""
textBox.Font = Enum.Font.Code
textBox.PlaceholderText = "What is the secret word?"
textBox.BackgroundColor3 = colorNormal
local function onFocused()
textBox.BackgroundColor3 = colorNormal
end
local function onFocusLost(enterPressed, _inputObject)
if enterPressed then
local guess = textBox.Text
if guess == secretWord then
textBox.Text = "ACCESS GRANTED"
textBox.BackgroundColor3 = colorCorrect
else
textBox.Text = "ACCESS DENIED"
textBox.BackgroundColor3 = colorWrong
end
else
-- The player stopped editing without pressing Enter
textBox.Text = ""
textBox.BackgroundColor3 = colorNormal
end
end
textBox.FocusLost:Connect(onFocusLost)
textBox.Focused:Connect(onFocused)
-- Place this code in a LocalScript within a TextLabel/TextButton
local textLabel = script.Parent
-- Some colors we'll use with TextColor3
local colorNormal = Color3.new(0, 0, 0) -- black
local colorSoon = Color3.new(1, 0.5, 0.5) -- red
local colorDone = Color3.new(0.5, 1, 0.5) -- green
-- Loop infinitely
while true do
-- Count backwards from 10 to 1
for i = 10, 1, -1 do
-- Set the text
textLabel.Text = "Time: " .. i
-- Set the color based on how much time is left
if i > 3 then
textLabel.TextColor3 = colorNormal
else
textLabel.TextColor3 = colorSoon
end
task.wait(1)
end
textLabel.Text = "GO!"
textLabel.TextColor3 = colorDone
task.wait(2)
end
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Place a StringValue called "GameState" in the ReplicatedStorage
local vGameState = ReplicatedStorage:WaitForChild("GameState")
-- Place this code in a TextLabel
local textLabel = script.Parent
-- Some colors we'll use with TextColor3
local colorNormal = Color3.new(0, 0, 0) -- black
local colorCountdown = Color3.new(1, 0.5, 0) -- orange
local colorRound = Color3.new(0.25, 0.25, 1) -- blue
-- We'll run this function to update the TextLabel as the state of the
-- game changes.
local function update()
-- Update the text
textLabel.Text = "State: " .. vGameState.Value
-- Set the color of the text based on the current game state
if vGameState.Value == "Countdown" then
textLabel.TextColor3 = colorCountdown
elseif vGameState.Value == "Round" then
textLabel.TextColor3 = colorRound
else
textLabel.TextColor3 = colorNormal
end
end
-- Pattern: update once when we start and also when vGameState changes
-- We should always see the most updated GameState.
update()
vGameState.Changed:Connect(update)
TextDirection
TextEditable
TextEditable détermine si l'utilisateur peut modifier le Text via l'entrée. Il est recommandé de désactiver ClearTextOnFocus lorsque cette propriété est désactivée, sinon le texte pourrait être effacé à l'aide de l'entrée. Cette propriété est utile pour créer des Boîtes de texte lisibles à partir duquel
TextScaled
Au lieu d'utiliser TextScaled, nous vous recommandons d'utiliser AutomaticSize, une nouvelle méthode pour dimensionner automatiquement l'interface utilisateur qui vous donnera le meilleur résultat visuel possible.
La propriété TextScaled détermine si le texte est échelonné afin qu'il occupe l'espace de l'ensemble de l'élément de l'interface utilisateur. Lorsque ceci est activé, TextBox.TextSize est ignoré et TextBox.TextWrapped est automatiquement activé. Cette propriété est utile pour les éléments de rendu du texte dans BillboardGuis.
Lorsque cette propriété est utilisée pour l'interface utilisateur de l'espace d'écran, il peut être souhaitable d'utiliser un UITextSizeConstraint pour restreindre la portée des tailles de texte possibles.
TextScaled et AutomaticSize
Il est recommandé aux développeurs d'éviter l'utilisation de TextScaled et d'ajuster l'interface utilisateur pour profiter de la propriété AutoSize plutôt. Voici les principales différences entre les deux propriétés :
- TextScaled met l'interface utilisateur (le texte) à l'échelle pour tenir compte de l'interface utilisateur. Sans une attention minutieuse, certains textes peuvent devenir introuvables si la taille est trop petite.
- AutomaticSize redimensionne l'interface utilisateur pour tenir le contenu.
Avec AutomaticSize, vous pouvez ajuster votre interface utilisateur pour tenir le contenu (texte) tout en maintenant une taille de police cohérente. Pour plus d'informations sur l'utilisation de la taille d'automatisation, consultez l'article de taille d'automatisation de l'interface utilisateur.
Nous suggérons que vous ne appliquiez pas TextScaled et AutomaticSize sur le même objet d'interface. Si vous appliquez les deux propriétés :
- AutomaticSize détermine la quantité maximale d'espace disponible que peut utiliser un GuiObject (dans ce cas, le texte)
- TextScaled utilise l'espace disponible déterminé par AutomaticSize, pour ajuster la taille de police à l'espace disponible, ce qui s'étend jusqu'à la taille de police maximale (100), si il n'y a pas de contraintes de taille
- La taille de sortie sera : le texte va à la taille de police 100 et l'objet UI s'étendra pour s'adapter à ce texte
L'utilisation de both AutomaticSize et TextScaled à la même time peut entraîner des différences de mise à l'échelle signifiantes que lorsque AutomaticSize est off.
Échantillons de code
local textLabel = script.Parent
-- This text wrapping demo is best shown on a 200x50 px rectangle
textLabel.Size = UDim2.new(0, 200, 0, 50)
-- Some content to spell out
local content = "Here's a long string of words that will "
.. "eventually exceed the UI element's width "
.. "and form line breaks. Useful for paragraphs "
.. "that are really long."
-- A function that will spell text out two characters at a time
local function spellTheText()
-- Iterate from 1 to the length of our content
for i = 1, content:len() do
-- Get a substring of our content: 1 to i
textLabel.Text = content:sub(1, i)
-- Color the text if it doesn't fit in our box
if textLabel.TextFits then
textLabel.TextColor3 = Color3.new(0, 0, 0) -- Black
else
textLabel.TextColor3 = Color3.new(1, 0, 0) -- Red
end
-- Wait a brief moment on even lengths
if i % 2 == 0 then
task.wait()
end
end
end
while true do
-- Spell the text with scale/wrap off
textLabel.TextWrapped = false
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with wrap on
textLabel.TextWrapped = true
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with text scaling on
-- Note: Text turns red (TextFits = false) once text has to be
-- scaled down in order to fit within the UI element.
textLabel.TextScaled = true
-- Note: TextWrapped is enabled implicitly when TextScaled = true
--textLabel.TextWrapped = true
spellTheText()
task.wait(1)
end
TextSize
La propriété TextSize détermine la hauteur en décalage d'une ligne de texte rendue. L'unité est en décalage, non pas en points (ce qui est utilisé dans la plupart des programmes de lecture de documents). La police «Héritage» ne contient pas cette propriété.
Échantillons de code
local textLabel = script.Parent
textLabel.Text = "Kaboom!"
while true do
for size = 5, 100, 5 do
textLabel.TextSize = size
textLabel.TextTransparency = size / 100
task.wait()
end
task.wait(1)
end
TextStrokeColor3
La couleur de la police de texte est définie par la propriété TextStrokeColor3. Cette propriété et TextBox.TextStrokeTransparency déterminent les propriétés visuelles de la police de texte.
Le rendu du texte est rendu avant le texte normal et est simplement 4 rendus du même texte dans +/- 1 pixel offsets dans chaque direction. Le rendu du texte fonctionne indépendamment et identiquement à TextBox.TextColor3 et TextBox.TextTransparency .
Échantillons de code
local textLabel = script.Parent
-- How fast the highlight ought to blink
local freq = 2
-- Set to yellow highlight color
textLabel.TextStrokeColor3 = Color3.new(1, 1, 0)
while true do
-- math.sin oscillates from -1 to 1, so we change the range to 0 to 1:
local transparency = math.sin(workspace.DistributedGameTime * math.pi * freq) * 0.5 + 0.5
textLabel.TextStrokeTransparency = transparency
task.wait()
end
TextStrokeTransparency
La propriété TextStrokeTransparency détermine la transparence du stroke, ou de l'ours, du texte rendu. Cette propriété et TextBox.TextStrokeColor3 déterminent les propriétés visuelles du stroke.
La couleur du texte est rendue avant le texte normal et est simplement 4 rendus du même texte dans +/- 1 pixel offsets dans chaque direction. La couleur du texte est rendue indépendamment
Échantillons de code
local textLabel = script.Parent
-- How fast the highlight ought to blink
local freq = 2
-- Set to yellow highlight color
textLabel.TextStrokeColor3 = Color3.new(1, 1, 0)
while true do
-- math.sin oscillates from -1 to 1, so we change the range to 0 to 1:
local transparency = math.sin(workspace.DistributedGameTime * math.pi * freq) * 0.5 + 0.5
textLabel.TextStrokeTransparency = transparency
task.wait()
end
TextTransparency
La couleur de texte 3 détermine la transparence de tout le texte rendu par un élément UI. Cette couleur, junto avec TextBox.Font, TextBox.TextSize et TextBox.TextColor3, déterminera les propriétés visuelles du texte. Le texte est rendu après le traitement du texte ( 1> Class.Toolbar.TextStrokeTransparency
Fading text in using a numeric for-loop is a fantastic way to draw a joueur's attention to text appearing on screen.
-- Count backwards from 1 to 0, decrementing by 0.1for i = 1, 0, -0.1 dotextLabel.TextTransparency = itask.wait(0.1)end
Échantillons de code
local TweenService = game:GetService("TweenService")
local textLabel = script.Parent
local content = {
"Welcome to my game!",
"Be sure to have fun!",
"Please give suggestions!",
"Be nice to other players!",
"Don't grief other players!",
"Check out the shop!",
"Tip: Don't die!",
}
local tweenInfo = TweenInfo.new(1, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)
local RNG = Random.new()
local fadeIn = TweenService:Create(textLabel, tweenInfo, {
TextTransparency = 0,
})
local fadeOut = TweenService:Create(textLabel, tweenInfo, {
TextTransparency = 1,
})
local lastIndex
while true do
-- Step 0: Fade out before doing anything
fadeOut:Play()
task.wait(tweenInfo.Time)
-- Step 1: pick content that wasn't the last displayed
local index
repeat
index = RNG:NextInteger(1, #content)
until lastIndex ~= index
-- Make sure we don't show the same thing next time
lastIndex = index
-- Step 2: show the content
textLabel.Text = content[index]
fadeIn:Play()
task.wait(tweenInfo.Time + 1)
end
local textLabel = script.Parent
textLabel.Text = "Kaboom!"
while true do
for size = 5, 100, 5 do
textLabel.TextSize = size
textLabel.TextTransparency = size / 100
task.wait()
end
task.wait(1)
end
TextWrapped
Lorsqu'elle est activée, cette propriété rendra le texte sur plusieurs lignes dans l'espace d'un élément GUI afin que TextBox.TextBounds ne dépassent jamais la limite GuiBase2d.AbsoluteSize de l'élément GUI.
Ceci est obtenu en brisant de longues lignes de texte en plusieurs lignes. Les interruptions de ligne préfèrent l'espace blanc ; si une longue mot ininterrompu dépasse la largeur de l'élément, ce mot sera brisé en plusieurs lignes.
Si des lignes supplémentaires se brisaient, la hauteur verticale du texte (la composante Y de TextBox.TextBounds ) dépasserait la hauteur verticale de l'élément (la composante Y de GuiBase2d.AbsoluteSize), alors cette ligne ne serait pas rendue du tout.
Échantillons de code
local textLabel = script.Parent
-- This text wrapping demo is best shown on a 200x50 px rectangle
textLabel.Size = UDim2.new(0, 200, 0, 50)
-- Some content to spell out
local content = "Here's a long string of words that will "
.. "eventually exceed the UI element's width "
.. "and form line breaks. Useful for paragraphs "
.. "that are really long."
-- A function that will spell text out two characters at a time
local function spellTheText()
-- Iterate from 1 to the length of our content
for i = 1, content:len() do
-- Get a substring of our content: 1 to i
textLabel.Text = content:sub(1, i)
-- Color the text if it doesn't fit in our box
if textLabel.TextFits then
textLabel.TextColor3 = Color3.new(0, 0, 0) -- Black
else
textLabel.TextColor3 = Color3.new(1, 0, 0) -- Red
end
-- Wait a brief moment on even lengths
if i % 2 == 0 then
task.wait()
end
end
end
while true do
-- Spell the text with scale/wrap off
textLabel.TextWrapped = false
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with wrap on
textLabel.TextWrapped = true
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with text scaling on
-- Note: Text turns red (TextFits = false) once text has to be
-- scaled down in order to fit within the UI element.
textLabel.TextScaled = true
-- Note: TextWrapped is enabled implicitly when TextScaled = true
--textLabel.TextWrapped = true
spellTheText()
task.wait(1)
end
TextXAlignment
TextXAlignment détermine l'alignement horizontal (X-axe) du texte rendu dans l'espace d'un élément d'interface utilisateur. Il fonctionne de la même façon que la propriété de texte d'alignement à gauche, à droite et au centre (il n'y a pas d'option d'alignement). Pour gauche et pour droite, le texte est rendu afin que les limites de texte gauche/droite touchent le bord de l'espace de l'élément. Pour le centre, chaque ligne de texte est centrée
Cette propriété est utilisée conjointement avec TextBox.TextYAlignment pour déterminer entièrement l'alignement du texte sur les deux axes. Cette propriété n'affectera pas les propriétés de lecture TextBox.TextBounds et TextBox.TextFits.
Échantillons de code
-- Paste this in a LocalScript within a TextLabel/TextButton/TextBox
local textLabel = script.Parent
local function setAlignment(xAlign, yAlign)
textLabel.TextXAlignment = xAlign
textLabel.TextYAlignment = yAlign
textLabel.Text = xAlign.Name .. " + " .. yAlign.Name
end
while true do
-- Iterate over both TextXAlignment and TextYAlignment enum items
for _, yAlign in pairs(Enum.TextYAlignment:GetEnumItems()) do
for _, xAlign in pairs(Enum.TextXAlignment:GetEnumItems()) do
setAlignment(xAlign, yAlign)
task.wait(1)
end
end
end
TextYAlignment
TextYAlignment détermine l'alignement vertical (Y-axe) du texte rendu dans l'espace d'un élément UI. Pour les hauts et les bas, le texte est rendu afin que les limites de texte supérieures/inférieures touchent l'边 de l'espace de l'élément. Pour les centres, le texte est rendu afin qu'il y ait un espace équilibré des limites de texte supérieures/inférieures à l'边 de l'élément et des limites de texte inférieures/égales à
Cette propriété est utilisée conjointement avec TextBox.TextXAlignment pour déterminer entièrement l'alignement du texte sur les deux axes. Cette propriété n'affectera pas les propriétés de lecture TextBox.TextBounds et TextBox.TextFits.
Échantillons de code
-- Paste this in a LocalScript within a TextLabel/TextButton/TextBox
local textLabel = script.Parent
local function setAlignment(xAlign, yAlign)
textLabel.TextXAlignment = xAlign
textLabel.TextYAlignment = yAlign
textLabel.Text = xAlign.Name .. " + " .. yAlign.Name
end
while true do
-- Iterate over both TextXAlignment and TextYAlignment enum items
for _, yAlign in pairs(Enum.TextYAlignment:GetEnumItems()) do
for _, xAlign in pairs(Enum.TextXAlignment:GetEnumItems()) do
setAlignment(xAlign, yAlign)
task.wait(1)
end
end
end
Méthodes
CaptureFocus
Force le client à se concentrer sur la zone de texte.
Retours
Échantillons de code
local ContextActionService = game:GetService("ContextActionService")
local ACTION_NAME = "FocusTheTextBox"
local textBox = script.Parent
local function handleAction(actionName, inputState, _inputObject)
if actionName == ACTION_NAME and inputState == Enum.UserInputState.End then
textBox:CaptureFocus()
end
end
ContextActionService:BindAction(ACTION_NAME, handleAction, false, Enum.KeyCode.Q)
ReleaseFocus
Force le client à dé焦ser la boîte de texte. Le submitted paramètre vous permet d'écraser le enterPressed paramètre dans l'événement TextBox.FocusLost.
Cet élément devrait être utilisé avec un LocalScript pour fonctionner comme prévu en mode en ligne.
Le code affiché ci-dessous forcera le client à décentrer le « Texture » 5 secondes après sa sélection :
local TextBox = script.Parent
TextBox.Focused:Connect(function()
wait(5)
TextBox:ReleaseFocus()
end)
Veuillez noter que l'exemple ci-dessus suppose que c'est dans un LocalScript, en tant qu'enfant d'un TextBox.
Paramètres
Retours
Échantillons de code
local textBox = script.Parent
local function onFocused()
task.wait(5)
textBox:ReleaseFocus()
end
textBox.Focused:Connect(onFocused)
Évènements
FocusLost
Se déclenche lorsque le client laisse leur focus quitter la TextBox - généralement lorsqu'un client clique/touche en dehors de la TextBox. Cela déclenche également si un TextBox force le focus sur l'utilisateur.
Il peut être utilisé avec TextBox.Focused pour suivre quand un TextBox gagne et perd le focus.
Voir également le UserInputService.TextBoxFocused et UserInputService.TextBoxFocusReleased pour des fonctions similaires qui dépendent du service UserInputService.
Cet événement ne s'exécutera que lorsqu'il est utilisé dans un LocalScript .
Paramètres
Un booléen indiquant si le client a appuyé sur Entrée pour perdre le focus ( true ) ou non ( false ).
Une instance InputObject indiquant le type d'entrée qui a causé la perte de focus de la boîte de textes.
Échantillons de code
local gui = script.Parent
local textBox = gui.TextBox
local function focusLost(enterPressed)
if enterPressed then
print("Focus was lost because enter was pressed!")
else
print("Focus was lost without enter being pressed")
end
end
textBox.FocusLost:Connect(focusLost)
local textBox = script.Parent
local function onFocusLost(enterPressed, inputThatCausedFocusLost)
if enterPressed then
print("Player pressed Enter")
else
print("Player pressed", inputThatCausedFocusLost.KeyCode)
end
end
textBox.FocusLost:Connect(onFocusLost)
Focused
Se déclenche lorsque le TextBox gagne en focus - généralement lorsqu'un client clique/touche sur un TextBox pour commencer l'entrée de texte. Cela déclenche également si un TextBox force le focus sur l'utilisateur.
Il peut être utilisé avec TextBox.FocusLost pour suivre quand un TextBox gagne et perd le focus.
Voir également le UserInputService.TextBoxFocused et UserInputService.TextBoxFocusReleased pour des fonctions similaires qui dépendent du service UserInputService.
Cet événement ne s'exécutera que lorsqu'il est utilisé dans un LocalScript .
Échantillons de code
local textBox = script.Parent
local function onFocused()
print("Focused")
end
textBox.Focused:Connect(onFocused)