UnityEngine.GUI.BeginScrollView(UnityEngine.Rect, UnityEngine.Vector2, UnityEngine.Rect, bool, bool, UnityEngine.GUIStyle, UnityEngine.GUIStyle)

public void Draw()
        {
            if (DrawInner == null) return;

            if (AreaInner.width <= 0)
            {
                AreaInner = new Rect(0, 0, AreaOuter.width - WidthScrollLine, AreaOuter.height);
            }
            if (AreaInner.width <= 0) return;

            ScrollPosition = GUI.BeginScrollView(
                AreaOuter
                , ScrollPosition
                , AreaInner);
            var rectDraw = DrawInner(AreaInner);
            GUI.EndScrollView();
            if (rectDraw.height > AreaInner.height) AreaInner.height = rectDraw.height;
            if (AreaOuter.height > AreaInner.height) AreaInner.height = AreaOuter.height;
        }

public void Drow(Rect chatAreaOuter, bool scrollToDown = false)
        {
            var chatAreaInner = new Rect(0, 0, chatAreaOuter.width - ListBox<string>.WidthScrollLine, 0);
            if (chatAreaInner.width <= 0) return;
            //chatAreaInner.height = Text.CalcHeight(ChatText, chatAreaInner.width);
            GUI.skin.textField.wordWrap = true;
            chatAreaInner.height = GUI.skin.textField.CalcHeight(new GUIContent(Text), chatAreaInner.width);
            //if (chatAreaInner.height > chatAreaOuter.height) chatAreaInner.height -= chatAreaOuter.height;
            if (scrollToDown)
            {
                ScrollPosition.y = chatAreaInner.height - chatAreaOuter.height;
            }

            ScrollPosition = GUI.BeginScrollView(chatAreaOuter, ScrollPosition, chatAreaInner);
            GUILayout.BeginArea(chatAreaInner);
            var text = GUILayout.TextArea(Text ?? "", "Label");
            if (Editable)
            {
                Text = text;
            }
            GUILayout.EndArea();
            GUI.EndScrollView();


        }

public virtual void Drow()
        {
            if (DataSource == null) return;
            if (LineHeight == 0) LineHeight = TextHeight;

            ScrollPosition = GUI.BeginScrollView(
                Area
                , ScrollPosition
                , new Rect(0, 0, Area.width - WidthScrollLine, DataSource.Count * LineHeight));
            
            var rect = new Rect(0, 0, Area.width - WidthScrollLine, LineHeight);
            for (int i = 0; i < DataSource.Count; i++)
            {
                //светлый фон каждой второй строки
                if (OddLineHighlight && i % 2 == 1)
                {
                    Widgets.DrawAltRect(rect);
                }

                //отрисовка строки
                DrowLine(i, DataSource[i], rect);

                //выделенная строка
                if (ShowSelected && i == SelectedIndex)
                {
                    Widgets.DrawHighlightSelected(rect);
                    //Widgets.DrawHighlight(rect);
                }
                //подсветка строки под курсором
                if (!OddLineHighlight && Mouse.IsOver(rect))
                {
                    Widgets.DrawHighlight(rect);
                }
                //всплывающая подсказка
                if (Tooltip != null)
                {
                    var tt = Tooltip(DataSource[i]);
                    if (!string.IsNullOrEmpty(tt))
                    {
                        TooltipHandler.TipRegion(rect, tt);
                    }
                }

                //событие нажатия на строку
                if (Widgets.ButtonInvisible(rect))
                {
                    SelectedIndex = i;
                    if (OnClick != null) OnClick(i, DataSource[i]);
                }
                rect.y += LineHeight;
            }

            GUI.EndScrollView();
        }

public static Vector2 BeginScrollView(Rect position, Vector2 scrollView, Rect viewRect)
        {
            return UGUI.BeginScrollView(position, scrollView, viewRect, Style.ScrollView, Style.ScrollView);
        }

public static Vector2 BeginScrollView(Rect position, Vector2 scrollView, Rect viewRect, bool alwaysHorizontal, bool alwaysVertical)
        {
            return UGUI.BeginScrollView(position, scrollView, viewRect, alwaysHorizontal, alwaysVertical, Style.ScrollView, Style.ScrollView);
        }

public static Vector2 BeginScrollView(SmartRect position, Vector2 scrollView, Rect viewRect, bool move = false)
        {
            scrollView = UGUI.BeginScrollView(position.ToRect(), scrollView, viewRect, Style.ScrollView, Style.ScrollView);
            if (move)
            {
                position.MoveY();
            }

            return scrollView;
        }

public static Vector2 BeginScrollView(SmartRect position, Vector2 scrollView, Rect viewRect, bool alwaysHorizontal, bool alwaysVertical, bool move = false)
        {
            scrollView = UGUI.BeginScrollView(position.ToRect(), scrollView, viewRect, alwaysHorizontal, alwaysVertical, Style.ScrollView, Style.ScrollView);
            if (move)
            {
                position.MoveY();
            }

            return scrollView;
        }

public void Render(Rect rect, IEnumerable<T> itemList, float elementHeight = 20f, float elementPadding = 1f)
        {
            var totalElementHeight = elementHeight + elementPadding;
            var width = rect.width;
            var height = rect.height;

            if (!object.ReferenceEquals(itemList, _itemList))
            {
                _itemList = itemList;
                _filteredList = null;
            }

            GUI.BeginGroup(rect);

            // Search Field
            var searchFieldRect = new Rect(5f, 5f, width - 25f, elementHeight);
            var lastSearchString = _searchString;
            GUI.SetNextControlName("Apex_ListView_Search");
            _searchString = EditorGUI.TextField(searchFieldRect, _searchString, SharedStyles.BuiltIn.searchFieldStyle);
            EditorGUI.FocusTextInControl("Apex_ListView_Search");

            var searchCancelRect = new Rect(searchFieldRect.x + searchFieldRect.width, 5f, 10f, elementHeight);
            if (GUI.Button(searchCancelRect, GUIContent.none, string.IsNullOrEmpty(_searchString) ? SharedStyles.BuiltIn.searchCancelButtonEmpty : SharedStyles.BuiltIn.searchCancelButton))
            {
                _searchString = string.Empty;
                GUIUtility.keyboardControl = 0;
            }

            // filter list based on search string
            if (_filteredList == null || !string.Equals(lastSearchString, _searchString, StringComparison.OrdinalIgnoreCase))
            {
                if (string.IsNullOrEmpty(_searchString))
                {
                    _filteredList = _itemList as T[];
                    if (_filteredList == null)
                    {
                        _filteredList = _itemList.ToArray();
                    }
                }
                else
                {
                    _filteredList = _itemList.Where(t => _searchPredicate(t, _searchString)).ToArray();
                }

                _selectRangeStart = _selectRangeEnd = -1;
                _selectedIndexes.Clear();
            }

            // Scroll View
            var noneItemAdjust = _allowNoneSelect ? 1 : 0;
            float listStartY = searchFieldRect.y + searchFieldRect.height + 5f;
            var scrollViewRect = new Rect(0f, listStartY, width, height - listStartY);
            var innerScrollView = new Rect(0f, 0f, scrollViewRect.width - 20f, (_filteredList.Length + noneItemAdjust) * totalElementHeight);

            //Do preselect if applicable
            var evt = Event.current;
            if (evt != null && evt.type == EventType.Repaint && _selectPredicate != null)
            {
                _selectedIndexes.AddRange(_filteredList.Select((item, idx) => _selectPredicate(item) ? idx : -1).Where(idx => idx >= 0));
                if (_selectedIndexes.Count > 0)
                {
                    _selectRangeStart = _selectRangeEnd = _selectedIndexes.Min();
                    EnsureInView(_selectRangeStart, totalElementHeight, scrollViewRect.height);
                }

                _selectPredicate = null;
            }

            _scrollPos = GUI.BeginScrollView(scrollViewRect, _scrollPos, innerScrollView);

            // Element List
            int startIdx = Math.Max(Mathf.FloorToInt(_scrollPos.y / totalElementHeight) - noneItemAdjust, 0);
            int endIdx = Math.Min(startIdx + Mathf.CeilToInt(Mathf.Min(scrollViewRect.height, innerScrollView.height) / totalElementHeight), _filteredList.Length);

            if (_allowNoneSelect && _scrollPos.y < totalElementHeight)
            {
                var itemRect = new Rect(2f, 0f, innerScrollView.width, elementHeight);

                var style = _noneSelected ? SharedStyles.BuiltIn.objectSelectorBoxActive : SharedStyles.BuiltIn.objectSelectorBoxNormal;
                GUI.Box(itemRect, "None", style);
            }

            var currentY = (startIdx + noneItemAdjust) * totalElementHeight;
            for (var i = startIdx; i < endIdx; i++)
            {
                var item = _filteredList[i];
                var itemRect = new Rect(2f, currentY, innerScrollView.width, elementHeight);

                var style = _selectedIndexes.Contains(i) ? SharedStyles.BuiltIn.objectSelectorBoxActive : SharedStyles.BuiltIn.objectSelectorBoxNormal;
                GUI.Box(itemRect, _itemRenderer(item), style);

                currentY += totalElementHeight;
            }

            GUI.EndScrollView();

            //Handle mouse clicks and key presses
            if (evt.type == EventType.MouseDown && evt.button == MouseButton.left)
            {
                evt.Use();
                float adjustedMouseY = evt.mousePosition.y + (_scrollPos.y - listStartY);
                var index = Mathf.FloorToInt(adjustedMouseY / totalElementHeight) - noneItemAdjust;

                if (_allowNoneSelect && index < 0)
                {
                    SelectNone();
                }
                else if (_allowMultiSelect)
                {
                    if (evt.command || evt.control)
                    {
                        SingleToggle(index);
                    }
                    else if (evt.shift)
                    {
                        RangeSelect(index);
                    }
                    else
                    {
                        SingleSelect(index);
                    }
                }
                else
                {
                    SingleSelect(index);
                }

                //We allow double-click selection under all cirreplacedstances
                _singleSelected = (_onSelect != null) && (evt.clickCount == 2) && (_selectedIndexes.Count == 1 || _noneSelected);
                if (!_singleSelected)
                {
                    _owner.Repaint();
                }
            }
            else if (evt.type == EventType.MouseUp && evt.button == MouseButton.left)
            {
                evt.Use();

                if (_singleSelected)
                {
                    // double click detected
                    DoSelect();
                }
            }
            else if (evt.type == EventType.KeyUp)
            {
                if (evt.keyCode == KeyCode.DownArrow)
                {
                    evt.Use();

                    if (_selectRangeStart < 0 && _allowNoneSelect && !_noneSelected)
                    {
                        SelectNone();
                    }
                    else if (_allowMultiSelect && evt.shift)
                    {
                        RangeSelect(_selectRangeEnd + 1);
                    }
                    else
                    {
                        SingleSelect(_selectRangeStart + 1);
                    }

                    EnsureInView(_selectRangeEnd, totalElementHeight, scrollViewRect.height);
                }
                else if (evt.keyCode == KeyCode.UpArrow)
                {
                    evt.Use();

                    if (_selectRangeStart == 0 && _selectRangeEnd == 0 && _allowNoneSelect)
                    {
                        SelectNone();
                    }
                    else if (_selectRangeEnd < 0 && !_noneSelected)
                    {
                        SingleSelect(_filteredList.Length - 1);
                    }
                    else if (_allowMultiSelect && evt.shift)
                    {
                        RangeSelect(_selectRangeEnd - 1);
                    }
                    else
                    {
                        SingleSelect(_selectRangeStart - 1);
                    }

                    EnsureInView(_selectRangeStart, totalElementHeight, scrollViewRect.height);
                }
                else if (evt.keyCode == KeyCode.A && (evt.control || evt.command))
                {
                    evt.Use();
                    _noneSelected = false;
                    AddSelected(0, _filteredList.Length - 1);
                }
                else if (evt.keyCode == KeyCode.Return || evt.keyCode == KeyCode.KeypadEnter)
                {
                    evt.Use();

                    if (_onSelect != null && (_selectedIndexes.Count > 0 || _noneSelected))
                    {
                        DoSelect();
                    }
                }
            }

            GUI.EndGroup();
        }

