using System;

using System.Collections;

using System.Collections.Generic;

using System.Diagnostics;

using UnityEditor;

using UnityEngine.Events;

using UnityEngine.EventSystems;

using UnityEngine.Serialization;

namespace UnityEngine.UI

{

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

public class InputField : Selectable, IUpdateSelectedHandler, IBeginDragHandler, IDragHandler, IEndDragHandler, IPointerClickHandler, ISubmitHandler, ICanvasElement, ILayoutElement, IEventSystemHandler

{

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>

{

}

protected enum EditState

{

Continue,

Finish

}

protected TouchScreenKeyboard m_Keyboard;

private static readonly char[] kSeparators = new char[]

{

' ',

'.',

',',

'\t',

'\r',

'\n'

};

[FormerlySerializedAs("text"), SerializeField]

protected Text m_TextComponent;

[SerializeField]

protected Graphic m_Placeholder;

[SerializeField]

private InputField.ContentType m_ContentType = InputField.ContentType.Standard;

[FormerlySerializedAs("inputType"), SerializeField]

private InputField.InputType m_InputType = InputField.InputType.Standard;

[FormerlySerializedAs("asteriskChar"), SerializeField]

private char m_AsteriskChar = '*';

[FormerlySerializedAs("keyboardType"), SerializeField]

private TouchScreenKeyboardType m_KeyboardType = TouchScreenKeyboardType.Default;

[SerializeField]

private InputField.LineType m_LineType = InputField.LineType.SingleLine;

[FormerlySerializedAs("hideMobileInput"), SerializeField]

private bool m_HideMobileInput = false;

[FormerlySerializedAs("validation"), SerializeField]

private InputField.CharacterValidation m_CharacterValidation = InputField.CharacterValidation.None;

[FormerlySerializedAs("characterLimit"), SerializeField]

private int m_CharacterLimit = 0;

[FormerlySerializedAs("onSubmit"), FormerlySerializedAs("m_OnSubmit"), FormerlySerializedAs("m_EndEdit"), SerializeField]

private InputField.SubmitEvent m_OnEndEdit = new InputField.SubmitEvent();

[FormerlySerializedAs("onValueChange"), FormerlySerializedAs("m_OnValueChange"), SerializeField]

private InputField.OnChangeEvent m_OnValueChanged = new InputField.OnChangeEvent();

[FormerlySerializedAs("onValidateInput"), SerializeField]

private InputField.OnValidateInput m_OnValidateInput;

[SerializeField]

private Color m_CaretColor = new Color(0.196078435f, 0.196078435f, 0.196078435f, 1f);

[SerializeField]

private bool m_CustomCaretColor = false;

[FormerlySerializedAs("selectionColor"), SerializeField]

private Color m_SelectionColor = new Color(0.65882355f, 0.807843149f, 1f, 0.7529412f);

[FormerlySerializedAs("mValue"), SerializeField]

protected string m_Text = string.Empty;

[Range(0f, 4f), SerializeField]

private float m_CaretBlinkRate = 0.85f;

[Range(1f, 5f), SerializeField]

private int m_CaretWidth = 1;

[SerializeField]

private bool m_ReadOnly = false;

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 bool m_PreventFontCallback = false;

[NonSerialized]

protected Mesh m_Mesh;

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.1f;

protected bool m_CaretVisible;

private Coroutine m_BlinkCoroutine = null;

private float m_BlinkStartTime = 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;

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

private Event m_ProcessingEvent = new Event();

private BaseInput input

{

get

{

BaseInput result;

if (EventSystem.current && EventSystem.current.currentInputModule)

{

result = EventSystem.current.currentInputModule.input;

}

else

{

result = null;

}

return result;

}

}

private string compositionString

{

get

{

return (!(this.input != null)) ? Input.compositionString : this.input.compositionString;

}

}

protected Mesh mesh

{

get

{

if (this.m_Mesh == null)

{

this.m_Mesh = new Mesh();

}

return this.m_Mesh;

}

}

protected TextGenerator cachedInputTextGenerator

{

get

{

if (this.m_InputTextCache == null)

{

this.m_InputTextCache = new TextGenerator();

}

return this.m_InputTextCache;

}

}

public bool shouldHideMobileInput

{

get

{

RuntimePlatform platform = Application.platform;

bool result;

switch (platform)

{

case RuntimePlatform.IPhonePlayer:

case RuntimePlatform.Android:

goto IL_34;

case RuntimePlatform.PS3:

case RuntimePlatform.XBOX360:

IL_1F:

if (platform != RuntimePlatform.TizenPlayer && platform != RuntimePlatform.tvOS)

{

result = true;

return result;

}

goto IL_34;

}

goto IL_1F;

IL_34:

result = this.m_HideMobileInput;

return result;

}

set

{

SetPropertyUtility.SetStruct<bool>(ref this.m_HideMobileInput, value);

}

}

private bool shouldActivateOnSelect

{

get

{

return Application.platform != RuntimePlatform.tvOS;

}

}

public string text

{

get

{

return this.m_Text;

}

set

{

if (!(this.text == value))

{

if (value == null)

{

value = "";

}

value = value.Replace("\0", string.Empty);

if (this.m_LineType == InputField.LineType.SingleLine)

{

value = value.Replace("\n", "").Replace("\t", "");

}

if (this.onValidateInput != null || this.characterValidation != InputField.CharacterValidation.None)

{

this.m_Text = "";

InputField.OnValidateInput onValidateInput = this.onValidateInput ?? new InputField.OnValidateInput(this.Validate);

this.m_CaretPosition = (this.m_CaretSelectPosition = value.Length);

int num = (this.characterLimit <= 0) ? value.Length : Math.Min(this.characterLimit, value.Length);

for (int i = 0; i < num; i++)

{

char c = onValidateInput(this.m_Text, this.m_Text.Length, value[i]);

if (c != '\0')

{

this.m_Text += c;

}

}

}

else

{

this.m_Text = ((this.characterLimit <= 0 || value.Length <= this.characterLimit) ? value : value.Substring(0, this.characterLimit));

}

if (!Application.isPlaying)

{

this.SendOnValueChangedAndUpdateLabel();

}

else

{

if (this.m_Keyboard != null)

{

this.m_Keyboard.text = this.m_Text;

}

if (this.m_CaretPosition > this.m_Text.Length)

{

this.m_CaretPosition = (this.m_CaretSelectPosition = this.m_Text.Length);

}

else if (this.m_CaretSelectPosition > this.m_Text.Length)

{

this.m_CaretSelectPosition = this.m_Text.Length;

}

this.SendOnValueChangedAndUpdateLabel();

}

}

}

}

public bool isFocused

{

get

{

return this.m_AllowInput;

}

}

public float caretBlinkRate

{

get

{

return this.m_CaretBlinkRate;

}

set

{

if (SetPropertyUtility.SetStruct<float>(ref this.m_CaretBlinkRate, value))

{

if (this.m_AllowInput)

{

this.SetCaretActive();

}

}

}

}

public int caretWidth

{

get

{

return this.m_CaretWidth;

}

set

{

if (SetPropertyUtility.SetStruct<int>(ref this.m_CaretWidth, value))

{

this.MarkGeometryAsDirty();

}

}

}

public Text textComponent

{

get

{

return this.m_TextComponent;

}

set

{

if (SetPropertyUtility.SetClass<Text>(ref this.m_TextComponent, value))

{

this.EnforceTextHOverflow();

}

}

}

public Graphic placeholder

{

get

{

return this.m_Placeholder;

}

set

{

SetPropertyUtility.SetClass<Graphic>(ref this.m_Placeholder, value);

}

}

public Color caretColor

{

get

{

return (!this.customCaretColor) ? this.textComponent.color : this.m_CaretColor;

}

set

{

if (SetPropertyUtility.SetColor(ref this.m_CaretColor, value))

{

this.MarkGeometryAsDirty();

}

}

}

public bool customCaretColor

{

get

{

return this.m_CustomCaretColor;

}

set

{

if (this.m_CustomCaretColor != value)

{

this.m_CustomCaretColor = value;

this.MarkGeometryAsDirty();

}

}

}

public Color selectionColor

{

get

{

return this.m_SelectionColor;

}

set

{

if (SetPropertyUtility.SetColor(ref this.m_SelectionColor, value))

{

this.MarkGeometryAsDirty();

}

}

}

public InputField.SubmitEvent onEndEdit

{

get

{

return this.m_OnEndEdit;

}

set

{

SetPropertyUtility.SetClass<InputField.SubmitEvent>(ref this.m_OnEndEdit, value);

}

}

[Obsolete("onValueChange has been renamed to onValueChanged")]

public InputField.OnChangeEvent onValueChange

{

get

{

return this.onValueChanged;

}

set

{

this.onValueChanged = value;

}

}

public InputField.OnChangeEvent onValueChanged

{

get

{

return this.m_OnValueChanged;

}

set

{

SetPropertyUtility.SetClass<InputField.OnChangeEvent>(ref this.m_OnValueChanged, value);

}

}

public InputField.OnValidateInput onValidateInput

{

get

{

return this.m_OnValidateInput;

}

set

{

SetPropertyUtility.SetClass<InputField.OnValidateInput>(ref this.m_OnValidateInput, value);

}

}

public int characterLimit

{

get

{

return this.m_CharacterLimit;

}

set

{

if (SetPropertyUtility.SetStruct<int>(ref this.m_CharacterLimit, Math.Max(0, value)))

{

this.UpdateLabel();

}

}

}

public InputField.ContentType contentType

{

get

{

return this.m_ContentType;

}

set

{

if (SetPropertyUtility.SetStruct<InputField.ContentType>(ref this.m_ContentType, value))

{

this.EnforceContentType();

}

}

}

public InputField.LineType lineType

{

get

{

return this.m_LineType;

}

set

{

if (SetPropertyUtility.SetStruct<InputField.LineType>(ref this.m_LineType, value))

{

this.SetToCustomIfContentTypeIsNot(new InputField.ContentType[]

{

InputField.ContentType.Standard,

InputField.ContentType.Autocorrected

});

this.EnforceTextHOverflow();

}

}

}

public InputField.InputType inputType

{

get

{

return this.m_InputType;

}

set

{

if (SetPropertyUtility.SetStruct<InputField.InputType>(ref this.m_InputType, value))

{

this.SetToCustom();

}

}

}

public TouchScreenKeyboardType keyboardType

{

get

{

return this.m_KeyboardType;

}

set

{

if (SetPropertyUtility.SetStruct<TouchScreenKeyboardType>(ref this.m_KeyboardType, value))

{

this.SetToCustom();

}

}

}

public InputField.CharacterValidation characterValidation

{

get

{

return this.m_CharacterValidation;

}

set

{

if (SetPropertyUtility.SetStruct<InputField.CharacterValidation>(ref this.m_CharacterValidation, value))

{

this.SetToCustom();

}

}

}

public bool readOnly

{

get

{

return this.m_ReadOnly;

}

set

{

this.m_ReadOnly = value;

}

}

public bool multiLine

{

get

{

return this.m_LineType == InputField.LineType.MultiLineNewline || this.lineType == InputField.LineType.MultiLineSubmit;

}

}

public char asteriskChar

{

get

{

return this.m_AsteriskChar;

}

set

{

if (SetPropertyUtility.SetStruct<char>(ref this.m_AsteriskChar, value))

{

this.UpdateLabel();

}

}

}

public bool wasCanceled

{

get

{

return this.m_WasCanceled;

}

}

protected int caretPositionInternal

{

get

{

return this.m_CaretPosition + this.compositionString.Length;

}

set

{

this.m_CaretPosition = value;

this.ClampPos(ref this.m_CaretPosition);

}

}

protected int caretSelectPositionInternal

{

get

{

return this.m_CaretSelectPosition + this.compositionString.Length;

}

set

{

this.m_CaretSelectPosition = value;

this.ClampPos(ref this.m_CaretSelectPosition);

}

}

private bool hasSelection

{

get

{

return this.caretPositionInternal != this.caretSelectPositionInternal;

}

}

[Obsolete("caretSelectPosition has been deprecated. Use selectionFocusPosition instead (UnityUpgradable) -> selectionFocusPosition", true)]

public int caretSelectPosition

{

get

{

return this.selectionFocusPosition;

}

protected set

{

this.selectionFocusPosition = value;

}

}

public int caretPosition

{

get

{

return this.m_CaretSelectPosition + this.compositionString.Length;

}

set

{

this.selectionAnchorPosition = value;

this.selectionFocusPosition = value;

}

}

public int selectionAnchorPosition

{

get

{

return this.m_CaretPosition + this.compositionString.Length;

}

set

{

if (this.compositionString.Length == 0)

{

this.m_CaretPosition = value;

this.ClampPos(ref this.m_CaretPosition);

}

}

}

public int selectionFocusPosition

{

get

{

return this.m_CaretSelectPosition + this.compositionString.Length;

}

set

{

if (this.compositionString.Length == 0)

{

this.m_CaretSelectPosition = value;

this.ClampPos(ref this.m_CaretSelectPosition);

}

}

}

private static string clipboard

{

get

{

return GUIUtility.systemCopyBuffer;

}

set

{

GUIUtility.systemCopyBuffer = value;

}

}

public virtual float minWidth

{

get

{

return 0f;

}

}

public virtual float preferredWidth

{

get

{

float result;

if (this.textComponent == null)

{

result = 0f;

}

else

{

TextGenerationSettings generationSettings = this.textComponent.GetGenerationSettings(Vector2.zero);

result = this.textComponent.cachedTextGeneratorForLayout.GetPreferredWidth(this.m_Text, generationSettings) / this.textComponent.pixelsPerUnit;

}

return result;

}

}

public virtual float flexibleWidth

{

get

{

return -1f;

}

}

public virtual float minHeight

{

get

{

return 0f;

}

}

public virtual float preferredHeight

{

get

{

float result;

if (this.textComponent == null)

{

result = 0f;

}

else

{

TextGenerationSettings generationSettings = this.textComponent.GetGenerationSettings(new Vector2(this.textComponent.rectTransform.rect.size.x, 0f));

result = this.textComponent.cachedTextGeneratorForLayout.GetPreferredHeight(this.m_Text, generationSettings) / this.textComponent.pixelsPerUnit;

}

return result;

}

}

public virtual float flexibleHeight

{

get

{

return -1f;

}

}

public virtual int layoutPriority

{

get

{

return 1;

}

}

protected InputField()

{

this.EnforceTextHOverflow();

}

protected void ClampPos(ref int pos)

{

if (pos < 0)

{

pos = 0;

}

else if (pos > this.text.Length)

{

pos = this.text.Length;

}

}

protected override void OnValidate()

{

base.OnValidate();

this.EnforceContentType();

this.EnforceTextHOverflow();

this.m_CharacterLimit = Math.Max(0, this.m_CharacterLimit);

if (this.IsActive())

{

this.UpdateLabel();

if (this.m_AllowInput)

{

this.SetCaretActive();

}

}

}

protected override void OnEnable()

{

base.OnEnable();

if (this.m_Text == null)

{

this.m_Text = string.Empty;

}

this.m_DrawStart = 0;

this.m_DrawEnd = this.m_Text.Length;

if (this.m_CachedInputRenderer != null)

{

this.m_CachedInputRenderer.SetMaterial(this.m_TextComponent.GetModifiedMaterial(Graphic.defaultGraphicMaterial), Texture2D.whiteTexture);

}

if (this.m_TextComponent != null)

{

this.m_TextComponent.RegisterDirtyVerticesCallback(new UnityAction(this.MarkGeometryAsDirty));

this.m_TextComponent.RegisterDirtyVerticesCallback(new UnityAction(this.UpdateLabel));

this.m_TextComponent.RegisterDirtyMaterialCallback(new UnityAction(this.UpdateCaretMaterial));

this.UpdateLabel();

}

}

protected override void OnDisable()

{

this.m_BlinkCoroutine = null;

this.DeactivateInputField();

if (this.m_TextComponent != null)

{

this.m_TextComponent.UnregisterDirtyVerticesCallback(new UnityAction(this.MarkGeometryAsDirty));

this.m_TextComponent.UnregisterDirtyVerticesCallback(new UnityAction(this.UpdateLabel));

this.m_TextComponent.UnregisterDirtyMaterialCallback(new UnityAction(this.UpdateCaretMaterial));

}

CanvasUpdateRegistry.UnRegisterCanvasElementForRebuild(this);

if (this.m_CachedInputRenderer != null)

{

this.m_CachedInputRenderer.Clear();

}

if (this.m_Mesh != null)

{

UnityEngine.Object.DestroyImmediate(this.m_Mesh);

}

this.m_Mesh = null;

base.OnDisable();

}

[DebuggerHidden]

private IEnumerator CaretBlink()

{

InputField.<CaretBlink>c__Iterator0 <CaretBlink>c__Iterator = new InputField.<CaretBlink>c__Iterator0();

<CaretBlink>c__Iterator.$this = this;

return <CaretBlink>c__Iterator;

}

private void SetCaretVisible()

{

if (this.m_AllowInput)

{

this.m_CaretVisible = true;

this.m_BlinkStartTime = Time.unscaledTime;

this.SetCaretActive();

}

}

private void SetCaretActive()

{

if (this.m_AllowInput)

{

if (this.m_CaretBlinkRate > 0f)

{

if (this.m_BlinkCoroutine == null)

{

this.m_BlinkCoroutine = base.StartCoroutine(this.CaretBlink());

}

}

else

{

this.m_CaretVisible = true;

}

}

}

private void UpdateCaretMaterial()

{

if (this.m_TextComponent != null && this.m_CachedInputRenderer != null)

{

this.m_CachedInputRenderer.SetMaterial(this.m_TextComponent.GetModifiedMaterial(Graphic.defaultGraphicMaterial), Texture2D.whiteTexture);

}

}

protected void OnFocus()

{

this.SelectAll();

}

protected void SelectAll()

{

this.caretPositionInternal = this.text.Length;

this.caretSelectPositionInternal = 0;

}

public void MoveTextEnd(bool shift)

{

int length = this.text.Length;

if (shift)

{

this.caretSelectPositionInternal = length;

}

else

{

this.caretPositionInternal = length;

this.caretSelectPositionInternal = this.caretPositionInternal;

}

this.UpdateLabel();

}

public void MoveTextStart(bool shift)

{

int num = 0;

if (shift)

{

this.caretSelectPositionInternal = num;

}

else

{

this.caretPositionInternal = num;

this.caretSelectPositionInternal = this.caretPositionInternal;

}

this.UpdateLabel();

}

private bool InPlaceEditing()

{

return !TouchScreenKeyboard.isSupported;

}

private void UpdateCaretFromKeyboard()

{

RangeInt selection = this.m_Keyboard.selection;

int start = selection.start;

int end = selection.end;

bool flag = false;

if (this.caretPositionInternal != start)