public FocusChangeDirection GetFocusChangeDirection(Focusable currentFocusable, EventBase e) { FocusChangeDirection result; if (currentFocusable is IMGUIContainer && e.imguiEvent != null) { result = FocusChangeDirection.none; } else { if (e.GetEventTypeId() == EventBase <KeyDownEvent> .TypeId()) { KeyDownEvent keyDownEvent = e as KeyDownEvent; EventModifiers modifiers = keyDownEvent.modifiers; if (keyDownEvent.character == '\t') { if (currentFocusable == null) { result = FocusChangeDirection.none; return(result); } if ((modifiers & EventModifiers.Shift) == EventModifiers.None) { result = VisualElementFocusChangeDirection.right; return(result); } result = VisualElementFocusChangeDirection.left; return(result); } } result = FocusChangeDirection.none; } return(result); }
private static void AboutToReleaseFocus(Focusable focusable, Focusable willGiveFocusTo, FocusChangeDirection direction) { using (FocusOutEvent pooled = FocusEventBase <FocusOutEvent> .GetPooled(focusable, willGiveFocusTo, direction)) { UIElementsUtility.eventDispatcher.DispatchEvent(pooled, null); } }
private static void AboutToGrabFocus(Focusable focusable, Focusable willTakeFocusFrom, FocusChangeDirection direction) { using (FocusInEvent pooled = FocusEventBase <FocusInEvent> .GetPooled(focusable, willTakeFocusFrom, direction)) { UIElementsUtility.eventDispatcher.DispatchEvent(pooled, null); } }
public FocusChangeDirection GetFocusChangeDirection(Focusable currentFocusable, EventBase e) { FocusChangeDirection none; if (currentFocusable is IMGUIContainer && e.imguiEvent != null) { none = FocusChangeDirection.none; } else { if (e.GetEventTypeId() == EventBase <KeyDownEvent> .TypeId()) { KeyDownEvent keyDownEvent = e as KeyDownEvent; EventModifiers modifiers = keyDownEvent.modifiers; if (keyDownEvent.keyCode == KeyCode.Tab) { if (currentFocusable == null) { return(FocusChangeDirection.none); } if ((modifiers & EventModifiers.Shift) == EventModifiers.None) { return(VisualElementFocusChangeDirection.right); } return(VisualElementFocusChangeDirection.left); } } none = FocusChangeDirection.none; } return(none); }
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); }
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); } }
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); }
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); } }
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 GrabFocus(Focusable focusable, Focusable willTakeFocusFrom, FocusChangeDirection direction) { using (FocusEvent e = FocusEvent.GetPooled(focusable, willTakeFocusFrom, direction)) { UIElementsUtility.eventDispatcher.DispatchEvent(e, null); } }
static void ReleaseFocus(Focusable focusable, Focusable willGiveFocusTo, FocusChangeDirection direction) { using (BlurEvent e = BlurEvent.GetPooled(focusable, willGiveFocusTo, direction)) { UIElementsUtility.eventDispatcher.DispatchEvent(e, null); } }
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); } }
internal void SyncIMGUIFocus(int imguiKeyboardControlID, Focusable imguiContainerHavingKeyboardControl) { imguiKeyboardControl = imguiKeyboardControlID; if (imguiKeyboardControl != 0) { SwitchFocus(imguiContainerHavingKeyboardControl, FocusChangeDirection.unspecified); } else { SwitchFocus(null, FocusChangeDirection.unspecified); } }
private int GetFocusableInternalIndex(Focusable f) { if (f != null) { for (int i = 0; i < this.m_FocusRing.Count; i++) { if (f == this.m_FocusRing[i].m_Focusable) { return(i); } } } return(-1); }
private int GetFocusableInternalIndex(Focusable f) { int result; if (f != null) { for (int i = 0; i < this.m_FocusRing.Count; i++) { if (f == this.m_FocusRing[i].m_Focusable) { result = i; return(result); } } } result = -1; return(result); }
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); }
public FocusChangeDirection GetFocusChangeDirection(Focusable currentFocusable, EventBase e) { // FUTURE: // We could implement an extendable adapter system to convert event to a focus change direction. // This would enable new event sources to change the focus. if (currentFocusable as IMGUIContainer != null && e.imguiEvent != null) { // Let IMGUIContainer manage the focus change. return(FocusChangeDirection.none); } if (e.GetEventTypeId() == KeyDownEvent.TypeId()) { KeyDownEvent kde = e as KeyDownEvent; EventModifiers modifiers = kde.modifiers; if (kde.character == '\t') { if (currentFocusable == null) { // Dont start going around a focus ring if there is no current focused element. return(FocusChangeDirection.none); } else if ((modifiers & EventModifiers.Shift) == 0) { return(VisualElementFocusChangeDirection.right); } else { return(VisualElementFocusChangeDirection.left); } } } return(FocusChangeDirection.none); }
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 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); } } }
internal void DoFocusChange(Focusable f) { focusedElement = f; }
internal void SwitchFocus(Focusable newFocusedElement) { this.SwitchFocus(newFocusedElement, FocusChangeDirection.unspecified); }
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); } }