void AddonsMenu(int id)
        {
            if (id == 0)
            {
                var list = ULTRAKIT.Loader.AddonLoader.addons;

                if (GUI.Button(new Rect(5, 5, addonMenuWidth - 10, 50), $"Addons:{list.Count}"))
                {
                }

                active = true;

                if (active)
                {
                    if (list.Count > 20)
                    {
                        Scroll = GUI.BeginScrollView(new Rect(5, 60, 155, 800), Scroll, _scroll, false, false);
                        for (int i = 0; i < list.Count; i++)
                        {
                            if (GUI.Button(new Rect(5, 60 + (35 * (i)), addonMenuWidth - 10, 30), list.ElementAt(i)?.Data?.ModName ?? "Unnamed Mod"))
                            {
                                Selected = list.ElementAt(i);
                            }
                            _scroll = new Rect(5, 60, 155, 95 + (35 * i));
                            if (wind.height > 800)
                            {
                                wind.height = 800;
                            }
                            else
                            {
                                wind.height = 95 + (35 * i);
                            }
                        }
                        GUI.EndScrollView();
                    }
                    else
                    {
                        for (int i = 0; i < list.Count; i++)
                        {
                            if(list.ElementAt(i).Enabled == false)
                            {
                                if (GUI.Button(new Rect(5, 60 + (35 * (i)), addonMenuWidth - 10, 30), $"<color=grey>{list.ElementAt(i)?.Data?.ModName ?? "Unnamed Mod "}</color>"))
                                {
                                    Selected = list.ElementAt(i);
                                }
                            }
                            else
                            {
                                if (GUI.Button(new Rect(5, 60 + (35 * (i)), addonMenuWidth - 10, 30), list.ElementAt(i)?.Data?.ModName ?? "Unnamed Mod "))
                                {
                                    Selected = list.ElementAt(i);
                                }
                            }
                            wind.height = 95 + (35 * i);//95 + (35 * i)
                        }
                    }
                }
                else
                {
                    wind = guirect;
                }
            }
        }

private void OnGUI() {

			if(lastPreplacedDetectedNoWebTestsSoDisplayDebugAsExample && testsAndTheirDependenciesList.Count == 0) {

				MapDependencies();

			}

			GUIStyle refButton = new GUIStyle(GUI.skin.button);
			refButton.normal.textColor = EditorGUIUtility.isProSkin ? Color.white : Color.black;
			Color defaultBgColor = GUI.backgroundColor;
			GUI.backgroundColor = Color.gray;
			if(GUI.Button(new Rect(0,0,75, 25), "Refresh", refButton)) {
				
				inspectedNodeWindow = -1;
				RenderedNodes = new List<DependencyNode>();
				testsAndTheirDependenciesList = new List<KeyValuePair<string, string[]>>();
				DependencyWebs = new List<DependencyNode>();
				MapDependencies();

			}
			GUI.backgroundColor = defaultBgColor;

			Rect allSize = new Rect(0, 0, lastRenderX + infoBoxMinWidth, maxWindowY + infoBoxMinWidth);
			scroll = GUI.BeginScrollView(new Rect(0, 0, lastRenderX, lastRenderY), scroll, new Rect(0, 0, lastRenderX + infoBoxMinWidth, lastRenderY + infoBoxMinWidth), GUIStyle.none, GUIStyle.none);
			GUI.Box(allSize, string.Empty);

			for(int all = 0; all < DependencyWebs.Count; all++) {

				int index = 0;
				DependencyNode parentNode = DependencyWebs[all];
				if(!RenderedNodes.Where(x => x.TestName == parentNode.TestName).Any()) {
					RenderedNodes.Add(parentNode);
					index = RenderedNodes.Count - 1;
					float width = DetermineRectWidthBasedOnLengthOfString(RenderedNodes[index].TestName);
					Rect newRect = originRect;
					newRect.width = width; 
					RenderedNodes[index].rect = GenerateNewNonOverlappingRectPositionForNewNode(newRect);
				} else { 
					index = RenderedNodes.FindIndex(a => a.TestName == parentNode.TestName);
				}

				//Create new node, or find existing one, and draw lines between this node and the dependency.
				List<KeyValuePair<DependencyNodeConnectionType,string>> LinkedNodeTestNames = RenderedNodes[index].Dependencies.ToList();
				for(int s = 0; s < LinkedNodeTestNames.Count; s++) {

					if(LinkedNodeTestNames[s].Key == DependencyNodeConnectionType.Incoming) {

						string testName = LinkedNodeTestNames[s].Value;
						DependencyNode thisNode = new DependencyNode();

						int indexChild = 0;

						List<DependencyNode> match = RenderedNodes.Where(x => x.TestName == testName).ToList();
						if(!match.Any()) {
							thisNode.TestName = testName;
							thisNode.Dependencies = DependencyWebs.Where(x => x.TestName == thisNode.TestName).Select(x => x.Dependencies).Single();
							RenderedNodes.Add(thisNode);
							indexChild = RenderedNodes.Count - 1;
							float width = DetermineRectWidthBasedOnLengthOfString(RenderedNodes[indexChild].TestName);
							Rect newRect = RenderedNodes[all].rect;
							newRect.width = width; 
							RenderedNodes[indexChild].rect = GenerateNewNonOverlappingRectPositionForNewNode(newRect);
						} else {
							indexChild = RenderedNodes.FindIndex(a => a.TestName == testName);
						}

						Handles.BeginGUI();
						Handles.DrawBezier(RenderedNodes[index].rect.center, RenderedNodes[indexChild].rect.center, new Vector2(RenderedNodes[index].rect.xMax + 50f, RenderedNodes[index].rect.center.y), new Vector2(RenderedNodes[indexChild].rect.xMin - 50f, RenderedNodes[indexChild].rect.center.y), Color.cyan, null, 5f);
						Handles.EndGUI();

					}

				}

			}

			GUIStyle f = new GUIStyle(EditorStyles.foldout);
			f.richText = true;

			//Render each node window object.
			BeginWindows();
			for(int i = 0; i < RenderedNodes.Count; i++) {

				RenderedNodes[i].rect = GUI.Window(i, RenderedNodes[i].rect, WindowEvents, RenderedNodes[i].TestName);

			}
			EndWindows();

			string nodeDetails = inspectedNodeWindow >= 0 ? GetNodeDetails(RenderedNodes[inspectedNodeWindow]) : GetNodeDetails(new DependencyNode());
			float boxHeight = TestMonitorHelpers.DetermineRectHeightBasedOnLinesInNodeDetails(nodeDetails) + 50;
			float boxWidth = longestTestNameInInfoBox > infoBoxMinWidth ? longestTestNameInInfoBox : infoBoxMinWidth;

			bool overflowX = boxWidth > infoBoxMinWidth;
			//Account for size of scroll bar in scrollable space
			if(overflowX) {

				boxHeight += 40;

			}
			float scrollViewHeight = boxHeight < position.height ? boxHeight : position.height;
			bool overflowY = scrollViewHeight == position.height;
			if(overflowY) {

				boxWidth += 40;

			}

			GUI.EndScrollView();

			GUIStyle verticalScrollBar = new GUIStyle(GUI.skin.verticalScrollbar);
			GUIStyle horizontalScrollBar = overflowX ? new GUIStyle(GUI.skin.horizontalScrollbar) : GUIStyle.none;

			infoBoxScroll = GUI.BeginScrollView(new Rect(position.width - infoBoxMinWidth, 0, infoBoxMinWidth, scrollViewHeight), infoBoxScroll, new Rect(new Vector2(position.width - (infoBoxMinWidth - 5), 4), new Vector2(boxWidth, boxHeight)), horizontalScrollBar, verticalScrollBar);

			//Display selected node's details in details panel.
			GUIStyle infoBox = new GUIStyle(GUI.skin.box);
			infoBox.richText = true;
			infoBox.normal.background = MakeTextureFromColor(new Color(0.175f, 0.175f, 0.175f, 1f));
			infoBox.alignment = TextAnchor.UpperLeft;
			GUI.Box(new Rect(new Vector2(position.width - (infoBoxMinWidth - 5), 4), new Vector2(boxWidth, boxHeight)), nodeDetails, infoBox);

			lastRenderX = position.width + infoBoxMinWidth;
			lastRenderY = position.height;

			GUI.EndScrollView();

		}

