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

{

// Setting the content type acts as a shortcut for setting a combination of InputType, CharacterValidation, LineType, and TouchScreenKeyboardType

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 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")]

[FormerlySerializedAs("m_EndEdit")]

[SerializeField]

private SubmitEvent m_OnEndEdit = new SubmitEvent();

/// <summary>

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

/// </summary>

[FormerlySerializedAs("onValueChange")]

[FormerlySerializedAs("m_OnValueChange")]

[SerializeField]

private OnChangeEvent m_OnValueChanged = new OnChangeEvent();

/// <summary>

/// Custom validation callback.

/// </summary>

[FormerlySerializedAs("onValidateInput")]

[SerializeField]

private OnValidateInput m_OnValidateInput;

[SerializeField]

private Color m_CaretColor = new Color(50f / 255f, 50f / 255f, 50f / 255f, 1f);

[SerializeField]

private bool m_CustomCaretColor = false;

[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, 4f)]

private float m_CaretBlinkRate = 0.85f;

[SerializeField]

[Range(1, 5)]

private int m_CaretWidth = 1;

[SerializeField]

private bool m_ReadOnly = false;

#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 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.10f;

protected bool m_CaretVisible;

private Coroutine m_BlinkCoroutine = 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 Mesh mesh

{

get

{

if (m_Mesh == null)

m_Mesh = new Mesh();

return m_Mesh;

}

}

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:

case RuntimePlatform.TizenPlayer:

case RuntimePlatform.tvOS:

return m_HideMobileInput;

}

return true;

}

}

bool shouldActivateOnSelect

{

get

{

return Application.platform != RuntimePlatform.tvOS;

}

}

/// <summary>

/// Input field's current text value.

/// </summary>

public string text

{

get

{

// only return keyboard data if it's activated for this input field

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

EventSystem.current.currentSelectedGameObject == gameObject)

{

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 int caretWidth { get { return m_CaretWidth; } set { if (SetPropertyUtility.SetStruct(ref m_CaretWidth, value)) MarkGeometryAsDirty(); } }

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 caretColor { get { return customCaretColor ? m_CaretColor : textComponent.color; } set { if (SetPropertyUtility.SetColor(ref m_CaretColor, value)) MarkGeometryAsDirty(); } }

public bool customCaretColor { get { return m_CustomCaretColor; } set { if (m_CustomCaretColor != value) { m_CustomCaretColor = value; MarkGeometryAsDirty(); } } }

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

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

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

public OnChangeEvent onValueChange { get { return onValueChanged; } set { onValueChanged = value; } }

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

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

public int characterLimit { get { return m_CharacterLimit; } set { if (SetPropertyUtility.SetStruct(ref m_CharacterLimit, Math.Max(0, value))) UpdateLabel(); } }

// 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(); } }

public bool readOnly { get { return m_ReadOnly; } set { m_ReadOnly = value; } }

// 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 { if (SetPropertyUtility.SetStruct(ref m_AsteriskChar, value)) UpdateLabel(); } }

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.

/// Getters are public Setters are protected

/// </summary>

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

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

private bool hasSelection { get { return caretPositionInternal != caretSelectPositionInternal; } }

#if UNITY_EDITOR

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

public int caretSelectPosition { get { return selectionFocusPosition; } protected set { selectionFocusPosition = value; } }

#endif

/// <summary>

/// Get: Returns the focus position as thats the position that moves around even during selection.

/// Set: Set both the anchor and focus position such that a selection doesn't happen

/// </summary>

public int caretPosition

{

get { return m_CaretSelectPosition + Input.compositionString.Length; }

set { selectionAnchorPosition = value; selectionFocusPosition = value; }

}

/// <summary>

/// Get: Returns the fixed position of selection

/// Set: If Input.compositionString is 0 set the fixed position

/// </summary>

public int selectionAnchorPosition

{

get { return m_CaretPosition + Input.compositionString.Length; }

set

{

if (Input.compositionString.Length != 0)

return;

m_CaretPosition = value;

ClampPos(ref m_CaretPosition);

}

}

/// <summary>

/// Get: Returns the variable position of selection

/// Set: If Input.compositionString is 0 set the variable position

/// </summary>

public int selectionFocusPosition

{

get { return m_CaretSelectPosition + Input.compositionString.Length; }

set

{

if (Input.compositionString.Length != 0)

return;

m_CaretSelectPosition = value;

ClampPos(ref m_CaretSelectPosition);

}

}

#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();

m_CharacterLimit = Math.Max(0, m_CharacterLimit);

//This can be invoked before OnEnabled is called. So we shouldn't be accessing other objects, before OnEnable is called.

if (!IsActive())

return;

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 we have a cached renderer then we had OnDisable called so just restore the material.

if (m_CachedInputRenderer != null)

m_CachedInputRenderer.SetMaterial(Graphic.defaultGraphicMaterial, Texture2D.whiteTexture);

if (m_TextComponent != null)

{

m_TextComponent.RegisterDirtyVerticesCallback(MarkGeometryAsDirty);

m_TextComponent.RegisterDirtyVerticesCallback(UpdateLabel);

UpdateLabel();

}

}

protected override void OnDisable()

{

// the coroutine will be terminated, so this will ensure it restarts when we are next activated

m_BlinkCoroutine = null;

DeactivateInputField();

if (m_TextComponent != null)

{

m_TextComponent.UnregisterDirtyVerticesCallback(MarkGeometryAsDirty);

m_TextComponent.UnregisterDirtyVerticesCallback(UpdateLabel);

}

CanvasUpdateRegistry.UnRegisterCanvasElementForRebuild(this);

// Clear needs to be called otherwise sync never happens as the object is disabled.

if (m_CachedInputRenderer != null)

m_CachedInputRenderer.Clear();

if (m_Mesh != null)

DestroyImmediate(m_Mesh);

m_Mesh = null;

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)

{

// the blink rate is expressed as a frequency

float blinkPeriod = 1f / m_CaretBlinkRate;

// the caret should be ON if we are in the first half of the blink period

bool blinkState = (Time.unscaledTime - m_BlinkStartTime) % blinkPeriod < blinkPeriod / 2;

if (m_CaretVisible != blinkState)

{

m_CaretVisible = blinkState;

if (!hasSelection)

MarkGeometryAsDirty();

}

// Then wait again.

yield return null;

}

m_BlinkCoroutine = 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_BlinkCoroutine == null)

