using System;

using System.Collections;

using System.Collections.Generic;

using System.Text;

using UnityEngine.Events;

using UnityEngine.EventSystems;

using UnityEngine.Serialization;

namespace UnityEngine.UI

{

/// <summary>

/// Editable text input field.

/// </summary>

[AddComponentMenu("UI/Input Field", 31)]

public class InputField

: Selectable,

IUpdateSelectedHandler,

IBeginDragHandler,

IDragHandler,

IEndDragHandler,

IPointerClickHandler,

ISubmitHandler,

ICanvasElement

{

public enum ContentType

{

Standard,

Autocorrected,

IntegerNumber,

DecimalNumber,

Alphanumeric,

Name,

EmailAddress,

Password,

Pin,

Custom

}

public enum InputType

{

Standard,

AutoCorrect,

Password,

}

public enum CharacterValidation

{

None,

Integer,

Decimal,

Alphanumeric,

Name,

EmailAddress

}

public enum LineType

{

SingleLine,

MultiLineSubmit,

MultiLineNewline

}

public delegate char OnValidateInput(string text, int charIndex, char addedChar);

[Serializable]

public class SubmitEvent : UnityEvent<string> {}

[Serializable]

public class OnChangeEvent : UnityEvent<string> {}

static protected TouchScreenKeyboard m_Keyboard;

static private readonly char[] kSeparators = { ' ', '.', ',' };

#region Exposed properties

/// <summary>

/// Text Text used to display the input's value.

/// </summary>

[SerializeField]

[FormerlySerializedAs("text")]

protected Text m_TextComponent;

[SerializeField]

protected Graphic m_Placeholder;

[SerializeField]

private ContentType m_ContentType = ContentType.Standard;

/// <summary>

/// Type of data expected by the input field.

/// </summary>

[FormerlySerializedAs("inputType")]

[SerializeField]

private InputType m_InputType = InputType.Standard;

/// <summary>

/// The character used to hide text in password field.

/// </summary>

[FormerlySerializedAs("asteriskChar")]

[SerializeField]

private char m_AsteriskChar = '*';

/// <summary>

/// Keyboard type applies to mobile keyboards that get shown.

/// </summary>

[FormerlySerializedAs("keyboardType")]

[SerializeField]

private TouchScreenKeyboardType m_KeyboardType = TouchScreenKeyboardType.Default;

[SerializeField]

private LineType m_LineType = LineType.SingleLine;

/// <summary>

/// Should hide mobile input.

/// </summary>

[FormerlySerializedAs("hideMobileInput")]

[SerializeField]

private bool m_HideMobileInput = false;

/// <summary>

/// What kind of validation to use with the input field's data.

/// </summary>

[FormerlySerializedAs("validation")]

[SerializeField]

private CharacterValidation m_CharacterValidation = CharacterValidation.None;

/// <summary>

/// Maximum number of characters allowed before input no longer works.

/// </summary>

[FormerlySerializedAs("characterLimit")]

[SerializeField]

private int m_CharacterLimit = 0;

/// <summary>

/// Event delegates triggered when the input field submits its data.

/// </summary>

[FormerlySerializedAs("onSubmit")]

[FormerlySerializedAs("m_OnSubmit")]

[SerializeField]

private SubmitEvent m_EndEdit = new SubmitEvent();

/// <summary>

/// Event delegates triggered when the input field changes its data.

/// </summary>

[FormerlySerializedAs("onValueChange")]

[SerializeField]

private OnChangeEvent m_OnValueChange = new OnChangeEvent();

/// <summary>

/// Custom validation callback.

/// </summary>

[FormerlySerializedAs("onValidateInput")]

[SerializeField]

private OnValidateInput m_OnValidateInput;

[FormerlySerializedAs("selectionColor")]

[SerializeField]

private Color m_SelectionColor = new Color(168f / 255f, 206f / 255f, 255f / 255f, 192f / 255f);

/// <summary>

/// Input field's value.

/// </summary>

[SerializeField]

[FormerlySerializedAs("mValue")]

protected string m_Text = string.Empty;

[SerializeField]

[Range(0f, 8f)]

private float m_CaretBlinkRate = 1.7f;

#endregion

protected int m_CaretPosition = 0;

protected int m_CaretSelectPosition = 0;

private RectTransform caretRectTrans = null;

protected UIVertex[] m_CursorVerts = null;

private TextGenerator m_InputTextCache;

private CanvasRenderer m_CachedInputRenderer;

private readonly List<UIVertex> m_Vbo = new List<UIVertex>();

private bool m_AllowInput = false;

private bool m_ShouldActivateNextUpdate = false;

private bool m_UpdateDrag = false;

private bool m_DragPositionOutOfBounds = false;

private const float kHScrollSpeed = 0.05f;

private const float kVScrollSpeed = 0.10f;

protected bool m_CaretVisible;

private Coroutine m_BlickCoroutine = null;

private float m_BlinkStartTime = 0.0f;

protected int m_DrawStart = 0;

protected int m_DrawEnd = 0;

private Coroutine m_DragCoroutine = null;

private string m_OriginalText = "";

private bool m_WasCanceled = false;

private bool m_HasDoneFocusTransition = false;

// Doesn't include dot and @ on purpose! See usage for details.

const string kEmailSpecialCharacters = "!#$%&'*+-/=?^_`{|}~";

protected InputField()

{}

protected TextGenerator cachedInputTextGenerator

{

get

{

if (m_InputTextCache == null)

m_InputTextCache = new TextGenerator();

return m_InputTextCache;

}

}

/// <summary>

/// Should the mobile keyboard input be hidden.

/// </summary>

public bool shouldHideMobileInput

{

set

{

SetPropertyUtility.SetStruct(ref m_HideMobileInput, value);

}

get

{

switch (Application.platform)

{

case RuntimePlatform.Android:

case RuntimePlatform.BlackBerryPlayer:

case RuntimePlatform.IPhonePlayer:

return m_HideMobileInput;

}

return true;

}

}

/// <summary>

/// Input field's current text value.

/// </summary>

public string text

{

get

{

if (m_Keyboard != null && m_Keyboard.active && !InPlaceEditing())

return m_Keyboard.text;

return m_Text;

}

set

{

if (this.text == value)

return;

m_Text = value;

#if UNITY_EDITOR

if (!Application.isPlaying)

{

SendOnValueChangedAndUpdateLabel();

return;

}

#endif

if (m_Keyboard != null)

m_Keyboard.text = m_Text;

if (m_CaretPosition > m_Text.Length)

m_CaretPosition = m_CaretSelectPosition = m_Text.Length;

SendOnValueChangedAndUpdateLabel();

}

}

public bool isFocused

{

get { return m_AllowInput; }

}

public float caretBlinkRate

{

get { return m_CaretBlinkRate; }

set

{

if (SetPropertyUtility.SetStruct(ref m_CaretBlinkRate, value))

{

if (m_AllowInput)

SetCaretActive();

}

}

}

public Text textComponent { get { return m_TextComponent; } set { SetPropertyUtility.SetClass(ref m_TextComponent, value); } }

public Graphic placeholder { get { return m_Placeholder; } set { SetPropertyUtility.SetClass(ref m_Placeholder, value); } }

public Color selectionColor { get { return m_SelectionColor; } set { SetPropertyUtility.SetColor(ref m_SelectionColor, value); } }

public SubmitEvent onEndEdit { get { return m_EndEdit; } set { SetPropertyUtility.SetClass(ref m_EndEdit, value); } }

public OnChangeEvent onValueChange { get { return m_OnValueChange; } set { SetPropertyUtility.SetClass(ref m_OnValueChange, value); } }

public OnValidateInput onValidateInput { get { return m_OnValidateInput; } set { SetPropertyUtility.SetClass(ref m_OnValidateInput, value); } }

public int characterLimit { get { return m_CharacterLimit; } set { SetPropertyUtility.SetStruct(ref m_CharacterLimit, value); } }

// Content Type related

public ContentType contentType { get { return m_ContentType; } set { if (SetPropertyUtility.SetStruct(ref m_ContentType, value)) EnforceContentType(); } }

public LineType lineType { get { return m_LineType; } set { if (SetPropertyUtility.SetStruct(ref m_LineType, value)) SetToCustomIfContentTypeIsNot(ContentType.Standard, ContentType.Autocorrected); } }

public InputType inputType { get { return m_InputType; } set { if (SetPropertyUtility.SetStruct(ref m_InputType, value)) SetToCustom(); } }

public TouchScreenKeyboardType keyboardType { get { return m_KeyboardType; } set { if (SetPropertyUtility.SetStruct(ref m_KeyboardType, value)) SetToCustom(); } }

public CharacterValidation characterValidation { get { return m_CharacterValidation; } set { if (SetPropertyUtility.SetStruct(ref m_CharacterValidation, value)) SetToCustom(); } }

// Derived property

public bool multiLine { get { return m_LineType == LineType.MultiLineNewline || lineType == LineType.MultiLineSubmit; } }

// Not shown in Inspector.

public char asteriskChar { get { return m_AsteriskChar; } set { SetPropertyUtility.SetStruct(ref m_AsteriskChar, value); } }

public bool wasCanceled { get { return m_WasCanceled; } }

protected void ClampPos(ref int pos)

{

if (pos < 0) pos = 0;

else if (pos > text.Length) pos = text.Length;

}

/// <summary>

/// Current position of the cursor.

/// </summary>

protected int caretPosition { get { return m_CaretPosition + Input.compositionString.Length; } set { m_CaretPosition = value; ClampPos(ref m_CaretPosition); } }

protected int caretSelectPos { get { return m_CaretSelectPosition + Input.compositionString.Length; } set { m_CaretSelectPosition = value; ClampPos(ref m_CaretSelectPosition); } }

private bool hasSelection { get { return caretPosition != caretSelectPos; } }

#if UNITY_EDITOR

// Remember: This is NOT related to text validation!

// This is Unity's own OnValidate method which is invoked when changing values in the Inspector.

protected override void OnValidate()

{

base.OnValidate();

EnforceContentType();

UpdateLabel();

if (m_AllowInput)

SetCaretActive();

}

#endif // if UNITY_EDITOR

protected override void OnEnable()

{

base.OnEnable();

if (m_Text == null)

m_Text = string.Empty;

m_DrawStart = 0;

m_DrawEnd = m_Text.Length;

if (m_TextComponent != null)

{

m_TextComponent.RegisterDirtyVerticesCallback(MarkGeometryAsDirty);

m_TextComponent.RegisterDirtyVerticesCallback(UpdateLabel);

UpdateLabel();

}

}

protected override void OnDisable()

{

DeactivateInputField();

if (m_TextComponent != null)

{

m_TextComponent.UnregisterDirtyVerticesCallback(MarkGeometryAsDirty);

m_TextComponent.UnregisterDirtyVerticesCallback(UpdateLabel);

}

CanvasUpdateRegistry.UnRegisterCanvasElementForRebuild(this);

if (m_CachedInputRenderer)

m_CachedInputRenderer.SetVertices(null, 0);

base.OnDisable();

}

IEnumerator CaretBlink()

{

// Always ensure caret is initially visible since it can otherwise be confusing for a moment.

m_CaretVisible = true;

yield return null;

while (isFocused && m_CaretBlinkRate > 0)

{

// Update caret state as first thing after waiting.

// This also ensures m_CaretBlinkRate didn't get set to 0 in between

// checking it above and running this time comparison.

if (m_BlinkStartTime + (1f / m_CaretBlinkRate) < Time.unscaledTime)

{

m_CaretVisible = !m_CaretVisible;

m_BlinkStartTime = Time.unscaledTime;

UpdateGeometry();

}

// Then wait again.

yield return null;

}

m_BlickCoroutine = null;

}

void SetCaretVisible()

{

if (!m_AllowInput)

return;

m_CaretVisible = true;

m_BlinkStartTime = Time.unscaledTime;

SetCaretActive();

}

// SetCaretActive will not set the caret immediately visible - it will wait for the next time to blink.

// However, it will handle things correctly if the blink speed changed from zero to non-zero or non-zero to zero.

void SetCaretActive()

{

if (!m_AllowInput)

return;

if (m_CaretBlinkRate > 0.0f)

{

if (m_BlickCoroutine == null)

m_BlickCoroutine = StartCoroutine(CaretBlink());

}

else

{

m_CaretVisible = true;

}

}

protected void OnFocus()

{

SelectAll();

}

protected void SelectAll()

{

caretPosition = text.Length;

caretSelectPos = 0;

}

public void MoveTextEnd(bool shift)

{

int position = text.Length;

if (shift)

{

caretSelectPos = position;

}

else

{

caretPosition = position;

caretSelectPos = caretPosition;

}

UpdateLabel();

}

public void MoveTextStart(bool shift)

{

int position = 0;

if (shift)

{

caretSelectPos = position;

}

else

{

caretPosition = position;

caretSelectPos = caretPosition;

}

UpdateLabel();

}

// TODO: Why doesnt this use GUIUtility.systemCopyBuffer??

static string clipboard

{

get

{

TextEditor te = new TextEditor();

te.Paste();

return te.content.text;

}

set

{

TextEditor te = new TextEditor();

te.content = new GUIContent(value);

te.OnFocus();

te.Copy();

}

}

private bool InPlaceEditing()

{

return !TouchScreenKeyboard.isSupported;

}

/// <summary>

/// Update the text based on input.

/// </summary>

// TODO: Make LateUpdate a coroutine instead. Allows us to control the update to only be when the field is active.

protected virtual void LateUpdate()

{

// Only activate if we are not already activated.

if (m_ShouldActivateNextUpdate)

{

if (!isFocused)

{

ActivateInputFieldInternal();

m_ShouldActivateNextUpdate = false;

return;

}

// Reset as we are already activated.

m_ShouldActivateNextUpdate = false;

}

if (InPlaceEditing() || !isFocused)

return;

AssignPositioningIfNeeded();

if (m_Keyboard == null || !m_Keyboard.active)

{

if (m_Keyboard != null && m_Keyboard.wasCanceled)

m_WasCanceled = true;

OnDeselect(null);

return;

}

string val = m_Keyboard.text;

if (m_Text != val)

{

m_Text = "";

for (int i = 0; i < val.Length; ++i)

{

char c = val[i];

if (c == '\r' || (int)c == 3)

c = '\n';

if (onValidateInput != null)

c = onValidateInput(m_Text, m_Text.Length, c);

else if (characterValidation != CharacterValidation.None)

c = Validate(m_Text, m_Text.Length, c);

if (lineType == LineType.MultiLineSubmit && c == '\n')

{

m_Keyboard.text = m_Text;

OnDeselect(null);

return;

}

if (c != 0)

m_Text += c;

}

if (characterLimit > 0 && m_Text.Length > characterLimit)

m_Text = m_Text.Substring(0, characterLimit);

caretPosition = caretSelectPos = m_Text.Length;

// Set keyboard text before updating label, as we might have changed it with validation

// and update label will take the old value from keyboard if we don't change it here

if (m_Text != val)

m_Keyboard.text = m_Text;

SendOnValueChangedAndUpdateLabel();

}

if (m_Keyboard.done)

{

if (m_Keyboard.wasCanceled)

m_WasCanceled = true;

OnDeselect(null);

}

}

public Vector2 ScreenToLocal(Vector2 screen)

{

var theCanvas = m_TextComponent.canvas;

if (theCanvas == null)

return screen;

Vector3 pos = Vector3.zero;

if (theCanvas.renderMode == RenderMode.ScreenSpaceOverlay)

{

pos = m_TextComponent.transform.InverseTransformPoint(screen);

}

else if (theCanvas.worldCamera != null)

{

Ray mouseRay = theCanvas.worldCamera.ScreenPointToRay(screen);

float dist;

Plane plane = new Plane(m_TextComponent.transform.forward, m_TextComponent.transform.position);

plane.Raycast(mouseRay, out dist);

pos = m_TextComponent.transform.InverseTransformPoint(mouseRay.GetPoint(dist));

}

return new Vector2(pos.x, pos.y);

}

private int GetUnclampedCharacterLineFromPosition(Vector2 pos, TextGenerator generator)

{

if (!multiLine)

return 0;

float height = m_TextComponent.rectTransform.rect.yMax;

// Position is above first line.

if (pos.y > height)

return -1;

for (int i = 0; i < generator.lineCount; ++i)

{

float lineHeight = generator.lines[i].height / m_TextComponent.pixelsPerUnit;

if (pos.y <= height && pos.y > (height - lineHeight))

return i;

height -= lineHeight;

}

// Position is after last line.

return generator.lineCount;

}

/// <summary>

/// Given an input position in local space on the Text return the index for the selection cursor at this position.

/// </summary>

protected int GetCharacterIndexFromPosition(Vector2 pos)

{

TextGenerator gen = m_TextComponent.cachedTextGenerator;

if (gen.lineCount == 0)

return 0;

int line = GetUnclampedCharacterLineFromPosition(pos, gen);

if (line < 0)

return 0;

if (line >= gen.lineCount)

return gen.characterCountVisible;

int startCharIndex = gen.lines[line].startCharIdx;

int endCharIndex = GetLineEndPosition(gen, line);

for (int i = startCharIndex; i < endCharIndex; i++)

{

if (i >= gen.characterCountVisible)

break;

UICharInfo charInfo = gen.characters[i];

Vector2 charPos = charInfo.cursorPos / m_TextComponent.pixelsPerUnit;

float distToCharStart = pos.x - charPos.x;

float distToCharEnd = charPos.x + (charInfo.charWidth / m_TextComponent.pixelsPerUnit) - pos.x;

if (distToCharStart < distToCharEnd)

return i;

}

return endCharIndex;

}

private bool MayDrag(PointerEventData eventData)

{

return IsActive() &&

IsInteractable() &&

eventData.button == PointerEventData.InputButton.Left &&

m_TextComponent != null &&

m_Keyboard == null;

}

public virtual void OnBeginDrag(PointerEventData eventData)

{

if (!MayDrag(eventData))

return;

m_UpdateDrag = true;

}

public virtual void OnDrag(PointerEventData eventData)

{

if (!MayDrag(eventData))

return;

Vector2 localMousePos;

RectTransformUtility.ScreenPointToLocalPointInRectangle(textComponent.rectTransform, eventData.position, eventData.pressEventCamera, out localMousePos);

caretSelectPos = GetCharacterIndexFromPosition(localMousePos) + m_DrawStart;

MarkGeometryAsDirty();

m_DragPositionOutOfBounds = !RectTransformUtility.RectangleContainsScreenPoint(textComponent.rectTransform, eventData.position, eventData.pressEventCamera);

if (m_DragPositionOutOfBounds && m_DragCoroutine == null)

m_DragCoroutine = StartCoroutine(MouseDragOutsideRect(eventData));

eventData.Use();

}

IEnumerator MouseDragOutsideRect(PointerEventData eventData)

{

while (m_UpdateDrag && m_DragPositionOutOfBounds)

{

Vector2 localMousePos;

RectTransformUtility.ScreenPointToLocalPointInRectangle(textComponent.rectTransform, eventData.position, eventData.pressEventCamera, out localMousePos);

Rect rect = textComponent.rectTransform.rect;

if (multiLine)

{

if (localMousePos.y > rect.yMax)

MoveUp(true, true);

else if (localMousePos.y < rect.yMin)

MoveDown(true, true);

}

else

{

if (localMousePos.x < rect.xMin)

MoveLeft(true, false);

else if (localMousePos.x > rect.xMax)

MoveRight(true, false);

}

UpdateLabel();

float delay = multiLine ? kVScrollSpeed : kHScrollSpeed;

yield return new WaitForSeconds(delay);

}

m_DragCoroutine = null;

}

public virtual void OnEndDrag(PointerEventData eventData)

{

if (!MayDrag(eventData))

return;

m_UpdateDrag = false;

}

public override void OnPointerDown(PointerEventData eventData)

{

if (!MayDrag(eventData))

return;

EventSystem.current.SetSelectedGameObject(gameObject, eventData);

bool hadFocusBefore = m_AllowInput;

base.OnPointerDown(eventData);

if (!InPlaceEditing())

{

if (m_Keyboard == null || !m_Keyboard.active)

{

OnSelect(eventData);

return;

}

}

// Only set caret position if we didn't just get focus now.

// Otherwise it will overwrite the select all on focus.

if (hadFocusBefore)

{

Vector2 pos = ScreenToLocal(eventData.position);

caretSelectPos = caretPosition = GetCharacterIndexFromPosition(pos) + m_DrawStart;

}

UpdateLabel();

eventData.Use();

}

protected enum EditState

{

Continue,

Finish

}

protected EditState KeyPressed(Event evt)

{

var currentEventModifiers = evt.modifiers;

RuntimePlatform rp = Application.platform;

bool isMac = (rp == RuntimePlatform.OSXEditor || rp == RuntimePlatform.OSXPlayer || rp == RuntimePlatform.OSXWebPlayer);

bool ctrl = isMac ? (currentEventModifiers & EventModifiers.Command) != 0 : (currentEventModifiers & EventModifiers.Control) != 0;

bool shift = (currentEventModifiers & EventModifiers.Shift) != 0;

switch (evt.keyCode)

{

case KeyCode.Backspace:

{

Backspace();

return EditState.Continue;

}

case KeyCode.Delete:

{

ForwardSpace();

return EditState.Continue;

}

case KeyCode.Home:

{

MoveTextStart(shift);

return EditState.Continue;

}

case KeyCode.End:

{

MoveTextEnd(shift);

return EditState.Continue;

}

// Select All

case KeyCode.A:

{

if (ctrl)

{

SelectAll();

return EditState.Continue;

}

break;

}

// Copy

case KeyCode.C:

{

if (ctrl)

{

clipboard = GetSelectedString();

return EditState.Continue;

}

break;

}

// Paste

case KeyCode.V:

{

if (ctrl)

{

Append(clipboard);

return EditState.Continue;

}

break;

}

// Cut

case KeyCode.X:

{

if (ctrl)

{

clipboard = GetSelectedString();

Delete();

SendOnValueChangedAndUpdateLabel();

return EditState.Continue;

}

break;

}

case KeyCode.LeftArrow:

{

MoveLeft(shift, ctrl);

return EditState.Continue;

}

case KeyCode.RightArrow:

{

MoveRight(shift, ctrl);

return EditState.Continue;

}

case KeyCode.UpArrow:

{

MoveUp(shift);

return EditState.Continue;

}

case KeyCode.DownArrow:

{

MoveDown(shift);

return EditState.Continue;

}

// Submit

case KeyCode.Return:

case KeyCode.KeypadEnter:

{

if (lineType != LineType.MultiLineNewline)

{

return EditState.Finish;

}

break;

}

case KeyCode.Escape:

{

m_WasCanceled = true;

return EditState.Finish;

}

}

// Dont allow return chars to be entered into single line fields.

if (!multiLine && (evt.character == '\t'))

return EditState.Continue;

char c = evt.character;

// Convert carriage return and end-of-text characters to newline.

if (c == '\r' || (int)c == 3)

c = '\n';

if (IsValidChar(c))

{

Append(c);

}

if (c == 0)

{

if (Input.compositionString.Length > 0)

{

UpdateLabel();

}

}

return EditState.Continue;

}

private bool IsValidChar(char c)

{

// Delete key on mac

if ((int)c == 127)

return false;

// Accept newline and tab

if (c == '\t' || c == '\n')

return true;

return m_TextComponent.font.HasCharacter(c);

}

/// <summary>

/// Handle the specified event.

/// </summary>

private Event m_ProcessingEvent = new Event();

public void ProcessEvent(Event e)

{

KeyPressed(e);

}

public virtual void OnUpdateSelected(BaseEventData eventData)

{

if (!isFocused)

return;

bool consumedEvent = false;

while (Event.PopEvent(m_ProcessingEvent))

{

if (m_ProcessingEvent.rawType == EventType.KeyDown)

{

consumedEvent = true;

var shouldContinue = KeyPressed(m_ProcessingEvent);

if (shouldContinue == EditState.Finish)

{

DeactivateInputField();

break;

}

}

}

if (consumedEvent)

UpdateLabel();

eventData.Use();

}

private string GetSelectedString()

{

if (!hasSelection)

return "";

int startPos = caretPosition;

int endPos = caretSelectPos;

// Ensure pos is always less then selPos to make the code simpler

if (startPos > endPos)

{

int temp = startPos;

startPos = endPos;

endPos = temp;

}

StringBuilder builder = new StringBuilder();

for (int i = startPos; i < endPos; ++i)

{

builder.Append(text[i]);

}

return builder.ToString();

}