public void OnGUI(SeqenceState state)
        {
            if (hierachy == null)
            {
                BuildTreeHierachy(state);
            }
            winRect = SeqenceWindow.inst.winArea;
            posRect = winRect;
            posRect.x = x;
            posRect.y = _y;
            posRect.height = winRect.height - _y;
            posRect.width = winRect.width - x;
            viewRect = posRect;
            viewRect.height = TracksBtmY - _y;
            viewRect.width -= 20;
            width = winRect.width;
            SyncTreeWidth();

            float y = WindowConstants.trackRowYPosition;
            Rect clip = new Rect(0, y, winRect.width, winRect.height - y);

            GUI.BeginClip(clip);
            if (hierachy != null)
                for (int i = 0; i < hierachy.Count; i++)
                {
                    hierachy[i].OnGUI(scroll);
                }
            GUI.EndClip();
            bool vshow = viewRect.height > posRect.height;
            if (vshow)
            {
                scroll = GUI.BeginScrollView(posRect, scroll, viewRect, false, vshow);
                GUI.EndScrollView();
            }
        }

internal void OnGUI(Rect fullPos)
        {
            DrawOutline(fullPos, 1f);

            Rect pos = new Rect(fullPos.x + k_BorderSize, fullPos.y + k_BorderSize, fullPos.width - 2 * k_BorderSize, fullPos.height - 2 * k_BorderSize);


            if (m_Dimensions.y == 0 || m_Dimensions.x != pos.width - k_ScrollbarPadding)
            {
                //recalculate height.
                m_Dimensions.x = pos.width - k_ScrollbarPadding;
                m_Dimensions.y = 0;
                foreach (var message in m_Messages)
                {
                    m_Dimensions.y += m_Style[0].CalcHeight(new GUIContent(message.message), m_Dimensions.x);
                }
            }

            m_ScrollPosition = GUI.BeginScrollView(pos, m_ScrollPosition, new Rect(0, 0, m_Dimensions.x, m_Dimensions.y));
            int counter = 0;
            float runningHeight = 0.0f;
            foreach (var message in m_Messages)
            {
                int index = counter % 2;
                var content = new GUIContent(message.message);
                float height = m_Style[index].CalcHeight(content, m_Dimensions.x);

                GUI.Box(new Rect(0, runningHeight, m_Dimensions.x, height), content, m_Style[index]);
                GUI.DrawTexture(new Rect(0, runningHeight, 32f, 32f), message.icon);
                //TODO - cleanup formatting issues and switch to HelpBox
                //EditorGUI.HelpBox(new Rect(0, runningHeight, m_dimensions.x, height), message.message, (MessageType)message.severity);

                counter++;
                runningHeight += height;
            }
            GUI.EndScrollView();
        }

private void DrawLayers(Rect verticalParent) {

        Vector2 offset = new Vector2(10, 20);

        // INIT LAYER RECT
        float layerRectPositionX = verticalParent.x + offset.x;
        float layerRectPositionY = verticalParent.yMax + offset.y;
        float layerRectWidth = verticalParent.width-offset.x*2;
        float layerRectHeight = 40;
        float spaceBetweenLayers = 10;

        // SCROLL VIEW STUFF
        Rect viewRect = new Rect(layerRectPositionX, layerRectPositionY, layerRectWidth+ offset.x, (layerRectHeight + spaceBetweenLayers) * (PIASession.Instance.ImageData.Layers.Count + 1) + offset.y*2);
        Rect sliderRect = new Rect(layerRectPositionX, layerRectPositionY, layerRectWidth+offset.x, leftSide.GetRect().height - verticalParent.height - offset.y);

        // caching and changing default gui skins for scroll view 
        GUIStyle nativeVerticalScrollbarThumb = GUI.skin.verticalScrollbarThumb;
        GUI.skin.verticalScrollbarThumb.normal.background = PIATextureDatabase.Instance.GetTexture("empty");
        GUIStyle nativeVerticalScrollbarDownButton = GUI.skin.verticalScrollbarDownButton;
        GUI.skin.verticalScrollbarDownButton.normal.background = PIATextureDatabase.Instance.GetTexture("empty");
        GUIStyle nativeVerticalScrollbarUpButton = GUI.skin.verticalScrollbarUpButton;
        GUI.skin.verticalScrollbarUpButton.normal.background = PIATextureDatabase.Instance.GetTexture("empty");

        // DRAWING LAYERS 
        layersSlider = GUI.BeginScrollView(sliderRect, layersSlider, viewRect, false, false, skin.GetStyle("horizontalscrollbar"), skin.GetStyle("verticalscrollbar"));
        {
            for (int i = 0; i < PIASession.Instance.ImageData.Layers.Count; i++)
            {
                var item = PIASession.Instance.ImageData.Layers[i];
                Rect layerRect = new Rect(layerRectPositionX, layerRectPositionY, layerRectWidth, layerRectHeight);

                GUI.DrawTexture(layerRect, blackBarBG);
                GUILayout.BeginArea(layerRect);
                {
                    GUILayout.FlexibleSpace();

                    GUILayout.BeginHorizontal();
                    {
                        // LABEL
                        GUILayout.BeginVertical();
                        {
                            GUILayout.FlexibleSpace();

                            GUILayout.BeginHorizontal();
                            {
                                GUILayout.Space(15);
                                GUILayout.Label(item.Name, skin.GetStyle("editorbutton2"));
                                GUILayout.FlexibleSpace();

                            }
                            GUILayout.EndHorizontal();
                            GUILayout.FlexibleSpace();
                        }
                        GUILayout.EndVertical();

                        // EYE & DELETE & TOOLTIP
                        GUILayout.BeginVertical();
                        {
                            GUILayout.FlexibleSpace();

                            GUILayout.BeginHorizontal();
                            {
                                item.Hidden = GUILayout.Toggle(item.Hidden, GUIContent.none, skin.GetStyle("layereye"), GUILayout.MaxWidth(30), GUILayout.MaxHeight(30));
                                Rect layerEyeGlobalRect = PIATooltipUtility.ChildToGlobalRect(GUILayoutUtility.GetLastRect(), layerRect, new Rect(-5, 40, 1, 1));
                                Rect layerEyeTooltipRect = new Rect(0, 0, 150, 22.5f);
                                PIATooltip layerEyeTooltip = new PIATooltip(layerEyeTooltipRect, "Show layer On / Off");
                                PIATooltip.SetPositionPreset(ref layerEyeTooltip, layerEyeGlobalRect, PIATooltip.PIATooltipPreset.Down);
                                PIATooltipUtility.AddTooltip(layerEyeGlobalRect, layerEyeTooltip);
                                GUILayout.Space(5);
                                if (i != 0)
                                {
                                    if (GUILayout.Button(GUIContent.none, skin.GetStyle("deletelayer"), GUILayout.MaxWidth(30), GUILayout.MaxHeight(30)))
                                    {
                                        PIASession.Instance.ImageData.RemoveLayer(i);
                                        return;
                                    }
                                    Rect deleteLayerGlobalRect = PIATooltipUtility.ChildToGlobalRect(GUILayoutUtility.GetLastRect(), layerRect, new Rect(-5, 40, 1, 1));
                                    Rect deleteLayerTooltipRect = new Rect(0, 0, 50, 22.5f);
                                    PIATooltip deleteLayerTooltip = new PIATooltip(deleteLayerTooltipRect, "Delete");
                                    PIATooltip.SetPositionPreset(ref deleteLayerTooltip, deleteLayerGlobalRect, PIATooltip.PIATooltipPreset.Down);
                                    PIATooltipUtility.AddTooltip(deleteLayerGlobalRect, deleteLayerTooltip);


                                }
                                GUILayout.Space(5);
                            }
                            GUILayout.EndHorizontal();
                            GUILayout.FlexibleSpace();


                        }
                        GUILayout.EndVertical();

                    }
                    GUILayout.EndHorizontal();

                    GUILayout.FlexibleSpace();


                }
                GUILayout.EndArea();

                // LAYER SELECTION BUTTON
                if (GUI.Button(layerRect, GUIContent.none, skin.GetStyle("bglayerbutton")))
                {
                    PIASession.Instance.ImageData.CurrentLayer = i;
                }
                layerRectPositionY += layerRectHeight + spaceBetweenLayers;

                // SELECTED LAYER OVERLAY
                if (i == PIASession.Instance.ImageData.CurrentLayer)
                {
                    GUI.Label(layerRect, GUIContent.none, skin.GetStyle("selectedlayeroverlay"));
                }

                PIASession.Instance.ImageData.Layers[i] = item;
            }

            // ADD LAYER 
            Rect addLayerRect = new Rect(layerRectPositionX, layerRectPositionY, layerRectWidth, layerRectHeight);
            GUI.DrawTexture(addLayerRect, blackBarBG);
            GUILayout.BeginArea(addLayerRect);
            {
                GUILayout.FlexibleSpace();

                GUILayout.BeginHorizontal();
                {
                    // ICON
                    GUILayout.BeginVertical();
                    {
                        GUILayout.FlexibleSpace();

                        GUILayout.BeginHorizontal();
                        {
                            GUILayout.Space(15);
                            GUILayout.Label("", skin.GetStyle("addlayerlabelicon"), GUILayout.MaxWidth(30), GUILayout.MaxHeight(30));
                        }
                        GUILayout.EndHorizontal();
                        GUILayout.FlexibleSpace();


                    }
                    GUILayout.EndVertical();

                    // LABEL
                    GUILayout.BeginVertical();
                    {
                        GUILayout.FlexibleSpace();

                        GUILayout.BeginHorizontal();
                        {
                            GUILayout.Space(15);
                            GUILayout.Label("Add layer", skin.GetStyle("editorbutton2"));
                            GUILayout.FlexibleSpace();

                        }
                        GUILayout.EndHorizontal();
                        GUILayout.FlexibleSpace();

                    }
                    GUILayout.EndVertical();

                }
                GUILayout.EndHorizontal();

                GUILayout.FlexibleSpace();

            }
            GUILayout.EndArea();

            // ADD LAYER BUTTON
            if (GUI.Button(addLayerRect, "", skin.GetStyle("bglayerbutton")))
            {
                PIASession.Instance.ImageData.AddLayer();
            }
        }
        GUI.EndScrollView();

        // resetting scroll view gui skin
        GUI.skin.verticalScrollbarThumb = nativeVerticalScrollbarThumb;
        GUI.skin.verticalScrollbarDownButton = nativeVerticalScrollbarDownButton;
        GUI.skin.verticalScrollbarUpButton = nativeVerticalScrollbarUpButton;
    }

