public bool AttachView(EditorWindow parent, ScriptableObject webView, bool initialize = false)
 {
     this.parentWin = parent;
     this.internalWebView = webView;
     if (this.internalWebView != null)
     {
         this.hostView = Tools.GetReflectionField<object>(parent, "m_Parent");
         this.dockedGetterMethod = this.parentWin.GetType().GetProperty("docked", Tools.FullBinding).GetGetMethod(true);
         if (this.hostView != null && dockedGetterMethod != null)
         {
             if (initialize)
             {
                 Rect initViewRect = new Rect(0, 20, this.parentWin.position.width, this.parentWin.position.height - ((this.IsDocked()) ? 20 : 40));
                 this.InitWebView(this.hostView, (int)initViewRect.x, (int)initViewRect.y, (int)initViewRect.width, (int)initViewRect.height, false);
                 this.SetHideFlags(HideFlags.HideAndDontSave);
                 this.AllowRightClickMenu(true);
             }
         }
         else
         {
             throw new Exception("Failed to get parent window or docked property");
         }
     }
     return (this.internalWebView != null);
 }

        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
        {
            EditorGUI.BeginProperty(position, label, property);
            {
                if (EditorGUI.PropertyField(position, property))
                {
                    EditorGUILayout.PropertyField(property.FindPropertyRelative("type"));

                    switch (property.FindPropertyRelative("type").enumValueIndex)
                    {
                        case 0: // None
                            break;
                        case 1: // Sphere
                            EditorGUILayout.PropertyField(property.FindPropertyRelative("center"));
                            EditorGUILayout.PropertyField(property.FindPropertyRelative("radius"));
                            EditorGUILayout.PropertyField(property.FindPropertyRelative("physicsMaterial"));
                            break;
                        case 2: // Box
                            EditorGUILayout.PropertyField(property.FindPropertyRelative("center"));
                            EditorGUILayout.PropertyField(property.FindPropertyRelative("size"));
                            EditorGUILayout.PropertyField(property.FindPropertyRelative("physicsMaterial"));
                            break;
                        case 3: // Capsule
                            EditorGUILayout.PropertyField(property.FindPropertyRelative("center"));
                            EditorGUILayout.PropertyField(property.FindPropertyRelative("direction"));
                            EditorGUILayout.PropertyField(property.FindPropertyRelative("radius"));
                            EditorGUILayout.PropertyField(property.FindPropertyRelative("height"));
                            EditorGUILayout.PropertyField(property.FindPropertyRelative("physicsMaterial"));
                            break;
                    }
                }
            }
            EditorGUI.EndProperty();
        }

        static void HierarchyItemCB(int instanceID, Rect selectionRect)
        {
            GameObject go = EditorUtility.InstanceIDToObject(instanceID) as GameObject;

            if (go == null)
            {
                return;
            }   

            if (_icon != null && go.GetComponent<ProCamera2D>() != null)
            {
                Rect r = new Rect(selectionRect);
                r.x = r.width - 5;

                GUI.Label(r, _icon);
                return;
            }

            if (_icon_plugin != null && go.GetComponent<BasePC2D>() != null)
            {
                Rect r = new Rect(selectionRect);
                r.x = r.width - 5;

                GUI.Label(r, _icon_plugin);
            }
        }

        void CalculateOffset()
        {
            // Remove the delta movement
            _transform.Translate(-ProCamera2D.DeltaMovement, Space.World);

            // Calculate the window rect
            _cameraWindowRectInWorldCoords = GetRectAroundTransf(CameraWindowRect, ProCamera2D.ScreenSizeInWorldCoordinates, _transform);

            // If camera final horizontal position outside camera window rect
            var horizontalDeltaMovement = 0f;
            if (ProCamera2D.CameraTargetPositionSmoothed.x >= _cameraWindowRectInWorldCoords.x + _cameraWindowRectInWorldCoords.width)
            {
                horizontalDeltaMovement = ProCamera2D.CameraTargetPositionSmoothed.x - (Vector3H(_transform.localPosition) + _cameraWindowRectInWorldCoords.width / 2 + CameraWindowRect.x);
            }
            else if (ProCamera2D.CameraTargetPositionSmoothed.x <= _cameraWindowRectInWorldCoords.x)
            {
                horizontalDeltaMovement = ProCamera2D.CameraTargetPositionSmoothed.x - (Vector3H(_transform.localPosition) - _cameraWindowRectInWorldCoords.width / 2 + CameraWindowRect.x);
            }

            // If camera final vertical position outside camera window rect
            var verticalDeltaMovement = 0f;
            if (ProCamera2D.CameraTargetPositionSmoothed.y >= _cameraWindowRectInWorldCoords.y + _cameraWindowRectInWorldCoords.height)
            {
                verticalDeltaMovement = ProCamera2D.CameraTargetPositionSmoothed.y - (Vector3V(_transform.localPosition) + _cameraWindowRectInWorldCoords.height / 2 + CameraWindowRect.y);
            }
            else if (ProCamera2D.CameraTargetPositionSmoothed.y <= _cameraWindowRectInWorldCoords.y)
            {
                verticalDeltaMovement = ProCamera2D.CameraTargetPositionSmoothed.y - (Vector3V(_transform.localPosition) - _cameraWindowRectInWorldCoords.height / 2 + CameraWindowRect.y);
            }

            var deltaMovement = VectorHV(horizontalDeltaMovement, verticalDeltaMovement);
            _transform.Translate(deltaMovement, Space.World);
        }

        private void Awake()
        {
            instance = this;

            GameEvents.onShowUI.Add(OnShowUI);
            GameEvents.onHideUI.Add(OnHideUI);

            mainGuid = Guid.NewGuid().GetHashCode();
            bodyGuid = Guid.NewGuid().GetHashCode();
            configGuid = Guid.NewGuid().GetHashCode();

            MainWindowRect = new Rect(Screen.width / 4, 0, 200, 10); //Overwritten by LoadGUI
            BodyWindowRect = new Rect((Screen.width / 2) - 75, Screen.height / 4, 150, 10);
            ConfigWindowRect = new Rect((Screen.width / 2) - 100, Screen.height / 4, 200, 10);

            LoadGUI();

            if (visibility_mode == 2)
            {
                CreateStockToolbar();
            }
            else if (visibility_mode == 3)
            {
                CreateBlizzyToolbar();
            }
        }

		public virtual void OnWindowGUI(Rect viewRect)
		{
			if(!isShown && CanShow())
			{
				isShown = true;
				DoShow();
			}
			
			if(isShown && !CanShow())
			{
				isShown = false;
				DoHide();
			}

			if(CanShow())
			{
				windowRect = GUILayout.Window(windowID, windowRect, DoWindow, header);

				DoGUI();

				if(isHovered)
				{
					int controlID = GUIUtility.GetControlID("WindowHovered".GetHashCode(), FocusType.Passive);
					
					if(Event.current.GetTypeForControl(controlID) == EventType.Layout)
					{
						HandleUtility.AddControl(controlID,0f);
					}
				}
			}
		}

        // RimWorld.AreaAllowedGUI
        public static void DoStockpileSelectors( Rect rect, ref Zone_Stockpile stockpile, Map map )
        {
            // get all stockpiles
            List<Zone_Stockpile> allStockpiles = map.zoneManager.AllZones.OfType<Zone_Stockpile>().ToList();

            // count + 1 for all stockpiles
            int areaCount = allStockpiles.Count + 1;

            // create colour swatch
            if ( textures == null || textures.Count != areaCount - 1 )
                CreateTextures( allStockpiles );

            float widthPerCell = rect.width / areaCount;
            Text.WordWrap = false;
            Text.Font = GameFont.Tiny;
            Rect nullAreaRect = new Rect( rect.x, rect.y, widthPerCell, rect.height );
            DoZoneSelector( nullAreaRect, ref stockpile, null, BaseContent.GreyTex );
            int areaIndex = 1;
            for( int j = 0; j < allStockpiles.Count; j++ )
            {
                float xOffset = areaIndex * widthPerCell;
                Rect stockpileRect = new Rect( rect.x + xOffset, rect.y, widthPerCell, rect.height );
                DoZoneSelector( stockpileRect, ref stockpile, allStockpiles[j], textures[j] );
                areaIndex++;
            }
            Text.WordWrap = true;
            Text.Font = GameFont.Small;
        }

        public static GameObject CreateDecal(Material mat, Rect uvCoords, float scale)
        {
            GameObject decal = new GameObject();
            decal.name = "Decal" + decal.GetInstanceID();

            decal.AddComponent<MeshFilter>().sharedMesh = DecalMesh("DecalMesh" + decal.GetInstanceID(), mat, uvCoords, scale);
            decal.AddComponent<MeshRenderer>().sharedMaterial = mat;

            #if UNITY_5
            decal.GetComponent<MeshRenderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
            #else
            decal.GetComponent<MeshRenderer>().castShadows = false;
            #endif

            qd_Decal decalComponent = decal.AddComponent<qd_Decal>();

            decalComponent.SetScale(scale);
            decalComponent.SetTexture( (Texture2D)mat.mainTexture );
            decalComponent.SetUVRect(uvCoords);

            #if DEBUG
            decal.AddComponent<qd_DecalDebug>();
            #endif

            return decal;
        }

 private static ListViewShared.ListViewElementsEnumerator DoListView(ListViewState state, int[] colWidths, string dragTitle)
 {
   Rect rect = ListViewGUILayout.dummyRect;
   int yFrom = 0;
   int yTo = 0;
   ListViewShared.InternalLayoutedListViewState ilvState = state.ilvState;
   int controlId = GUIUtility.GetControlID(ListViewGUILayout.listViewHash, FocusType.Native);
   state.ID = controlId;
   state.selectionChanged = false;
   ilvState.state = state;
   if (Event.current.type != EventType.Layout)
   {
     rect = new Rect(0.0f, state.scrollPos.y, GUIClip.visibleRect.width, GUIClip.visibleRect.height);
     if ((double) rect.width <= 0.0)
       rect.width = 1f;
     if ((double) rect.height <= 0.0)
       rect.height = 1f;
     state.ilvState.rect = rect;
     yFrom = (int) rect.yMin / state.rowHeight;
     yTo = yFrom + (int) Math.Ceiling(((double) rect.yMin % (double) state.rowHeight + (double) rect.height) / (double) state.rowHeight) - 1;
     ilvState.invisibleRows = yFrom;
     ilvState.endRow = yTo;
     ilvState.rectHeight = (int) rect.height;
     if (yFrom < 0)
       yFrom = 0;
     if (yTo >= state.totalRows)
       yTo = state.totalRows - 1;
   }
   if (colWidths == null)
   {
     ListViewGUILayout.dummyWidths[0] = (int) rect.width;
     colWidths = ListViewGUILayout.dummyWidths;
   }
   return new ListViewShared.ListViewElementsEnumerator((ListViewShared.InternalListViewState) ilvState, colWidths, yFrom, yTo, dragTitle, new Rect(0.0f, (float) (yFrom * state.rowHeight), rect.width, (float) state.rowHeight));
 }

 public static void Line(float yOrigin, Color color)
 {
     var rect = new Rect(0, yOrigin, Screen.width, 1);
     GUI.color = color;
     GUI.DrawTexture(rect, Drawing.Pixel);
     Colors.ResetUIColor();
 }

        internal static void Display(int windowId)
        {
            // Reset Tooltip active flag...
              ToolTipActive = false;

              Rect rect = new Rect(Position.width - 20, 4, 16, 16);
              if (GUI.Button(rect, new GUIContent("", "Close Window")))
              {
            ShowWindow = false;
            ToolTip = "";
              }
              if (Event.current.type == EventType.Repaint && ShowToolTips)
            ToolTip = SMToolTips.SetActiveToolTip(rect, GUI.tooltip, ref ToolTipActive, 10);

              // This is a scroll panel (we are using it to make button lists...)
              GUILayout.BeginVertical();
              DisplayWindowTabs();
              // This is a scroll panel (we are using it to make button lists...)
              _displayViewerPosition = GUILayout.BeginScrollView(_displayViewerPosition, SMStyle.ScrollStyle,
            GUILayout.Height(200), GUILayout.Width(370));
              DisplaySelectedTab(_displayViewerPosition);
              GUILayout.EndScrollView();

              DisplayTabActions();
              GUILayout.EndVertical();
              GUI.DragWindow(new Rect(0, 0, Screen.width, 30));
              SMAddon.RepositionWindow(ref Position);
        }

        private static void DrawPanel(Rect rect, Color color, PanelStyleOption option)
        {
            GUI.color = color;
            GUI.Box(rect, "", PanelStyle(option));

            Colors.ResetUIColor();
        }

 public static void DrawFilledCurve(Rect r, AudioCurveRendering.AudioCurveAndColorEvaluator eval)
 {
   if (Event.current.type != EventType.Repaint)
     return;
   HandleUtility.ApplyWireMaterial();
   GL.Begin(1);
   float pixelsPerPoint = EditorGUIUtility.pixelsPerPoint;
   float num1 = 1f / pixelsPerPoint;
   float num2 = 0.5f * num1;
   float num3 = Mathf.Ceil(r.width) * pixelsPerPoint;
   float num4 = Mathf.Floor(r.x) + AudioCurveRendering.pixelEpsilon;
   float num5 = 1f / (num3 - 1f);
   float max = r.height * 0.5f;
   float num6 = r.y + 0.5f * r.height;
   float y = r.y + r.height;
   Color col;
   float b = Mathf.Clamp(max * eval(0.0f, out col), -max, max);
   for (int index = 0; (double) index < (double) num3; ++index)
   {
     float x = num4 + (float) index * num1;
     float a = Mathf.Clamp(max * eval((float) index * num5, out col), -max, max);
     float num7 = Mathf.Min(a, b) - num2;
     float num8 = Mathf.Max(a, b) + num2;
     GL.Color(new Color(col.r, col.g, col.b, 0.0f));
     AudioMixerDrawUtils.Vertex(x, num6 - num8);
     GL.Color(col);
     AudioMixerDrawUtils.Vertex(x, num6 - num7);
     AudioMixerDrawUtils.Vertex(x, num6 - num7);
     AudioMixerDrawUtils.Vertex(x, y);
     b = a;
   }
   GL.End();
 }

 public static Rect BeginCurveFrame(Rect r)
 {
   AudioCurveRendering.DrawCurveBackground(r);
   r = AudioCurveRendering.DrawCurveFrame(r);
   GUI.BeginGroup(r);
   return new Rect(0.0f, 0.0f, r.width, r.height);
 }

		override public void OnGUI(Rect position, MaterialProperty prop, string label, MaterialEditor editor) {
			if (!checkVisible (editor)) return;

			Color col = GUI.contentColor;
			Color bcol = GUI.backgroundColor;
			GUI.contentColor = new Color(1f, 1f, 0.8f, 1f);
			GUI.backgroundColor = backgroundColor;
			//position.y -= 15;
			Rect pos=new Rect(position);
			pos.y += 3;
			pos.height -= 3;
			//if (visibilityProp1==null || visibilityProp1=="indent") {
	//			pos.height -= 10;
	//			pos.y += 10;
			//}

			if (visibilityProp1!=null) {
				pos.x+=12;
				pos.width-=12;
			}
	//		pos.height = 17;
			EditorGUI.HelpBox(pos, (foldoutFlag ? "     ":"")+label, MessageType.None);

			if (foldoutFlag) {
				Rect fpos = new Rect(pos);
				fpos.x += 15;
				fpos.y += 1;
				bool state = EditorGUI.Foldout(fpos, prop.floatValue==1, "", true);
				prop.floatValue = state ? 1 : 0;
			}

			GUI.contentColor = col;
			GUI.backgroundColor = bcol;
		}

        public void drawKKSettingsGUI()
        {
            KKWindow = new GUIStyle(GUI.skin.window);
            KKWindow.padding = new RectOffset(3, 3, 5, 5);

            KKSettingsRect = GUI.Window(0xC10B3A8, KKSettingsRect, drawKKSettingsWindow, "", KKWindow);
        }

        private void HandleWindowEvents(Rect resizeRect)
        {
            var theEvent = Event.current;
            if (theEvent != null)
            {
                if (!mouseDown)
                {
                    if (theEvent.type == EventType.MouseDown && theEvent.button == 0 && resizeRect.Contains(theEvent.mousePosition))
                    {
                        mouseDown = true;
                        theEvent.Use();
                    }
                }
                else if (theEvent.type != EventType.Layout)
                {
                    if (Input.GetMouseButton(0))
                    {
                        // Flip the mouse Y so that 0 is at the top
                        float mouseY = Screen.height - Input.mousePosition.y;

                        WindowRect.width = Mathf.Clamp(Input.mousePosition.x - WindowRect.x + (resizeRect.width / 2), 50, Screen.width - WindowRect.x);
                        WindowRect.height = Mathf.Clamp(mouseY - WindowRect.y + (resizeRect.height / 2), 50, Screen.height - WindowRect.y);
                    }
                    else
                    {
                        mouseDown = false;
                    }
                }
            }
        }

        public Monitor(Int32[] arr, UInt16 ptr, UInt16 chars, UInt16 colPtr, UInt16 modePointer)
        {
            mem = arr;
            pointer = ptr;
            charSetPtr = chars;
            colors = new Color[16];
            modePtr = modePointer;
            for (int i = 0; i < 16; ++i) {
                colors[i] = new Color();
                colors[i].a = 1.0f;
            }
            colorPointer = colPtr;

            image = new Texture2D(256, 256, TextureFormat.ARGB32, false);
            windowPos = new Rect();
            if ((windowPos.x == 0) && (windowPos.y == 0))//windowPos is used to position the GUI window, lets set it in the center of the screen
            {
                windowPos = new Rect(Screen.width / 2, Screen.height / 2, 100, 100);
            }
            //Set all the pixels to black. If you don't do this the image contains random junk.
            for (int y = 0; y < image.height; y++) {
                for (int x = 0; x < image.width; x++) {
                    image.SetPixel(x, y, Color.black);
                }
            }
            image.Apply();
        }

 // RimWorld.AreaAllowedGUI
 private static void DoZoneSelector( Rect rect, ref Zone_Stockpile zoneAllowed, Zone_Stockpile zone, Texture2D tex)
 {
     rect = rect.ContractedBy( 1f );
     GUI.DrawTexture( rect, tex );
     Text.Anchor = TextAnchor.MiddleLeft;
     string label = zone?.label ?? "Any stockpile";
     Rect innerRect = rect;
     innerRect.xMin += 3f;
     innerRect.yMin += 2f;
     Widgets.Label( innerRect, label );
     if( zoneAllowed == zone )
     {
         Widgets.DrawBox( rect, 2 );
     }
     if( Mouse.IsOver( rect ) )
     {
         if( zone != null )
         {
             if ( zone.AllSlotCellsList() != null && zone.AllSlotCellsList().Count > 0 )
                 Find.CameraDriver.JumpTo( zone.AllSlotCellsList().FirstOrDefault() );
         }
         if( Input.GetMouseButton( 0 ) &&
              zoneAllowed != zone )
         {
             zoneAllowed = zone;
             SoundDefOf.DesignateDragStandardChanged.PlayOneShotOnCamera();
         }
     }
     TooltipHandler.TipRegion( rect, label );
     Text.Anchor = TextAnchor.UpperLeft;
 }

		public void OnGUI(Rect rect)
		{
			int controlID = GUIUtility.GetControlID(FocusType.Keyboard);
			if (AudioMixersTreeView.s_Styles == null)
			{
				AudioMixersTreeView.s_Styles = new AudioMixersTreeView.Styles();
			}
			this.m_TreeView.OnEvent();
			Rect r;
			Rect rect2;
			AudioMixerDrawUtils.DrawRegionBg(rect, out r, out rect2);
			AudioMixerDrawUtils.HeaderLabel(r, AudioMixersTreeView.s_Styles.header, AudioMixersTreeView.s_Styles.audioMixerIcon);
			if (GUI.Button(new Rect(r.xMax - 15f, r.y + 3f, 15f, 15f), AudioMixersTreeView.s_Styles.addText, EditorStyles.label))
			{
				AudioMixersTreeViewGUI audioMixersTreeViewGUI = this.m_TreeView.gui as AudioMixersTreeViewGUI;
				audioMixersTreeViewGUI.BeginCreateNewMixer();
			}
			this.m_TreeView.OnGUI(rect2, controlID);
			if (this.m_TreeView.data.GetVisibleRows().Count == 0)
			{
				EditorGUI.BeginDisabledGroup(true);
				GUI.Label(new RectOffset(-20, 0, -2, 0).Add(rect2), "No mixers found");
				EditorGUI.EndDisabledGroup();
			}
			AudioMixerDrawUtils.DrawScrollDropShadow(rect2, this.m_TreeView.state.scrollPos.y, this.m_TreeView.gui.GetTotalSize(this.m_TreeView.data.GetVisibleRows()).y);
			this.HandleCommandEvents(controlID);
			this.HandleObjectSelectorResult();
		}