void SwitchFocus(Focusable newFocusedElement, FocusChangeDirection direction) { if (newFocusedElement == focusedElement) { return; } var oldFocusedElement = focusedElement; if (newFocusedElement == null || !newFocusedElement.canGrabFocus) { if (oldFocusedElement != null) { AboutToReleaseFocus(oldFocusedElement, newFocusedElement, direction); ReleaseFocus(oldFocusedElement, newFocusedElement, direction); } } else if (newFocusedElement != oldFocusedElement) { if (oldFocusedElement != null) { AboutToReleaseFocus(oldFocusedElement, newFocusedElement, direction); } AboutToGrabFocus(newFocusedElement, oldFocusedElement, direction); if (oldFocusedElement != null) { ReleaseFocus(oldFocusedElement, newFocusedElement, direction); } GrabFocus(newFocusedElement, oldFocusedElement, direction); } }
protected internal override void ExecuteDefaultAction(EventBase evt) { // no call to base.ExecuteDefaultAction(evt): // - we dont want mouse click to directly give focus to IMGUIContainer: // they should be handled by IMGUI and if an IMGUI control grabs the // keyboard, the IMGUIContainer will gain focus via FocusController.SyncIMGUIFocus. // - same thing for tabs: IMGUI should handle them. // - we dont want to set the PseudoState.Focus flag on IMGUIContainer. // They are focusable, but only for the purpose of focusing their children. // Here, we set flags that will be acted upon in DoOnGUI(), since we need to change IMGUI state. if (evt.GetEventTypeId() == BlurEvent.TypeId()) { BlurEvent be = evt as BlurEvent; VisualElement relatedTargetElement = be.relatedTarget as VisualElement; // To mimic IMGUI behavior, we only want to clear GUIUtility.keyboardControl // when there is something else actually taking focus (canGrabFocus == true) // or when the clicked element is the top level IMGUIContainer (relatedTargetElement.parent == panel.visualTree). if (relatedTargetElement != null && (be.relatedTarget.canGrabFocus || relatedTargetElement.parent == panel.visualTree)) { lostFocus = true; } } else if (evt.GetEventTypeId() == FocusEvent.TypeId()) { FocusEvent fe = evt as FocusEvent; receivedFocus = true; focusChangeDirection = fe.direction; } }
void ReleaseFocus(Focusable focusable, Focusable willGiveFocusTo, FocusChangeDirection direction) { using (BlurEvent e = BlurEvent.GetPooled(focusable, willGiveFocusTo, direction, this)) { focusable.SendEvent(e); } }
void GrabFocus(Focusable focusable, Focusable willTakeFocusFrom, FocusChangeDirection direction) { using (FocusEvent e = FocusEvent.GetPooled(focusable, willTakeFocusFrom, direction, this)) { focusable.SendEvent(e); } }
static void GrabFocus(Focusable focusable, Focusable willTakeFocusFrom, FocusChangeDirection direction) { using (FocusEvent e = FocusEvent.GetPooled(focusable, willTakeFocusFrom, direction)) { UIElementsUtility.eventDispatcher.DispatchEvent(e, null); } }
private void SwitchFocus(Focusable newFocusedElement, FocusChangeDirection direction) { if (newFocusedElement != this.focusedElement) { Focusable focusedElement = this.focusedElement; if (newFocusedElement == null || !newFocusedElement.canGrabFocus) { if (focusedElement != null) { FocusController.AboutToReleaseFocus(focusedElement, newFocusedElement, direction); this.focusedElement = null; FocusController.ReleaseFocus(focusedElement, newFocusedElement, direction); } } else if (newFocusedElement != focusedElement) { if (focusedElement != null) { FocusController.AboutToReleaseFocus(focusedElement, newFocusedElement, direction); } FocusController.AboutToGrabFocus(newFocusedElement, focusedElement, direction); this.focusedElement = newFocusedElement; if (focusedElement != null) { FocusController.ReleaseFocus(focusedElement, newFocusedElement, direction); } FocusController.GrabFocus(newFocusedElement, focusedElement, direction); } } }
static void ReleaseFocus(Focusable focusable, Focusable willGiveFocusTo, FocusChangeDirection direction) { using (BlurEvent e = BlurEvent.GetPooled(focusable, willGiveFocusTo, direction)) { UIElementsUtility.eventDispatcher.DispatchEvent(e, null); } }
protected override void Init() { base.Init(); this.flags = EventBase.EventFlags.Capturable; this.relatedTarget = null; this.direction = FocusChangeDirection.unspecified; }
public static T GetPooled(IEventHandler target, Focusable relatedTarget, FocusChangeDirection direction) { T pooled = EventBase <T> .GetPooled(); pooled.target = target; pooled.relatedTarget = relatedTarget; pooled.direction = direction; return(pooled); }
public void SwitchFocusOnEvent(EventBase e) { FocusChangeDirection focusChangeDirection = this.focusRing.GetFocusChangeDirection(this.focusedElement, e); if (focusChangeDirection != FocusChangeDirection.none) { Focusable nextFocusable = this.focusRing.GetNextFocusable(this.focusedElement, focusChangeDirection); this.SwitchFocus(nextFocusable, focusChangeDirection); } }
public void SwitchFocusOnEvent(EventBase e) { FocusChangeDirection direction = focusRing.GetFocusChangeDirection(focusedElement, e); if (direction != FocusChangeDirection.none) { Focusable f = focusRing.GetNextFocusable(focusedElement, direction); SwitchFocus(f, direction); } }
protected internal override void ExecuteDefaultAction(EventBase evt) { if (evt.GetEventTypeId() == EventBase <BlurEvent> .TypeId()) { BlurEvent blurEvent = evt as BlurEvent; if (blurEvent.relatedTarget == null || !blurEvent.relatedTarget.canGrabFocus) { this.lostFocus = true; } } else if (evt.GetEventTypeId() == EventBase <FocusEvent> .TypeId()) { FocusEvent focusEvent = evt as FocusEvent; this.receivedFocus = true; this.focusChangeDirection = focusEvent.direction; } }
protected internal override void ExecuteDefaultAction(EventBase evt) { if (evt.GetEventTypeId() == EventBase <BlurEvent> .TypeId()) { BlurEvent blurEvent = evt as BlurEvent; VisualElement visualElement = blurEvent.relatedTarget as VisualElement; if (visualElement != null && (blurEvent.relatedTarget.canGrabFocus || visualElement.parent == base.panel.visualTree)) { this.lostFocus = true; } } else if (evt.GetEventTypeId() == EventBase <FocusEvent> .TypeId()) { FocusEvent focusEvent = evt as FocusEvent; this.receivedFocus = true; this.focusChangeDirection = focusEvent.direction; } }
public Focusable GetNextFocusable(Focusable currentFocusable, FocusChangeDirection direction) { Focusable result; if (direction == FocusChangeDirection.none || direction == FocusChangeDirection.unspecified) { result = currentFocusable; } else { this.DoUpdate(); if (this.m_FocusRing.Count == 0) { result = null; } else { int num = 0; if (direction == VisualElementFocusChangeDirection.right) { num = this.GetFocusableInternalIndex(currentFocusable) + 1; if (num == this.m_FocusRing.Count) { num = 0; } } else if (direction == VisualElementFocusChangeDirection.left) { num = this.GetFocusableInternalIndex(currentFocusable) - 1; if (num == -1) { num = this.m_FocusRing.Count - 1; } } result = this.m_FocusRing[num].m_Focusable; } } return(result); }
protected internal override void ExecuteDefaultAction(EventBase evt) { // no call to base.ExecuteDefaultAction(evt): // - we dont want mouse click to directly give focus to IMGUIContainer: // they should be handled by IMGUI and if an IMGUI control grabs the // keyboard, the IMGUIContainer will gain focus via FocusController.SyncIMGUIFocus. // - same thing for tabs: IMGUI should handle them. // - we dont want to set the PseudoState.Focus flag on IMGUIContainer. // They are focusable, but only for the purpose of focusing their children. // Here, we set flags that will be acted upon in DoOnGUI(), since we need to change IMGUI state. if (evt.GetEventTypeId() == BlurEvent.TypeId()) { // A lost focus event is ... a lost focus event. // The specific handling of the IMGUI will be done in the DoOnGUI() above... lostFocus = true; } else if (evt.GetEventTypeId() == FocusEvent.TypeId()) { FocusEvent fe = evt as FocusEvent; receivedFocus = true; focusChangeDirection = fe.direction; } else if (evt.GetEventTypeId() == DetachFromPanelEvent.TypeId()) { if (elementPanel != null) { elementPanel.IMGUIContainersCount--; } } else if (evt.GetEventTypeId() == AttachToPanelEvent.TypeId()) { if (elementPanel != null) { elementPanel.IMGUIContainersCount++; } } }
public Focusable GetNextFocusable(Focusable currentFocusable, FocusChangeDirection direction) { if (direction == FocusChangeDirection.none || direction == FocusChangeDirection.unspecified) { return(currentFocusable); } else { DoUpdate(); if (m_FocusRing.Count == 0) { return(null); } int index = 0; if (direction == VisualElementFocusChangeDirection.right) { index = GetFocusableInternalIndex(currentFocusable) + 1; if (index == m_FocusRing.Count) { index = 0; } } else if (direction == VisualElementFocusChangeDirection.left) { index = GetFocusableInternalIndex(currentFocusable) - 1; if (index == -1) { index = m_FocusRing.Count - 1; } } return(m_FocusRing[index].m_Focusable); } }
private static void AboutToGrabFocus(Focusable focusable, Focusable willTakeFocusFrom, FocusChangeDirection direction) { using (FocusInEvent pooled = FocusEventBase <FocusInEvent> .GetPooled(focusable, willTakeFocusFrom, direction)) { UIElementsUtility.eventDispatcher.DispatchEvent(pooled, null); } }
private void DoOnGUI(Event evt) { if (m_OnGUIHandler == null || panel == null) { return; } // Save the GUIClip count to make sanity checks after calling the OnGUI handler int guiClipCount = GUIClip.Internal_GetCount(); SaveGlobals(); UIElementsUtility.BeginContainerGUI(cache, evt, this); if (evt.type != EventType.Layout) { if (lostFocus) { if (focusController != null) { // We dont want to clear the GUIUtility.keyboardControl if another IMGUIContainer // just set it in the if (receivedFocus) block below. So we only clear it if either // // - there is no focused element // - we are the currently focused element (that would be surprising) // - the currently focused element is not an IMGUIContainer (in this case, // GUIUtility.keyboardControl should be 0). if (focusController.focusedElement == null || focusController.focusedElement == this || !(focusController.focusedElement is IMGUIContainer)) { GUIUtility.keyboardControl = 0; focusController.imguiKeyboardControl = 0; } } lostFocus = false; } if (receivedFocus) { // If we just received the focus and GUIUtility.keyboardControl is not already one of our control, // set the GUIUtility.keyboardControl to our first or last focusable control. if (focusChangeDirection != FocusChangeDirection.unspecified && focusChangeDirection != FocusChangeDirection.none) { // We assume we are using the VisualElementFocusRing. if (focusChangeDirection == VisualElementFocusChangeDirection.left) { GUIUtility.SetKeyboardControlToLastControlId(); } else if (focusChangeDirection == VisualElementFocusChangeDirection.right) { GUIUtility.SetKeyboardControlToFirstControlId(); } } receivedFocus = false; focusChangeDirection = FocusChangeDirection.unspecified; if (focusController != null) { focusController.imguiKeyboardControl = GUIUtility.keyboardControl; } } // We intentionally don't send the NewKeuboardFocus command here since it creates an issue with the AutomatedWindow // newKeyboardFocusControlID = GUIUtility.keyboardControl; } GUIDepth = GUIUtility.Internal_GetGUIDepth(); EventType originalEventType = Event.current.type; bool isExitGUIException = false; try { // On a layout event, we should not try to get the worldTransform... it is dependant on the layout, which is being calculated (thus, not good) if (originalEventType != EventType.Layout) { Matrix4x4 currentTransform; Rect clippingRect; GetCurrentTransformAndClip(this, evt, out currentTransform, out clippingRect); // Push UIElements matrix in GUIClip to make mouse position relative to the IMGUIContainer top left using (new GUIClip.ParentClipScope(currentTransform, clippingRect)) { m_OnGUIHandler(); } } else { m_OnGUIHandler(); } } catch (Exception exception) { // only for layout events: we always intercept any exceptions to not interrupt event processing if (originalEventType == EventType.Layout) { isExitGUIException = GUIUtility.IsExitGUIException(exception); if (!isExitGUIException) { Debug.LogException(exception); } } else { // rethrow event if not in layout throw; } } finally { if (evt.type != EventType.Layout) { int currentKeyboardFocus = GUIUtility.keyboardControl; int result = GUIUtility.CheckForTabEvent(evt); if (focusController != null) { if (result < 0) { // If CheckForTabEvent returns -1 or -2, we have reach the end/beginning of its control list. // We should switch the focus to the next VisualElement. Focusable currentFocusedElement = focusController.focusedElement; using (KeyDownEvent e = KeyDownEvent.GetPooled('\t', KeyCode.Tab, result == -1 ? EventModifiers.None : EventModifiers.Shift)) { focusController.SwitchFocusOnEvent(e); } if (currentFocusedElement == this) { if (focusController.focusedElement == this) { // We still have the focus. We should cycle around our controls. if (result == -2) { GUIUtility.SetKeyboardControlToLastControlId(); } else if (result == -1) { GUIUtility.SetKeyboardControlToFirstControlId(); } newKeyboardFocusControlID = GUIUtility.keyboardControl; focusController.imguiKeyboardControl = GUIUtility.keyboardControl; } else { // We lost the focus. Set the focused element ID to 0 until next // IMGUIContainer have a chance to set it to its own control. // Doing this will ensure we draw ourselves without any focused control. GUIUtility.keyboardControl = 0; focusController.imguiKeyboardControl = 0; } } } else if (result > 0) { // A positive result indicates that the focused control has changed to one of our elements; result holds the control id. focusController.imguiKeyboardControl = GUIUtility.keyboardControl; newKeyboardFocusControlID = GUIUtility.keyboardControl; } else if (result == 0) { // This means the event is not a tab. Synchronize our focus info with IMGUI. if (currentKeyboardFocus != GUIUtility.keyboardControl || originalEventType == EventType.MouseDown) { focusController.SyncIMGUIFocus(GUIUtility.keyboardControl, this); } } } // Cache the fact that we have focusable controls or not. hasFocusableControls = GUIUtility.HasFocusableControls(); } } // The Event will probably be nuked with the next function call, so we get its type now. EventType eventType = Event.current.type; UIElementsUtility.EndContainerGUI(); RestoreGlobals(); if (!isExitGUIException) { // This is the same logic as GUIClipState::EndOnGUI if (eventType != EventType.Ignore && eventType != EventType.Used) { int currentCount = GUIClip.Internal_GetCount(); if (currentCount > guiClipCount) { Debug.LogError("GUI Error: You are pushing more GUIClips than you are popping. Make sure they are balanced)"); } else if (currentCount < guiClipCount) { Debug.LogError("GUI Error: You are popping more GUIClips than you are pushing. Make sure they are balanced)"); } } } // Clear extraneous GUIClips while (GUIClip.Internal_GetCount() > guiClipCount) { GUIClip.Internal_Pop(); } if (eventType == EventType.Used) { Dirty(ChangeType.Repaint); } }
private void DoOnGUI(Event evt) { if (this.m_OnGUIHandler != null && base.panel != null) { int num = GUIClip.Internal_GetCount(); this.SaveGlobals(); UIElementsUtility.BeginContainerGUI(this.cache, evt, this); if (evt.type != EventType.Layout) { if (this.lostFocus) { if (this.focusController != null) { if (this.focusController.focusedElement == null || this.focusController.focusedElement == this || !(this.focusController.focusedElement is IMGUIContainer)) { GUIUtility.keyboardControl = 0; this.focusController.imguiKeyboardControl = 0; } } this.lostFocus = false; } if (this.receivedFocus) { if (this.focusChangeDirection != FocusChangeDirection.unspecified && this.focusChangeDirection != FocusChangeDirection.none) { if (this.focusChangeDirection == VisualElementFocusChangeDirection.left) { GUIUtility.SetKeyboardControlToLastControlId(); } else if (this.focusChangeDirection == VisualElementFocusChangeDirection.right) { GUIUtility.SetKeyboardControlToFirstControlId(); } } this.receivedFocus = false; this.focusChangeDirection = FocusChangeDirection.unspecified; if (this.focusController != null) { this.focusController.imguiKeyboardControl = GUIUtility.keyboardControl; } } } this.GUIDepth = GUIUtility.Internal_GetGUIDepth(); EventType type = Event.current.type; bool flag = false; try { Matrix4x4 objectTransform; Rect clipRect; IMGUIContainer.GetCurrentTransformAndClip(this, evt, out objectTransform, out clipRect); using (new GUIClip.ParentClipScope(objectTransform, clipRect)) { this.m_OnGUIHandler(); } } catch (Exception exception) { if (type != EventType.Layout) { throw; } flag = GUIUtility.IsExitGUIException(exception); if (!flag) { Debug.LogException(exception); } } finally { if (evt.type != EventType.Layout) { int keyboardControl = GUIUtility.keyboardControl; int num2 = GUIUtility.CheckForTabEvent(evt); if (this.focusController != null) { if (num2 < 0) { Focusable focusedElement = this.focusController.focusedElement; using (KeyDownEvent pooled = KeyboardEventBase <KeyDownEvent> .GetPooled('\t', KeyCode.Tab, (num2 != -1) ? EventModifiers.Shift : EventModifiers.None)) { this.focusController.SwitchFocusOnEvent(pooled); } if (focusedElement == this) { if (this.focusController.focusedElement == this) { if (num2 == -2) { GUIUtility.SetKeyboardControlToLastControlId(); } else if (num2 == -1) { GUIUtility.SetKeyboardControlToFirstControlId(); } this.newKeyboardFocusControlID = GUIUtility.keyboardControl; this.focusController.imguiKeyboardControl = GUIUtility.keyboardControl; } else { GUIUtility.keyboardControl = 0; this.focusController.imguiKeyboardControl = 0; } } } else if (num2 > 0) { this.focusController.imguiKeyboardControl = GUIUtility.keyboardControl; this.newKeyboardFocusControlID = GUIUtility.keyboardControl; } else if (num2 == 0) { if (keyboardControl != GUIUtility.keyboardControl || type == EventType.MouseDown) { this.focusController.SyncIMGUIFocus(GUIUtility.keyboardControl, this); } } } this.hasFocusableControls = GUIUtility.HasFocusableControls(); } } EventType type2 = Event.current.type; UIElementsUtility.EndContainerGUI(); this.RestoreGlobals(); if (!flag) { if (type2 != EventType.Ignore && type2 != EventType.Used) { int num3 = GUIClip.Internal_GetCount(); if (num3 > num) { Debug.LogError("GUI Error: You are pushing more GUIClips than you are popping. Make sure they are balanced)"); } else if (num3 < num) { Debug.LogError("GUI Error: You are popping more GUIClips than you are pushing. Make sure they are balanced)"); } } } while (GUIClip.Internal_GetCount() > num) { GUIClip.Internal_Pop(); } if (type2 == EventType.Used) { base.Dirty(ChangeType.Repaint); } } }
private static void GrabFocus(Focusable focusable, Focusable willTakeFocusFrom, FocusChangeDirection direction) { FocusEvent pooled = FocusEventBase <FocusEvent> .GetPooled(focusable, willTakeFocusFrom, direction); UIElementsUtility.eventDispatcher.DispatchEvent(pooled, null); EventBase <FocusEvent> .ReleasePooled(pooled); }
private static void ReleaseFocus(Focusable focusable, Focusable willGiveFocusTo, FocusChangeDirection direction) { BlurEvent pooled = FocusEventBase <BlurEvent> .GetPooled(focusable, willGiveFocusTo, direction); UIElementsUtility.eventDispatcher.DispatchEvent(pooled, null); EventBase <BlurEvent> .ReleasePooled(pooled); }
private void DoOnGUI(Event evt, Matrix4x4 worldTransform, Rect clippingRect, bool isComputingLayout = false) { // Extra checks are needed here because client code might have changed the IMGUIContainer // since we enter HandleIMGUIEvent() if (m_OnGUIHandler == null || panel == null) { return; } // Save the GUIClip count to make sanity checks after calling the OnGUI handler int guiClipCount = GUIClip.Internal_GetCount(); SaveGlobals(); UIElementsUtility.BeginContainerGUI(cache, evt, this); // For the IMGUI, we need to update the GUI.color with the actual play mode tint ... // In fact, this is taken from EditorGUIUtility.ResetGUIState(). // Here, the play mode tint is either white (no tint, or not in play mode) or the right color (if in play mode) GUI.color = UIElementsUtility.editorPlayModeTintColor; // From now on, Event.current is either evt or a copy of evt. // Since Event.current may change while being processed, we do not rely on evt below but use Event.current instead. if (Event.current.type != EventType.Layout) { if (lostFocus) { if (focusController != null) { // We dont want to clear the GUIUtility.keyboardControl if another IMGUIContainer // just set it in the if (receivedFocus) block below. So we only clear it if either // // - there is no focused element // - we are the currently focused element (that would be surprising) // - the currently focused element is not an IMGUIContainer (in this case, // GUIUtility.keyboardControl should be 0). if (focusController.focusedElement == null || focusController.focusedElement == this || !(focusController.focusedElement is IMGUIContainer) || useUIElementsFocusStyle) { GUIUtility.keyboardControl = 0; focusController.imguiKeyboardControl = 0; } } lostFocus = false; } if (receivedFocus) { // If we just received the focus and GUIUtility.keyboardControl is not already one of our control, // set the GUIUtility.keyboardControl to our first or last focusable control. if (focusChangeDirection != FocusChangeDirection.unspecified && focusChangeDirection != FocusChangeDirection.none) { // We assume we are using the VisualElementFocusRing. if (focusChangeDirection == VisualElementFocusChangeDirection.left) { GUIUtility.SetKeyboardControlToLastControlId(); } else if (focusChangeDirection == VisualElementFocusChangeDirection.right) { GUIUtility.SetKeyboardControlToFirstControlId(); } } else if (useUIElementsFocusStyle) { // When the direction is not set, this is because we are coming back to this specific IMGUIContainer // with a mean other than TAB, we need to make sure to return to the element that was focused before... if ((focusController == null) || (focusController.imguiKeyboardControl == 0)) { GUIUtility.SetKeyboardControlToFirstControlId(); } else { GUIUtility.keyboardControl = focusController.imguiKeyboardControl; } } receivedFocus = false; focusChangeDirection = FocusChangeDirection.unspecified; if (focusController != null) { focusController.imguiKeyboardControl = GUIUtility.keyboardControl; } } // We intentionally don't send the NewKeuboardFocus command here since it creates an issue with the AutomatedWindow // newKeyboardFocusControlID = GUIUtility.keyboardControl; } EventType originalEventType = Event.current.type; bool isExitGUIException = false; try { // If we are computing the layout, we should not try to get the worldTransform... // it is dependant on the layout, which is being calculated (thus, not good) if (!isComputingLayout) { // Push UIElements matrix in GUIClip to make mouse position relative to the IMGUIContainer top left using (new GUIClip.ParentClipScope(worldTransform, clippingRect)) { m_OnGUIHandler(); } } else { m_OnGUIHandler(); } } catch (Exception exception) { // only for layout events: we always intercept any exceptions to not interrupt event processing if (originalEventType == EventType.Layout) { isExitGUIException = GUIUtility.IsExitGUIException(exception); if (!isExitGUIException) { Debug.LogException(exception); } } else { // rethrow event if not in layout throw; } } finally { if (Event.current.type != EventType.Layout) { int currentKeyboardFocus = GUIUtility.keyboardControl; int result = GUIUtility.CheckForTabEvent(Event.current); if (focusController != null) { if (result < 0) { // If CheckForTabEvent returns -1 or -2, we have reach the end/beginning of its control list. // We should switch the focus to the next VisualElement. Focusable currentFocusedElement = focusController.focusedElement; using (KeyDownEvent e = KeyDownEvent.GetPooled('\t', KeyCode.Tab, result == -1 ? EventModifiers.None : EventModifiers.Shift)) { focusController.SwitchFocusOnEvent(e); } if (currentFocusedElement == this) { if (focusController.focusedElement == this) { // We still have the focus. We should cycle around our controls. if (result == -2) { GUIUtility.SetKeyboardControlToLastControlId(); } else if (result == -1) { GUIUtility.SetKeyboardControlToFirstControlId(); } newKeyboardFocusControlID = GUIUtility.keyboardControl; focusController.imguiKeyboardControl = GUIUtility.keyboardControl; } else { // We lost the focus. Set the focused element ID to 0 until next // IMGUIContainer have a chance to set it to its own control. // Doing this will ensure we draw ourselves without any focused control. GUIUtility.keyboardControl = 0; focusController.imguiKeyboardControl = 0; } } } else if (result > 0) { // A positive result indicates that the focused control has changed to one of our elements; result holds the control id. focusController.imguiKeyboardControl = GUIUtility.keyboardControl; newKeyboardFocusControlID = GUIUtility.keyboardControl; } else if (result == 0) { // This means the event is not a tab. Synchronize our focus info with IMGUI. if ((currentKeyboardFocus != GUIUtility.keyboardControl) || (originalEventType == EventType.MouseDown)) { focusController.SyncIMGUIFocus(GUIUtility.keyboardControl, this); } else if (GUIUtility.keyboardControl != focusController.imguiKeyboardControl) { // Here we want to resynchronize our internal state ... newKeyboardFocusControlID = GUIUtility.keyboardControl; if (focusController.focusedElement == this) { // In this case, the focused element is the right one in the Focus Controller... we are just updating the internal imguiKeyboardControl focusController.imguiKeyboardControl = GUIUtility.keyboardControl; } else { // In this case, the focused element is NOT the right one in the Focus Controller... we also have to refocus... focusController.SyncIMGUIFocus(GUIUtility.keyboardControl, this); } } } } // Cache the fact that we have focusable controls or not. hasFocusableControls = GUIUtility.HasFocusableControls(); } } // This will copy Event.current into evt. UIElementsUtility.EndContainerGUI(evt); RestoreGlobals(); if (!isExitGUIException) { // This is the same logic as GUIClipState::EndOnGUI if (evt.type != EventType.Ignore && evt.type != EventType.Used) { int currentCount = GUIClip.Internal_GetCount(); if (currentCount > guiClipCount) { Debug.LogError("GUI Error: You are pushing more GUIClips than you are popping. Make sure they are balanced."); } else if (currentCount < guiClipCount) { Debug.LogError("GUI Error: You are popping more GUIClips than you are pushing. Make sure they are balanced."); } } } // Clear extraneous GUIClips while (GUIClip.Internal_GetCount() > guiClipCount) { GUIClip.Internal_Pop(); } if (evt.type == EventType.Used) { IncrementVersion(VersionChangeType.Repaint); } }
private static void AboutToReleaseFocus(Focusable focusable, Focusable willGiveFocusTo, FocusChangeDirection direction) { using (FocusOutEvent pooled = FocusEventBase <FocusOutEvent> .GetPooled(focusable, willGiveFocusTo, direction)) { UIElementsUtility.eventDispatcher.DispatchEvent(pooled, null); } }