private void DrawFrames(Rect parent)
    {
        PIAImageData imageData = PIASession.Instance.ImageData;
        Vector2 offset = new Vector2(20, 20);
        Vector2 bgSize = new Vector2(15, 15);

        // FRAME RECT
        float frameRectPositionX = offset.x;
        float frameRectPositionY = offset.y;
        float frameRectWidth = 100;
        float frameRectHeight = frameRectWidth;
        float spaceBetweenFrames = 25;

        // FRAME INDEX RECT
        float frameNumberRectWidth = 22;
        float frameNumberRectHeight = 22;

        // DELETE RECT
        float deleteFrameRectWidth = 32;
        float deleteFrameRectHeight = 32;
        Vector2 deleteFrameRectOffset = new Vector2(2, 2);

        // DUPLICATE RECT
        float duplicateFrameRectWidth = 32;
        float duplicateFrameRectHeight = 32;
        Vector2 duplicateFrameRectOffset = new Vector2(2, 2);

        // MOVE UP RECT
        float moveFrameUpRectWidth = 32;
        float moveFrameUpRectHeight = 32;
        Vector2 moveFrameUpRectOffset = new Vector2(2, 2);
       
        // MOVE DOWN RECT
        float moveFrameDownRectWidth = 32;
        float moveFrameDownRectHeight = 32;
        Vector2 moveFrameDownRectOffset = new Vector2(2, 2);

        // ADD FRAME RECT
        float addFrameIconRectWidth = 40;
        float addFrameIconRectHeight = 40;

        // SCROLL VIEW RECT
        Rect viewRect = new Rect(0, 0, parent.width, (frameRectHeight+spaceBetweenFrames) * (imageData.Frames.Count+1)+offset.y);
        Rect sliderRect = new Rect(0, 0, parent.width, parent.height-offset.y);

        // caching and changing default gui skins for scroll view 
        GUIStyle nativeVerticalScrollbarThumb = GUI.skin.verticalScrollbarThumb;
        GUI.skin.verticalScrollbarThumb.normal.background = PIATextureDatabase.Instance.GetTexture("empty");
        GUIStyle nativeVerticalScrollbarDownButton = GUI.skin.verticalScrollbarDownButton;
        GUI.skin.verticalScrollbarDownButton.normal.background = PIATextureDatabase.Instance.GetTexture("empty");
        GUIStyle nativeVerticalScrollbarUpButton = GUI.skin.verticalScrollbarUpButton;
        GUI.skin.verticalScrollbarUpButton.normal.background = PIATextureDatabase.Instance.GetTexture("empty");
        
        // DRAWING FRAMES
        framesSlider = GUI.BeginScrollView(sliderRect, framesSlider,viewRect,false,false,skin.GetStyle("horizontalscrollbar"),skin.GetStyle("verticalscrollbar"));
        {
            for (int i = 0; i < imageData.Frames.Count; i++)
            {
                var item = imageData.Frames[i];

                // refreshing rects
                Rect frameRect = new Rect(frameRectPositionX, frameRectPositionY, frameRectWidth, frameRectHeight);
                Rect frameBGRect = new Rect(frameRect.x - bgSize.x / 2, frameRect.y - bgSize.y / 2, frameRect.width + bgSize.x,
                    frameRect.height + bgSize.y);
                Rect frameNumberBGRect = new Rect(frameBGRect.xMax, frameBGRect.center.y - frameNumberRectHeight / 2, frameNumberRectWidth, frameNumberRectHeight);
                Rect deleteFrameRect = new Rect(frameRect.xMax - deleteFrameRectWidth - deleteFrameRectOffset.x,
                    frameRect.y + deleteFrameRectOffset.y, deleteFrameRectWidth, deleteFrameRectHeight);
                Rect duplicateFrameRect = new Rect(frameRect.xMax - duplicateFrameRectWidth - duplicateFrameRectOffset.x,
                    frameRect.yMax - duplicateFrameRectOffset.y - duplicateFrameRectHeight, duplicateFrameRectWidth, duplicateFrameRectHeight);
                Rect moveFrameUpFrameRect = new Rect(frameRect.x + moveFrameUpRectOffset.x,
                   frameRect.y + moveFrameUpRectOffset.y , moveFrameUpRectWidth, moveFrameUpRectHeight);
                Rect moveFrameDownFrameRect = new Rect(frameRect.x  + moveFrameDownRectOffset.x,
                                   frameRect.yMax - moveFrameDownRectOffset.y - moveFrameDownRectHeight, moveFrameDownRectWidth, moveFrameDownRectHeight);
               
                // INDEX NUMBER
                GUI.DrawTexture(frameNumberBGRect, blackBarBG);
                GUI.Label(frameNumberBGRect, i.ToString(), skin.GetStyle("editorbutton2"));

                // BG
                GUI.DrawTexture(frameBGRect, blackBarBG);
               
                // FRAME CONTENT
                EditorGUI.DrawTextureTransparent(frameRect, imageData.Frames[i].GetFrameTexture());

                if (PIAInputArea.IsMouseInsideRect(frameBGRect))
                {
                    if (imageData.Frames.Count > 1)
                    {
                        // DELETE
                        if (GUI.Button(deleteFrameRect, GUIContent.none, skin.GetStyle("deleteframe")))
                        {
                            PIASession.Instance.ImageData.RemoveFrame(i);
                        }
                        Rect deleteFrameGlobalRect = PIATooltipUtility.ChildToGlobalRect(deleteFrameRect,parent);
                        Rect deleteFrameTooltipRect = new Rect(0, 0, 50, 22.5f);
                        PIATooltip deleteFrameTooltip = new PIATooltip(deleteFrameTooltipRect, "Delete");
                        PIATooltip.SetPositionPreset(ref deleteFrameTooltip, deleteFrameGlobalRect, PIATooltip.PIATooltipPreset.Right);
                        PIATooltipUtility.AddTooltip(deleteFrameGlobalRect, deleteFrameTooltip);

                    }

                    // DUPLICATE
                    if (GUI.Button(duplicateFrameRect, GUIContent.none, skin.GetStyle("copyframe")))
                    {
                        PIAFrame newFrame = PIASession.Instance.ImageData.AddFrame();
                        newFrame.CopyFrom(item);
                        
                    }
                    Rect duplicateFrameGlobalRect = PIATooltipUtility.ChildToGlobalRect(duplicateFrameRect, parent);
                    Rect duplicateFrameTooltipRect = new Rect(0, 0, 75, 22.5f);
                    PIATooltip duplicateFrameTooltip = new PIATooltip(duplicateFrameTooltipRect, "Duplicate");
                    PIATooltip.SetPositionPreset(ref duplicateFrameTooltip, duplicateFrameGlobalRect, PIATooltip.PIATooltipPreset.Up);
                    PIATooltipUtility.AddTooltip(duplicateFrameGlobalRect, duplicateFrameTooltip);

                    // MOVE UP
                    if (i > 0) {
                        if (GUI.Button(moveFrameUpFrameRect, GUIContent.none, skin.GetStyle("moveframup")))
                        {
                            imageData.MoveFrameUp(i);
                        }
                        Rect moveFrameUpGlobalRect = PIATooltipUtility.ChildToGlobalRect(moveFrameUpFrameRect, parent);
                        Rect moveFrameUpTooltipRect = new Rect(0, 0, 75, 22.5f);
                        PIATooltip moveFrameUpTooltip = new PIATooltip(moveFrameUpTooltipRect, "Move up");
                        PIATooltip.SetPositionPreset(ref moveFrameUpTooltip, moveFrameUpGlobalRect, PIATooltip.PIATooltipPreset.Left);
                        PIATooltipUtility.AddTooltip(moveFrameUpGlobalRect, moveFrameUpTooltip);

                    }

                    // MOVE DOWN
                    if (i < imageData.Frames.Count - 1) {
                        if (GUI.Button(moveFrameDownFrameRect, GUIContent.none, skin.GetStyle("moveframedown")))
                        {
                            imageData.MoveFrameDown(i);

                        }
                        Rect moveFrameDownGlobalRect = PIATooltipUtility.ChildToGlobalRect(moveFrameDownFrameRect,parent);
                        Rect moveFrameDownTooltipRect = new Rect(0, 0, 90, 22.5f);
                        PIATooltip moveFrameDownTooltip = new PIATooltip(moveFrameDownTooltipRect, "Move down");
                        PIATooltip.SetPositionPreset(ref moveFrameDownTooltip, moveFrameDownGlobalRect, PIATooltip.PIATooltipPreset.Left);
                        PIATooltipUtility.AddTooltip(moveFrameDownGlobalRect, moveFrameDownTooltip);

                    }
                }

                // FRAME SELECTION BG
                if (GUI.Button(frameBGRect, GUIContent.none, skin.GetStyle("bglayerbutton")))
                {
                    PIASession.Instance.ImageData.CurrentFrameIndex = i;
                }

                frameRectPositionY += frameRectHeight + spaceBetweenFrames;

                // FRAME SELECTION OVERLAY
                if (i == PIASession.Instance.ImageData.CurrentFrameIndex)
                {
                    GUI.Label(frameBGRect, GUIContent.none, skin.GetStyle("selectedframeoverlay"));
                }
            }

            // ADD NEW FRAME
            Rect addFrameRect = new Rect(frameRectPositionX, frameRectPositionY, frameRectWidth, frameRectHeight);
            Rect addFrameBGRect = new Rect(addFrameRect.x - bgSize.x / 2, addFrameRect.y - bgSize.y / 2, addFrameRect.width + bgSize.x,
                    addFrameRect.height + bgSize.y);
            Rect addFrameBGLabelIcon = new Rect(addFrameRect.center.x - addFrameIconRectWidth / 2, addFrameRect.center.y - addFrameIconRectHeight / 2, addFrameIconRectWidth, addFrameIconRectHeight);
            GUI.DrawTexture(addFrameBGRect, blackBarBG);
            GUI.Label(addFrameBGLabelIcon, GUIContent.none, skin.GetStyle("addframe"));

            if (GUI.Button(addFrameRect, GUIContent.none, skin.GetStyle("bglayerbutton")))
            {
                PIASession.Instance.ImageData.AddFrame();
            }
            frameRectPositionY += frameRectHeight + spaceBetweenFrames;
        }
        GUI.EndScrollView();

        // resetting scroll view gui skin
        GUI.skin.verticalScrollbarThumb = nativeVerticalScrollbarThumb;
        GUI.skin.verticalScrollbarDownButton = nativeVerticalScrollbarDownButton;
        GUI.skin.verticalScrollbarUpButton = nativeVerticalScrollbarUpButton;


    }

