public static void OnExecuteCommand(this IInspectorDrawer inspectorDrawer, Event e) { if (DrawGUI.ExecutingCustomMenuCommand || !inspectorDrawer.HasFocus) { #if DEV_MODE && DEBUG_IGNORED_COMMANDS Debug.LogWarning(StringUtils.ToColorizedString("Ignoring ExecuteCommand with name \"", e.commandName + "\"\nDrawer.HasFocus=", inspectorDrawer.HasFocus, ", ExecutingCustomMenuCommand=", DrawGUI.ExecutingCustomMenuCommand, ", FocusedDrawer=" + inspectorDrawer.Manager.FocusedControl)); #endif return; } #if DEV_MODE && DEBUG_EXECUTE_COMMAND if (!string.Equals(e.commandName, "NewKeyboardFocus", System.StringComparison.Ordinal)) { Debug.Log("Detected ExecuteCommand with name: " + e.commandName + "\nFocusedControl=" + StringUtils.ToString(inspectorDrawer.Manager.FocusedControl) + ", keyCode=" + e.keyCode); } #endif #if DEV_MODE && DEBUG_NEW_KEYBOARD_FOCUS if (string.Equals(e.commandName, "NewKeyboardFocus", System.StringComparison.Ordinal)) { var m = inspectorDrawer.Manager; Debug.Log(StringUtils.ToColorizedString("NewKeyboardFocus part=", m.SelectedInspectorPart, ", control=", m.FocusedControl, ", KeyboardControl=", KeyboardControlUtility.KeyboardControl)); } #endif var selectedView = inspectorDrawer.SelectedOrDefaultView(); if (selectedView != null && inspectorDrawer.HasFocus) { selectedView.OnExecuteCommand(e); } }
private void AfterUndoOrRedo() { var inspector = InspectorUtility.ActiveInspector; if (inspector != null) { // Disable the undo system temporarily so that new undo entries aren't generated as unintended side effects // when cached values in the inspector are updated (this should not happen, but making sure). Disable(); onUpdateBroadcaster = inspector.InspectorDrawer; onUpdateBroadcaster.OnUpdate += EnableDelayedAfterOnUpdate; // Stop editing text field when Undo is detected, so that if the value that was undone // is the field that is being edited, the changes will be seen immediately. if (DrawGUI.EditingTextField) { var focusedDrawer = inspector.Manager.FocusedControl; if (focusedDrawer != null) { DrawGUI.EditingTextField = false; } } } if (OnOndoOrRedoPerformed != null) { OnOndoOrRedoPerformed(); } }
public IInspector Create(Type inspectorType, IInspectorDrawer drawer, InspectorPreferences preferences, Object[] inspected, Vector2 scrollPos, bool viewIsLocked) { IInspector result; object instanceFromPool; if (pool.TryGet(inspectorType, out instanceFromPool)) { result = (IInspector)instanceFromPool;; } else { result = (IInspector)inspectorType.CreateInstance(); } #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(!activeInstances.Contains(result)); Debug.Assert(!activeInstances.Contains(null)); #endif AddToActiveInstances(result); result.Setup(drawer, preferences, inspected, scrollPos, viewIsLocked); #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(activeInstances.Contains(result), "Created inspector " + result + " not found in InspectorManager.activeInstances"); Debug.Assert(!pool.Contains(result), "Created inspector " + result + " still found in InspectorManager.pool"); #endif return(result); }
private void StopTween() { #if DEV_MODE && DEBUG_ENABLED UnityEngine.Debug.Log(StringUtils.ToColorizedString("TweenedBool.StopTween with tweenProgress=", tweenProgress, ", targetValue=", targetValue, ", NowTweening=", NowTweening)); #endif inspectorDrawer.OnUpdate -= Update; tweeningCount--; //DrawGUI.CancelOnEveryBeginOnGUI(inspectorDrawer.Repaint); inspectorDrawer = null; if (targetValue) { if (tweenProgress >= 1f) { if (onTweenFinished != null) { var callback = onTweenFinished; onTweenFinished = null; callback(targetValue); } } } else if (tweenProgress <= 0f) { if (onTweenFinished != null) { var callback = onTweenFinished; onTweenFinished = null; callback(targetValue); } } }
/// <inheritdoc/> public override void Setup(IInspectorDrawer drawer, InspectorPreferences setPreferences, Object[] inspected, Vector2 scrollPos, bool viewIsLocked) { #if DEV_MODE && DEBUG_SETUP_TIME var timer = new ExecutionTimeLogger(); timer.Start(GetType().Name + ".Setup"); #endif #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(setPreferences != null); #endif previewDrawer = new PreviewDrawer(this); // Call base.Setup before calling Setup for the toolbar, so that the Preferences field gets assigned first base.Setup(drawer, setPreferences, inspected, scrollPos, viewIsLocked); #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(Preferences != null); Debug.Assert(Preferences == setPreferences); #endif #if DEV_MODE && DEBUG_SETUP_TIME timer.FinishAndLogResults(); #endif }
public static IInspector SelectedOrDefaultView(this IInspectorDrawer inspectorDrawer) { var mainView = inspectorDrawer.MainView; var splittable = inspectorDrawer as ISplittableInspectorDrawer; if (splittable != null && splittable.ViewIsSplit) { var manager = splittable.Manager; var selected = manager.SelectedInspector; if (mainView == selected) { return(mainView); } var splitView = splittable.SplitView; if (splitView == selected) { return(splitView); } if (splitView == manager.ActiveInspector) { return(splitView); } } return(mainView); }
public void Dispose() { if (inspectorDrawer != null) { inspectorDrawer.OnUpdate -= Update; inspectorDrawer = null; } }
/// <inheritdoc/> public void OnNextLayout(IDrawerDelayableAction action, IInspectorDrawer changingInspectorDrawer = null) { onNextLayoutDelayed.Enqueue(action); if (changingInspectorDrawer != null) { changingInspectorDrawer.RefreshView(); } else { EnsureOnGUICallbacks(true); } }
/// <inheritdoc/> public override void Setup(IInspectorDrawer drawer, InspectorPreferences setPreferences, Object[] inspected, Vector2 scrollPos, bool viewIsLocked) { #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(setPreferences != null); #endif // Call base.Setup before calling Setup for the toolbar, so that the Preferences field gets assigned first base.Setup(drawer, setPreferences, inspected, scrollPos, viewIsLocked); #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(Preferences != null); Debug.Assert(Preferences == setPreferences); #endif }
public void SetTarget([NotNull] IInspectorDrawer inspectorDrawer, bool setTarget, Action <bool> onFinished = null) { #if DEV_MODE && DEBUG_ENABLED UnityEngine.Debug.Log(StringUtils.ToColorizedString("TweenedBool.SetTarget(", setTarget, ") with tweenProgress=", tweenProgress, ", targetValue=", targetValue, ", NowTweening=", NowTweening, ", onFinished=", onFinished)); #endif #if SAFE_MODE || DEV_MODE if (inspectorDrawer == null) { UnityEngine.Debug.LogError("TweenedBool.SetTarget called with null inspectorDrawer. Use SetValueInstant instead!"); targetValue = setTarget; tweenProgress = setTarget ? 1f : 0f; return; } #endif targetValue = setTarget; // stop any tweens in progress if (NowTweening) { StopTween(); } // if already at target value, we don't need to do any tweening // and should call onFinished immediately if (setTarget ? tweenProgress >= 1f : tweenProgress <= 0f) { if (onFinished != null) { onFinished(targetValue); } return; } onTweenFinished += onFinished; this.inspectorDrawer = inspectorDrawer; StartTween(); // if tween speed is invalid value or extremely high value // then skip the animation completely if (tweenSpeed <= 0f || tweenSpeed >= 144f) { SetValueInstant(targetValue); } }
private void Awake() { if (inspectorDrawer == null) { var componentTypes = TypeExtensions.GetImplementingComponentTypes(typeof(IInspectorDrawer), false); for (int n = componentTypes.Length - 1; n >= 0; n--) { inspectorDrawer = GetComponent(componentTypes[n]) as IInspectorDrawer; if (inspectorDrawer != null) { break; } } Debug.Assert(inspectorDrawer != null, "InspectorClickSelector could not find any Component implementing ISelectionManager in scene!"); } }
/// <summary> /// Method used for creating new Inspector instances. All instances should be /// created through the Manager, so that the IInspectorManager->IInspectorDrawer->IInspector /// hierarchy can be properly set up. /// </summary> /// <typeparam name="TInspector"> Type of the inspector. </typeparam> /// <param name="result">[out]The created inspector</param> /// <param name="drawer"> The drawer of the inspector. </param> /// <param name="preferences"> Preferences for the inspector. </param> /// <param name="inspected"> The inspected Unity Objects. </param> /// <param name="scrollPos"> The current scroll position of the inspector. </param> /// <param name="viewIsLocked"> True if view is locked. </param> /// <param name="setup"> Delegate to the Setup method for the Inspector. </param> public void Create <TInspector>(out TInspector result, IInspectorDrawer drawer, InspectorPreferences preferences, Object[] inspected, Vector2 scrollPos, bool viewIsLocked, SetupForInspected <TInspector> setup) where TInspector : class, IInspector, new() { if (!pool.TryGet(out result)) { result = new TInspector(); } #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(!activeInstances.Contains(result)); Debug.Assert(!activeInstances.Contains(null)); #endif AddToActiveInstances(result); setup(result, preferences, drawer, inspected, scrollPos, viewIsLocked); #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(activeInstances.Contains(result), "Created inspector " + result + " not found in InspectorManager.activeInstances"); Debug.Assert(!pool.Contains(result), "Created inspector " + result + " still found in InspectorManager.pool"); #endif }
public static void OnValidateCommand(this IInspectorDrawer inspectorDrawer, Event e) { if (DrawGUI.ExecutingCustomMenuCommand || !inspectorDrawer.HasFocus) { #if DEV_MODE Debug.Log("Ignoring ValidateCommand with name: " + e.commandName); #endif return; } #if DEV_MODE Debug.Log("Detected ValidateCommand with name: " + e.commandName); #endif var selectedView = inspectorDrawer.Manager.SelectedInspector; if (selectedView != null && selectedView.InspectorDrawer == inspectorDrawer && inspectorDrawer.HasFocus) { selectedView.OnValidateCommand(e); } }
/// <inheritdoc/> public void OnNextOnGUI(Action action, IInspectorDrawer changingInspectorDrawer = null) { #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(action != null); #endif #if DEV_MODE && DEBUG_ON_NEXT_ONGUI Debug.Log("OnNextOnGUI(" + StringUtils.ToString(action) + ") with changingInspectorDrawer=" + StringUtils.ToString(changingInspectorDrawer), changingInspectorDrawer as Object); #endif DrawGUI.OnNextBeginOnGUI(action, false); if (changingInspectorDrawer != null) { changingInspectorDrawer.RefreshView(); } else { EnsureOnGUICallbacks(false); } }
/// <inheritdoc/> public void OnNextLayout(Action action, IInspectorDrawer changingInspectorDrawer = null) { #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(action != null); #endif #if DEV_MODE && DEBUG_ON_NEXT_LAYOUT Debug.Log("OnNextLayout(" + StringUtils.ToString(action) + ")", changingInspectorDrawer as Object); #endif onNextLayout += action; if (changingInspectorDrawer != null) { changingInspectorDrawer.RefreshView(); } else { EnsureOnGUICallbacks(true); } }
public void OnInspectorDrawerLostFocus(IInspectorDrawer inspectorDrawer) { if (focusedDrawer != null) { if (inspector.InspectorDrawer == inspectorDrawer) { focusedDrawer.OnInspectorLostFocusWhileSelected(); if (isMultiSelection) { for (int n = multiSelection.Count - 1; n >= 0; n--) { var multiSelected = multiSelection[n]; if (multiSelected != focusedDrawer) { multiSelected.OnInspectorLostFocusWhileSelected(); } } } } } }
/// <summary> Deserialize inspector state. </summary> /// <param name="drawer"> The drawer of the inspector. </param> /// <param name="inspector"> /// The inspector over which the state should be deserialized. If this is null, a new split view /// will be opened in the drawer, and state will be deserialized over that. /// </param> public void Deserialize(IInspectorDrawer drawer, [CanBeNull] IInspector inspector) { #if DEV_MODE && DEBUG_ENABLED Debug.Log("Restoring state of " + inspector + " from " + inspected.Length + " int..."); #endif if (inspector == null) { var splittable = drawer as ISplittableInspectorDrawer; if (viewLocked) { splittable.ShowInSplitView(Deserialize()); } else { splittable.SetSplitView(true); } inspector = splittable.SplitView; } else { inspector.State.ViewIsLocked = viewLocked; if (viewLocked) { inspector.RebuildDrawers(Deserialize(), false); } else { inspector.RebuildDrawersIfTargetsChanged(); } } if (!string.IsNullOrEmpty(filter)) { inspector.SetFilter(filter); } inspector.OnNextLayout(() => inspector.State.ScrollPos = scrollPos); }
internal static void UpdateDimensions(IInspectorDrawer inspectorDrawer, ISplittableInspectorDrawer splittable) { var inspectorWindowRect = inspectorDrawer.position; inspectorWindowRect.x = 0f; inspectorWindowRect.y = 0f; if (splittable != null && splittable.ViewIsSplit) { inspectorWindowRect.height *= 0.5f; var view = inspectorDrawer.MainView; view.State.UpdateDimensions(false, false, inspectorWindowRect, view.ToolbarHeight, view.PreviewAreaHeight); view = splittable.SplitView; if (view == null) { #if DEV_MODE Debug.LogWarning("Splittable.ViewIsSplit was true but SplitView was null. Fixing now!"); #endif splittable.SetSplitView(true); view = splittable.SplitView; #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(view != null, inspectorDrawer + " SplitView still null after calling SetSplitView(true)!"); #endif } inspectorWindowRect.y += inspectorWindowRect.height; view.State.UpdateDimensions(false, false, inspectorWindowRect, view.ToolbarHeight, view.PreviewAreaHeight); } else { var view = inspectorDrawer.MainView; view.State.UpdateDimensions(false, false, inspectorWindowRect, view.ToolbarHeight, view.PreviewAreaHeight); } }
public static void OnKeyDown(this IInspectorDrawer inspectorDrawer, Event e) { #if DEV_MODE && DEBUG_KEYBOARD_INPUT Debug.Log(StringUtils.ToColorizedString(inspectorDrawer.ToString(), ".OnKeyDown(", e.keyCode, ") with HasFocus=", inspectorDrawer.HasFocus, ", selectedControl=", StringUtils.ToString(inspectorDrawer.SelectedOrDefaultView().FocusedDrawer), ", SelectedPart=", inspectorDrawer.Manager.SelectedInspectorPart)); #endif if (!inspectorDrawer.HasFocus) { return; } var view = inspectorDrawer.SelectedOrDefaultView(); var keys = view.Preferences.keyConfigs; #if !POWER_INSPECTOR_LITE if (keys.stepBackInSelectionHistory.DetectAndUseInput(e)) { view.StepBackInSelectionHistory(); return; } if (keys.stepForwardInSelectionHistory.DetectAndUseInput(e)) { view.StepForwardInSelectionHistory(); return; } #endif inspectorDrawer.Repaint(); DrawGUI.RegisterInputEvent(e); var activeView = inspectorDrawer.SelectedOrDefaultView(); // give controls time to react to selection changes, editing text field changes etc. // before cached values are updated. (e.g. unapplied changes in delayed fields are // not discarded before they have time to get applied activeView.ResetNextUpdateCachedValues(); #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(!inspectorDrawer.HasFocus || activeView.Selected); #endif #if DEV_MODE && DEBUG_KEYBOARD_INPUT Debug.Log(StringUtils.ToColorizedString("OnKeyDown activeView.Selected=", activeView.Selected, ", activeView.FocusedDrawer=", activeView.FocusedDrawer + ", Manager.SelectedInspector=", inspectorDrawer.Manager.SelectedInspector, ", inspectorDrawer.HasFocus=", inspectorDrawer.HasFocus)); #endif if (activeView.Toolbar.OnKeyboardInputGivenWhenNotSelected(e, activeView.Preferences.keyConfigs)) { if (e.type != EventType.Used) { DrawGUI.Use(e); ExitGUIUtility.ExitGUI(); } } IDrawer selectedControl = null; if (activeView.Selected) { selectedControl = activeView.FocusedDrawer; if (selectedControl != null) { var onKeyboardInputBeingGiven = selectedControl.OnKeyboardInputBeingGiven; if (onKeyboardInputBeingGiven != null) { #if DEV_MODE && DEBUG_KEYBOARD_INPUT Debug.Log("onKeyboardInputBeingGiven(" + StringUtils.ToString(e) + "): " + StringUtils.ToString(onKeyboardInputBeingGiven)); #endif if (onKeyboardInputBeingGiven(selectedControl, e, selectedControl.Inspector.Preferences.keyConfigs)) { return; } } if (selectedControl.OnKeyboardInputGiven(e, selectedControl.Inspector.Preferences.keyConfigs)) { return; } } else if (inspectorDrawer.Manager.SelectedInspectorPart == InspectorPart.Toolbar) { activeView.Toolbar.OnKeyboardInputGiven(e, activeView.Preferences.keyConfigs); } else if (inspectorDrawer.Manager.SelectedInspectorPart == InspectorPart.Viewport || inspectorDrawer.Manager.SelectedInspectorPart == InspectorPart.None) { bool fieldChangeInputGiven; if (keys.DetectNextField(e, true) || keys.DetectPreviousField(e, true) || keys.nextFieldLeft.DetectAndUseInput(e) || keys.nextFieldRight.DetectAndUseInput(e) || keys.nextFieldDown.DetectAndUseInput(e) || keys.nextFieldUp.DetectAndUseInput(e)) { fieldChangeInputGiven = true; } else if (e.modifiers == EventModifiers.FunctionKey) { switch (e.keyCode) { case KeyCode.DownArrow: case KeyCode.UpArrow: case KeyCode.LeftArrow: case KeyCode.RightArrow: fieldChangeInputGiven = true; break; default: fieldChangeInputGiven = false; break; } } else { fieldChangeInputGiven = false; } if (fieldChangeInputGiven) { var drawers = activeView.State.drawers; if (drawers.Length == 0) { if (activeView.Toolbar != null) { activeView.Toolbar.OnFindCommandGiven(); } else { KeyboardControlUtility.SetKeyboardControl(0, 3); } } else { var first = drawers[0]; var select = first.GetNextSelectableDrawerRight(true, null); #if DEV_MODE && DEBUG_NEXT_FIELD Debug.Log(first + ".GetNextSelectableDrawerRight: " + StringUtils.ToString(select)); #endif if (select != null) { activeView.Select(select, ReasonSelectionChanged.SelectNextControl); } } } } } if (DrawGUI.EditingTextField && keys.DetectTextFieldReservedInput(e, TextFieldType.TextRow)) { #if DEV_MODE && DEBUG_KEYBOARD_INPUT Debug.Log(StringUtils.ToColorizedString("OnKeyboardInputGiven( ", StringUtils.ToString(e), ") DetectTextFieldReservedInput: ", true, " with selectedControl=", selectedControl)); #endif return; } if (keys.addComponent.DetectInput(e)) { #if DEV_MODE Debug.Log("AddComponent shortcut detected"); #endif if (AddComponentButtonDrawer.OpenSelectedOrFirstFoundInstance(activeView)) { DrawGUI.Use(e); } } if (keys.toggleSplitView.DetectInput(e)) { var splittable = inspectorDrawer as ISplittableInspectorDrawer; if (splittable != null && splittable.CanSplitView) { DrawGUI.Use(e); bool setSplitView = !splittable.ViewIsSplit; splittable.MainView.OnNextLayout(() => splittable.SetSplitView(setSplitView)); } } if (keys.refresh.DetectAndUseInput(e)) { var selectedInspector = inspectorDrawer.Manager.SelectedInspector; if (selectedInspector != null && selectedInspector.InspectorDrawer == inspectorDrawer) { selectedInspector.ForceRebuildDrawers(); } else { var mainView = inspectorDrawer.MainView; mainView.ForceRebuildDrawers(); var splittable = inspectorDrawer as ISplittableInspectorDrawer; if (splittable != null && splittable.ViewIsSplit) { splittable.SplitView.ForceRebuildDrawers(); } } } var keyCode = e.keyCode; switch (keyCode) { case KeyCode.Menu: if (selectedControl != null) { selectedControl.OpenContextMenu(e, selectedControl.RightClickArea, false, selectedControl.SelectedPart); } break; case KeyCode.Space: inspectorDrawer.Manager.RegisterKeyHeldDown(keyCode, "space"); break; case KeyCode.F2: inspectorDrawer.Repaint(); if (!DrawGUI.EditingTextField) { DrawGUI.Use(e); DrawGUI.EditingTextField = true; } break; case KeyCode.Escape: #if DEV_MODE Debug.Log("!!! ESCAPE !!!"); #endif //when dragging a control, allow aborting using the escape key if (inspectorDrawer.Manager.MouseDownInfo.MouseDownOverDrawer != null) { inspectorDrawer.Manager.MouseDownInfo.Clear(); } if (DrawGUI.EditingTextField) { DrawGUI.Use(e); DrawGUI.EditingTextField = false; } break; case KeyCode.AltGr: case KeyCode.RightAlt: KeyConfig.OnAltGrDown(); break; #if DEV_MODE case KeyCode.I: if (e.control && e.alt) { Debug.Log("INFO: FocusedDrawer=" + StringUtils.ToString(inspectorDrawer.SelectedOrDefaultView().FocusedDrawer) + ", EditingTextField=" + DrawGUI.EditingTextField); } break; #endif } }
public IInspector Create(Type inspectorType, IInspectorDrawer drawer, InspectorPreferences preferences) { return(Create(inspectorType, drawer, preferences, ArrayPool <Object> .ZeroSizeArray, Vector2.zero, false)); }
public static bool IsPowerInspectorWindow(IInspectorDrawer test) { return(string.Equals(test.GetType().Name, "PowerInspectorWindow")); }
private static PreferencesDrawer GetPrefencesDrawer(IInspectorDrawer preferencesWindow) { return(GetPrefencesDrawer(preferencesWindow.MainView)); }
public static void OnKeyUp(this IInspectorDrawer inspectorDrawer, Event e) { inspectorDrawer.Manager.OnKeyUp(e); }
/// <summary> Initializes the PowerInspector instance. </summary> /// <param name="inspector"> The inspector. </param> /// <param name="preferences"> inspector preferences. </param> /// <param name="drawer"> The drawer. </param> /// <param name="inspected"> The inspected targets. </param> /// <param name="scrollPos"> The viewport scroll position. </param> /// <param name="viewIsLocked"> True if view is locked. </param> public static void Setup(PowerInspector inspector, InspectorPreferences preferences, IInspectorDrawer drawer, Object[] inspected, Vector2 scrollPos, bool viewIsLocked) { inspector.Setup(drawer, preferences, inspected, scrollPos, viewIsLocked); }
public static void Setup([NotNull] SimpleInspector inspector, [NotNull] InspectorPreferences preferences, [NotNull] IInspectorDrawer drawer, [NotNull] Object[] inspected, Vector2 scrollPos, bool viewIsLocked) { inspector.Setup(drawer, preferences, inspected, scrollPos, viewIsLocked); }
public IInspector Create <TInspector>(IInspectorDrawer drawer, InspectorPreferences preferences) where TInspector : class, IInspector, new() { return(Create <TInspector>(drawer, preferences, ArrayPool <Object> .ZeroSizeArray, Vector2.zero, false)); }
/// <summary> /// This should be called at the beginning of OnGUI of every instance of classes that implement IInspectorDrawer. /// /// SEE ALSO: DrawGUI.BeginOnGUI and InspectorUtility.BeginInspector. /// </summary> /// <param name="inspectorDrawer"> The inspector drawer instance. </param> /// <param name="splittable"> The inspector drawer if it implements ISplittableInspectorDrawer, otherwise null. </param> public static void BeginInspectorDrawer([NotNull] IInspectorDrawer inspectorDrawer, [CanBeNull] ISplittableInspectorDrawer splittable) { #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(inspectorDrawer != null); #endif var manager = inspectorDrawer.Manager; activeInspectorDrawer = inspectorDrawer; ActiveManager = manager; activeManager.ActiveInspector = inspectorDrawer.MainView; var e = Event.current; #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(e != null); #endif var mouseDownInfo = activeManager.MouseDownInfo; // Events like MouseUp, DragUpdated and DragPerformed are normally ignored when the cursor is outside EditorWindow bounds // but when a field is being dragged we still need those events (especially important for the MouseUp event!) var type = mouseDownInfo.GetEventTypeForMouseUpDetection(e); if (mouseDownInfo.NowReordering) { var reordering = mouseDownInfo.Reordering; var dropTarget = reordering.MouseoveredDropTarget; // When reordering and cursor is not above a valid drop target, set DragAndDropVisualMode to rejected, // unless dragging Object references outside window bounds, where want to allow dragging into other // EditorWindows. // UPDATE: This broke drag n drop e.g. from Component header to object reference field inside a custom editor. //if(dropTarget.Parent == null && ((DrawGUI.Active.DragAndDropObjectReferences.Length == 0 || activeManager.MouseoveredInspector != null))) if (dropTarget.Parent == null && DrawGUI.Active.DragAndDropObjectReferences.Length == 0) { #if DEV_MODE Debug.LogWarning("Reordering Rejected because dropTarget.Parent=null && DrawGUI.Active.DragAndDropObjectReferences=" + StringUtils.ToString(DrawGUI.Active.DragAndDropObjectReferences) + ", activeManager.MouseoveredInspector=" + StringUtils.ToString(activeManager.MouseoveredInspector)); #endif // Update: only do this once cursor has moved, otherwise it can look strange during simple click events if (mouseDownInfo.CursorMovedAfterMouseDown) { DrawGUI.Active.DragAndDropVisualMode = DragAndDropVisualMode.Rejected; } } DrawGUI.Active.AddCursorRect(new Rect(0f, 0f, 100000f, 100000f), MouseCursor.MoveArrow); } else if (mouseDownInfo.NowDraggingPrefix) { DrawGUI.Active.SetCursor(MouseCursor.SlideArrow); } switch (type) { case EventType.Repaint: if (inspectorDrawer.MainView.RequiresConstantRepaint() || (splittable != null && splittable.ViewIsSplit && splittable.SplitView.RequiresConstantRepaint())) { inspectorDrawer.Repaint(); } break; case EventType.Layout: activeManager.OnLayout(); UpdateDimensions(inspectorDrawer, splittable); break; case EventType.ValidateCommand: inspectorDrawer.OnValidateCommand(e); break; case EventType.ExecuteCommand: if (OnExecuteCommand != null) { if (inspectorDrawer == manager.FirstInspectorDrawer) { #if DEV_MODE && DEBUG_EXECUTE_COMMAND Debug.Log("ExecuteCommand(" + e.commandName + ")"); #endif OnExecuteCommand(ActiveManager.LastSelectedActiveOrDefaultInspector(), e.commandName); } #if DEV_MODE && DEBUG_EXECUTE_COMMAND else { Debug.Log("ExecuteCommand(" + e.commandName + ") not sent with e=" + StringUtils.ToString(e) + ", OnExecuteCommand=" + StringUtils.ToString(OnExecuteCommand)); } #endif } inspectorDrawer.OnExecuteCommand(e); break; case EventType.MouseUp: case EventType.DragPerform: #if DEV_MODE && (DEBUG_MOUSE_UP || DEBUG_DRAG_N_DROP) Debug.Log(type + " with IsUnityObjectDrag=" + StringUtils.True + ", MouseDownInfo.Inspector=" + activeManager.MouseDownInfo.Inspector + ", activeInspectorDrawer.MouseIsOver=" + (inspectorDrawer == null ? StringUtils.Null : StringUtils.ToColorizedString(inspectorDrawer.MouseIsOver))); #endif inspectorDrawer.Repaint(); mouseDownInfo.OnMouseUp(activeManager); break; case EventType.DragExited: //IMPORTANT NOTE: DragExited gets called when during DragNDrop cursor leaves EditorWindow bounds! #if DEV_MODE && UNITY_EDITOR Debug.Log(type + " with LastInputEvent().type=" + DrawGUI.LastInputEvent().type + ", IsUnityObjectDrag=" + StringUtils.ToColorizedString(DrawGUI.IsUnityObjectDrag) + ", EditorWindow.focusedWindow=" + UnityEditor.EditorWindow.focusedWindow + ", activeManager.MouseoveredInspector=" + activeManager.MouseoveredInspector + ", mouseoveredDrawer.position=" + (activeManager.MouseoveredInspector == null || activeManager.MouseoveredInspector.InspectorDrawer == null ? StringUtils.Null : activeManager.MouseoveredInspector.InspectorDrawer.position.ToString()) + ", MouseDownInfo.Inspector=" + activeManager.MouseDownInfo.Inspector + ", Drawer.MouseIsOver=" + (activeInspectorDrawer == null ? StringUtils.Null : StringUtils.ToColorizedString(activeInspectorDrawer.MouseIsOver))); #endif if (mouseDownInfo.IsDragExitedReallyMouseLeaveWindowEvent()) { #if DEV_MODE Debug.LogWarning("Ignoring DragExited call because IsDragExitedReallyMouseLeaveWindowEvent=" + StringUtils.True + " - cursor probably just left EditorWindow bounds."); #endif break; } inspectorDrawer.Repaint(); mouseDownInfo.OnMouseUp(activeManager); break; case EventType.MouseDown: ActiveManager.MouseDownInfo.OnMouseDown(); #if DEV_MODE && DEBUG_ON_MOUSE_DOWN Debug.Log("MouseDown with button=" + e.button + ", keyCode=" + e.keyCode + ", MouseoveredSelectable=" + StringUtils.ToString(ActiveManager.MouseoveredSelectable)); #endif break; case EventType.KeyDown: inspectorDrawer.OnKeyDown(e); break; case EventType.KeyUp: inspectorDrawer.Manager.OnKeyUp(e); break; } }
public void OnDisposing([NotNull] IInspector disposing) { if (lastSelectedInspector == disposing) { lastSelectedInspector = null; } var type = disposing.GetType(); var lastSelectedInspectorOfSameType = GetLastSelectedInspector(type); if (lastSelectedInspectorOfSameType == disposing) { lastSelectedInspectors.Remove(type); } var inspectorDrawer = disposing.InspectorDrawer; if (inspectorDrawer != null) { if (inspectorDrawer.NowClosing) { #if DEV_MODE && DEBUG_DISPOSE UnityEngine.Debug.Log("OnDisposing(" + disposing + "): NowClosing was " + StringUtils.True); #endif var inspectorDrawerType = inspectorDrawer.GetType(); var lastSelectedInspectorDrawer = GetLastSelectedInspectorDrawer(inspectorDrawerType); if (lastSelectedInspectorDrawer == inspectorDrawer) { #if DEV_MODE && DEBUG_DISPOSE UnityEngine.Debug.Log("OnDisposing(" + disposing + "): removed " + inspectorDrawer.GetType().Name + " from lastSelectedInspectorDrawers"); #endif lastSelectedInspectorDrawers.Remove(inspectorDrawerType); } #if UNITY_EDITOR if (lastSelectedEditorWindow == inspectorDrawer) { #if DEV_MODE && DEBUG_DISPOSE UnityEngine.Debug.Log("OnDisposing(" + disposing + "): setting lastSelectedEditorWindow to null"); #endif lastSelectedEditorWindow = null; } #endif } #if DEV_MODE && DEBUG_DISPOSE else { UnityEngine.Debug.Log("OnDisposing(" + disposing + "): NowClosing was " + StringUtils.False); } #endif } else { #if DEV_MODE && DEBUG_DISPOSE UnityEngine.Debug.Log("OnDisposing(" + disposing + "): inspectorDrawer was null!"); #endif CleanUpLastSelectedInspectorDrawers(); } }
/// <summary> /// This should be called at the beginning of OnGUI of every instance of classes that implement IInspector. /// /// Handles things like setting the ActiveInspector, updating mouseovered inspector part, and broadcasting various events. /// /// SEE ALSO: DrawGUI.BeginOnGUI and InspectorUtility.BeginInspectorDrawer. /// </summary> public static void BeginInspector([NotNull] IInspector inspector, ref bool anyInspectorPartMouseovered) { inspectorBeginScreenPoint = GUIUtility.GUIToScreenPoint(Vector2.zero); GUISpace.Current = Space.Window; activeInspectorDrawer = inspector.InspectorDrawer; ActiveManager = activeInspectorDrawer.Manager; #if DEV_MODE Debug.Assert(activeManager.ActiveInstances.Contains(inspector)); #endif var e = Event.current; var setMouseoveredPart = inspector.GetMouseoveredPartUpdated(ref anyInspectorPartMouseovered); if (setMouseoveredPart != InspectorPart.None) { inspector.InspectorDrawer.Manager.SetMouseoveredInspector(inspector, setMouseoveredPart); } else if (activeManager.MouseoveredInspector == inspector) { #if DEV_MODE && DEBUG_SET_MOUSEOVERED_INSPECTOR Debug.Log(StringUtils.ToColorizedString("SetMouseoveredInspector(", StringUtils.Null, ") with anyInspectorPartMouseovered=", anyInspectorPartMouseovered, ", IgnoreAllMouseInputs=", activeManager.IgnoreAllMouseInputs, ", Cursor.CanRequestLocalPosition=", Cursor.CanRequestLocalPosition, ", Cursor.LocalPosition=", Cursor.LocalPosition, ", windowRect=", inspector.State.WindowRect)); #endif activeManager.SetMouseoveredInspector(null, InspectorPart.None); } activeManager.ActiveInspector = inspector; var state = inspector.State; inspector.NowDrawingPart = InspectorPart.Other; if (OnInspectorGUIBegin != null) { OnInspectorGUIBegin(inspector); } var mouseDownInfo = activeManager.MouseDownInfo; // Events like MouseUp, DragUpdated and DragPerformed are normally ignored when the cursor is outside EditorWindow bounds // but when a field is being dragged we still need those events (especially important for the MouseUp event!) var type = mouseDownInfo.GetEventTypeForMouseUpDetection(e); switch (type) { case EventType.MouseUp: case EventType.DragPerform: case EventType.DragExited: #if DEV_MODE && DEBUG_DRAG_N_DROP Debug.Log(StringUtils.ToColorizedString("BeginInspector: " + e.type + " with ObjectReferences=", DrawGUI.Active.DragAndDropObjectReferences, ", MouseDownEventWasUsed=", mouseDownInfo.MouseDownEventWasUsed, ", IgnoreAllMouseInputs=", activeManager.IgnoreAllMouseInputs, ", mouseoveredPart=", setMouseoveredPart, ", button=", Event.current.button + ", mouseDownInfo.Inspector=", mouseDownInfo.Inspector, ", MouseDownOverControl=", mouseDownInfo.MouseDownOverDrawer)); #endif if (e.type == EventType.DragExited && mouseDownInfo.IsDragExitedReallyMouseLeaveWindowEvent()) { #if DEV_MODE Debug.LogWarning("Ignoring DragExited call because IsDragExitedReallyMouseLeaveWindowEvent=" + StringUtils.True + " - cursor probably just left EditorWindow bounds."); #endif break; } var mouseoveredInspector = activeManager.MouseoveredInspector; if (!activeManager.IgnoreAllMouseInputs && mouseoveredInspector != null) { if (e.type == EventType.DragPerform || (e.type == EventType.MouseUp && Event.current.button == 0)) { mouseoveredInspector.LastInputTime = Platform.Time; var reordering = mouseDownInfo.Reordering; var reorderingTo = reordering.MouseoveredDropTarget.Parent; if (reorderingTo != null && !mouseDownInfo.IsClick) { reorderingTo.OnMemberDragNDrop(mouseDownInfo, DrawGUI.Active.DragAndDropObjectReferences); } #if DEV_MODE && DEBUG_DRAG_N_DROP else { Debug.Log(StringUtils.ToColorizedString("Won't call OnMemberDragNDrop. reorderingTo=", reorderingTo, ", mouseDownInfo.IsClick=", mouseDownInfo.IsClick)); } #endif } #if DEV_MODE && DEBUG_DRAG_N_DROP else { Debug.Log(StringUtils.ToColorizedString("Won't call OnMemberDragNDrop. currentEvent.type=", e.type, ", Event.current.button=", Event.current.button)); } #endif } #if DEV_MODE && DEBUG_DRAG_N_DROP else { Debug.Log(StringUtils.ToColorizedString("Won't call OnMemberDragNDrop. IgnoreAllMouseInputs=", activeManager.IgnoreAllMouseInputs, ", setMouseoveredPart=", setMouseoveredPart)); } #endif if (mouseDownInfo.Inspector == inspector) { if (e.type != EventType.MouseUp || Event.current.button == 0) { if (mouseDownInfo.MouseDownOverDrawer != null) { #if DEV_MODE if (!mouseDownInfo.IsClick && !mouseDownInfo.CursorMovedAfterMouseDown) { Debug.LogWarning("Calling OnMouseUpAfterDownOverControl with IsClick=" + StringUtils.False + ", but CursorMovedAfterMouseDown was also false. Bug?"); } #endif mouseDownInfo.MouseDownOverDrawer.OnMouseUpAfterDownOverControl(e, mouseDownInfo.IsClick); } mouseDownInfo.Clear(true); } } break; case EventType.MouseDown: #if DEV_MODE && DEBUG_ON_MOUSE_DOWN Debug.Log(StringUtils.ToColorizedString("BeginInspector(" + inspector + ") - MouseDown with IgnoreAllMouseInputs=", activeManager.IgnoreAllMouseInputs, ", setMouseoveredPart=", setMouseoveredPart)); #endif if (!activeManager.IgnoreAllMouseInputs && setMouseoveredPart != InspectorPart.None) { inspector.LastInputTime = Platform.Time; inspector.OnMouseDown(e); //give controls time to react to selection changes, editing text field changes etc. //before cached values are updated } break; case EventType.KeyDown: inspector.LastInputTime = Platform.Time; break; case EventType.ContextClick: if (!activeManager.IgnoreAllMouseInputs && setMouseoveredPart != InspectorPart.None) { inspector.OnContextClick(e); } break; } if (state.keyboardControlLastFrame != KeyboardControlUtility.KeyboardControl) { state.previousKeyboardControl = state.keyboardControlLastFrame; state.keyboardControlLastFrame = KeyboardControlUtility.KeyboardControl; #if UNITY_EDITOR state.previousKeyboardControlRect = state.keyboardRectLastFrame; state.keyboardRectLastFrame = KeyboardControlUtility.Info.KeyboardRect; #endif } }
private void MakeArrayGUI <T> (SerializedProperty property, String displayName) { var ggg = new SerializedPropertyList <T>(property); _arrayGUI = new ArrayGUI <T>(displayName, () => ggg); }