UnityEngineSourceCode

C#语言基础
下载此实例
开发语言：C#
实例大小：0.24M
下载次数：29
浏览次数：510
发布时间：2015-09-01
实例类别：C#语言基础
发布人：隐溯
文件格式：.rar
所需积分：0
实例介绍

【实例简介】
【实例截图】
【核心代码】
namespace UnityEngine
{
    using System;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;
    using UnityEngineInternal;
 
    public class GUI
    {
        private static int beginGroupHash = "BeginGroup".GetHashCode();
        private static int boxHash = "Box".GetHashCode();
        private static int buttonGridHash = "ButtonGrid".GetHashCode();
        private static int repeatButtonHash = "repeatButton".GetHashCode();
        private static GenericStack s_ScrollViewStates = new GenericStack();
        private static GUISkin s_Skin;
        internal static Rect s_ToolTipRect;
        private static int scrollControlID;
        private static float scrollStepSize = 10f;
        private static int scrollviewHash = "scrollView".GetHashCode();
        private static int sliderHash = "Slider".GetHashCode();
        private static int toggleHash = "Toggle".GetHashCode();
 
        static GUI()
        {
            nextScrollStepTime = DateTime.Now;
        }
 
        public static void BeginGroup(Rect position)
        {
            BeginGroup(position, GUIContent.none, GUIStyle.none);
        }
 
        public static void BeginGroup(Rect position, string text)
        {
            BeginGroup(position, GUIContent.Temp(text), GUIStyle.none);
        }
 
        public static void BeginGroup(Rect position, GUIContent content)
        {
            BeginGroup(position, content, GUIStyle.none);
        }
 
        public static void BeginGroup(Rect position, GUIStyle style)
        {
            BeginGroup(position, GUIContent.none, style);
        }
 
        public static void BeginGroup(Rect position, Texture image)
        {
            BeginGroup(position, GUIContent.Temp(image), GUIStyle.none);
        }
 
        public static void BeginGroup(Rect position, string text, GUIStyle style)
        {
            BeginGroup(position, GUIContent.Temp(text), style);
        }
 
        public static void BeginGroup(Rect position, GUIContent content, GUIStyle style)
        {
            GUIUtility.CheckOnGUI();
            int controlID = GUIUtility.GetControlID(beginGroupHash, FocusType.Passive);
            if ((content != GUIContent.none) || (style != GUIStyle.none))
            {
                if (Event.current.type == EventType.Repaint)
                {
                    style.Draw(position, content, controlID);
                }
                else if (position.Contains(Event.current.mousePosition))
                {
                    GUIUtility.mouseUsed = true;
                }
            }
            GUIClip.Push(position, Vector2.zero, Vector2.zero, false);
        }
 
        public static void BeginGroup(Rect position, Texture image, GUIStyle style)
        {
            BeginGroup(position, GUIContent.Temp(image), style);
        }
 
        public static Vector2 BeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect)
        {
            return BeginScrollView(position, scrollPosition, viewRect, false, false, skin.horizontalScrollbar, skin.verticalScrollbar, skin.scrollView);
        }
 