public void Show(Action<int> onItemSelected)
        {
            if (forceToUnShow)
            {
                forceToUnShow = false;
                isClickedComboButton = false;
            }

            var done = false;
            var controlID = GUIUtility.GetControlID(FocusType.Preplacedive);

            Vector2 currentMousePosition = Vector2.zero;
            if (Event.current.GetTypeForControl(controlID) == EventType.mouseUp)
            {
                if (isClickedComboButton)
                {
                    done = true;
                    currentMousePosition = Event.current.mousePosition;
                }
            }

            if (GUI.Button(Rect, ButtonContent, buttonStyle))
            {
                if (useControlID == -1)
                {
                    useControlID = controlID;
                    isClickedComboButton = false;
                }

                if (useControlID != controlID)
                {
                    forceToUnShow = true;
                    useControlID = controlID;
                }
                isClickedComboButton = true;
            }

            if (isClickedComboButton)
            {
                GUI.enabled = false;
                GUI.color = new Color(1, 1, 1, 2);

                var location = GUIUtility.GUIToScreenPoint(new Vector2(Rect.x, Rect.y + listStyle.CalcHeight(listContent[0], 1.0f)));
                var size = new Vector2(Rect.width, listStyle.CalcHeight(listContent[0], 1.0f) * listContent.Length);

                var innerRect = new Rect(0, 0, size.x, size.y);

                var outerRectScreen = new Rect(location.x, location.y, size.x, size.y);
                if (outerRectScreen.yMax > _windowYmax)
                {
                    outerRectScreen.height = _windowYmax - outerRectScreen.y;
                    outerRectScreen.width += 20;
                }

                if (currentMousePosition != Vector2.zero && outerRectScreen.Contains(GUIUtility.GUIToScreenPoint(currentMousePosition)))
                    done = false;

                CurrentDropdownDrawer = () =>
                {
                    GUI.enabled = true;

                    var outerRectLocal = GUIUtility.ScreenToGUIRect(outerRectScreen);

                    GUI.Box(outerRectLocal, GUIContent.none, GUI.skin.box);

                    _scrollPosition = GUI.BeginScrollView(outerRectLocal, _scrollPosition, innerRect, false, false);
                    {
                        const int initialSelectedItem = -1;
                        var newSelectedItemIndex = GUI.SelectionGrid(innerRect, initialSelectedItem, listContent, 1, listStyle);
                        if (newSelectedItemIndex != initialSelectedItem)
                        {
                            onItemSelected(newSelectedItemIndex);
                            isClickedComboButton = false;
                        }
                    }
                    GUI.EndScrollView(true);
                };
            }

            if (done)
                isClickedComboButton = false;
        }