m_BlinkCoroutine = StartCoroutine(CaretBlink());

}

else

{

m_CaretVisible = true;

}

}

protected void OnFocus()

{

SelectAll();

}

protected void SelectAll()

{

caretPositionInternal = text.Length;

caretSelectPositionInternal = 0;

}

public void MoveTextEnd(bool shift)

{

int position = text.Length;

if (shift)

{

caretSelectPositionInternal = position;

}

else

{

caretPositionInternal = position;

caretSelectPositionInternal = caretPositionInternal;

}

UpdateLabel();

}

public void MoveTextStart(bool shift)

{

int position = 0;

if (shift)

{

caretSelectPositionInternal = position;

}

else

{

caretPositionInternal = position;

caretSelectPositionInternal = caretPositionInternal;

}

UpdateLabel();

}

static string clipboard

{

get

{

return GUIUtility.systemCopyBuffer;

}

set

{

GUIUtility.systemCopyBuffer = value;

}

}

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)

{

if (!m_ReadOnly)

text = m_Keyboard.text;

if (m_Keyboard.wasCanceled)

m_WasCanceled = true;

}

OnDeselect(null);

return;

}

string val = m_Keyboard.text;

if (m_Text != val)

{

if (m_ReadOnly)

{

m_Keyboard.text = m_Text;

}

else

{

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);

caretPositionInternal = caretSelectPositionInternal = 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;

// transform y to local scale

float y = pos.y * m_TextComponent.pixelsPerUnit;

float lastBottomY = 0.0f;

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

{

float topY = generator.lines[i].topY;

float bottomY = topY - generator.lines[i].height;

// pos is somewhere in the leading above this line

if (y > topY)

{

// determine which line we're closer to

float leading = topY - lastBottomY;

if (y > topY - 0.5f * leading)

return i - 1;

else

return i;

}

if (y > bottomY)

return i;

lastBottomY = bottomY;

}

// 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);

caretSelectPositionInternal = 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);

caretSelectPositionInternal = caretPositionInternal = 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;

bool alt = (currentEventModifiers & EventModifiers.Alt) != 0;

bool ctrlOnly = ctrl && !alt && !shift;

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 (ctrlOnly)

{

SelectAll();

return EditState.Continue;

}

break;

}

// Copy

case KeyCode.C:

{

if (ctrlOnly)

{

if (inputType != InputType.Password)

clipboard = GetSelectedString();

else

clipboard = "";

return EditState.Continue;

}

break;

}

// Paste

case KeyCode.V:

{

if (ctrlOnly)

{

Append(clipboard);

return EditState.Continue;

}

break;

}

// Cut