diff options
Diffstat (limited to 'Runtime/Export/GUIUtility.txt')
| -rw-r--r-- | Runtime/Export/GUIUtility.txt | 476 |
1 files changed, 476 insertions, 0 deletions
diff --git a/Runtime/Export/GUIUtility.txt b/Runtime/Export/GUIUtility.txt new file mode 100644 index 0000000..99fcbc9 --- /dev/null +++ b/Runtime/Export/GUIUtility.txt @@ -0,0 +1,476 @@ +C++RAW + +#include "UnityPrefix.h" +#include "Runtime/Misc/AssetBundle.h" +#include "Runtime/Misc/ResourceManager.h" +#include "Runtime/Mono/MonoBehaviour.h" +#include "Runtime/IMGUI/GUIStyle.h" +#include "Runtime/Filters/Misc/Font.h" +#include "Runtime/Misc/InputEvent.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Camera/CameraUtil.h" +#include "Runtime/IMGUI/GUIManager.h" +#include "Runtime/Utilities/CopyPaste.h" +#include "Runtime/IMGUI/GUIState.h" +#include "Runtime/IMGUI/GUIClip.h" +#include "Runtime/IMGUI/IMGUIUtils.h" +#include "Runtime/IMGUI/GUIWindows.h" +#include "Runtime/Input/InputManager.h" +#include "Runtime/Scripting/ScriptingUtility.h" +#if UNITY_EDITOR + +#include "Editor/Src/EditorHelper.h" +#include "Editor/Mono/MonoEditorUtility.h" +#include "Editor/Src/OptimizedGUIBlock.h" +#include "Editor/Src/AssetPipeline/AssetDatabase.h" +#include "Editor/Src/Undo/UndoManager.h" + +extern float s_GUIStyleIconSizeX; +extern float s_GUIStyleIconSizeY; +#endif + +using namespace Unity; +using namespace std; + +CSRAW + +// Use this define to debug who grabs and releases hotcontrol +//#define DEBUG_HOTCONTROL + +// Use this define to debug controlID consistency together with 's_LogControlID' (default false) to enable logging in +// a codepath thats needs tested for consistency. E.g: +// if (Event.current.rawType == EventType.MouseUp) +// GUIUtility.s_LogControlID = true; +// And remember to set s_LogControlID to false at end of secion of interest. +//#define DEBUG_CONTROLID + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Collections; + +namespace UnityEngine +{ + +// Throw this to immediately exit from GUI code. +// *undocumented* +CLASS ExitGUIException : System.Exception +END + +// Used by GUIUtility.GetcontrolID to inform the UnityGUI system if a given control can get keyboard focus. +ENUM FocusType + // This control can get keyboard focus on Windows, but not on Mac. Used for buttons, checkboxes and other "pressable" things. + Native = 0, + // This is a proper keyboard control. It can have input focus on all platforms. Used for TextField and TextArea controls + Keyboard = 1, + // This control can never recieve keyboard focus. + Passive = 2 +END + +CSRAW + +// Utility class for making new GUI controls. +NONSEALED_CLASS GUIUtility + + /// *listonly* + CSRAW public static int GetControlID (FocusType focus) + { + return GetControlID (0, focus); + } + /// *listonly* + CUSTOM public static int GetControlID (int hint, FocusType focus) + { + return GetGUIState().GetControlID (hint, focus); + } + /// *listonly* + CSRAW public static int GetControlID (GUIContent contents,FocusType focus) + { + return GetControlID (contents.hash, focus); + } + /// *listonly* + CSRAW public static int GetControlID (FocusType focus, Rect position) + { + return Internal_GetNextControlID2 (0, focus, position); + } + /// *listonly* + CSRAW public static int GetControlID (int hint, FocusType focus, Rect position) + { + return Internal_GetNextControlID2 (hint, focus, position); + } + // Get a unique ID for a control. + CSRAW static public int GetControlID (GUIContent contents, FocusType focus, Rect position) + { + return Internal_GetNextControlID2 (contents.hash, focus, position); + } + + CUSTOM private static int Internal_GetNextControlID2 (int hint, FocusType focusType, Rect rect) + { + return GetGUIState().GetControlID (hint, focusType, rect); + } + + // Get a state object from a controlID. + CSRAW public static object GetStateObject (Type t, int controlID) { return GUIStateObjects.GetStateObject (t, controlID); } + + // Get an existing state object from a controlID. + CSRAW public static object QueryStateObject (Type t, int controlID) { return GUIStateObjects.QueryStateObject (t, controlID); } + + CUSTOM static internal int GetPermanentControlID () + { + return GetGUIState().m_EternalGUIState->GetNextUniqueID (); + } + +CSRAW + #if DEBUG_HOTCONTROL + static public string s_WhoGrabbedHotControl, s_WhoReleasedHotControl; + #endif + + #if DEBUG_CONTROLID + static public bool s_LogControlID = false; + #endif + + + // The controlID of the current hot control. + CSRAW public static int hotControl { get { return Internal_GetHotControl(); } + set { + #if DEBUG_HOTCONTROL + if (value != 0) + { + s_WhoGrabbedHotControl = StackTraceUtility.ExtractStackTrace(); + Debug.Log("GRABBED " + s_WhoGrabbedHotControl); + } + else + { + s_WhoReleasedHotControl = StackTraceUtility.ExtractStackTrace(); + Debug.Log("RELEASE: " + s_WhoReleasedHotControl); + } + #endif + + Internal_SetHotControl (value); + } } + + CUSTOM private static int Internal_GetHotControl () + { + return IMGUI::GetHotControl (GetGUIState()); + } + CUSTOM private static void Internal_SetHotControl (int value) + { + IMGUI::SetHotControl (GetGUIState(), value); + } + + CUSTOM internal static void UpdateUndoName () + { + #if UNITY_EDITOR + GetUndoManager().UpdateUndoName (); + #endif + } + + // The controlID of the control that has keyboard focus. + CUSTOM_PROP static int keyboardControl + { return IMGUI::GetKeyboardControl (GetGUIState()); } + { IMGUI::SetKeyboardControl (GetGUIState(), value); } + +// Keep for debugging keyboardControl (prints the callstack when keyboardControl changes) +// CSRAW public static int keyboardControl +// { +// get { return GetKeyboardControl (); } +// set { Debug.Log ("Set keyboardControl " + value); SetKeyboardControl (value);} +// } +// CUSTOM static int GetKeyboardControl () {return IMGUI::GetKeyboardControl (GetGUIState()); } +// CUSTOM static void SetKeyboardControl (int id) {IMGUI::SetKeyboardControl (GetGUIState(), id); } + + //*undocumented* + CSRAW public static void ExitGUI () + { + // We have to always throw the ExitGUIException otherwise the exiting out of recursive on GUI will not work. + throw new ExitGUIException (); + } + + CUSTOM internal static void SetDidGUIWindowsEatLastEvent (bool value) { + GUIManager::SetDidGUIWindowsEatLastEvent (value); + } + + // Get access to the system-wide pasteboard. + CUSTOM_PROP static internal string systemCopyBuffer { return scripting_string_new(GetCopyBuffer ()); } { SetCopyBuffer (value); } + + CSRAW internal static GUISkin GetDefaultSkin() { + return Internal_GetDefaultSkin (s_SkinMode); + } + + CUSTOM private static GUISkin Internal_GetDefaultSkin (int skinMode) { + return GetDefaultSkin (skinMode)->GetInstance (); + } + + CUSTOM private static Object Internal_GetBuiltinSkin (int skin) { + return GetBuiltinSkin (skin)->GetInstance (); + } + + // internal so we can get to it from EditorGUIUtility.GetBuiltinSkin + CSRAW internal static GUISkin GetBuiltinSkin (int skin) { + return Internal_GetBuiltinSkin (skin) as GUISkin; + } + + [NotRenamed] static internal int s_SkinMode; + [NotRenamed] static internal int s_OriginalID; + CSRAW internal static void BeginGUI (int skinMode, int instanceID, int useGUILayout ) { + s_SkinMode = skinMode; + s_OriginalID = instanceID; + GUI.skin = null; + + // Switch to the correct ID list & clear keyboard loop if we're about to layout (we rebuild it during layout, so we want it cleared beforehand) + if (useGUILayout != 0) + { + GUILayoutUtility.SelectIDList (instanceID, false); + GUILayoutUtility.Begin (instanceID); + } + + GUI.changed = false; + } + + CUSTOM private static void Internal_ExitGUI () + { + #if UNITY_EDITOR + OptimizedGUIBlock::Abandon (); + s_GUIStyleIconSizeX = 0.0f; + s_GUIStyleIconSizeY = 0.0f; + #endif + } + + // End the 2D GUI. + CSRAW internal static void EndGUI (int layoutType) + { + try + { + if (Event.current.type == EventType.Layout) + { + switch (layoutType) + { + case 0: // kNoLayout + break; + case 1: // kGameLayout + GUILayoutUtility.Layout (); + break; + case 2: // kEditorLayout + GUILayoutUtility.LayoutFromEditorWindow (); + break; + } + } + + GUILayoutUtility.SelectIDList (s_OriginalID, false); + GUIContent.ClearStaticCache(); + } + finally { + Internal_ExitGUI(); + } + } + + // End the 2D GUI. + CSRAW internal static bool EndGUIFromException (System.Exception exception) { + // Check if the exception is a ExitGUIException + if (exception == null) + return false; + if (exception as ExitGUIException == null +#if !UNITY_FLASH && !UNITY_WEBGL + && exception.InnerException as ExitGUIException == null +#endif + ) + return false; + + Internal_ExitGUI (); + + return true; + } + + // Only allow calling GUI functions from inside OnGUI + CSRAW static internal void CheckOnGUI() { + if (Internal_GetGUIDepth () <= 0) + { + throw new ArgumentException("You can only call GUI functions from inside OnGUI."); + } + } + + CUSTOM static internal int Internal_GetGUIDepth () + { + return GetGUIState().m_OnGUIDepth; + } + + CUSTOM_PROP static internal bool mouseUsed + { return GetGUIState().m_CanvasGUIState.m_IsMouseUsed != 0; } + { GetGUIState().m_CanvasGUIState.m_IsMouseUsed = value ? 1 : 0; } + + CSRAW + + static internal Vector2 s_EditorScreenPointOffset = Vector2.zero; + static internal bool s_HasKeyboardFocus = false; + + // Convert a point from GUI position to screen space. + CSRAW public static Vector2 GUIToScreenPoint (Vector2 guiPoint) + { + return GUIClip.Unclip (guiPoint) + s_EditorScreenPointOffset; + } + + // Convert a rect from GUI position to screen space. + CSRAW internal static Rect GUIToScreenRect (Rect guiRect) + { + Vector2 screenPoint = GUIToScreenPoint (new Vector2 (guiRect.x, guiRect.y)); + guiRect.x = screenPoint.x; + guiRect.y = screenPoint.y; + return guiRect; + } + + // Convert a point from screen space to GUI position. + CSRAW public static Vector2 ScreenToGUIPoint (Vector2 screenPoint) + { + return GUIClip.Clip (screenPoint) - s_EditorScreenPointOffset; + } + + // Convert a rect from screen space to GUI position. + CSRAW public static Rect ScreenToGUIRect (Rect screenRect) + { + Vector2 guiPoint = ScreenToGUIPoint (new Vector2 (screenRect.x, screenRect.y)); + screenRect.x = guiPoint.x; + screenRect.y = guiPoint.y; + return screenRect; + } + + // Helper function to rotate the GUI around a point. + public static void RotateAroundPivot (float angle, Vector2 pivotPoint) { + Matrix4x4 mat = GUI.matrix; + GUI.matrix = Matrix4x4.identity; + Vector2 point = GUIClip.Unclip(pivotPoint); + Matrix4x4 newMat = Matrix4x4.TRS (point, Quaternion.Euler (0,0,angle), Vector3.one) * Matrix4x4.TRS (-point, Quaternion.identity, Vector3.one); + GUI.matrix = newMat *mat; + } + + // Helper function to scale the GUI around a point. + public static void ScaleAroundPivot (Vector2 scale, Vector2 pivotPoint) { + Matrix4x4 mat = GUI.matrix; + Vector2 point = GUIClip.Unclip(pivotPoint); + Matrix4x4 newMat = Matrix4x4.TRS (point, Quaternion.identity, new Vector3 (scale.x, scale.y, 1)) * Matrix4x4.TRS (-point, Quaternion.identity, Vector3.one); + GUI.matrix = newMat * mat; + } + + // Check to see if there's a modal IMGUI window that's currently open + CUSTOM_PROP public static bool hasModalWindow + { + GUIState& state = GetGUIState(); + return state.m_MultiFrameGUIState.m_Windows != NULL && state.m_MultiFrameGUIState.m_Windows->m_ModalWindow != NULL; + } + + //*undocumented* + CUSTOM_PROP static internal bool textFieldInput + { return GetInputManager().GetTextFieldInput (); } + { GetInputManager().SetTextFieldInput (value); } +END + + +CLASS internal GUIClip + // Push a clip rect to the stack with pixel offsets. + CUSTOM internal static void Push (Rect screenRect, Vector2 scrollOffset, Vector2 renderOffset, bool resetOffset) + { + GetGUIState().m_CanvasGUIState.m_GUIClipState.Push (IMGUI::GetCurrentEvent(GetGUIState()), screenRect, scrollOffset, renderOffset, resetOffset); + } + + // Removes the topmost clipping rectangle, undoing the effect of the latest GUIClip.Push + CUSTOM internal static void Pop () + { + GetGUIState().m_CanvasGUIState.m_GUIClipState.Pop (IMGUI::GetCurrentEvent(GetGUIState())); + } + + // Get the topmost rectangle + CUSTOM internal static Rect GetTopRect () + { + return GetGUIState().m_CanvasGUIState.m_GUIClipState.GetTopRect (); + } + + + CUSTOM_PROP static bool enabled + { return GetGUIState().m_CanvasGUIState.m_GUIClipState.GetEnabled(); } + + + // Unclips /pos/ to physical device coordinates. + CSRAW static public Vector2 Unclip (Vector2 pos) + { + Unclip_Vector2(ref pos); + return pos; + } + + CUSTOM private static void Unclip_Vector2 (ref Vector2 pos) + { + pos = GetGUIState().m_CanvasGUIState.m_GUIClipState.Unclip (pos); + } + + // The topmost physical rect in unclipped coordinates + // Used in editor to clip cursor rects inside scrollviews + CUSTOM_PROP static Rect topmostRect + { return GetGUIState().m_CanvasGUIState.m_GUIClipState.GetTopMostPhysicalRect (); } + + + // Unclips /rect/ to physical device coordinates. + CSRAW public static Rect Unclip (Rect rect) + { + Unclip_Rect(ref rect); + return rect; + } + CUSTOM private static void Unclip_Rect (ref Rect rect) + { + rect = GetGUIState().m_CanvasGUIState.m_GUIClipState.Unclip(rect); + } + + // Clips /absolutePos/ to drawing coordinates + CSRAW static public Vector2 Clip (Vector2 absolutePos) + { + Clip_Vector2 (ref absolutePos); + return absolutePos; + } + + CUSTOM private static void Clip_Vector2 (ref Vector2 absolutePos) + { + absolutePos = GetGUIState().m_CanvasGUIState.m_GUIClipState.Clip(absolutePos); + } + + // Convert /absoluteRect/ to drawing coordinates + CSRAW static public Rect Clip (Rect absoluteRect) + { + Internal_Clip_Rect (ref absoluteRect); + return absoluteRect; + } + + CUSTOM static private void Internal_Clip_Rect (ref Rect absoluteRect) + { + absoluteRect = GetGUIState().m_CanvasGUIState.m_GUIClipState.Clip (absoluteRect); + } + + // Reapply the clipping info. + CUSTOM internal static void Reapply () + { + GetGUIState().m_CanvasGUIState.m_GUIClipState.Reapply (IMGUI::GetCurrentEvent(GetGUIState())); + } + + // Set the GUIMatrix. This is here as this class handles all coordinate transforms anyways. + CUSTOM internal static Matrix4x4 GetMatrix() + { + return GetGUIState().m_CanvasGUIState.m_GUIClipState.GetMatrix(); + } + + CUSTOM internal static void SetMatrix (Matrix4x4 m) + { + GetGUIState().m_CanvasGUIState.m_GUIClipState.SetMatrix(IMGUI::GetCurrentEvent(GetGUIState()), m); + } + + // The visible rectangle. + CUSTOM_PROP static Rect visibleRect + { return GetGUIState().m_CanvasGUIState.m_GUIClipState.GetVisibleRect (); } + + CSRAW public static Vector2 GetAbsoluteMousePosition () + { + Vector2 vec; + Internal_GetAbsoluteMousePosition(out vec); + return vec; + } + CUSTOM private static void Internal_GetAbsoluteMousePosition (out Vector2 output) + { + *output = GetGUIState().m_CanvasGUIState.m_GUIClipState.GetAbsoluteMousePosition(); + } +END + +CSRAW } |