void ConsoleWindow(int windowID)
        {

            printLogs = GUI.Toggle(new Rect(10, 5, 10, 10), printLogs, "", skin.GetStyle("logButton"));
            printWarnings = GUI.Toggle(new Rect(25, 5, 10, 10), printWarnings, "", skin.GetStyle("warningButton"));
            printErrors = GUI.Toggle(new Rect(40, 5, 10, 10), printErrors, "", skin.GetStyle("errorButton"));
            printNetwork = GUI.Toggle(new Rect(55, 5, 10, 10), printNetwork, "", skin.GetStyle("networkButton"));

            if (GUI.Button(new Rect(windowRect.width - 25, 7, 15, 5), "-", skin.GetStyle("exitButton")))
            {
                _active = !_active;
            }

            if (Event.current.keyCode == KeyCode.UpArrow && Event.current.type == EventType.KeyDown)
            {
                if (GUI.GetNameOfFocusedControl() == "consoleInputField")
                {
                    InputHistoryHandler();
                    FocusOnInputField(false);
                }
            }
#if UNITY_STANDALONE
            GUI.SetNextControlName("dragHandle");

            GUI.DragWindow(new Rect(0, 0, windowRect.width, 20));//Draw drag handle of window
#endif
            int scrollHeight = 0;
            GUI.SetNextControlName("outputBox");

            GUI.Box(new Rect(20, 20, windowRect.width - 40, windowRect.height - 85), "", skin.box);//Draw console window box

            GUI.SetNextControlName("consoleInputField");
            Rect inputFieldRect = new Rect(20, windowRect.height - 45, windowRect.width - 160, 25);
            Widgets.Instance.DrawCommandHints(inputFieldRect, skin.GetStyle("hint"));
            input = GUI.TextField(inputFieldRect, input, inputLimit, skin.textField);


            foreach (ConsoleOutput c in consoleOutputs)
            {
                scrollHeight += c.lines * lineSpacing;
            }

            scrollPosition = GUI.BeginScrollView(new Rect(20, 20, windowRect.width - 40, windowRect.height - 85), scrollPosition, new Rect(20, 20, windowRect.width - 60, scrollHeight));
            if (scrollDownTrigger)
            {
                scrollPosition = new Vector2(scrollPosition.x, scrollHeight);
                scrollDownTrigger = false;
            }

            GUI.SetNextControlName("textArea");
            DrawOutput();

            GUI.EndScrollView();

            GUI.SetNextControlName("submitButton");

            if (GUI.Button(new Rect(windowRect.width - 130, windowRect.height - 45, 80, 25), "Submit", skin.button))
            {
                if (!String.IsNullOrEmpty(input))
                {
                    SubmitInput(input);
                    scrollPosition = new Vector2(scrollPosition.x, consoleOutputs.Count * 40);
                }

            }

            if (inputFocusTrigger)
            {
                FocusOnInputField(false);

            }
            if (!String.IsNullOrEmpty(input) && Event.current.keyCode == KeyCode.Return && Event.current.type == EventType.KeyUp)
            {

                if (GUI.GetNameOfFocusedControl() == "consoleInputField" || GUI.GetNameOfFocusedControl() == "")
                {
                    if (inputFocusTrigger)
                    {
                        inputFocusTrigger = false;
                    }
                    else
                    {
                        SubmitInput(input);

                    }

                }

            }
            GUI.SetNextControlName("clearButton");

            if (GUI.Button(new Rect(windowRect.width - 40, windowRect.height - 45, 20, 25), "X", skin.button))
            {
                consoleOutputs.Clear();
                inputHistory.Clear();
                scrollPosition = new Vector2(scrollPosition.x, consoleOutputs.Count * 20);
            }

            if (String.IsNullOrEmpty(input) && Event.current.keyCode == KeyCode.Return && Event.current.type == EventType.KeyUp)
            {

                GUI.FocusControl("consoleInputField");

            }
            if (GUI.GetNameOfFocusedControl() == "" && submitFocusTrigger)
            {
                GUI.FocusControl("consoleInputField");
                submitFocusTrigger = false;
            }

            GUI.Box(new Rect(windowRect.width - 15, windowRect.height - 15, 10, 10), "", skin.GetStyle("corner"));

            WindowResizeHandler();
        }

internal void OnGUI(Rect fullPos)
        {
            DrawOutline(fullPos, 1f);

            Rect pos = new Rect(fullPos.x + k_BorderSize, fullPos.y + k_BorderSize, fullPos.width - 2 * k_BorderSize, fullPos.height - 2 * k_BorderSize);
            

            if (m_Dimensions.y == 0 || m_Dimensions.x != pos.width - k_ScrollbarPadding)
            {
                //recalculate height.
                m_Dimensions.x = pos.width - k_ScrollbarPadding;
                m_Dimensions.y = 0;
                foreach (var message in m_Messages)
                {
                    m_Dimensions.y += m_Style[0].CalcHeight(new GUIContent(message.message), m_Dimensions.x);
                }
            }

            m_ScrollPosition = GUI.BeginScrollView(pos, m_ScrollPosition, new Rect(0, 0, m_Dimensions.x, m_Dimensions.y));
            int counter = 0;
            float runningHeight = 0.0f;
            foreach (var message in m_Messages) 
            {
                int index = counter % 2;
                var content = new GUIContent(message.message);
                float height = m_Style[index].CalcHeight(content, m_Dimensions.x);

                GUI.Box(new Rect(0, runningHeight, m_Dimensions.x, height), content, m_Style[index]);
                GUI.DrawTexture(new Rect(0, runningHeight, 32f, 32f), message.icon);
                //TODO - cleanup formatting issues and switch to HelpBox
                //EditorGUI.HelpBox(new Rect(0, runningHeight, m_dimensions.x, height), message.message, (MessageType)message.severity);

                counter++;
                runningHeight += height;
            }
            GUI.EndScrollView();
        }

private static void spawnItemMenu()
        {
            if (showItemList)
            {
                string[] allitems = Constants.allitems;
                GUI.Label(new Rect(520f, 225f, 200f, 20f), "Item Spawner:");
                scrollViewVector = GUI.BeginScrollView(new Rect(dropDownRect2.x - 100f, dropDownRect2.y + 25f, dropDownRect2.width, dropDownRect2.height), scrollViewVector, new Rect(0f, 0f, dropDownRect2.width, Mathf.Max(dropDownRect2.height, (float)(allitems.Length * 25))));
                GUI.Box(new Rect(0f, 0f, dropDownRect2.width, Mathf.Max(dropDownRect2.height, (float)(allitems.Length * 25))), "");
                for (int l = 0; l < allitems.Length; l++)
                {
                    if (GUI.Button(new Rect(0f, (float)(l * 25), dropDownRect2.height, 25f), ""))
                    {
                        selectedItem = l;
                        if (PhotonNetwork.InRoom)
                        {
                            MyPlayer = Main.GetLocalPlayer();
                            MelonLogger.Log(allitems[selectedItem].ToString());
                            PhotonNetwork.Instantiate(allitems[selectedItem], MyPlayer.transform.position, Quaternion.idenreplacedy, 0, null);
                        }
                    }
                    GUI.Label(new Rect(5f, (float)(l * 25), dropDownRect2.height, 25f), allitems[l]);
                }
                GUI.EndScrollView();
            }
        }

private void DrawSelectionArea(Rect scrollRect)
        {
            Rect contentRect = new Rect(0, 0,
                scrollRect.width - GUI.skin.verticalScrollbar.fixedWidth,
                visibleItems.Count * ROW_HEIGHT);

            scroll = GUI.BeginScrollView(scrollRect, scroll, contentRect);

            Rect rowRect = new Rect(0, 0, scrollRect.width, ROW_HEIGHT);

            for (int i = 0; i < visibleItems.Count; i++)
            {
                if (scrollToIndex == i &&
                    (Event.current.type == EventType.Repaint
                     || Event.current.type == EventType.Layout))
                {
                    Rect r = new Rect(rowRect);
                    r.y += scrollOffset;
                    GUI.ScrollTo(r);
                    scrollToIndex = -1;
                    scroll.x = 0;
                }

                if (rowRect.Contains(Event.current.mousePosition))
                {
                    if (Event.current.type == EventType.MouseMove ||
                        Event.current.type == EventType.ScrollWheel)
                    {
                        //if new item force update so it's snappier
                        if (hoverIndex != 1)
                        {
                            this.editorWindow.Repaint();
                        }

                        hoverIndex = i;
                    }

                    if (Event.current.type == EventType.MouseDown)
                    {
                        //onSelectionMade(list.Entries[i].Index);
                        SelectByOrigIndex(visibleItems[i].origIndex);
                        EditorWindow.focusedWindow.Close();
                    }
                }

                DrawRow(rowRect, i);

                rowRect.y = rowRect.yMax;
            }

            GUI.EndScrollView();
        }

