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, 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 bool DoOnGUI(Event evt) { bool result; if (this.m_OnGUIHandler == null || base.panel == null) { result = false; } else { int num = GUIClip.Internal_GetCount(); this.SaveGlobals(); int instanceID = (this.executionContext == 0) ? base.elementPanel.instanceID : this.executionContext; UIElementsUtility.BeginContainerGUI(this.cache, instanceID, evt, this); this.GUIDepth = GUIUtility.Internal_GetGUIDepth(); EventType type = Event.current.type; bool flag = false; try { this.m_OnGUIHandler(); } catch (Exception exception) { if (type != EventType.Layout) { throw; } flag = GUIUtility.IsExitGUIException(exception); if (!flag) { Debug.LogException(exception); } } GUIUtility.CheckForTabEvent(evt); EventType type2 = Event.current.type; UIElementsUtility.EndContainerGUI(); this.RestoreGlobals(); if (!flag) { if (type2 != EventType.Ignore && type2 != EventType.Used) { int num2 = GUIClip.Internal_GetCount(); if (num2 > num) { Debug.LogError("GUI Error: You are pushing more GUIClips than you are popping. Make sure they are balanced)"); } else if (num2 < 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); result = true; } else { result = false; } } return(result); }
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); } } }