// Unity C# reference source

// Copyright (c) Unity Technologies. For terms of use, see

// https://unity3d.com/legal/licenses/Unity_Reference_Only_License

using System;

using System.Linq;

using System.Collections.Generic;

using UnityEditor.SceneManagement;

using UnityEngine;

using UnityEngine.Scripting;

using UnityEditorInternal;

using UnityEditor.Scripting.ScriptCompilation;

using Object = UnityEngine.Object;

using Event = UnityEngine.Event;

using UnityEditor.Build;

namespace UnityEditor

{

// Class for editor-only GUI. This class contains general purpose 2D additions to UnityGUI.

// These work pretty much like the normal GUI functions - and also have matching implementations in [[EditorGUILayout]]

public sealed partial class EditorGUI

{

private static RecycledTextEditor activeEditor;

internal static DelayedTextEditor s_DelayedTextEditor = new DelayedTextEditor();

internal static RecycledTextEditor s_RecycledEditor = new RecycledTextEditor();

internal static string s_OriginalText = "";

internal static string s_RecycledCurrentEditingString;

internal static double s_RecycledCurrentEditingFloat;

internal static long s_RecycledCurrentEditingInt;

private static bool bKeyEventActive = false;

internal static bool s_DragToPosition = true;

internal static bool s_Dragged = false;

internal static bool s_PostPoneMove = false;

internal static bool s_SelectAllOnMouseUp = true;

private const double kFoldoutExpandTimeout = 0.7;

private static double s_FoldoutDestTime;

private static int s_DragUpdatedOverID = 0;

private static int s_FoldoutHash = "Foldout".GetHashCode();

private static int s_TagFieldHash = "s_TagFieldHash".GetHashCode();

private static int s_PPtrHash = "s_PPtrHash".GetHashCode();

private static int s_ObjectFieldHash = "s_ObjectFieldHash".GetHashCode();

private static int s_ToggleHash = "s_ToggleHash".GetHashCode();

private static int s_ColorHash = "s_ColorHash".GetHashCode();

private static int s_CurveHash = "s_CurveHash".GetHashCode();

private static int s_LayerMaskField = "s_LayerMaskField".GetHashCode();

private static int s_MaskField = "s_MaskField".GetHashCode();

private static int s_EnumFlagsField = "s_EnumFlagsField".GetHashCode();

private static int s_GenericField = "s_GenericField".GetHashCode();

private static int s_PopupHash = "EditorPopup".GetHashCode();

private static int s_KeyEventFieldHash = "KeyEventField".GetHashCode();

private static int s_TextFieldHash = "EditorTextField".GetHashCode();

private static int s_SearchFieldHash = "EditorSearchField".GetHashCode();

private static int s_TextAreaHash = "EditorTextField".GetHashCode();

private static int s_PasswordFieldHash = "PasswordField".GetHashCode();

private static int s_FloatFieldHash = "EditorTextField".GetHashCode();

private static int s_DelayedTextFieldHash = "DelayedEditorTextField".GetHashCode();

private static int s_ArraySizeFieldHash = "ArraySizeField".GetHashCode();

private static int s_SliderHash = "EditorSlider".GetHashCode();

private static int s_SliderKnobHash = "EditorSliderKnob".GetHashCode();

private static int s_MinMaxSliderHash = "EditorMinMaxSlider".GetHashCode();

private static int s_TitlebarHash = "GenericTitlebar".GetHashCode();

private static int s_ProgressBarHash = "s_ProgressBarHash".GetHashCode();

private static int s_SelectableLabelHash = "s_SelectableLabel".GetHashCode();

private static int s_SortingLayerFieldHash = "s_SortingLayerFieldHash".GetHashCode();

private static int s_TextFieldDropDownHash = "s_TextFieldDropDown".GetHashCode();

private static int s_DragCandidateState = 0;

private static float kDragDeadzone = 16;

private static Vector2 s_DragStartPos;

private static double s_DragStartValue = 0;

private static long s_DragStartIntValue = 0;

private static double s_DragSensitivity = 0;

private const float kDragSensitivity = .03f;

internal const float kMiniLabelW = 13;

internal const float kLabelW = 80;

internal const float kSpacing = 5;

internal const float kSpacingSubLabel = 2;

internal const float kSliderMinW = 60;

internal const float kSliderMaxW = 100;

internal const float kSingleLineHeight = 16;

internal const float kStructHeaderLineHeight = 16;

internal const float kObjectFieldThumbnailHeight = 64;

internal const float kObjectFieldMiniThumbnailHeight = 18f;

internal const float kObjectFieldMiniThumbnailWidth = 32f;

internal static string kFloatFieldFormatString = "g7";

internal static string kDoubleFieldFormatString = "g15";

internal static string kIntFieldFormatString = "#######0";

internal static int ms_IndentLevel = 0;

private const float kIndentPerLevel = 15;

internal const int kControlVerticalSpacing = 2;

internal const int kVerticalSpacingMultiField = 0;

internal static string s_UnitString = "";

internal const int kInspTitlebarIconWidth = 16;

internal const int kWindowToolbarHeight = 17;

private static string kEnabledPropertyName = "m_Enabled";

private static float[] s_Vector2Floats = {0, 0};

private static int[] s_Vector2Ints = { 0, 0 };

private static GUIContent[] s_XYLabels = {EditorGUIUtility.TextContent("X"), EditorGUIUtility.TextContent("Y")};

private static float[] s_Vector3Floats = {0, 0, 0};

private static int[] s_Vector3Ints = { 0, 0, 0 };

private static GUIContent[] s_XYZLabels = {EditorGUIUtility.TextContent("X"), EditorGUIUtility.TextContent("Y"), EditorGUIUtility.TextContent("Z")};

private static float[] s_Vector4Floats = {0, 0, 0, 0};

private static GUIContent[] s_XYZWLabels = {EditorGUIUtility.TextContent("X"), EditorGUIUtility.TextContent("Y"), EditorGUIUtility.TextContent("Z"), EditorGUIUtility.TextContent("W")};

private static GUIContent[] s_WHLabels = {EditorGUIUtility.TextContent("W"), EditorGUIUtility.TextContent("H")};

private static GUIContent s_CenterLabel = EditorGUIUtility.TextContent("Center");

private static GUIContent s_ExtentLabel = EditorGUIUtility.TextContent("Extent");

private static GUIContent s_PositionLabel = EditorGUIUtility.TextContent("Position");

private static GUIContent s_SizeLabel = EditorGUIUtility.TextContent("Size");

internal static readonly GUIContent s_ClipingPlanesLabel = EditorGUIUtility.TextContent("Clipping Planes|Distances from the camera to start and stop rendering.");

internal static readonly GUIContent[] s_NearAndFarLabels = { EditorGUIUtility.TextContent("Near|The closest point relative to the camera that drawing will occur."), EditorGUIUtility.TextContent("Far|The furthest point relative to the camera that drawing will occur.\n") };

internal const float kNearFarLabelsWidth = 35f;

private static int s_ColorPickID;

private static int s_CurveID;

internal static Color kCurveColor = Color.green;

internal static Color kCurveBGColor = new Color(0.337f, 0.337f, 0.337f, 1f);

internal static EditorGUIUtility.SkinnedColor kSplitLineSkinnedColor = new EditorGUIUtility.SkinnedColor(new Color(0.6f, 0.6f, 0.6f, 1.333f), new Color(0.12f, 0.12f, 0.12f, 1.333f));

private const int kInspTitlebarToggleWidth = 16;

private const int kInspTitlebarSpacing = 2;

private static GUIContent s_PropertyFieldTempContent = new GUIContent();

private static GUIContent s_IconDropDown;

private static Material s_IconTextureInactive;

private static bool s_HasPrefixLabel;

private static GUIContent s_PrefixLabel = new GUIContent((string)null);

private static Rect s_PrefixTotalRect;

private static Rect s_PrefixRect;

private static GUIStyle s_PrefixStyle;

private static Color s_PrefixGUIColor;

// Makes the following controls give the appearance of editing multiple different values.

public static bool showMixedValue

{

get { return s_ShowMixedValue; }

set { s_ShowMixedValue = value; }

}

private static bool s_ShowMixedValue;

private static GUIContent s_MixedValueContent = EditorGUIUtility.TextContent("\u2014|Mixed Values");

internal static GUIContent mixedValueContent

{

get { return s_MixedValueContent; }

}

private static Color s_MixedValueContentColor = new Color(1, 1, 1, 0.5f);

private static Color s_MixedValueContentColorTemp = Color.white;

internal static void BeginHandleMixedValueContentColor()

{

s_MixedValueContentColorTemp = GUI.contentColor;

GUI.contentColor = showMixedValue ? (GUI.contentColor * s_MixedValueContentColor) : GUI.contentColor;

}

internal static void EndHandleMixedValueContentColor()

{

GUI.contentColor = s_MixedValueContentColorTemp;

}

[RequiredByNativeCode]

internal static bool IsEditingTextField()

{

return RecycledTextEditor.s_ActuallyEditing && activeEditor != null;

}

internal static void EndEditingActiveTextField()

{

if (activeEditor != null)

{

activeEditor.EndEditing();

}

}

public static void FocusTextInControl(string name)

{

GUI.FocusControl(name);

EditorGUIUtility.editingTextField = true;

}

// STACKS

internal static void ClearStacks()

{

s_EnabledStack.Clear();

s_ChangedStack.Clear();

s_PropertyStack.Clear();

ScriptAttributeUtility.s_DrawerStack.Clear();

}

private static Stack<PropertyGUIData> s_PropertyStack = new Stack<PropertyGUIData>();

private static Stack<bool> s_EnabledStack = new Stack<bool>();

// @TODO: API soon to be deprecated but still in a grace period; documentation states that users

// are encouraged to use EditorGUI.DisabledScope instead. Uncomment next line when appropriate.

// [System.Obsolete("Use DisabledScope instead", false)]

public class DisabledGroupScope : GUI.Scope

{

public DisabledGroupScope(bool disabled)

{

BeginDisabledGroup(disabled);

}

protected override void CloseScope()

{

EndDisabledGroup();

}

}

// Create a group of controls that can be disabled.

// @TODO: API soon to be deprecated but still in a grace period; documentation states that users

// are encouraged to use EditorGUI.DisabledScope instead. Uncomment next line when appropriate.

// [System.Obsolete("Use DisabledScope instead", false)]

public static void BeginDisabledGroup(bool disabled)

{

BeginDisabled(disabled);

}

// Ends a disabled group started with BeginDisabledGroup.

// @TODO: API soon to be deprecated but still in a grace period; documentation states that users

// are encouraged to use EditorGUI.DisabledScope instead. Uncomment next line when appropriate.

// [System.Obsolete("Use DisabledScope instead", false)]

public static void EndDisabledGroup()

{

EndDisabled();

}

public struct DisabledScope : IDisposable

{

bool m_Disposed;

public DisabledScope(bool disabled)

{

m_Disposed = false;

BeginDisabled(disabled);

}

public void Dispose()

{

if (m_Disposed)

return;

m_Disposed = true;

if (!GUIUtility.guiIsExiting)

EndDisabled();

}

}

// Create a group of controls that can be disabled.

internal static void BeginDisabled(bool disabled)

{

s_EnabledStack.Push(GUI.enabled);

GUI.enabled &= !disabled;

}

// Ends a disabled group started with BeginDisabled.

internal static void EndDisabled()

{

// Stack might have been cleared with ClearStack(), check before pop.

if (s_EnabledStack.Count > 0)

GUI.enabled = s_EnabledStack.Pop();

}

private static Stack<bool> s_ChangedStack = new Stack<bool>();

public class ChangeCheckScope : GUI.Scope

{

bool m_ChangeChecked;

bool m_Changed;

public bool changed

{

get

{

if (!m_ChangeChecked)

{

m_ChangeChecked = true;

m_Changed = EndChangeCheck();

}

return m_Changed;

}

}

public ChangeCheckScope()

{

BeginChangeCheck();

}

protected override void CloseScope()

{

if (!m_ChangeChecked)

EndChangeCheck();

}

}

// Check if any control was changed inside a block of code.

public static void BeginChangeCheck()

{

s_ChangedStack.Push(GUI.changed);

GUI.changed = false;

}

// Ends a change check started with BeginChangeCheck ().

// Note: BeginChangeCheck/EndChangeCheck supports nesting

// For ex.,

// BeginChangeCheck()

// BeginChangeCheck()

// <GUI control changes>

// EndChangeCheck() <-- will return true

// EndChangeCheck() <-- will return true

public static bool EndChangeCheck()

{

bool changed = GUI.changed;

GUI.changed |= s_ChangedStack.Pop();

return changed;

}

internal partial class RecycledTextEditor : TextEditor

{

internal static bool s_ActuallyEditing = false; // internal so we can save this state.

internal static bool s_AllowContextCutOrPaste = true; // e.g. selectable labels only allow for copying

IMECompositionMode m_IMECompositionModeBackup;

// *undocumented*

internal bool IsEditingControl(int id)

{

return GUIUtility.keyboardControl == id && controlID == id && s_ActuallyEditing && GUIView.current.hasFocus;

}

// *undocumented*

public virtual void BeginEditing(int id, string newText, Rect position, GUIStyle style, bool multiline, bool passwordField)

{

if (IsEditingControl(id))

{

return;

}

if (EditorGUI.activeEditor != null)

{

EditorGUI.activeEditor.EndEditing();

}

EditorGUI.activeEditor = this;

controlID = id;

text = s_OriginalText = newText;

this.multiline = multiline;

this.style = style;

this.position = position;

isPasswordField = passwordField;

s_ActuallyEditing = true;

scrollOffset = Vector2.zero;

UnityEditor.Undo.IncrementCurrentGroup();

m_IMECompositionModeBackup = Input.imeCompositionMode;

Input.imeCompositionMode = IMECompositionMode.On;

}

// *undocumented*

public virtual void EndEditing()

{

if (EditorGUI.activeEditor == this)

{

EditorGUI.activeEditor = null;

}

controlID = 0;

s_ActuallyEditing = false;

s_AllowContextCutOrPaste = true;

UnityEditor.Undo.IncrementCurrentGroup();

Input.imeCompositionMode = m_IMECompositionModeBackup;

}

}

// There can be two way something can get focus

internal sealed partial class DelayedTextEditor : RecycledTextEditor

{

private int controlThatHadFocus = 0, messageControl = 0;

internal string controlThatHadFocusValue = "";

private GUIView viewThatHadFocus;

private bool m_CommitCommandSentOnLostFocus;

private const string CommitCommand = "DelayedControlShouldCommit";

private bool m_IgnoreBeginGUI = false;

//*undocumented*

public void BeginGUI()

{

if (m_IgnoreBeginGUI)

{

return;

}

if (GUIUtility.keyboardControl == controlID)

{

controlThatHadFocus = GUIUtility.keyboardControl;

controlThatHadFocusValue = text;

viewThatHadFocus = GUIView.current;

}

else

{

controlThatHadFocus = 0;

}

}

//*undocumented*

public void EndGUI(EventType type)

{

int sendID = 0;

if (controlThatHadFocus != 0 && controlThatHadFocus != GUIUtility.keyboardControl)

{

sendID = controlThatHadFocus;

controlThatHadFocus = 0;

}

if (sendID != 0 && !m_CommitCommandSentOnLostFocus)

{

messageControl = sendID;

// Debug.Log ("" + messageControl + " lost focus to " + GUIUtility.keyboardControl+ " in " + type+". Sending Message. value:" + controlThatHadFocusValue);

m_IgnoreBeginGUI = true;

// Explicitly set the keyboardControl for the view that had focus in preparation for the following SendEvent,

// but only if the current view is the view that had focus.

// This is necessary as GUIView::OnInputEvent (native) will load the old keyboardControl for nested OnGUI calls.

if (GUIView.current == viewThatHadFocus)

viewThatHadFocus.SetKeyboardControl(GUIUtility.keyboardControl);

viewThatHadFocus.SendEvent(EditorGUIUtility.CommandEvent(CommitCommand));

m_IgnoreBeginGUI = false;

// Debug.Log ("Afterwards: " + GUIUtility.keyboardControl);

messageControl = 0;

}

}

//*undocumented*

public override void EndEditing()

{

//The following block handles the case where a different window is focus while editing delayed text box

if (Event.current == null)

{

// We set this flag because of a bug that was trigger when you switched focus to another window really fast

// right after focusing on the text box. For some reason keyboardControl was changed and the commit message

// was being sent twice which caused layout issues.

m_CommitCommandSentOnLostFocus = true;

m_IgnoreBeginGUI = true;

messageControl = controlID;

var temp = GUIUtility.keyboardControl;

viewThatHadFocus.SetKeyboardControl(0);

viewThatHadFocus.SendEvent(EditorGUIUtility.CommandEvent(CommitCommand));

m_IgnoreBeginGUI = false;

viewThatHadFocus.SetKeyboardControl(temp);

messageControl = 0;

}

base.EndEditing();

}

//*undocumented*

public string OnGUI(int id, string value, out bool changed)

{

Event evt = Event.current;

if (evt.type == EventType.ExecuteCommand && evt.commandName == CommitCommand && id == messageControl)

{

m_CommitCommandSentOnLostFocus = false;

// Only set changed to true if the value has actually changed. Otherwise EditorGUI.EndChangeCheck will report false positives,

// which could for example cause unwanted undo's to be registered (in the case of e.g. editing terrain resolution, this can cause several seconds of delay)

changed = value != controlThatHadFocusValue;

evt.Use();

messageControl = 0;

return controlThatHadFocusValue;

}

changed = false;

return value;

}

}

internal sealed partial class PopupMenuEvent

{

public string commandName;

public GUIView receiver;

public PopupMenuEvent(string cmd, GUIView v)

{

commandName = cmd;

receiver = v;

}

public void SendEvent()

{

if (receiver)

{

receiver.SendEvent(EditorGUIUtility.CommandEvent(commandName));

}

else

{

Debug.LogError("BUG: We don't have a receiver set up, please report");

}

}

}

private static void ShowTextEditorPopupMenu()

{

GenericMenu pm = new GenericMenu();

if (s_RecycledEditor.hasSelection && !s_RecycledEditor.isPasswordField)

{

if (RecycledTextEditor.s_AllowContextCutOrPaste)

{

pm.AddItem(EditorGUIUtility.TextContent("Cut"), false, new PopupMenuEvent("Cut", GUIView.current).SendEvent);

}

pm.AddItem(EditorGUIUtility.TextContent("Copy"), false, new PopupMenuEvent("Copy", GUIView.current).SendEvent);

}

else

{

if (RecycledTextEditor.s_AllowContextCutOrPaste)

{

pm.AddDisabledItem(EditorGUIUtility.TextContent("Cut"));

}

pm.AddDisabledItem(EditorGUIUtility.TextContent("Copy"));

}

if (s_RecycledEditor.CanPaste() && RecycledTextEditor.s_AllowContextCutOrPaste)

{

pm.AddItem(EditorGUIUtility.TextContent("Paste"), false, new PopupMenuEvent("Paste", GUIView.current).SendEvent);

}

else

{

// pm.AddDisabledItem (EditorGUIUtility.TextContent ("Paste"));

}

pm.ShowAsContext();

}

// Is the platform-dependent "action" modifier key held down? (RO)

public static bool actionKey

{

get

{

if (Event.current == null)

{

return false;

}

if (Application.platform == RuntimePlatform.OSXEditor)

{

return Event.current.command;

}

else

{

return Event.current.control;

}

}

}

internal static void BeginCollectTooltips()

{

EditorGUI.isCollectingTooltips = true;

}

internal static void EndCollectTooltips()

{

EditorGUI.isCollectingTooltips = false;

}

/// *listonly*

public static void DropShadowLabel(Rect position, string text)

{

DoDropShadowLabel(position, EditorGUIUtility.TempContent(text), "PreOverlayLabel", .6f);

}

/// *listonly*

public static void DropShadowLabel(Rect position, GUIContent content)

{

DoDropShadowLabel(position, content, "PreOverlayLabel", .6f);

}

/// *listonly*

public static void DropShadowLabel(Rect position, string text, GUIStyle style)

{

DoDropShadowLabel(position, EditorGUIUtility.TempContent(text), style, .6f);

}

// Draws a label with a drop shadow.

public static void DropShadowLabel(Rect position, GUIContent content, GUIStyle style)

{

DoDropShadowLabel(position, content, style, .6f);

}

internal static void DoDropShadowLabel(Rect position, GUIContent content, GUIStyle style, float shadowOpa)

{

if (Event.current.type != EventType.Repaint)

{

return;

}

DrawLabelShadow(position, content, style, shadowOpa);

style.Draw(position, content, false, false, false, false);

}

internal static void DrawLabelShadow(Rect position, GUIContent content, GUIStyle style, float shadowOpa)

{

Color temp = GUI.color, temp2 = GUI.contentColor, temp3 = GUI.backgroundColor;

// Draw only background

GUI.contentColor = new Color(0, 0, 0, 0);

style.Draw(position, content, false, false, false, false);

// Blur foreground

position.y += 1;

GUI.backgroundColor = new Color(0, 0, 0, 0);

GUI.contentColor = temp2;

Draw4(position, content, 1, GUI.color.a * shadowOpa, style);

Draw4(position, content, 2, GUI.color.a * shadowOpa * .42f, style);

// Draw final foreground

GUI.color = temp;

GUI.backgroundColor = temp3;

}

private static void Draw4(Rect position, GUIContent content, float offset, float alpha, GUIStyle style)

{

GUI.color = new Color(0, 0, 0, alpha);

position.y -= offset;

style.Draw(position, content, false, false, false, false);

position.y += offset * 2;

style.Draw(position, content, false, false, false, false);

position.y -= offset;

position.x -= offset;

style.Draw(position, content, false, false, false, false);

position.x += offset * 2;

style.Draw(position, content, false, false, false, false);

}

// Should we select all text from the current field when the mouse goes up?

// (We need to keep track of this to support both SwipeSelection & initial click selects all)

internal static string DoTextField(RecycledTextEditor editor, int id, Rect position, string text, GUIStyle style, string allowedletters, out bool changed, bool reset, bool multiline, bool passwordField)

{

Event evt = Event.current;

// If the text field represents multiple values, the text should always start out being empty when editing it.

// This empty text will not be saved when simply clicking in the text field, or tabbing to it,

// since GUI.changed is only set to true if the user alters the string.

// Nevertheless, we also backup and return the original value if nothing changed.

// It's just nice that output is the same as input when nothing changed,

// even if the output should really be ignored when GUI.changed is false.

string origText = text;

// We assume the text is actually valid, but we do not want to change the returned value if nothing was changed

// So we should only check for null string on the internal text and not affect the origText which will be returned if nothing changed

if (text == null)

{

text = string.Empty;

}

if (showMixedValue)

{

text = string.Empty;

}

// If we have keyboard control and our window have focus, we need to sync up the editor.

if (HasKeyboardFocus(id) && Event.current.type != EventType.Layout)

{

// If the editor is already set up, we just need to sync position, etc...

if (editor.IsEditingControl(id))

{

editor.position = position;

editor.style = style;

editor.controlID = id;

editor.multiline = multiline;

editor.isPasswordField = passwordField;

editor.DetectFocusChange();

}

else if (EditorGUIUtility.editingTextField || (evt.GetTypeForControl(id) == EventType.ExecuteCommand && evt.commandName == "NewKeyboardFocus"))

{

// This one is worse: we are the new keyboardControl, but didn't know about it.

// this means a Tab operation or setting focus from code.

editor.BeginEditing(id, text, position, style, multiline, passwordField);

// If cursor is invisible, it's a selectable label, and we don't want to select all automatically

if (GUI.skin.settings.cursorColor.a > 0)

editor.SelectAll();

if (evt.GetTypeForControl(id) == EventType.ExecuteCommand)

{

evt.Use();

}

}

}

// Inform editor that someone removed focus from us.

if (editor.controlID == id && GUIUtility.keyboardControl != id)

{

editor.EndEditing();

}

bool mayHaveChanged = false;

string textBeforeKey = editor.text;

switch (evt.GetTypeForControl(id))

{

case EventType.ValidateCommand:

if (GUIUtility.keyboardControl == id)

{

switch (evt.commandName)

{

case "Cut":

case "Copy":

if (editor.hasSelection)

{

evt.Use();

}

break;

case "Paste":

if (editor.CanPaste())

{

evt.Use();

}

break;

case "SelectAll":

case "Delete":

evt.Use();

break;

case "UndoRedoPerformed":

editor.text = text;

evt.Use();

break;

}

}

break;

case EventType.ExecuteCommand:

if (GUIUtility.keyboardControl == id)

{

switch (evt.commandName)

{

case "OnLostFocus":

if (activeEditor != null)

{

activeEditor.EndEditing();

}

evt.Use();

break;

case "Cut":

editor.BeginEditing(id, text, position, style, multiline, passwordField);

editor.Cut();

mayHaveChanged = true;

break;

case "Copy":

editor.Copy();

evt.Use();

break;

case "Paste":

editor.BeginEditing(id, text, position, style, multiline, passwordField);

editor.Paste();

mayHaveChanged = true;

break;

case "SelectAll":

editor.SelectAll();

evt.Use();

break;

case "Delete":

// This "Delete" command stems from a Shift-Delete in the text editor.

// On Windows, Shift-Delete in text does a cut whereas on Mac, it does a delete.

editor.BeginEditing(id, text, position, style, multiline, passwordField);

if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX)

{

editor.Delete();

}

else

{

editor.Cut();

}

mayHaveChanged = true;

evt.Use();

break;

}

}

break;

case EventType.MouseUp:

if (GUIUtility.hotControl == id)

{

if (s_Dragged && s_DragToPosition)

{

//GUIUtility.keyboardControl = id;

//editor.BeginEditing (id, text, position, style, multiline, passwordField);

editor.MoveSelectionToAltCursor();

mayHaveChanged = true;

}

else if (s_PostPoneMove)

{

editor.MoveCursorToPosition(Event.current.mousePosition);

}

else if (s_SelectAllOnMouseUp)

{

// If cursor is invisible, it's a selectable label, and we don't want to select all automatically

if (GUI.skin.settings.cursorColor.a > 0)

{

editor.SelectAll();

}

s_SelectAllOnMouseUp = false;

}

editor.MouseDragSelectsWholeWords(false);

s_DragToPosition = true;

s_Dragged = false;

s_PostPoneMove = false;

if (evt.button == 0)

{

GUIUtility.hotControl = 0;

evt.Use();

}

}

break;

case EventType.MouseDown:

if (position.Contains(evt.mousePosition) && evt.button == 0)

{

// Does this text field already have focus?

if (editor.IsEditingControl(id))

{ // if so, process the event normally

if (Event.current.clickCount == 2 && GUI.skin.settings.doubleClickSelectsWord)

{

editor.MoveCursorToPosition(Event.current.mousePosition);

editor.SelectCurrentWord();

editor.MouseDragSelectsWholeWords(true);

editor.DblClickSnap(TextEditor.DblClickSnapping.WORDS);

s_DragToPosition = false;

}

else if (Event.current.clickCount == 3 && GUI.skin.settings.tripleClickSelectsLine)

{

editor.MoveCursorToPosition(Event.current.mousePosition);

editor.SelectCurrentParagraph();

editor.MouseDragSelectsWholeWords(true);

editor.DblClickSnap(TextEditor.DblClickSnapping.PARAGRAPHS);

s_DragToPosition = false;

}

else

{

// if mouse is over the selection, postpone cursor movement till Mouse Up - this is so we can do correct text dragging.

// if (editor.hasSelection && editor.IsOverSelection(Event.current.mousePosition))

// s_PostPoneMove = true;

// else

editor.MoveCursorToPosition(Event.current.mousePosition);

s_SelectAllOnMouseUp = false;

}

}

else

{ // Otherwise, mark this as initial click and begin editing

GUIUtility.keyboardControl = id;

editor.BeginEditing(id, text, position, style, multiline, passwordField);

editor.MoveCursorToPosition(Event.current.mousePosition);

// If cursor is invisible, it's a selectable label, and we don't want to select all automatically

if (GUI.skin.settings.cursorColor.a > 0)

{

s_SelectAllOnMouseUp = true;

}

}

GUIUtility.hotControl = id;

evt.Use();

}

break;

case EventType.MouseDrag:

if (GUIUtility.hotControl == id)

{

if (!evt.shift && editor.hasSelection && s_DragToPosition)

{

editor.MoveAltCursorToPosition(Event.current.mousePosition);

}

else

{

if (evt.shift)

{

editor.MoveCursorToPosition(Event.current.mousePosition);

}

else

{

editor.SelectToPosition(Event.current.mousePosition);

}

s_DragToPosition = false;

s_SelectAllOnMouseUp = !editor.hasSelection;

}

s_Dragged = true;

evt.Use();

}

break;

case EventType.ContextClick:

if (position.Contains(evt.mousePosition))

{

if (!editor.IsEditingControl(id))

{ // First click: focus before showing popup

GUIUtility.keyboardControl = id;

editor.BeginEditing(id, text, position, style, multiline, passwordField);

editor.MoveCursorToPosition(Event.current.mousePosition);

}

ShowTextEditorPopupMenu();

Event.current.Use();

}

break;

case EventType.KeyDown:

if (GUIUtility.keyboardControl == id)

{

char c = evt.character;

// Let the editor handle all cursor keys, etc...

if (editor.IsEditingControl(id) && editor.HandleKeyEvent(evt))

{

evt.Use();

mayHaveChanged = true;

break;

}

if (evt.keyCode == KeyCode.Escape)

{

if (editor.IsEditingControl(id))

{

if (style == EditorStyles.toolbarSearchField || style == EditorStyles.searchField)

{

s_OriginalText = "";

}

editor.text = s_OriginalText;

editor.EndEditing();

mayHaveChanged = true;

}

}

else if (c == '\n' || (int)c == 3)

{

if (!editor.IsEditingControl(id))

{

editor.BeginEditing(id, text, position, style, multiline, passwordField);

editor.SelectAll();

}

else

{

if (!multiline || (evt.alt || evt.shift || evt.control))

{

editor.EndEditing();

}

else

{

editor.Insert(c);

mayHaveChanged = true;

break;

}

}

evt.Use();

}

else if (c == '\t' || evt.keyCode == KeyCode.Tab)

{

// Only insert tabs if multiline

if (multiline && editor.IsEditingControl(id))

{

bool validTabCharacter = (allowedletters == null || allowedletters.IndexOf(c) != -1);

bool validTabEvent = !(evt.alt || evt.shift || evt.control) && c == '\t';

if (validTabEvent && validTabCharacter)

{

editor.Insert(c);

mayHaveChanged = true;

}

}

}

else if ((int)c == 25 || (int)c == 27)

{

// Note, OS X send characters for the following keys that we need to eat:

// ASCII 25: "End Of Medium" on pressing shift tab

// ASCII 27: "Escape" on pressing ESC

}

else if (editor.IsEditingControl(id))

{

bool validCharacter = (allowedletters == null || allowedletters.IndexOf(c) != -1) && c != 0;

if (validCharacter)

{

editor.Insert(c);

mayHaveChanged = true;

}

else

{

// If the composition string is not empty, then it's likely that even though we didn't add a printable

// character to the string, we should refresh the GUI, to update the composition string.

if (Input.compositionString != "")

{

editor.ReplaceSelection("");

mayHaveChanged = true;

}

evt.Use();

}

}