private void DrawWindow(int id)
        {
            int bFontSize = GUI.skin.button.fontSize;
            int tfFontSize = GUI.skin.textField.fontSize;
            int tFontSize = GUI.skin.toggle.fontSize;
            int lFontSize = GUI.skin.label.fontSize;
            GUI.skin.button.fontSize = consoleFont.fontSize;
            GUI.skin.textField.fontSize = consoleFont.fontSize;
            GUI.skin.toggle.fontSize = consoleFont.fontSize;
            GUI.skin.label.fontSize = consoleFont.fontSize;

            if (cachedAC.Count == 0)
            {
                autoComplete = false;
            }

            // LISTENING TO THE KEY EVENTS
            if (Event.current.isKey && Event.current.type == EventType.KeyDown)
            {
                if (Event.current.keyCode == KeyCode.Escape && autoComplete)
                {
                    forceClose = true;
                    autoComplete = false;

                    Event.current.Use();
                    return;
                }
                else if (Event.current.keyCode == KeyCode.Escape && !autoComplete)
                {
                    SetWindowOff();

                    Event.current.Use();
                    return;
                }

                // SUBMITS THE TEXTFIELD
                if (Event.current.keyCode == KeyCode.Return || Event.current.keyCode == KeyCode.KeypadEnter)
                {
                    Console.ProcessInput(cmdText.TrimEnd(' '));
                    cmdText = string.Empty;
                    oldCmdText = null;

                    currHistory = -1;
                    completeIndex = 0;
                    autoComplete = false;

                    Event.current.Use();
                    return;
                }

                // AUTO COMPLETE TOGGLE
                if ((Event.current.modifiers == EventModifiers.Control || Event.current.modifiers == EventModifiers.Command) && Event.current.keyCode == KeyCode.Space)
                {
                    forceClose = false;

                    if (Regex.Matches(cmdText, "\"").Count % 2 == 0)
                        autoComplete = true;

                    justActivated = true;
                    oldCmdText = null;

                    Event.current.Use();
                    return;
                }

                // TAB AUTO COMPLETE
                if (Event.current.keyCode == KeyCode.Tab && Event.current.modifiers == EventModifiers.None && autoComplete)
                {
                    if (!selectComplete.Equals(string.Empty))
                    {
                        cmdText = selectComplete;
                        selectComplete = string.Empty;
                        moveCursor = true;

                        autoComplete = false;
                    }

                    Event.current.Use();
                    return;
                }

                // CYCLES HISTORY UP
                if (Event.current.keyCode == KeyCode.UpArrow && !autoComplete && Console.history.Count > 0)
                {
                    if (currHistory == -1)
                    {
                        cmdText = Console.history[Console.history.Count - 1];
                        currHistory = Console.history.Count - 1;
                    }
                    else
                    {
                        if (currHistory > 0)
                        {
                            cmdText = Console.history[currHistory - 1];
                            currHistory -= 1;
                        }
                    }

                    moveCursor = true;
                    Event.current.Use();
                    return;
                }
                else if (Event.current.keyCode == KeyCode.UpArrow && autoComplete)
                {
                    completeIndex--;

                    if (completeIndex < 0)
                        completeIndex = cachedAC.Count - 1;

                    aCompleteScroll.y = (25 * completeIndex) + 5;

                    Event.current.Use();
                    return;
                }

                // CYCLES HISTORY DOWN
                if (Event.current.keyCode == KeyCode.DownArrow && !autoComplete && Console.history.Count > 0)
                {
                    if (currHistory != -1)
                    {
                        if (currHistory < (Console.history.Count - 1))
                        {
                            cmdText = Console.history[currHistory + 1];
                            currHistory += 1;
                        }
                        else
                        {
                            cmdText = string.Empty;
                            currHistory = -1;
                        }
                    }

                    moveCursor = true;
                    Event.current.Use();
                    return;
                }
                else if (Event.current.keyCode == KeyCode.DownArrow && autoComplete)
                {
                    completeIndex++;

                    if (completeIndex > cachedAC.Count - 1)
                        completeIndex = 0;

                    aCompleteScroll.y = (25 * completeIndex) + 5;

                    Event.current.Use();
                    return;
                }

                // TRIGGER AUTO COMPLETE
                if (autoAC && Event.current.keyCode != KeyCode.None && Event.current.keyCode != KeyCode.Space && Event.current.keyCode != KeyCode.Escape && (!cmdText.Equals(oldCmdText) || cmdText.Equals(string.Empty)) && (Event.current.modifiers == EventModifiers.None || Event.current.modifiers == EventModifiers.Shift))
                {
                    if (cmdText.Equals(string.Empty))
                        forceClose = false;

                    autoComplete = !forceClose;
                }

                // FIXES SPACE && BACKSPACE
                if (autoAC && (Event.current.keyCode == KeyCode.Space) && Event.current.modifiers == EventModifiers.None)
                {
                    if (Regex.Matches(cmdText, "\"").Count % 2 == 0)
                        forceClose = false;

                    if (!forceClose)
                        autoComplete = true;
                }
            }

            // CONSOLE AREA
            GUI.BeginGroup(leftGroup);

            GUI.SetNextControlName(cmdName);
            cmdText = GUI.TextField(cmdRect, cmdText);

            if (cmdText.EndsWith(" ") && justActivated)
            {
                cmdText = cmdText.TrimEnd(' ');
                oldCmdText = null;
                justActivated = false;
            }

            if (!focus)
            {
                focus = true;
                GUI.FocusControl(cmdName);
            }

            textArea.wordWrap = false;
            textArea.clipping = TextClipping.Clip;
            textArea.richText = true;
            textArea.padding = new RectOffset(5, 5, 5, 5);
            textArea.font = consoleFont;

            tRect.width = TextSize.x;
            tRect.height = TextSize.y;

            GUI.BeginGroup(oRect, GUI.skin.textArea);
            consoleScroll = GUI.BeginScrollView(sRect, consoleScroll, tRect, false, true);
            GUI.Label(tRect, FullContent, textArea);
            GUI.EndScrollView();
            GUI.EndGroup();

            GUI.EndGroup();

            // MENU AREA
            GUI.BeginGroup(rightGroupA, GUI.skin.textArea);

            GUI.skin.button.fontStyle = FontStyle.Bold;

            if (GUI.Button(ulRect, openUnityLog))
                System.Diagnostics.Process.Start(Console.unityLogFile);

            if (GUI.Button(slRect, openSRMLLog))
                System.Diagnostics.Process.Start(Console.srmlLogFile);

            autoAC = GUI.Toggle(tacRect, autoAC, toggleAutoAC);

            if (autoAC != oldAutoAC)
            {
                if (autoAC)
                {
                    Console.LogSuccess("Auto complete will now open automatically.");
                }
                else
                {
                    Console.LogSuccess("Auto complete will only open by pressing CTRL+Space or CMD+Space");
                }

                oldAutoAC = autoAC;
            }

            GUI.EndGroup();

            GUI.BeginGroup(rightGroupB, GUI.skin.textArea);

            GUI.skin.label.alignment = TextAnchor.MiddleCenter;
            GUI.Label(cmRect, commands);
            GUI.skin.label.alignment = TextAnchor.MiddleLeft;

            caRect.height = (30 * Console.cmdButtons.Count) + 5;
            commandScroll = GUI.BeginScrollView(csRect, commandScroll, caRect, false, true);
            GUI.BeginGroup(caRect);

            int y = 5;
            foreach (ConsoleButton button in Console.cmdButtons.Values)
            {
                btnRect.y = y;
                if (GUI.Button(btnRect, button.Text))
                    Console.ProcessInput(button.Command.TrimEnd(' '), true);

                y += 30;
            }

            GUI.EndGroup();
            GUI.EndScrollView();

            GUI.skin.button.fontStyle = FontStyle.Normal;

            GUI.EndGroup();

            // UPDATES THE SCROLL POSITION FOR THE CONSOLE TO SHOW LATEST MESSAGES
            if (updateDisplay)
            {
                fullText = string.Empty;
                for (int i = 0; i < Console.lines.Count; i++)
                {
                    fullText += $"{(i == 0 ? string.Empty : "\n")}{Console.lines[i]}";
                }

                consoleScroll.y = TextSize.y;
                updateDisplay = false;
            }

            // MOVES THE CURSOR AFTER AUTO COMPLETE
            if (moveCursor)
            {
                TextEditor txt = (TextEditor)GUIUtility.GetStateObject(typeof(TextEditor), GUIUtility.keyboardControl);
                txt.MoveCursorToPosition(Vector2.one * 50000);

                autoComplete = false;
                moveCursor = false;
            }

            if (cmdText.Equals(string.Empty) && currHistory > -1)
                currHistory = -1;

            GUI.skin.button.fontSize = bFontSize;
            GUI.skin.textField.fontSize = tfFontSize;
            GUI.skin.toggle.fontSize = tFontSize;
            GUI.skin.label.fontSize = lFontSize;
        }