        public static Vector2 BeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, bool alwaysShowVertical)
        {
            return BeginScrollView(position, scrollPosition, viewRect, alwaysShowHorizontal, alwaysShowVertical, skin.horizontalScrollbar, skin.verticalScrollbar, skin.scrollView);
        }
 
        public static Vector2 BeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar)
        {
            return BeginScrollView(position, scrollPosition, viewRect, false, false, horizontalScrollbar, verticalScrollbar, skin.scrollView);
        }
 
        public static Vector2 BeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, bool alwaysShowVertical, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar)
        {
            return BeginScrollView(position, scrollPosition, viewRect, alwaysShowHorizontal, alwaysShowVertical, horizontalScrollbar, verticalScrollbar, null);
        }
 
        internal static Vector2 BeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, bool alwaysShowVertical, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar, GUIStyle background)
        {
            GUIUtility.CheckOnGUI();
            int controlID = GUIUtility.GetControlID(scrollviewHash, FocusType.Passive);
            ScrollViewState stateObject = (ScrollViewState) GUIUtility.GetStateObject(typeof(ScrollViewState), controlID);
            if (stateObject.apply)
            {
                scrollPosition = stateObject.scrollPosition;
                stateObject.apply = false;
            }
            stateObject.position = position;
            stateObject.scrollPosition = scrollPosition;
            stateObject.visibleRect = stateObject.viewRect = viewRect;
            stateObject.visibleRect.width = position.width;
            stateObject.visibleRect.height = position.height;
            s_ScrollViewStates.Push(stateObject);
            Rect screenRect = new Rect(position);
            switch (Event.current.type)
            {
                case EventType.Layout:
                    GUIUtility.GetControlID(sliderHash, FocusType.Passive);
                    GUIUtility.GetControlID(repeatButtonHash, FocusType.Passive);
                    GUIUtility.GetControlID(repeatButtonHash, FocusType.Passive);
                    GUIUtility.GetControlID(sliderHash, FocusType.Passive);
                    GUIUtility.GetControlID(repeatButtonHash, FocusType.Passive);
                    GUIUtility.GetControlID(repeatButtonHash, FocusType.Passive);
                    break;
 
                case EventType.Used:
                    break;
 
                default:
                {
                    bool flag = alwaysShowVertical;
                    bool flag2 = alwaysShowHorizontal;
                    if (flag2 || (viewRect.width > screenRect.width))
                    {
                        stateObject.visibleRect.height = (position.height - horizontalScrollbar.fixedHeight)   horizontalScrollbar.margin.top;
                        screenRect.height -= horizontalScrollbar.fixedHeight   horizontalScrollbar.margin.top;
                        flag2 = true;
                    }
                    if (flag || (viewRect.height > screenRect.height))
                    {
                        stateObject.visibleRect.width = (position.width - verticalScrollbar.fixedWidth)   verticalScrollbar.margin.left;
                        screenRect.width -= verticalScrollbar.fixedWidth   verticalScrollbar.margin.left;
                        flag = true;
                        if (!flag2 && (viewRect.width > screenRect.width))
                        {
                            stateObject.visibleRect.height = (position.height - horizontalScrollbar.fixedHeight)   horizontalScrollbar.margin.top;
                            screenRect.height -= horizontalScrollbar.fixedHeight   horizontalScrollbar.margin.top;
                            flag2 = true;
                        }
                    }
                    if ((Event.current.type == EventType.Repaint) && (background != GUIStyle.none))
                    {
                        background.Draw(position, position.Contains(Event.current.mousePosition), false, flag2 && flag, false);
                    }
                    if (flag2 && (horizontalScrollbar != GUIStyle.none))
                    {
                        scrollPosition.x = HorizontalScrollbar(new Rect(position.x, position.yMax - horizontalScrollbar.fixedHeight, screenRect.width, horizontalScrollbar.fixedHeight), scrollPosition.x, screenRect.width, 0f, viewRect.width, horizontalScrollbar);
                    }
                    else
                    {
                        GUIUtility.GetControlID(sliderHash, FocusType.Passive);
                        GUIUtility.GetControlID(repeatButtonHash, FocusType.Passive);
                        GUIUtility.GetControlID(repeatButtonHash, FocusType.Passive);
                        if (horizontalScrollbar != GUIStyle.none)
                        {
                            scrollPosition.x = 0f;
                        }
                        else
                        {
                            scrollPosition.x = Mathf.Clamp(scrollPosition.x, 0f, Mathf.Max((float) (viewRect.width - position.width), (float) 0f));
                        }
                    }
                    if (flag && (verticalScrollbar != GUIStyle.none))
                    {
                        scrollPosition.y = VerticalScrollbar(new Rect(screenRect.xMax   verticalScrollbar.margin.left, screenRect.y, verticalScrollbar.fixedWidth, screenRect.height), scrollPosition.y, screenRect.height, 0f, viewRect.height, verticalScrollbar);
                    }
                    else
                    {
                        GUIUtility.GetControlID(sliderHash, FocusType.Passive);
                        GUIUtility.GetControlID(repeatButtonHash, FocusType.Passive);
                        GUIUtility.GetControlID(repeatButtonHash, FocusType.Passive);
                        if (verticalScrollbar != GUIStyle.none)
                        {
                            scrollPosition.y = 0f;
                        }
                        else
                        {
                            scrollPosition.y = Mathf.Clamp(scrollPosition.y, 0f, Mathf.Max((float) (viewRect.height - position.height), (float) 0f));
                        }
                    }
                    break;
                }
            }
            GUIClip.Push(screenRect, new Vector2(Mathf.Round(-scrollPosition.x - viewRect.x), Mathf.Round(-scrollPosition.y - viewRect.y)), Vector2.zero, false);
            return scrollPosition;
        }
 
        internal static void BeginWindows(int skinMode, int editorWindowInstanceID)
        {
            GUILayoutGroup topLevel = GUILayoutUtility.current.topLevel;
            GenericStack layoutGroups = GUILayoutUtility.current.layoutGroups;
            GUILayoutGroup windows = GUILayoutUtility.current.windows;
            Matrix4x4 matrix = GUI.matrix;
            Internal_BeginWindows();
            GUI.matrix = matrix;
            GUILayoutUtility.current.topLevel = topLevel;
            GUILayoutUtility.current.layoutGroups = layoutGroups;
            GUILayoutUtility.current.windows = windows;
        }
 
        public static void Box(Rect position, string text)
        {
            Box(position, GUIContent.Temp(text), s_Skin.box);
        }
 
        public static void Box(Rect position, GUIContent content)
        {
            Box(position, content, s_Skin.box);
        }
 
        public static void Box(Rect position, Texture image)
        {
            Box(position, GUIContent.Temp(image), s_Skin.box);
        }
 
        public static void Box(Rect position, string text, GUIStyle style)
        {
            Box(position, GUIContent.Temp(text), style);
        }
 
        public static void Box(Rect position, GUIContent content, GUIStyle style)
        {
            GUIUtility.CheckOnGUI();
            int controlID = GUIUtility.GetControlID(boxHash, FocusType.Passive);
            if (Event.current.type == EventType.Repaint)
            {
                style.Draw(position, content, controlID);
            }
        }
 
        public static void Box(Rect position, Texture image, GUIStyle style)
        {
            Box(position, GUIContent.Temp(image), style);
        }
 
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void BringWindowToBack(int windowID);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void BringWindowToFront(int windowID);
        public static bool Button(Rect position, string text)
        {
            return DoButton(position, GUIContent.Temp(text), s_Skin.button.m_Ptr);
        }
 
        public static bool Button(Rect position, GUIContent content)
        {
            return DoButton(position, content, s_Skin.button.m_Ptr);
        }
 
        public static bool Button(Rect position, Texture image)
        {
            return DoButton(position, GUIContent.Temp(image), s_Skin.button.m_Ptr);
        }
 
        public static bool Button(Rect position, string text, GUIStyle style)
        {
            return DoButton(position, GUIContent.Temp(text), style.m_Ptr);
        }
 
        public static bool Button(Rect position, GUIContent content, GUIStyle style)
        {
            return DoButton(position, content, style.m_Ptr);
        }
 
        public static bool Button(Rect position, Texture image, GUIStyle style)
        {
            return DoButton(position, GUIContent.Temp(image), style.m_Ptr);
        }
 
        private static Rect[] CalcMouseRects(Rect position, int count, int xCount, float elemWidth, float elemHeight, GUIStyle style, GUIStyle firstStyle, GUIStyle midStyle, GUIStyle lastStyle, bool addBorders)
        {
            int num = 0;
            int num2 = 0;
            float xMin = position.xMin;
            float yMin = position.yMin;
            GUIStyle style2 = style;
            Rect[] rectArray = new Rect[count];
            if (count > 1)
            {
                style2 = firstStyle;
            }
            for (int i = 0; i < count; i  )
            {
                if (!addBorders)
                {
                    rectArray[i] = new Rect(xMin, yMin, elemWidth, elemHeight);
                }
                else
                {
                    rectArray[i] = style2.margin.Add(new Rect(xMin, yMin, elemWidth, elemHeight));
                }
                rectArray[i].width = Mathf.Round(rectArray[i].xMax) - Mathf.Round(rectArray[i].x);
                rectArray[i].x = Mathf.Round(rectArray[i].x);
                GUIStyle style3 = midStyle;
                if (i == (count - 2))
                {
                    style3 = lastStyle;
                }
                xMin  = elemWidth   Mathf.Max(style2.margin.right, style3.margin.left);
                num2  ;
                if (num2 >= xCount)
                {
                    num  ;
                    num2 = 0;
                    yMin  = elemHeight   Mathf.Max(style.margin.top, style.margin.bottom);
                    xMin = position.xMin;
                }
            }
            return rectArray;
        }
 
        internal static int CalcTotalHorizSpacing(int xCount, GUIStyle style, GUIStyle firstStyle, GUIStyle midStyle, GUIStyle lastStyle)
        {
            if (xCount < 2)
            {
                return 0;
            }
            if (xCount == 2)
            {
                return Mathf.Max(firstStyle.margin.right, lastStyle.margin.left);
            }
            int num = Mathf.Max(midStyle.margin.left, midStyle.margin.right);
            return ((Mathf.Max(firstStyle.margin.right, midStyle.margin.left)   Mathf.Max(midStyle.margin.right, lastStyle.margin.left))   (num * (xCount - 3)));
        }
 
        internal static void CallWindowDelegate(WindowFunction func, int id, GUISkin _skin, int forceRect, float width, float height, GUIStyle style)
        {
            GUILayoutUtility.SelectIDList(id, true);
            GUISkin skin = GUI.skin;
            if (Event.current.type == EventType.Layout)
            {
                if (forceRect != 0)
                {
                    GUILayoutOption[] options = new GUILayoutOption[] { GUILayout.Width(width), GUILayout.Height(height) };
                    GUILayoutUtility.BeginWindow(id, style, options);
                }
                else
                {
                    GUILayoutUtility.BeginWindow(id, style, null);
                }
            }
            GUI.skin = _skin;
            func(id);
            if (Event.current.type == EventType.Layout)
            {
                GUILayoutUtility.Layout();
            }
            GUI.skin = skin;
        }
 
        protected static Vector2 DoBeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, bool alwaysShowVertical, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar, GUIStyle background)
        {
            return BeginScrollView(position, scrollPosition, viewRect, alwaysShowHorizontal, alwaysShowVertical, horizontalScrollbar, verticalScrollbar, background);
        }
 
        private static bool DoButton(Rect position, GUIContent content, IntPtr style)
        {
            return INTERNAL_CALL_DoButton(ref position, content, style);
        }
 
        private static int DoButtonGrid(Rect position, int selected, GUIContent[] contents, int xCount, GUIStyle style, GUIStyle firstStyle, GUIStyle midStyle, GUIStyle lastStyle)
        {
            GUIUtility.CheckOnGUI();
            int length = contents.Length;
            if (length != 0)
            {
                int controlID = GUIUtility.GetControlID(buttonGridHash, FocusType.Native, position);
                int num3 = length / xCount;
                if ((length % xCount) != 0)
                {
                    num3  ;
                }
                float num4 = CalcTotalHorizSpacing(xCount, style, firstStyle, midStyle, lastStyle);
                float num5 = Mathf.Max(style.margin.top, style.margin.bottom) * (num3 - 1);
                float elemWidth = (position.width - num4) / ((float) xCount);
                float elemHeight = (position.height - num5) / ((float) num3);
                if (style.fixedWidth != 0f)
                {
                    elemWidth = style.fixedWidth;
                }
                if (style.fixedHeight != 0f)
                {
                    elemHeight = style.fixedHeight;
                }
                switch (Event.current.GetTypeForControl(controlID))
                {
                    case EventType.MouseDown:
                        if (position.Contains(Event.current.mousePosition) && (GetButtonGridMouseSelection(CalcMouseRects(position, length, xCount, elemWidth, elemHeight, style, firstStyle, midStyle, lastStyle, false), Event.current.mousePosition, true) != -1))
                        {
                            GUIUtility.hotControl = controlID;
                            Event.current.Use();
                        }
                        return selected;
 
                    case EventType.MouseUp:
                    {
                        if (GUIUtility.hotControl != controlID)
                        {
                            return selected;
                        }
                        GUIUtility.hotControl = 0;
                        Event.current.Use();
                        int num8 = GetButtonGridMouseSelection(CalcMouseRects(position, length, xCount, elemWidth, elemHeight, style, firstStyle, midStyle, lastStyle, false), Event.current.mousePosition, true);
                        changed = true;
                        return num8;
                    }
                    case EventType.MouseMove:
                    case EventType.KeyDown:
                    case EventType.KeyUp:
                    case EventType.ScrollWheel:
                        return selected;
 
                    case EventType.MouseDrag:
                        if (GUIUtility.hotControl == controlID)
                        {
                            Event.current.Use();
                        }
                        return selected;
 
                    case EventType.Repaint:
                    {
                        GUIStyle style2 = null;
                        GUIClip.Push(position, Vector2.zero, Vector2.zero, false);
                        position = new Rect(0f, 0f, position.width, position.height);
                        Rect[] buttonRects = CalcMouseRects(position, length, xCount, elemWidth, elemHeight, style, firstStyle, midStyle, lastStyle, false);
                        int num9 = GetButtonGridMouseSelection(buttonRects, Event.current.mousePosition, controlID == GUIUtility.hotControl);
                        bool flag = position.Contains(Event.current.mousePosition);
                        GUIUtility.mouseUsed |= flag;
                        for (int i = 0; i < length; i  )
                        {
                            GUIStyle style3 = null;
                            if (i != 0)
                            {
                                style3 = midStyle;
                            }
                            else
                            {
                                style3 = firstStyle;
                            }
                            if (i == (length - 1))
                            {
                                style3 = lastStyle;
                            }
                            if (length == 1)
                            {
                                style3 = style;
                            }
                            if (i != selected)
                            {
                                style3.Draw(buttonRects[i], contents[i], ((i == num9) && (enabled || (controlID == GUIUtility.hotControl))) && ((controlID == GUIUtility.hotControl) || (GUIUtility.hotControl == 0)), (controlID == GUIUtility.hotControl) && enabled, false, false);
                            }
                            else
                            {
                                style2 = style3;
                            }
                        }
                        if ((selected < length) && (selected > -1))
                        {
                            style2.Draw(buttonRects[selected], contents[selected], ((selected == num9) && (enabled || (controlID == GUIUtility.hotControl))) && ((controlID == GUIUtility.hotControl) || (GUIUtility.hotControl == 0)), (controlID == GUIUtility.hotControl) || ((selected == num9) && (GUIUtility.hotControl == 0)), true, false);
                        }
                        GUIClip.Pop();
                        return selected;
                    }
                }
            }
            return selected;
        }
 
        private static void DoLabel(Rect position, GUIContent content, IntPtr style)
        {
            INTERNAL_CALL_DoLabel(ref position, content, style);
        }
 
        private static Rect DoModalWindow(int id, Rect clientRect, WindowFunction func, GUIContent content, GUIStyle style, GUISkin skin)
        {
            return INTERNAL_CALL_DoModalWindow(id, ref clientRect, func, content, style, skin);
        }
 
        private static bool DoRepeatButton(Rect position, GUIContent content, GUIStyle style, FocusType focusType)
        {
            GUIUtility.CheckOnGUI();
            int controlID = GUIUtility.GetControlID(repeatButtonHash, focusType, position);
            EventType typeForControl = Event.current.GetTypeForControl(controlID);
            if (typeForControl != EventType.MouseDown)
            {
                if (typeForControl != EventType.MouseUp)
                {
                    if (typeForControl != EventType.Repaint)
                    {
                        return false;
                    }
                    style.Draw(position, content, controlID);
                    return ((controlID == GUIUtility.hotControl) && position.Contains(Event.current.mousePosition));
                }
            }
            else
            {
                if (position.Contains(Event.current.mousePosition))
                {
                    GUIUtility.hotControl = controlID;
                    Event.current.Use();
                }
                return false;
            }
            if (GUIUtility.hotControl == controlID)
            {
                GUIUtility.hotControl = 0;
                Event.current.Use();
                return position.Contains(Event.current.mousePosition);
            }
            return false;
        }
 
        internal static void DoTextField(Rect position, int id, GUIContent content, bool multiline, int maxLength, GUIStyle style)
        {
            if ((maxLength >= 0) && (content.text.Length > maxLength))
            {
                content.text = content.text.Substring(0, maxLength);
            }
            GUIUtility.CheckOnGUI();
            TextEditor stateObject = (TextEditor) GUIUtility.GetStateObject(typeof(TextEditor), id);
            stateObject.content.text = content.text;
            stateObject.SaveBackup();
            stateObject.position = position;
            stateObject.style = style;
            stateObject.multiline = multiline;
            stateObject.controlID = id;
            stateObject.ClampPos();
            Event current = Event.current;
            bool flag = false;
            switch (current.type)
            {
                case EventType.MouseDown:
                    if (position.Contains(current.mousePosition))
                    {
                        GUIUtility.hotControl = id;
                        GUIUtility.keyboardControl = id;
                        stateObject.m_HasFocus = true;
                        stateObject.MoveCursorToPosition(Event.current.mousePosition);
                        if ((Event.current.clickCount == 2) && skin.settings.doubleClickSelectsWord)
                        {
                            stateObject.SelectCurrentWord();
                            stateObject.DblClickSnap(TextEditor.DblClickSnapping.WORDS);
                            stateObject.MouseDragSelectsWholeWords(true);
                        }
                        if ((Event.current.clickCount == 3) && skin.settings.tripleClickSelectsLine)
                        {
                            stateObject.SelectCurrentParagraph();
                            stateObject.MouseDragSelectsWholeWords(true);
                            stateObject.DblClickSnap(TextEditor.DblClickSnapping.PARAGRAPHS);
                        }
                        current.Use();
                    }
                    goto Label_02E8;
 
                case EventType.MouseUp:
                    if (GUIUtility.hotControl == id)
                    {
                        stateObject.MouseDragSelectsWholeWords(false);
                        GUIUtility.hotControl = 0;
                        current.Use();
                    }
                    goto Label_02E8;
 
                case EventType.MouseDrag:
                    if (GUIUtility.hotControl != id)
                    {
                        goto Label_02E8;
                    }
                    if (!current.shift)
                    {
                        stateObject.SelectToPosition(Event.current.mousePosition);
                        break;
                    }
                    stateObject.MoveCursorToPosition(Event.current.mousePosition);
                    break;
 
                case EventType.KeyDown:
                    if (GUIUtility.keyboardControl == id)
                    {
                        if (stateObject.HandleKeyEvent(current))
                        {
                            current.Use();
                            flag = true;
                            content.text = stateObject.content.text;
                        }
                        else
                        {
                            if ((current.keyCode == KeyCode.Tab) || (current.character == '\t'))
                            {
                                return;
                            }
                            char character = current.character;
                            if (((character == '\n') && !multiline) && !current.alt)
                            {
                                return;
                            }
                            Font font = style.font;
                            if (font == null)
                            {
                                font = skin.font;
                            }
                            if (font.HasCharacter(character) || (character == '\n'))
                            {
                                stateObject.Insert(character);
                                flag = true;
                            }
                            else if (character == '\0')
                            {
                                if (Input.compositionString.Length > 0)
                                {
                                    stateObject.ReplaceSelection(string.Empty);
                                    flag = true;
                                }
                                current.Use();
                            }
                        }
                        goto Label_02E8;
                    }
                    return;
 
                case EventType.Repaint:
                    if (GUIUtility.keyboardControl == id)
                    {
                        stateObject.DrawCursor(content.text);
                    }
                    else
                    {
                        style.Draw(position, content, id, false);
                    }
                    goto Label_02E8;
 
                default:
                    goto Label_02E8;
            }
            current.Use();
        Label_02E8:
            if (GUIUtility.keyboardControl == id)
            {
                GUIUtility.textFieldInput = true;
            }
            if (flag)
            {
                changed = true;
                content.text = stateObject.content.text;
                if ((maxLength >= 0) && (content.text.Length > maxLength))
                {
                    content.text = content.text.Substring(0, maxLength);
                }
                current.Use();
            }
        }
 
        internal static bool DoToggle(Rect position, int id, bool value, GUIContent content, IntPtr style)
        {
            return INTERNAL_CALL_DoToggle(ref position, id, value, content, style);
        }
 
        private static Rect DoWindow(int id, Rect clientRect, WindowFunction func, GUIContent title, GUIStyle style, GUISkin skin, bool forceRectOnLayout)
        {
            return INTERNAL_CALL_DoWindow(id, ref clientRect, func, title, style, skin, forceRectOnLayout);
        }
 
        public static void DragWindow()
        {
            DragWindow(new Rect(0f, 0f, 10000f, 10000f));
        }
 
        public static void DragWindow(Rect position)
        {
            INTERNAL_CALL_DragWindow(ref position);
        }
 
        public static void DrawTexture(Rect position, Texture image)
        {
            float imageAspect = 0f;
            bool alphaBlend = true;
            ScaleMode stretchToFill = ScaleMode.StretchToFill;
            DrawTexture(position, image, stretchToFill, alphaBlend, imageAspect);
        }
 
        public static void DrawTexture(Rect position, Texture image, ScaleMode scaleMode)
        {
            float imageAspect = 0f;
            bool alphaBlend = true;
            DrawTexture(position, image, scaleMode, alphaBlend, imageAspect);
        }
 
        public static void DrawTexture(Rect position, Texture image, ScaleMode scaleMode, bool alphaBlend)
        {
            float imageAspect = 0f;
            DrawTexture(position, image, scaleMode, alphaBlend, imageAspect);
        }
 
        public static void DrawTexture(Rect position, Texture image, ScaleMode scaleMode, bool alphaBlend, float imageAspect)
        {
            if (Event.current.type == EventType.Repaint)
            {
                if (image == null)
                {
                    Debug.LogWarning("null texture passed to GUI.DrawTexture");
                }
                else
                {
                    if (imageAspect == 0f)
                    {
                        imageAspect = ((float) image.width) / ((float) image.height);
                    }
                    Material material = !alphaBlend ? blitMaterial : blendMaterial;
                    float num = position.width / position.height;
                    InternalDrawTextureArguments arguments = new InternalDrawTextureArguments {
                        texture = image,
                        leftBorder = 0,
                        rightBorder = 0,
                        topBorder = 0,
                        bottomBorder = 0,
                        color = color,
                        mat = material
                    };
                    switch (scaleMode)
                    {
                        case ScaleMode.StretchToFill:
                            arguments.screenRect = position;
                            arguments.sourceRect = new Rect(0f, 0f, 1f, 1f);
                            Graphics.DrawTexture(ref arguments);
                            break;
 
                        case ScaleMode.ScaleAndCrop:
                        {
                            if (num <= imageAspect)
                            {
                                float width = num / imageAspect;
                                arguments.screenRect = position;
                                arguments.sourceRect = new Rect(0.5f - (width * 0.5f), 0f, width, 1f);
                                Graphics.DrawTexture(ref arguments);
                                break;
                            }
                            float height = imageAspect / num;
                            arguments.screenRect = position;
                            arguments.sourceRect = new Rect(0f, (1f - height) * 0.5f, 1f, height);
                            Graphics.DrawTexture(ref arguments);
                            break;
                        }
                        case ScaleMode.ScaleToFit:
                        {
                            if (num <= imageAspect)
                            {
                                float num5 = num / imageAspect;
                                arguments.screenRect = new Rect(position.xMin, position.yMin   ((position.height * (1f - num5)) * 0.5f), position.width, num5 * position.height);
                                arguments.sourceRect = new Rect(0f, 0f, 1f, 1f);
                                Graphics.DrawTexture(ref arguments);
                                break;
                            }
                            float num4 = imageAspect / num;
                            arguments.screenRect = new Rect(position.xMin   ((position.width * (1f - num4)) * 0.5f), position.yMin, num4 * position.width, position.height);
                            arguments.sourceRect = new Rect(0f, 0f, 1f, 1f);
                            Graphics.DrawTexture(ref arguments);
                            break;
                        }
                    }
                }
            }
        }
 
        public static void DrawTextureWithTexCoords(Rect position, Texture image, Rect texCoords)
        {
            bool alphaBlend = true;
            DrawTextureWithTexCoords(position, image, texCoords, alphaBlend);
        }
 
        public static void DrawTextureWithTexCoords(Rect position, Texture image, Rect texCoords, bool alphaBlend)
        {
            if (Event.current.type == EventType.Repaint)
            {
                Material material = !alphaBlend ? blitMaterial : blendMaterial;
                InternalDrawTextureArguments arguments = new InternalDrawTextureArguments {
                    texture = image,
                    leftBorder = 0,
                    rightBorder = 0,
                    topBorder = 0,
                    bottomBorder = 0,
                    color = color,
                    mat = material,
                    screenRect = position,
                    sourceRect = texCoords
                };
                Graphics.DrawTexture(ref arguments);
            }
        }
 
        public static void EndGroup()
        {
            GUIClip.Pop();
        }
 
        public static void EndScrollView()
        {
            EndScrollView(true);
        }
 
        public static void EndScrollView(bool handleScrollWheel)
        {
            ScrollViewState state = (ScrollViewState) s_ScrollViewStates.Peek();
            GUIUtility.CheckOnGUI();
            GUIClip.Pop();
            s_ScrollViewStates.Pop();
            if ((handleScrollWheel && (Event.current.type == EventType.ScrollWheel)) && state.position.Contains(Event.current.mousePosition))
            {
                state.scrollPosition.x = Mathf.Clamp((float) (state.scrollPosition.x   (Event.current.delta.x * 20f)), (float) 0f, (float) (state.viewRect.width - state.visibleRect.width));
                state.scrollPosition.y = Mathf.Clamp((float) (state.scrollPosition.y   (Event.current.delta.y * 20f)), (float) 0f, (float) (state.viewRect.height - state.visibleRect.height));
                state.apply = true;
                Event.current.Use();
            }
        }
 
        internal static void EndWindows()
        {
            GUILayoutGroup topLevel = GUILayoutUtility.current.topLevel;
            GenericStack layoutGroups = GUILayoutUtility.current.layoutGroups;
            GUILayoutGroup windows = GUILayoutUtility.current.windows;
            Internal_EndWindows();
            GUILayoutUtility.current.topLevel = topLevel;
            GUILayoutUtility.current.layoutGroups = layoutGroups;
            GUILayoutUtility.current.windows = windows;
        }
 
        internal static void FindStyles(ref GUIStyle style, out GUIStyle firstStyle, out GUIStyle midStyle, out GUIStyle lastStyle, string first, string mid, string last)
        {
            if (style == null)
            {
                style = skin.button;
            }
            string name = style.name;
            midStyle = skin.FindStyle(name   mid);
            if (midStyle == null)
            {
                midStyle = style;
            }
            firstStyle = skin.FindStyle(name   first);
            if (firstStyle == null)
            {
                firstStyle = midStyle;
            }
            lastStyle = skin.FindStyle(name   last);
            if (lastStyle == null)
            {
                lastStyle = midStyle;
            }
        }
 
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void FocusControl(string name);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void FocusWindow(int windowID);
        private static int GetButtonGridMouseSelection(Rect[] buttonRects, Vector2 mousePos, bool findNearest)
        {
            for (int i = 0; i < buttonRects.Length; i  )
            {
                if (buttonRects[i].Contains(mousePos))
                {
                    return i;
                }
            }
            if (!findNearest)
            {
                return -1;
            }
            float num2 = 1E 07f;
            int num3 = -1;
            for (int j = 0; j < buttonRects.Length; j  )
            {
                Rect rect = buttonRects[j];
                Vector2 vector = new Vector2(Mathf.Clamp(mousePos.x, rect.xMin, rect.xMax), Mathf.Clamp(mousePos.y, rect.yMin, rect.yMax));
                Vector2 vector2 = mousePos - vector;
                float sqrMagnitude = vector2.sqrMagnitude;
                if (sqrMagnitude < num2)
                {
                    num3 = j;
                    num2 = sqrMagnitude;
                }
            }
            return num3;
        }
 
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string GetNameOfFocusedControl();
        internal static ScrollViewState GetTopScrollView()
        {
            if (s_ScrollViewStates.Count != 0)
            {
                return (ScrollViewState) s_ScrollViewStates.Peek();
            }
            return null;
        }
 
        public static float HorizontalScrollbar(Rect position, float value, float size, float leftValue, float rightValue)
        {
            return Scroller(position, value, size, leftValue, rightValue, skin.horizontalScrollbar, skin.horizontalScrollbarThumb, skin.horizontalScrollbarLeftButton, skin.horizontalScrollbarRightButton, true);
        }
 
        public static float HorizontalScrollbar(Rect position, float value, float size, float leftValue, float rightValue, GUIStyle style)
        {
            return Scroller(position, value, size, leftValue, rightValue, style, skin.GetStyle(style.name   "thumb"), skin.GetStyle(style.name   "leftbutton"), skin.GetStyle(style.name   "rightbutton"), true);
        }
 
        public static float HorizontalSlider(Rect position, float value, float leftValue, float rightValue)
        {
            return Slider(position, value, 0f, leftValue, rightValue, skin.horizontalSlider, skin.horizontalSliderThumb, true, GUIUtility.GetControlID(sliderHash, FocusType.Native, position));
        }
 
        public static float HorizontalSlider(Rect position, float value, float leftValue, float rightValue, GUIStyle slider, GUIStyle thumb)
        {
            return Slider(position, value, 0f, leftValue, rightValue, slider, thumb, true, GUIUtility.GetControlID(sliderHash, FocusType.Native, position));
        }
 
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void InitializeGUIClipTexture();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void Internal_BeginWindows();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern bool INTERNAL_CALL_DoButton(ref Rect position, GUIContent content, IntPtr style);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void INTERNAL_CALL_DoLabel(ref Rect position, GUIContent content, IntPtr style);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern Rect INTERNAL_CALL_DoModalWindow(int id, ref Rect clientRect, WindowFunction func, GUIContent content, GUIStyle style, GUISkin skin);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern bool INTERNAL_CALL_DoToggle(ref Rect position, int id, bool value, GUIContent content, IntPtr style);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern Rect INTERNAL_CALL_DoWindow(int id, ref Rect clientRect, WindowFunction func, GUIContent title, GUIStyle style, GUISkin skin, bool forceRectOnLayout);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void INTERNAL_CALL_DragWindow(ref Rect position);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void Internal_EndWindows();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void INTERNAL_get_backgroundColor(out Color value);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void INTERNAL_get_color(out Color value);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void INTERNAL_get_contentColor(out Color value);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern string Internal_GetMouseTooltip();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern string Internal_GetTooltip();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void INTERNAL_set_backgroundColor(ref Color value);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void INTERNAL_set_color(ref Color value);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void INTERNAL_set_contentColor(ref Color value);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void Internal_SetTooltip(string value);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        internal static extern void InternalRepaintEditorWindow();
        public static void Label(Rect position, string text)
        {
            Label(position, GUIContent.Temp(text), s_Skin.label);
        }
 
        public static void Label(Rect position, GUIContent content)
        {
            Label(position, content, s_Skin.label);
        }
 
        public static void Label(Rect position, Texture image)
        {
            Label(position, GUIContent.Temp(image), s_Skin.label);
        }
 
        public static void Label(Rect position, string text, GUIStyle style)
        {
            Label(position, GUIContent.Temp(text), style);
        }
 
        public static void Label(Rect position, GUIContent content, GUIStyle style)
        {
            DoLabel(position, content, style.m_Ptr);
        }
 
        public static void Label(Rect position, Texture image, GUIStyle style)
        {
            Label(position, GUIContent.Temp(image), style);
        }
 
        public static Rect ModalWindow(int id, Rect clientRect, WindowFunction func, string text)
        {
            return DoModalWindow(id, clientRect, func, GUIContent.Temp(text), skin.window, skin);
        }
 
        public static Rect ModalWindow(int id, Rect clientRect, WindowFunction func, GUIContent content)
        {
            return DoModalWindow(id, clientRect, func, content, skin.window, skin);
        }
 
        public static Rect ModalWindow(int id, Rect clientRect, WindowFunction func, Texture image)
        {
            return DoModalWindow(id, clientRect, func, GUIContent.Temp(image), skin.window, skin);
        }
 
        public static Rect ModalWindow(int id, Rect clientRect, WindowFunction func, string text, GUIStyle style)
        {
            return DoModalWindow(id, clientRect, func, GUIContent.Temp(text), style, skin);
        }
 
        public static Rect ModalWindow(int id, Rect clientRect, WindowFunction func, GUIContent content, GUIStyle style)
        {
            return DoModalWindow(id, clientRect, func, content, style, skin);
        }
 
        public static Rect ModalWindow(int id, Rect clientRect, WindowFunction func, Texture image, GUIStyle style)
        {
            return DoModalWindow(id, clientRect, func, GUIContent.Temp(image), style, skin);
        }
 
        public static string PasswordField(Rect position, string password, char maskChar)
        {
            return PasswordField(position, password, maskChar, -1, skin.textField);
        }
 
        public static string PasswordField(Rect position, string password, char maskChar, int maxLength)
        {
            return PasswordField(position, password, maskChar, maxLength, skin.textField);
        }
 
        public static string PasswordField(Rect position, string password, char maskChar, GUIStyle style)
        {
            return PasswordField(position, password, maskChar, -1, style);
        }
 
        public static string PasswordField(Rect position, string password, char maskChar, int maxLength, GUIStyle style)
        {
            GUIContent content = GUIContent.Temp(PasswordFieldGetStrToShow(password, maskChar));
            bool changed = GUI.changed;
            GUI.changed = false;
            DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), content, false, maxLength, style);
            string str = !GUI.changed ? password : content.text;
            GUI.changed |= changed;
            return str;
        }
 
        internal static string PasswordFieldGetStrToShow(string password, char maskChar)
        {
            return (((Event.current.type != EventType.Repaint) && (Event.current.type != EventType.MouseDown)) ? password : string.Empty.PadRight(password.Length, maskChar));
        }
 
        public static bool RepeatButton(Rect position, string text)
        {
            return DoRepeatButton(position, GUIContent.Temp(text), s_Skin.button, FocusType.Native);
        }
 
        public static bool RepeatButton(Rect position, GUIContent content)
        {
            return DoRepeatButton(position, content, s_Skin.button, FocusType.Native);
        }
 
        public static bool RepeatButton(Rect position, Texture image)
        {
            return DoRepeatButton(position, GUIContent.Temp(image), s_Skin.button, FocusType.Native);
        }
 
        public static bool RepeatButton(Rect position, string text, GUIStyle style)
        {
            return DoRepeatButton(position, GUIContent.Temp(text), style, FocusType.Native);
        }
 
        public static bool RepeatButton(Rect position, GUIContent content, GUIStyle style)
        {
            return DoRepeatButton(position, content, style, FocusType.Native);
        }
 
        public static bool RepeatButton(Rect position, Texture image, GUIStyle style)
        {
            return DoRepeatButton(position, GUIContent.Temp(image), style, FocusType.Native);
        }
 
        private static float Scroller(Rect position, float value, float size, float leftValue, float rightValue, GUIStyle slider, GUIStyle thumb, GUIStyle leftButton, GUIStyle rightButton, bool horiz)
        {
            Rect rect;
            Rect rect2;
            Rect rect3;
            GUIUtility.CheckOnGUI();
            int id = GUIUtility.GetControlID(sliderHash, FocusType.Passive, position);
            if (horiz)
            {
                rect = new Rect(position.x   leftButton.fixedWidth, position.y, (position.width - leftButton.fixedWidth) - rightButton.fixedWidth, position.height);
                rect2 = new Rect(position.x, position.y, leftButton.fixedWidth, position.height);
                rect3 = new Rect(position.xMax - rightButton.fixedWidth, position.y, rightButton.fixedWidth, position.height);
            }
            else
            {
                rect = new Rect(position.x, position.y   leftButton.fixedHeight, position.width, (position.height - leftButton.fixedHeight) - rightButton.fixedHeight);
                rect2 = new Rect(position.x, position.y, position.width, leftButton.fixedHeight);
                rect3 = new Rect(position.x, position.yMax - rightButton.fixedHeight, position.width, rightButton.fixedHeight);
            }
            value = Slider(rect, value, size, leftValue, rightValue, slider, thumb, horiz, id);
            bool flag = false;
            if (Event.current.type == EventType.MouseUp)
            {
                flag = true;
            }
            if (ScrollerRepeatButton(id, rect2, leftButton))
            {
                value -= scrollStepSize * ((leftValue >= rightValue) ? -1f : 1f);
            }
            if (ScrollerRepeatButton(id, rect3, rightButton))
            {
                value  = scrollStepSize * ((leftValue >= rightValue) ? -1f : 1f);
            }
            if (flag && (Event.current.type == EventType.Used))
            {
                scrollControlID = 0;
            }
            if (leftValue < rightValue)
            {
                value = Mathf.Clamp(value, leftValue, rightValue - size);
                return value;
            }
            value = Mathf.Clamp(value, rightValue, leftValue - size);
            return value;
        }
 
        internal static bool ScrollerRepeatButton(int scrollerID, Rect rect, GUIStyle style)
        {
            bool flag = false;
            if (DoRepeatButton(rect, GUIContent.none, style, FocusType.Passive))
            {
                bool flag2 = scrollControlID != scrollerID;
                scrollControlID = scrollerID;
                if (flag2)
                {
                    flag = true;
                    nextScrollStepTime = DateTime.Now.AddMilliseconds(250.0);
                }
                else if (DateTime.Now >= nextScrollStepTime)
                {
                    flag = true;
                    nextScrollStepTime = DateTime.Now.AddMilliseconds(30.0);
                }
                if (Event.current.type == EventType.Repaint)
                {
                    InternalRepaintEditorWindow();
                }
            }
            return flag;
        }
 
        public static void ScrollTo(Rect position)
        {
            GetTopScrollView().ScrollTo(GUIClip.Unclip(position));
        }
 
        public static int SelectionGrid(Rect position, int selected, string[] texts, int xCount)
        {
            return SelectionGrid(position, selected, GUIContent.Temp(texts), xCount, null);
        }
 
        public static int SelectionGrid(Rect position, int selected, GUIContent[] content, int xCount)
        {
            return SelectionGrid(position, selected, content, xCount, null);
        }
 
        public static int SelectionGrid(Rect position, int selected, Texture[] images, int xCount)
        {
            return SelectionGrid(position, selected, GUIContent.Temp(images), xCount, null);
        }
 
        public static int SelectionGrid(Rect position, int selected, string[] texts, int xCount, GUIStyle style)
        {
            return SelectionGrid(position, selected, GUIContent.Temp(texts), xCount, style);
        }
 
        public static int SelectionGrid(Rect position, int selected, GUIContent[] contents, int xCount, GUIStyle style)
        {
            if (style == null)
            {
                style = s_Skin.button;
            }
            return DoButtonGrid(position, selected, contents, xCount, style, style, style, style);
        }
 
        public static int SelectionGrid(Rect position, int selected, Texture[] images, int xCount, GUIStyle style)
        {
            return SelectionGrid(position, selected, GUIContent.Temp(images), xCount, style);
        }
 
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void SetNextControlName(string name);
        public static float Slider(Rect position, float value, float size, float start, float end, GUIStyle slider, GUIStyle thumb, bool horiz, int id)
        {
            GUIUtility.CheckOnGUI();
            SliderHandler handler = new SliderHandler(position, value, size, start, end, slider, thumb, horiz, id);
            return handler.Handle();
        }
 
        public static string TextArea(Rect position, string text)
        {
            GUIContent content = GUIContent.Temp(text);
            DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), content, true, -1, skin.textArea);
            return content.text;
        }
 
        public static string TextArea(Rect position, string text, int maxLength)
        {
            GUIContent content = GUIContent.Temp(text);
            DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), content, true, maxLength, skin.textArea);
            return content.text;
        }
 
        public static string TextArea(Rect position, string text, GUIStyle style)
        {
            GUIContent content = GUIContent.Temp(text);
            DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), content, true, -1, style);
            return content.text;
        }
 
        public static string TextArea(Rect position, string text, int maxLength, GUIStyle style)
        {
            GUIContent content = GUIContent.Temp(text);
            DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), content, false, maxLength, style);
            return content.text;
        }
 
        private static string TextArea(Rect position, GUIContent content, int maxLength, GUIStyle style)
        {
            GUIContent content2 = GUIContent.Temp(content.text, content.image);
            DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), content2, false, maxLength, style);
            return content2.text;
        }
 
        public static string TextField(Rect position, string text)
        {
            GUIContent content = GUIContent.Temp(text);
            DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), content, false, -1, skin.textField);
            return content.text;
        }
 
        public static string TextField(Rect position, string text, int maxLength)
        {
            GUIContent content = GUIContent.Temp(text);
            DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), content, false, maxLength, skin.textField);
            return content.text;
        }
 
        public static string TextField(Rect position, string text, GUIStyle style)
        {
            GUIContent content = GUIContent.Temp(text);
            DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), content, false, -1, style);
            return content.text;
        }
 
        public static string TextField(Rect position, string text, int maxLength, GUIStyle style)
        {
            GUIContent content = GUIContent.Temp(text);
            DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), content, true, maxLength, style);
            return content.text;
        }
 
        public static bool Toggle(Rect position, bool value, string text)
        {
            return Toggle(position, value, GUIContent.Temp(text), s_Skin.toggle);
        }
 
        public static bool Toggle(Rect position, bool value, GUIContent content)
        {
            return Toggle(position, value, content, s_Skin.toggle);
        }
 
        public static bool Toggle(Rect position, bool value, Texture image)
        {
            return Toggle(position, value, GUIContent.Temp(image), s_Skin.toggle);
        }
 
        public static bool Toggle(Rect position, bool value, string text, GUIStyle style)
        {
            return Toggle(position, value, GUIContent.Temp(text), style);
        }
 
        public static bool Toggle(Rect position, bool value, GUIContent content, GUIStyle style)
        {
            return DoToggle(position, GUIUtility.GetControlID(toggleHash, FocusType.Native, position), value, content, style.m_Ptr);
        }
 
        public static bool Toggle(Rect position, bool value, Texture image, GUIStyle style)
        {
            return Toggle(position, value, GUIContent.Temp(image), style);
        }
 
        public static int Toolbar(Rect position, int selected, string[] texts)
        {
            return Toolbar(position, selected, GUIContent.Temp(texts), s_Skin.button);
        }
 
        public static int Toolbar(Rect position, int selected, GUIContent[] content)
        {
            return Toolbar(position, selected, content, s_Skin.button);
        }
 
        public static int Toolbar(Rect position, int selected, Texture[] images)
        {
            return Toolbar(position, selected, GUIContent.Temp(images), s_Skin.button);
        }
 
        public static int Toolbar(Rect position, int selected, string[] texts, GUIStyle style)
        {
            return Toolbar(position, selected, GUIContent.Temp(texts), style);
        }
 
        public static int Toolbar(Rect position, int selected, GUIContent[] contents, GUIStyle style)
        {
            GUIStyle style2;
            GUIStyle style3;
            GUIStyle style4;
            FindStyles(ref style, out style2, out style3, out style4, "left", "mid", "right");
            return DoButtonGrid(position, selected, contents, contents.Length, style, style2, style3, style4);
        }
 
        public static int Toolbar(Rect position, int selected, Texture[] images, GUIStyle style)
        {
            return Toolbar(position, selected, GUIContent.Temp(images), style);
        }
 
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void UnfocusWindow();
        public static float VerticalScrollbar(Rect position, float value, float size, float topValue, float bottomValue)
        {
            return Scroller(position, value, size, topValue, bottomValue, skin.verticalScrollbar, skin.verticalScrollbarThumb, skin.verticalScrollbarUpButton, skin.verticalScrollbarDownButton, false);
        }
 
        public static float VerticalScrollbar(Rect position, float value, float size, float topValue, float bottomValue, GUIStyle style)
        {
            return Scroller(position, value, size, topValue, bottomValue, style, skin.GetStyle(style.name   "thumb"), skin.GetStyle(style.name   "upbutton"), skin.GetStyle(style.name   "downbutton"), false);
        }
 
        public static float VerticalSlider(Rect position, float value, float topValue, float bottomValue)
        {
            return Slider(position, value, 0f, topValue, bottomValue, skin.verticalSlider, skin.verticalSliderThumb, false, GUIUtility.GetControlID(sliderHash, FocusType.Native, position));
        }
 
        public static float VerticalSlider(Rect position, float value, float topValue, float bottomValue, GUIStyle slider, GUIStyle thumb)
        {
            return Slider(position, value, 0f, topValue, bottomValue, slider, thumb, false, GUIUtility.GetControlID(sliderHash, FocusType.Native, position));
        }
 
        public static Rect Window(int id, Rect clientRect, WindowFunction func, string text)
        {
            return DoWindow(id, clientRect, func, GUIContent.Temp(text), skin.window, skin, true);
        }
 
        public static Rect Window(int id, Rect clientRect, WindowFunction func, GUIContent content)
        {
            return DoWindow(id, clientRect, func, content, skin.window, skin, true);
        }
 
        public static Rect Window(int id, Rect clientRect, WindowFunction func, Texture image)
        {
            return DoWindow(id, clientRect, func, GUIContent.Temp(image), skin.window, skin, true);
        }
 
        public static Rect Window(int id, Rect clientRect, WindowFunction func, string text, GUIStyle style)
        {
            return DoWindow(id, clientRect, func, GUIContent.Temp(text), style, skin, true);
        }
 
        public static Rect Window(int id, Rect clientRect, WindowFunction func, GUIContent title, GUIStyle style)
        {
            return DoWindow(id, clientRect, func, title, style, skin, true);
        }
 
        public static Rect Window(int id, Rect clientRect, WindowFunction func, Texture image, GUIStyle style)
        {
            return DoWindow(id, clientRect, func, GUIContent.Temp(image), style, skin, true);
        }
 
        public static Color backgroundColor
        {
            get
            {
                Color color;
                INTERNAL_get_backgroundColor(out color);
                return color;
            }
            set
            {
                INTERNAL_set_backgroundColor(ref value);
            }
        }
 
        private static Material blendMaterial { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
 
        private static Material blitMaterial { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
 
        public static bool changed { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
 
        public static Color color
        {
            get
            {
                Color color;
                INTERNAL_get_color(out color);
                return color;
            }
            set
            {
                INTERNAL_set_color(ref value);
            }
        }
 
        public static Color contentColor
        {
            get
            {
                Color color;
                INTERNAL_get_contentColor(out color);
                return color;
            }
            set
            {
                INTERNAL_set_contentColor(ref value);
            }
        }
 
        public static int depth { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
 
        public static bool enabled { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
 
        public static Matrix4x4 matrix
        {
            get
            {
                return GUIClip.GetMatrix();
            }
            set
            {
                GUIClip.SetMatrix(value);
            }
        }
 
        protected static string mouseTooltip
        {
            get
            {
                return Internal_GetMouseTooltip();
            }
        }
 
        internal static DateTime nextScrollStepTime
        {
            [CompilerGenerated]
            get
            {
                return <nextScrollStepTime>k__BackingField;
            }
            [CompilerGenerated]
            set
            {
                <nextScrollStepTime>k__BackingField = value;
            }
        }
 
        internal static int scrollTroughSide
        {
            [CompilerGenerated]
            get
            {
                return <scrollTroughSide>k__BackingField;
            }
            [CompilerGenerated]
            set
            {
                <scrollTroughSide>k__BackingField = value;
            }
        }
 
        public static GUISkin skin
        {
            get
            {
                GUIUtility.CheckOnGUI();
                return s_Skin;
            }
            set
            {
                GUIUtility.CheckOnGUI();
                if (value == null)
                {
                    value = GUIUtility.GetDefaultSkin();
                }
                s_Skin = value;
                value.MakeCurrent();
            }
        }
 
        public static string tooltip
        {
            get
            {
                string str = Internal_GetTooltip();
                if (str != null)
                {
                    return str;
                }
                return string.Empty;
            }
            set
            {
                Internal_SetTooltip(value);
            }
        }
 
        protected static Rect tooltipRect
        {
            get
            {
                return s_ToolTipRect;
            }
            set
            {
                s_ToolTipRect = value;
            }
        }
 
        internal static bool usePageScrollbars { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
 
        internal sealed class ScrollViewState
        {
            public bool apply;
            public bool hasScrollTo;
            public Rect position;
            public Vector2 scrollPosition;
            public Rect scrollTo;
            public Rect viewRect;
            public Rect visibleRect;
 
            internal void ScrollTo(Rect position)
            {
                Vector2 vector = new Vector2(position.xMin, position.yMin);
                if (!this.hasScrollTo)
                {
                    this.hasScrollTo = true;
                    this.scrollTo.xMin = vector.x;
                    this.scrollTo.yMin = vector.y;
                    vector = new Vector2(position.xMax, position.yMax);
                    this.scrollTo.xMax = vector.x;
                    this.scrollTo.yMax = vector.y;
                    this.hasScrollTo = true;
                    Rect visibleRect = this.visibleRect;
                    visibleRect.x  = this.scrollPosition.x;
                    visibleRect.y  = this.scrollPosition.y;
                    Vector2 vector2 = new Vector2(this.scrollTo.xMax, this.scrollTo.yMax);
                    Vector2 vector3 = new Vector2(this.scrollTo.xMin, this.scrollTo.yMin);
                    if (vector2.x > visibleRect.xMax)
                    {
                        this.scrollPosition.x  = vector2.x - visibleRect.xMax;
                    }
                    if (vector3.x < visibleRect.xMin)
                    {
                        this.scrollPosition.x -= visibleRect.xMin - vector3.x;
                    }
                    if (vector2.y > visibleRect.yMax)
                    {
                        this.scrollPosition.y  = vector2.y - visibleRect.yMax;
                    }
                    if (vector3.y < visibleRect.yMin)
                    {
                        this.scrollPosition.y -= visibleRect.yMin - vector3.y;
                    }
                    this.apply = true;
                    this.hasScrollTo = false;
                }
                else
                {
                    this.scrollTo.x = Mathf.Min(vector.x, this.scrollTo.x);
                    this.scrollTo.y = Mathf.Min(vector.y, this.scrollTo.y);
                    vector = new Vector2(position.xMax, position.yMax);
                    this.scrollTo.xMax = Mathf.Max(vector.x, this.scrollTo.xMax);
                    this.scrollTo.yMax = Mathf.Max(vector.y, this.scrollTo.yMax);
                }
            }
        }
 
        public delegate void WindowFunction(int id);
    }
}
标签： C# unity3D
实例下载地址

UnityEngineSourceCode

点此下载实例
不能下载？内容有错？点击这里报错 + 投诉 + 提问
好例子网口号：伸出你的我的手 — 分享！
网友评论

我要评论
小贴士

感谢您为本站写下的评论，您的评论对其它用户来说具有重要的参考价值，所以请认真填写。
类似“顶”、“沙发”之类没有营养的文字，对勤劳贡献的楼主来说是令人沮丧的反馈信息。
相信您也不想看到一排文字/表情墙，所以请不要反馈意义不大的重复字符，也请尽量不要纯表情的回复。
提问之前请再仔细看一遍楼主的说明，或许是您遗漏了。
请勿到处挖坑绊人、招贴广告。既占空间让人厌烦，又没人会搭理，于人于己都无利。
关于好例子网

本站旨在为广大IT学习爱好者提供一个非营利性互相学习交流分享平台。本站所有资源都可以被免费获取学习研究。本站资源来自网友分享，对搜索内容的合法性不具有预见性、识别性、控制性，仅供学习研究，请务必在下载后24小时内给予删除，不得用于其他任何用途，否则后果自负。基于互联网的特殊性，平台无法对用户传输的作品、信息、内容的权属或合法性、安全性、合规性、真实性、科学性、完整权、有效性等进行实质审查；无论平台是否已进行审查，用户均应自行承担因其传输的作品、信息、内容而可能或已经产生的侵权或权属纠纷等法律责任。本站所有资源不代表本站的观点或立场，基于网友分享，根据中国法律《信息网络传播权保护条例》第二十二与二十三条之规定，若资源存在侵权或相关问题请联系本站客服人员，点此联系我们。关于更多版权及免责申明参见版权及免责申明
UnityEngineSourceCode

同类人气实例

实例介绍

实例下载地址

UnityEngineSourceCode

相关软件

相关文章

网友评论

小贴士

关于好例子网

下载周排行

下载总排行
