/// <summary> /// Waits until the active inspector has finished rendering and then opens the menu. /// Delaying the opening of the menu like this can help avoid with some graphical glitches that can happen if the menu is opened in the middle of an inspector being drawn. /// </summary> /// <param name="menu"> Menu that should be opened. </param> /// <param name="disposeAfter"> Should the menu object be disposed after menu has been opened? Set this to false if the Menu is cached and reused, otherwise set this true. </param> /// <param name="inspector"> Inspector for which the context menu is being opened. Null if not opening for any inspector. </param> /// <param name="inspectorPart"> Part of the inspector for which the context menu is being opened. None if not opening for any inspector. </param> /// <param name="subject"> IDrawer for which the context menu is opened. Null if context menu doesn't belong to any IDrawer (e.g. toolbar menu item). </param> /// <param name="part"> Part of the subject for which the context menu is opened. E.g. reference to the targeted toolbar item. Can be null. </param> /// <param name="doOnMenuClosed"> Delegate to be called once menu has closed. Set to ContextMenuUtility.SelectLastContextMenuSubject to select the context menu subject once the context menu window has been closed. </param> public static void Open([NotNull] Menu menu, bool disposeAfter, [CanBeNull] IInspector inspector, InspectorPart inspectorPart, [CanBeNull] IDrawer subject, [CanBeNull] object part, Action <object> doOnMenuClosed = null) { #if DEV_MODE Debug.Assert(menu.Count > 0); Debug.Assert(inspector != null || subject == null); #endif openingMenu = menu; openingMenuInspector = inspector; openingMenuInspectorPart = inspectorPart; openingMenuSubject = new DrawerTarget(subject); openingMenuPart = part; openingMenuPosition = null; disposeMenuAfterOpening = disposeAfter; onMenuClosed = doOnMenuClosed; if (IsSafeToChangeInspectorContents || inspector == null) { #if DEV_MODE Debug.Log("Opening context menu immediately"); #endif OpenContextMenu(); } else { openDelayCounter = 2; } }
/// <summary> /// Sets mouseovered inspector part to given value. Optionally clears controls. /// </summary> /// <param name="setInspector"> The inspector to set as the mouseovered inspector. Can be null. </param> /// <param name="clearControls"> /// True to also clear mouseovered selectable and right-clickable drawer. /// If setInspector is null, drawer will get cleared regardless of the value of this flag. /// </param> /// <returns> True if mouseovered inspector changed. </returns> public bool SetInspector([CanBeNull] IInspector setInspector, bool clearControls) { #if DEV_MODE && PI_ASSERTATIONS if (setInspector == null && !clearControls) { Debug.LogWarning("Mouseovered.SetInspector setInspector was " + StringUtils.Null + " but clearControls was " + StringUtils.False); } #endif bool changed; if (setInspector != inspector) { changed = true; #if DEV_MODE && DEBUG_SET_INSPECTOR Debug.Log(StringUtils.ToColorizedString("Mouseovered.SetInspector(", setInspector, ")")); #endif var inspectorWas = Inspector; Inspector = setInspector; if (setInspector == null) { InspectorPart = InspectorPart.None; ClearControls(); } else if (clearControls) { ClearControls(); } if (onInspectorChanged != null) { onInspectorChanged(inspectorWas, setInspector); } } else if (clearControls) { #if DEV_MODE && PI_ASSERTATIONS if (inspectorPart == InspectorPart.Viewport) { Debug.LogWarning("Mouseovered.SetInspector was called with clearControls " + StringUtils.True + " but inspector did not change and inspectorPart " + StringUtils.ToColorizedString(inspectorPart)); } #endif changed = ClearControls(); } else { changed = false; } #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(Inspector == setInspector); AssertStateIsValid(); #endif return(changed); }
/// <inheritdoc/> public void SetMouseoveredInspector(IInspector inspector, InspectorPart inspectorPart) { #if DEV_MODE && PI_ASSERTATIONS if (inspectorPart == InspectorPart.None) { if (inspector != null) { Debug.LogError("SetMouseoveredInspector was called with inspector " + inspector + " but inspectorPart " + StringUtils.ToColorizedString(inspectorPart) + "."); } } else if (inspector == null) { Debug.LogError("SetMouseoveredInspector was called with inspector " + StringUtils.Null + " but inspectorPart " + StringUtils.ToColorizedString(inspectorPart) + "."); } #endif #if DEV_MODE && DEBUG_SET_MOUSEOVERED_INSPECTOR if (mouseovered.Inspector != inspector || inspectorPart != mouseovered.InspectorPart) { Debug.Log(StringUtils.ToColorizedString("SetMouseoveredInspector(", inspector, ", part=", inspectorPart + ") with IgnoreAllMouseInputs=", IgnoreAllMouseInputs, ", Cursor.CanRequestLocalPosition=", Cursor.CanRequestLocalPosition, ", Cursor.LocalPosition=", Cursor.LocalPosition)); } #endif bool mouseoveredViewportChanged = false; if (mouseovered.Inspector != inspector) { mouseoveredViewportChanged = true; mouseovered.SetInspectorAndPart(inspector, inspectorPart, true); } else if (mouseovered.InspectorPart != inspectorPart) { if (inspectorPart == InspectorPart.Viewport || mouseovered.InspectorPart == InspectorPart.Viewport) { mouseoveredViewportChanged = true; } mouseovered.SetInspectorPart(inspectorPart); } if (mouseoveredViewportChanged && mouseDownInfo.IsDrag()) { if (inspectorPart != InspectorPart.Viewport) { mouseDownInfo.OnCursorLeftInspectorViewportDuringDrag(); } else { #if DEV_MODE && DEBUG_DRAG Debug.Log(StringUtils.ToColorizedString("OnCursorEnteredInspectorViewportDuringDrag(", inspector, ") with NowReordering=", mouseDownInfo.NowReordering, ", DrawGUI.IsUnityObjectDrag=", DrawGUI.IsUnityObjectDrag)); #endif mouseDownInfo.OnCursorEnteredInspectorViewportDuringDrag(inspector); } } }
private void Select(IInspector inspector, InspectorPart part, [CanBeNull] IDrawer control, ReasonSelectionChanged reason, int multiSelect) { #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(!(multiSelect != 0 && control == null), "Select was called with multiSelect " + multiSelect + " but control null. Reason: " + reason); Debug.Assert(control == null || part == InspectorPart.Viewport, "Select was called with InspectorPart " + part + " but control (" + control + ") not being null. Reason: " + reason); Debug.Assert(control == null || inspector != null, "Select was called with control null but inspector (" + inspector + ") not null. Reason: " + reason); Debug.Assert((part == InspectorPart.None) == (inspector == null), "Select was called with InspectorPart " + StringUtils.ToColorizedString(part) + " and inspector " + StringUtils.ToColorizedString(StringUtils.ToString(inspector)) + " (control = " + StringUtils.ToString(control) + "). Reason: " + reason); #endif selected.Set(inspector, part, control, multiSelect, reason); }
private void OnSelectionChanged(IInspector selectedInspector, InspectorPart inspectorPart, IDrawer focusedDrawer) { #if DEV_MODE Debug.Log(StringUtils.ToColorizedString("OnSelectionChanged: inspector=", selectedInspector, ", drawer=", focusedDrawer)); #endif if (selectedInspector == inspector && focusedDrawer != null) { ShowDocumentationForMember(focusedDrawer); } }
public void Set([CanBeNull] IInspector setInspector, InspectorPart setPart, [CanBeNull] IDrawer setDrawer, int multiSelect, ReasonSelectionChanged reason) { bool suppressed = suppressOnSelectionChangedEvents; suppressOnSelectionChangedEvents = true; SetInspectorAndPart(setInspector, setPart, reason); SetFocusedDrawer(setDrawer, multiSelect, reason); suppressOnSelectionChangedEvents = suppressed; HandleOnSelectionEvent(); }
/// <summary> /// Sets mouseovered inspector part to given value. /// </summary> /// <param name="setInspectorPart"> The inspector part to set as the mouseovered part. </param> /// <returns> True if mouseovered inspector part changed. </returns> public bool SetInspectorPart(InspectorPart setInspectorPart) { bool changed; if (InspectorPart != setInspectorPart) { changed = true; #if DEV_MODE && DEBUG_SET_INSPECTOR_PART Debug.Log(StringUtils.ToColorizedString("Mouseovered.SetInspectorPart(", setInspectorPart, ")")); #endif InspectorPart = setInspectorPart; if (inspectorPart == InspectorPart.None) { Clear(); } else { #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(Inspector != null); #endif if (inspectorPart != InspectorPart.Viewport) { ClearControls(); } } } else { changed = false; } #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(InspectorPart == setInspectorPart); if (setInspectorPart == InspectorPart.None) { Debug.Assert(Inspector == null); } else { Debug.Assert(Inspector != null); } AssertStateIsValid(); #endif return(changed); }
public void SetInspectorAndPart(IInspector setInspector, InspectorPart setPart, ReasonSelectionChanged reason) { bool suppressed = suppressOnSelectionChangedEvents; suppressOnSelectionChangedEvents = true; var fromInspector = inspector; var fromPart = inspectorPart; bool inspectorChanged = fromInspector != setInspector; bool partChanged = inspectorChanged || fromPart != setPart; #if DEV_MODE && DEBUG_SET_INSPECTOR UnityEngine.Debug.Log(StringUtils.ToColorizedString("Selected.SetInspectorAndPart(", setInspector, ", part=", setPart, ", reason=", reason, ") with inspectorChanged=", inspectorChanged, ", partChanged=", partChanged)); #endif if (partChanged) { if (setPart != InspectorPart.Viewport) { ClearSelectedDrawers(reason, null); } InspectorPart = setPart; SetInspectorOnly(setInspector); if (!inspectorChanged) { if (setInspector != null) { setInspector.OnSelectedPartChanged(fromPart, setPart, reason); } } else { if (fromInspector != null) { fromInspector.OnSelectedPartChanged(fromPart, InspectorPart.None, reason); } if (setInspector != null) { setInspector.OnSelectedPartChanged(InspectorPart.None, setPart, reason); } } } suppressOnSelectionChangedEvents = suppressed; HandleOnSelectionEvent(); }
/// <summary> /// Waits until the active inspector has finished rendering and then opens the menu /// at the given position as a dropdown menu. /// Delaying the opening of the menu like this can help avoid with some graphical glitches that /// can happen if the menu is opened in the middle of an inspector being drawn /// </summary> /// <param name="menu"> Menu that should be opened. </param> /// <param name="position"> Position where menu should be opened. </param> /// <param name="disposeAfter"> /// Should the menu object be disposed after menu has been opened? /// Set this to false if the Menu is cached and reused, otherwise set this true. /// </param> /// <param name="inspector"> Inspector for which the context menu is being opened. Null if not opening for any inspector. </param> /// <param name="inspectorPart"> Part of the inspector for which the context menu is being opened. None if not opening for any inspector. </param> /// <param name="subject"> IDrawer whose context menu is being opened. Null if context menu doesn't belong to any IDrawer (e.g. toolbar menu item). </param> /// <param name="part"> Can contain the part of the subject for which the context menu is opened. E.g. reference to the targeted toolbar item. </param> /// <param name="doOnMenuClosed"> Delegate to be called once menu has closed. Set to ContextMenuUtility.SelectLastContextMenuSubject to select the context menu subject once the context menu window has been closed. Can be null. </param> public static void OpenAt([NotNull] Menu menu, Rect position, bool disposeAfter, [CanBeNull] IInspector inspector, InspectorPart inspectorPart, [CanBeNull] IDrawer subject, [CanBeNull] object part, [CanBeNull] Action <object> doOnMenuClosed) { #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(menu != null); Debug.Assert(menu.Count > 0); Debug.Assert(position.x >= 0f); Debug.Assert(position.y >= 0f); Debug.Assert(position.x < Screen.currentResolution.width); Debug.Assert(position.y < Screen.currentResolution.height); if (subject != null) { Debug.Assert(inspector != null); Debug.Assert(inspector == subject.Inspector); Debug.Assert(inspectorPart == InspectorPart.Viewport); } Debug.Assert(inspectorPart != InspectorPart.None || inspector == null); Debug.Assert(inspectorPart == InspectorPart.None || inspector != null); #endif openingMenu = menu; openingMenuInspector = inspector; openingMenuInspectorPart = inspectorPart; openingMenuSubject = new DrawerTarget(subject); openingMenuPart = part; disposeMenuAfterOpening = disposeAfter; onMenuClosed = doOnMenuClosed; var openAtLocalPoint = position.position; var openAtScreenPoint = GUIUtility.GUIToScreenPoint(openAtLocalPoint); position.position = openAtScreenPoint; openingMenuPosition = position; if (IsSafeToChangeInspectorContents || inspector == null) { #if DEV_MODE && DEBUG_OPEN_MENU Debug.Log("Opening context menu @ " + position + " immediately."); #endif OpenContextMenu(); } else { #if DEV_MODE && DEBUG_OPEN_MENU Debug.Log("Opening context menu @ " + position + " delayed... inspector.State.WindowRect.y=" + inspector.State.WindowRect.y + ", LocalDrawAreaOffset=" + DrawGUI.GetLocalDrawAreaOffset()); #endif openDelayCounter = 2; inspector.RefreshView(); } }
public static bool MouseIsOver(this Rect area, Vector2 mousePosition, InspectorPart inspectorPart = InspectorPart.Viewport) { if (area.Contains(mousePosition)) { var manager = InspectorUtility.ActiveManager; if (manager != null) { if (manager.MouseoveredInspectorPart != inspectorPart) { #if DEV_MODE if (Event.current != null && Event.current.type == EventType.MouseDown) { Debug.LogWarning("MouseIsOver - ignoring click because MouseoveredInspectorPart (" + manager.MouseoveredInspectorPart + ") did not match required inspectorPart " + inspectorPart + "!"); } #endif return(false); } if (manager.IgnoreAllMouseInputs) { #if DEV_MODE if (Event.current != null && Event.current.type == EventType.MouseDown) { Debug.LogWarning("MouseIsOver - ignoring click because IgnoreAllMouseInputs was true!"); } #endif return(false); } if (manager.ActiveInspector != manager.MouseoveredInspector) { #if DEV_MODE if (Event.current != null && Event.current.type == EventType.MouseDown) { Debug.LogWarning("MouseIsOver - ignoring click because ActiveInspector (" + StringUtils.ToString(manager.ActiveInspector) + ") != MouseoveredInspector (" + StringUtils.ToString(manager.MouseoveredInspector) + ")!"); } #endif return(false); } } return(true); } return(false); }
/// <summary> /// Waits until the active inspector has finished rendering and then opens the menu at the given position as a dropdown menu. /// Delaying the opening of the menu like this can help avoid with some graphical glitches that can happen if the menu is opened in the middle of an inspector being drawn /// /// Once opened context menu has been the subject of the context menu will be selected (if necessary data is provided). /// </summary> /// <param name="menu"> Menu that should be opened. </param> /// <param name="position"> Position where menu should be opened. </param> /// <param name="disposeAfter"> /// Should the menu object be disposed after menu has been opened? /// Set this to false if the Menu is cached and reused, otherwise set this true. /// </param> /// <param name="inspector"> Inspector for which the context menu is being opened. Null if not opening for any inspector. </param> /// <param name="inspectorPart"> Part of the inspector for which the context menu is being opened. None if not opening for any inspector. </param> /// <param name="subject"> IDrawer whose context menu is being opened. Null if context menu doesn't belong to any IDrawer (e.g. toolbar menu item). </param> /// <param name="part"> Can contain the part of the subject for which the context menu is opened. E.g. reference to the targeted toolbar item. </param> public static void OpenAt([NotNull] Menu menu, Rect position, bool disposeAfter, [CanBeNull] IInspector inspector, InspectorPart inspectorPart, [CanBeNull] IDrawer subject, [CanBeNull] object part) { OpenAt(menu, position, disposeAfter, inspector, inspectorPart, subject, part, SelectLastContextMenuSubject); }
/// <inheritdoc/> public void Select(IInspector inspector, InspectorPart part, IDrawer control, ReasonSelectionChanged reason) { Select(inspector, part, control, reason, 0); }
public static bool DetectMouseButtonEvent(this Rect clickableArea, EventType eventType, int mouseButton, InspectorPart inspectorPart = InspectorPart.Viewport) { var e = Event.current; if (e.type == eventType && e.button == mouseButton) { return(MouseIsOver(clickableArea, e.mousePosition, inspectorPart)); } return(false); }
public static bool DetectClick(this Rect clickableArea, InspectorPart inspectorPart = InspectorPart.Viewport) { return(DetectMouseButtonEvent(clickableArea, EventType.MouseDown, 0)); }
/// <summary> /// Sets focused drawer and handles calling OnDeselected (first) and OnSelected (second) for setDrawer /// and any previously focused drawer that is no longer selected. Also makes sure that selected inspector /// and inspector part are valid. /// </summary> /// <param name="setDrawer"> The drawer to set as the focused drawer. Can be null if focused drawer should be set to none. </param> /// <param name="multiSelect"> If 0 this is not a multi selection, if -1 remove from multi-selection, and if 1 add to multi-selection. </param> /// <param name="reason">Reason why focus is changing.</param> private void SetFocusedDrawer([CanBeNull] IDrawer setDrawer, int multiSelect, ReasonSelectionChanged reason) { var focusedDrawerWas = focusedDrawer; #if DEV_MODE && PI_ASSERTATIONS UnityEngine.Debug.Assert(multiSelect == 0 || setDrawer != null); //multi-selecting doesn't make sense for a null drawer UnityEngine.Debug.Assert(multiSelect == 0 || setDrawer.Parent is ICollectionDrawer); //for now multi-selection is only supported for collection members UnityEngine.Debug.Assert(multiSelect != -1 || isMultiSelection); //can't remove from multi-selection if there is no multi-selection UnityEngine.Debug.Assert(!isMultiSelection || multiSelection.Count >= 2); //multi-selection requires at least two selected drawers #endif #if SAFE_MODE || DEV_MODE if (setDrawer != null && !setDrawer.Selectable) { #if DEV_MODE UnityEngine.Debug.LogError("SetFocusedDrawer(" + StringUtils.ToString(setDrawer) + ").Selectable was " + StringUtils.False); #endif for (setDrawer = setDrawer.Parent; setDrawer != null && !setDrawer.Selectable; setDrawer = setDrawer.Parent) { ; } } #endif #if SAFE_MODE || DEV_MODE if (setDrawer != null) { #if DEV_MODE && PI_ASSERTATIONS UnityEngine.Debug.Assert(setDrawer.Selectable, "SetFocusedDrawer(" + StringUtils.ToString(setDrawer) + ").Selectable was " + StringUtils.False); UnityEngine.Debug.Assert(!setDrawer.Inactive, "SetFocusedDrawer(" + StringUtils.ToString(setDrawer) + ").Inactive was " + StringUtils.True); UnityEngine.Debug.Assert(setDrawer.ShouldShowInInspector, "SetFocusedDrawer(" + StringUtils.ToString(setDrawer) + ").ShowInInspector was " + StringUtils.False); UnityEngine.Debug.Assert(inspector != null, "SetFocusedDrawer(" + StringUtils.ToString(setDrawer) + ") inspector was " + StringUtils.Null); UnityEngine.Debug.Assert(inspectorPart == InspectorPart.Viewport, "SetFocusedDrawer(" + StringUtils.ToString(setDrawer) + ") inspectorPart was " + inspectorPart); UnityEngine.Debug.Assert(!ObjectPicker.IsOpen, "SetFocusedDrawer(" + StringUtils.ToString(setDrawer) + ") ObjectPicker.IsOpen was " + StringUtils.True); //UnityEngine.Debug.Assert(inspector.InspectorDrawer.HasFocus); //this can be true if an item is right cicked #endif if (inspector == null) { Inspector = InspectorUtility.ActiveInspector; } inspectorPart = InspectorPart.Viewport; //this can be true if an item was just right-clicked if (!inspector.InspectorDrawer.HasFocus) { #if DEV_MODE UnityEngine.Debug.Log("Manually focusing window! Event=" + StringUtils.ToString(UnityEngine.Event.current)); #endif inspector.InspectorDrawer.FocusWindow(); } } #endif #if DEV_MODE && DEBUG_SET_DRAWER UnityEngine.Debug.Log(StringUtils.ToColorizedString("Selected.SetFocusedDrawer(", setDrawer, ", multiSelect=", multiSelect, ", reason=", reason, ")")); #endif switch (multiSelect) { case 0: focusedDrawer = setDrawer; ClearMultiSelection(reason, setDrawer); if (setDrawer != focusedDrawerWas) { if (focusedDrawerWas != null && !focusedDrawerWas.Inactive) { focusedDrawerWas.OnDeselected(reason, setDrawer); } if (setDrawer != null) { if (!(setDrawer is ITextFieldDrawer) && !(setDrawer is ICustomEditorDrawer)) { DrawGUI.EditingTextField = false; } setDrawer.OnSelected(reason, focusedDrawerWas, false); } else { DrawGUI.EditingTextField = false; } if (inspector != null) { // This can possibly help in ensuring that selection rects are drawn in the right place // and in ensuring that the inspector feels very responsive. inspector.OnNextLayout(inspector.RefreshView); } } break; case 1: DrawGUI.EditingTextField = false; bool wasSelected = IsSelected(setDrawer); focusedDrawer = setDrawer; multiSelection.AddIfDoesNotContain(focusedDrawerWas); multiSelection.AddIfDoesNotContain(setDrawer); UpdateMultiSelection(); if (!wasSelected) { setDrawer.OnSelected(reason, focusedDrawerWas, isMultiSelection); } if (inspector != null) { // This can possibly help in ensuring that selection rects are drawn in the right place // and in ensuring that the inspector feels very responsive. inspector.OnNextLayout(inspector.RefreshView); } break; case -1: multiSelection.Remove(setDrawer); if (setDrawer == focusedDrawer) { int selectedCount = multiSelection.Count; focusedDrawer = selectedCount == 0 ? setDrawer : multiSelection[selectedCount - 1]; } UpdateMultiSelection(); if (setDrawer != focusedDrawer && !setDrawer.Inactive) { setDrawer.OnDeselected(reason, focusedDrawer); } if (!isMultiSelection) { DrawGUI.EditingTextField = false; } else if (focusedDrawer != null) { if (!(setDrawer is ITextFieldDrawer)) { DrawGUI.EditingTextField = false; } } else { DrawGUI.EditingTextField = false; } if (inspector != null) { // This can possibly help in ensuring that selection rects are drawn in the right place // and in ensuring that the inspector feels very responsive. inspector.OnNextLayout(inspector.RefreshView); } break; } if (focusedDrawer != null) { rowIndex = focusedDrawer.GetSelectedRowIndex(); rowElementCount = setDrawer.GetRowSelectableCount(); } #if DEV_MODE && PI_ASSERTATIONS UnityEngine.Debug.Assert(multiSelect != 0 || !isMultiSelection); UnityEngine.Debug.Assert(!isMultiSelection || multiSelection.Count >= 2); #endif }
/// <inheritdoc/> public void Select(IInspector inspector, InspectorPart part, ReasonSelectionChanged reason) { selected.SetInspectorAndPart(inspector, part, reason); }
/// <inheritdoc/> public void AddToMultiSelection(IInspector setInspector, InspectorPart setPart, IDrawer add, ReasonSelectionChanged reason) { Select(setInspector, setPart, add, reason, 1); }
/// <summary> /// Sets mouseovered inspector part to given value. Optionally clears controls. /// </summary> /// <param name="setInspector"> The inspector to set as the mouseovered inspector. Can be null. </param> /// <param name="setInspectorPart"> The inspector part to set as the mouseovered part. </param> /// <param name="clearControls"> /// True to also clear mouseovered selectable and right-clickable drawer. /// If setInspector is null or InspectorPart is not Viewport, drawer will get cleared regardless of the value of this flag. /// </param> /// <returns> True if mouseovered inspector or part changed. </returns> public bool SetInspectorAndPart([CanBeNull] IInspector setInspector, InspectorPart setInspectorPart, bool clearControls) { #if DEV_MODE && PI_ASSERTATIONS var inspectorWasForDebugging = Inspector; var partWasForDebugging = InspectorPart; if (setInspector == null && !clearControls) { Debug.LogWarning("Mouseovered.SetInspector setInspector was " + StringUtils.Null + " but clearControls was " + StringUtils.False); } #endif bool changed; if (InspectorPart != setInspectorPart) { changed = true; #if DEV_MODE && (DEBUG_SET_INSPECTOR || DEBUG_SET_INSPECTOR_PART) Debug.Log(StringUtils.ToColorizedString("Mouseovered.SetInspectorAndPart(", setInspector, ", ", setInspectorPart, ")")); #endif var inspectorWas = Inspector; if (setInspectorPart == InspectorPart.None) { #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(clearControls); Debug.Assert(setInspector == null, "Mouseovered.SetInspectorAndPart called with inspectorPart " + StringUtils.Red("None") + " but setInspector " + setInspector); #endif Clear(); #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(Inspector == setInspector); #endif } else if (setInspectorPart != InspectorPart.Viewport || clearControls) { InspectorPart = setInspectorPart; SetInspector(setInspector, true); #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(Inspector == setInspector); #endif } else { InspectorPart = setInspectorPart; SetInspector(setInspector, false); #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(Inspector == setInspector); #endif } } else if (setInspector != Inspector) { var inspectorWas = Inspector; changed = true; #if DEV_MODE && (DEBUG_SET_INSPECTOR || DEBUG_SET_INSPECTOR_PART) Debug.Log(StringUtils.ToColorizedString("Mouseovered.SetInspectorAndPart(", setInspector, ", ", setInspectorPart, ")")); #endif Inspector = setInspector; if (setInspector == null) { SetInspector(null, true); } else { SetInspector(setInspector, clearControls); } #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(inspectorWas != setInspector); #endif } else { if (clearControls) { #if DEV_MODE if (setInspector != null && setInspectorPart == InspectorPart.Viewport) { Debug.LogWarning("Mouseovered.SetInspectorAndPart was called with clearControls " + StringUtils.True + " even though mouseovered inspector " + setInspector + " or part " + setInspectorPart + " did not change. Was this intentional?"); } #endif changed = ClearControls(); } else { changed = false; } } #if DEV_MODE && PI_ASSERTATIONS if (Inspector != setInspector) { Debug.LogError("Mouseovered.Inspector value was " + (Inspector == null ? "null" : Inspector.ToString()) + " after SetInspectorAndPart(" + (setInspector == null ? "null" : setInspector.ToString()) + ", " + StringUtils.ToColorizedString(InspectorPart) + ") finished. Inspector was " + (inspectorWasForDebugging == null ? "null" : inspectorWasForDebugging.ToString()) + " and part " + partWasForDebugging + " when method was called."); } AssertStateIsValid(); #endif return(changed); }
/// <inheritdoc/> public void RemoveFromMultiSelection(IInspector setInspector, InspectorPart setPart, IDrawer remove, ReasonSelectionChanged reason) { Select(setInspector, setPart, remove, reason, -1); }