private void DrawACWindow(int id)
        {
            int bFontSize = GUI.skin.button.fontSize;
            GUI.skin.button.fontSize = consoleFont.fontSize;

            bool spaces = cmdText.Contains(" ");
            string command = spaces ? cmdText.Substring(0, cmdText.IndexOf(' ')) : cmdText;

            TextEditor txt = (TextEditor)GUIUtility.GetStateObject(typeof(TextEditor), GUIUtility.keyboardControl);
            if (txt.hreplacedelection)
                command = string.Empty;

            intRect.height = (25 * cachedAC.Count) + 5;
            aCompleteScroll = GUI.BeginScrollView(acsRect, aCompleteScroll, intRect, false, true);
            GUI.BeginGroup(intRect);

            Texture2D bg = GUI.skin.textField.normal.background;
            GUI.skin.textField.normal.background = GUI.skin.button.active.background;
            GUI.skin.textField.richText = true;

            if (!spaces || txt.hreplacedelection)
            {
                if (!command.Equals(oldCmdText))
                {
                    cachedAC.RemoveAll(s => true); // .Clear() gets broken sometimes when you dynamically load an replacedembly, so do the same another way
                    foreach (string cmd in Console.commands.Keys)
                    {
                        if (cmd.ToLowerInvariant().StartsWith(command.ToLowerInvariant()))
                            cachedAC.Add(cmd);
                    }

                    oldCmdText = command;
                }

                if (cachedAC.Count > 0)
                {
                    if (completeIndex >= cachedAC.Count)
                        completeIndex = 0;

                    selectComplete = cmdText.Substring(0, cmdText.Length - command.Length) + cachedAC[completeIndex];

                    int y = 5;
                    for (int i = 0; i < cachedAC.Count; i++)
                    {
                        GUI.backgroundColor = Color.white;
                        if (completeIndex == i)
                            GUI.backgroundColor = Color.yellow;

                        cBtnRect.y = y;
                        if (GUI.Button(cBtnRect, $"{(completeIndex == i ? "►" : string.Empty)}<b><color=#77DDFF>{cachedAC[i].Substring(0, command.Length)}</color></b>{cachedAC[i].Substring(command.Length)}", GUI.skin.textField))
                        {
                            cmdText = cmdText.Substring(0, cmdText.Length - command.Length) + cachedAC[i];
                            GUI.FocusControl(cmdName);
                            moveCursor = true;

                            autoComplete = false;
                        }

                        y += 25;
                    }
                }
            }
            else
            {
                string[] args = Console.StripArgs(cmdText, true);

                int count = args.Length;
                string lastArg = args[count - 1];

                if (Console.commands.ContainsKey(command))
                {
                    List<string> autoC = Console.commands[command].GetAutoComplete(count - 1, lastArg);
                    autoC?.RemoveAll(s => s.Contains(" "));

                    if (autoC == null || autoC.Count == 0 || Regex.Matches(cmdText, "\"").Count % 2 != 0)
                        autoComplete = false;

                    if (autoComplete)
                    {
                        if (!cmdText.Equals(oldCmdText))
                        {
                            cachedAC.RemoveAll(s => true); // .Clear() gets broken sometimes when you dynamically load an replacedembly, so do the same another way
                            foreach (string cmd in autoC)
                            {
                                if (cmd.ToLowerInvariant().StartsWith(lastArg.ToLowerInvariant()))
                                    cachedAC.Add(cmd);
                            }

                            oldCmdText = cmdText;
                        }

                        if (cachedAC.Count > 0)
                        {
                            if (completeIndex >= cachedAC.Count)
                                completeIndex = 0;

                            selectComplete = cmdText.Substring(0, cmdText.Length - lastArg.Length) + cachedAC[completeIndex];

                            int y = 5;
                            for (int i = 0; i < cachedAC.Count; i++)
                            {
                                GUI.backgroundColor = Color.white;
                                if (completeIndex == i)
                                    GUI.backgroundColor = Color.yellow;

                                cBtnRect.y = y;
                                if (GUI.Button(cBtnRect, $"{(completeIndex == i ? "►" : string.Empty)}<b><color=#77DDFF>{cachedAC[i].Substring(0, lastArg.Length)}</color></b>{cachedAC[i].Substring(lastArg.Length)}", GUI.skin.textField))
                                {
                                    cmdText = cmdText.Substring(0, cmdText.Length - lastArg.Length) + cachedAC[i];
                                    GUI.FocusControl(cmdName);
                                    moveCursor = true;

                                    autoComplete = false;
                                }

                                y += 25;
                            }
                        }
                    }
                }
            }

            if (cachedAC.Count == 0)
                autoComplete = false;

            GUI.skin.textField.richText = false;
            GUI.skin.textField.normal.background = bg;

            GUI.EndGroup();
            GUI.EndScrollView();

            GUI.skin.button.fontSize = bFontSize;
        }

private void DrawWindow(int id)
		{
			Font defFont = GUI.skin.font;
			GUI.skin.font = consoleFont;

			Rect leftGroup = new Rect(15, 25, windowRect.width - 150, windowRect.height - 30);
			Rect rightGroup = new Rect(leftGroup.width + 25, leftGroup.y, 110, leftGroup.height - 5);

			// CONSOLE AREA
			GUI.BeginGroup(leftGroup);

			float cmdLineY = leftGroup.height - 25;
			cmdText = GUI.TextField(new Rect(0, cmdLineY, leftGroup.width, 20), cmdText);

			textArea.wordWrap = true;
			textArea.clipping = TextClipping.Clip;
			textArea.richText = true;
			textArea.padding = new RectOffset(5, 5, 5, 5);

			GUIContent fullContent = new GUIContent(fullText.ToString());
			Vector2 textSize = textArea.CalcSize(fullContent);

			Rect oRect = new Rect(0, 0, leftGroup.width, cmdLineY - 5);
			Rect sRect = new Rect(5, 7, oRect.width - 15, cmdLineY - 20);
			Rect tRect = new Rect(0, 0, textSize.x, textSize.y);
			GUI.BeginGroup(oRect, GUI.skin.textArea);
			consoleScroll = GUI.BeginScrollView(sRect, consoleScroll, tRect, false, true);
			GUI.Label(tRect, fullContent, textArea);
			GUI.EndScrollView();
			GUI.EndGroup();

			GUI.EndGroup();

			// MENU AREA
			GUI.BeginGroup(rightGroup, GUI.skin.textArea);

			if (GUI.Button(new Rect(10, 7, 90, 25), openUnityLog))
				System.Diagnostics.Process.Start(Console.unityLogFile);

			if (GUI.Button(new Rect(10, 37, 90, 25), openSRMLLog))
				System.Diagnostics.Process.Start(Console.srmlLogFile);

			if (GUI.Button(new Rect(10, 67, 90, 25), runMods))
				Console.ProcessInput("mods", true);

			if (GUI.Button(new Rect(10, 97, 90, 25), runCommands))
				Console.ProcessInput("help", true);

			if (GUI.Button(new Rect(10, 127, 90, 25), runReload))
				Console.ProcessInput("reload", true);

			GUI.EndGroup();

			// KEY LISTENING DONE HERE CAUSE UNITY COSUMES MOST KEY INPUTS WHEN A TEXTFIELD IS FOCUSED
			if (Event.current.isKey)
			{
				// SUBMITS THE TEXTFIELD
				if (Event.current.keyCode == KeyCode.Return || Event.current.keyCode == KeyCode.KeypadEnter)
				{
					Console.ProcessInput(cmdText);
					cmdText = string.Empty;
				}

				// CLOSES THE WINDOW
				if ((Event.current.command || Event.current.control) && Event.current.keyCode == KeyCode.Tab && canPress)
					ToggleWindow();

				// CYCLES HISTORY UP
				if (Event.current.keyCode == KeyCode.UpArrow)
				{
					if (currHistory == -1)
					{
						cmdText = Console.history[Console.history.Count - 1];
						currHistory = Console.history.Count - 1;
					}
					else
					{
						if (currHistory > 0)
						{
							cmdText = Console.history[currHistory - 1];
							currHistory = currHistory - 1;
						}
					}
				}

				// CYCLES HISTORY DOWN
				if (Event.current.keyCode == KeyCode.DownArrow)
				{
					if (currHistory != -1)
					{
						if (currHistory < (Console.history.Count - 1))
						{
							cmdText = Console.history[currHistory + 1];
							currHistory = currHistory + 1;
						}
						else
						{
							cmdText = "";
							currHistory = -1;
						}
					}
				}
			}

			// UPDATES THE SCROLL POSITION FOR THE CONSOLE TO SHOW LATEST MESSAGES
			if (updateDisplay)
			{
				consoleScroll.y = textArea.CalcSize(new GUIContent(fullText.ToString())).y;
				updateDisplay = false;
			}

			GUI.skin.font = defFont;
		}

public int OnLocalGUI( int yOffset, int in_maxWidth ) {


			if(Event.current.type == EventType.Repaint)
				currentScrollWidth = Mathf.Lerp(currentScrollWidth, targetScrollWidth, 0.3f);

			this.maxWidth = in_maxWidth;
			
			Rect scrollRectPos = new Rect(0f,yOffset,in_maxWidth,Screen.height/EditorGUIUtility.pixelsPerPoint-yOffset-20);
			bool useScrollbar = (innerScrollRect.height > scrollRectPos.height);

			targetScrollWidth = useScrollbar ? 15 : 0;

			int scrollBarWidth = (int)currentScrollWidth;
			
			
			innerScrollRect.width = in_maxWidth-scrollBarWidth;

			guiChanged = false;

			int offset = 0;
			
			if(innerScrollRect.height < scrollRectPos.height)
				innerScrollRect.height = scrollRectPos.height;

			this.maxWidth -= scrollBarWidth;

			int scrollPad = scrollBarWidth-15;
			GUI.BeginGroup(scrollRectPos);
			Rect scrollWrapper = scrollRectPos;
			scrollWrapper.x = 0;
			scrollWrapper.y = 0; // Since it's grouped
			scrollPos = GUI.BeginScrollView(scrollWrapper.PadRight(scrollPad),scrollPos,innerScrollRect,false,true);
			{
				//offset = SettingsMeta( 0 );
				bool showErrors = editor.nodeView.treeStatus.Errors.Count > 0;
				if( !showErrors )
					catConsole.expanded = false;
				EditorGUI.BeginDisabledGroup( !showErrors );
				offset = catConsole.Draw( offset );
				offset = GUISeparator( offset ); // ----------------------------------------------
				EditorGUI.EndDisabledGroup();
				offset = catMeta.Draw( offset );
				offset = GUISeparator( offset ); // ----------------------------------------------
				offset = catProperties.Draw(offset);
				offset = GUISeparator( offset ); // ----------------------------------------------
				offset = catLighting.Draw(offset);
				offset = GUISeparator( offset ); // ----------------------------------------------
				offset = catGeometry.Draw( offset );
				offset = GUISeparator( offset ); // ----------------------------------------------
				offset = catBlending.Draw(offset);
				offset = GUISeparator( offset ); // ----------------------------------------------
				offset = catExperimental.Draw(offset);
				offset = GUISeparator( offset ); // ----------------------------------------------
				
			}
			GUI.EndScrollView();
			GUI.EndGroup();
			this.maxWidth += scrollBarWidth;


			if( guiChanged ) {
				editor.ps = this;
				editor.OnShaderModified(NodeUpdateType.Hard);
			}
			
			innerScrollRect.height = offset;
			return offset;

		}