private void OnGUIHandler()
{
if (Event.current.type == EventType.ExecuteCommand && Event.current.commandName == "EyeDropperUpdate")
{
base.Dirty(ChangeType.Repaint);
}
Color valueAndNotify = EditorGUILayout.ColorField(GUIContent.none, this.value, this.showEyeDropper, this.showAlpha, this.hdr, new GUILayoutOption[0]);
this.SetValueAndNotify(valueAndNotify);
if (this.m_SetKbControl)
{
GUIUtility.SetKeyboardControlToFirstControlId();
this.m_SetKbControl = false;
}
}
private void OnGUIHandler()
{
// Dirty repaint on eye dropper update to preview the color under the cursor
if (Event.current.type == EventType.ExecuteCommand && Event.current.commandName == EventCommandNames.EyeDropperUpdate)
{
Dirty(ChangeType.Repaint);
}
Color newColor = EditorGUILayout.ColorField(GUIContent.none, value, showEyeDropper, showAlpha, hdr);
SetValueAndNotify(newColor);
if (m_SetKbControl)
{
GUIUtility.SetKeyboardControlToFirstControlId();
m_SetKbControl = false;
}
}
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 parentTransform, Rect clippingRect, bool isComputingLayout, Rect layoutSize, Action onGUIHandler, bool canAffectFocus = true)
{
// Extra checks are needed here because client code might have changed the IMGUIContainer
// since we enter HandleIMGUIEvent()
if (onGUIHandler == null ||
panel == null)
{
return;
}
// Save the GUIClip count to make sanity checks after calling the OnGUI handler
int guiClipCount = GUIClip.Internal_GetCount();
SaveGlobals();
// Save a copy of the container size.
var previousMeasuredWidth = layoutMeasuredWidth;
var previousMeasuredHeight = layoutMeasuredHeight;
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 own it.
if (GUIUtility.OwnsId(GUIUtility.keyboardControl))
{
GUIUtility.keyboardControl = 0;
focusController.imguiKeyboardControl = 0;
}
}
lostFocus = false;
}
if (receivedFocus)
{
if (hasFocusableControls)
{
if (focusChangeDirection != FocusChangeDirection.unspecified && focusChangeDirection != FocusChangeDirection.none)
{
// We got here by tabbing.
// We assume we are using the VisualElementFocusRing.
if (focusChangeDirection == VisualElementFocusChangeDirection.left)
{
GUIUtility.SetKeyboardControlToLastControlId();
}
else if (focusChangeDirection == VisualElementFocusChangeDirection.right)
{
GUIUtility.SetKeyboardControlToFirstControlId();
}
}
else if (GUIUtility.keyboardControl == 0 && m_IsFocusDelegated)
{
// Since GUIUtility.keyboardControl == 0, we got focused in some other way than by clicking inside us
// (for example it could be by clicking in an element that delegates focus to us).
// Give GUIUtility.keyboardControl to our first control.
GUIUtility.SetKeyboardControlToFirstControlId();
}
}
if (focusController != null)
{
if (focusController.imguiKeyboardControl != GUIUtility.keyboardControl && focusChangeDirection != FocusChangeDirection.unspecified)
{
newKeyboardFocusControlID = GUIUtility.keyboardControl;
}
focusController.imguiKeyboardControl = GUIUtility.keyboardControl;
}
receivedFocus = false;
focusChangeDirection = FocusChangeDirection.unspecified;
}
// We intentionally don't send the NewKeyboardFocus command here since it creates an issue with the AutomatedWindow
// newKeyboardFocusControlID = GUIUtility.keyboardControl;
}
EventType originalEventType = Event.current.type;
bool isExitGUIException = false;
try
{
using (new GUIClip.ParentClipScope(parentTransform, clippingRect))
{
using (k_OnGUIMarker.Auto())
{
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 && canAffectFocus)
{
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.GetLeafFocusedElement();
Focusable nextFocusedElement = focusController.FocusNextInDirection(result == -1
? VisualElementFocusChangeDirection.right
: VisualElementFocusChangeDirection.left);
if (currentFocusedElement == this)
{
if (nextFocusedElement == this)
{
// We will 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 will lose 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 (originalEventType == EventType.MouseDown && !focusOnlyIfHasFocusableControls)
{
focusController.SyncIMGUIFocus(GUIUtility.keyboardControl, this, true);
}
else if ((currentKeyboardFocus != GUIUtility.keyboardControl) || (originalEventType == EventType.MouseDown))
{
focusController.SyncIMGUIFocus(GUIUtility.keyboardControl, this, false);
}
else if (GUIUtility.keyboardControl != focusController.imguiKeyboardControl)
{
// Here we want to resynchronize our internal state ...
newKeyboardFocusControlID = GUIUtility.keyboardControl;
if (focusController.GetLeafFocusedElement() == 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, false);
}
}
}
}
// Cache the fact that we have focusable controls or not.
hasFocusableControls = GUIUtility.HasFocusableControls();
}
}
// This will copy Event.current into evt.
UIElementsUtility.EndContainerGUI(evt, layoutSize);
RestoreGlobals();
// See if the container size has changed. This is to make absolutely sure the VisualElement resizes
// if the IMGUI content resizes.
if (evt.type == EventType.Layout &&
(!Mathf.Approximately(previousMeasuredWidth, layoutMeasuredWidth) || !Mathf.Approximately(previousMeasuredHeight, layoutMeasuredHeight)))
{
if (isComputingLayout && clippingRect == Rect.zero)
{
this.schedule.Execute(() => IncrementVersion(VersionChangeType.Layout));
}
else
{
IncrementVersion(VersionChangeType.Layout);
}
}
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 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 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 void DoOnGUI(Event evt, Matrix4x4 parentTransform, Rect clippingRect, bool isComputingLayout, Rect layoutSize, Action onGUIHandler, bool canAffectFocus = true)
{
bool flag = onGUIHandler == null || base.panel == null;
if (!flag)
{
int num = GUIClip.Internal_GetCount();
this.SaveGlobals();
float layoutMeasuredWidth = this.layoutMeasuredWidth;
float layoutMeasuredHeight = this.layoutMeasuredHeight;
UIElementsUtility.BeginContainerGUI(this.cache, evt, this);
GUI.color = UIElementsUtility.editorPlayModeTintColor;
bool flag2 = Event.current.type != EventType.Layout;
if (flag2)
{
bool flag3 = this.lostFocus;
if (flag3)
{
bool flag4 = this.focusController != null;
if (flag4)
{
bool flag5 = GUIUtility.OwnsId(GUIUtility.keyboardControl);
if (flag5)
{
GUIUtility.keyboardControl = 0;
this.focusController.imguiKeyboardControl = 0;
}
}
this.lostFocus = false;
}
bool flag6 = this.receivedFocus;
if (flag6)
{
bool flag7 = this.hasFocusableControls;
if (flag7)
{
bool flag8 = this.focusChangeDirection != FocusChangeDirection.unspecified && this.focusChangeDirection != FocusChangeDirection.none;
if (flag8)
{
bool flag9 = this.focusChangeDirection == VisualElementFocusChangeDirection.left;
if (flag9)
{
GUIUtility.SetKeyboardControlToLastControlId();
}
else
{
bool flag10 = this.focusChangeDirection == VisualElementFocusChangeDirection.right;
if (flag10)
{
GUIUtility.SetKeyboardControlToFirstControlId();
}
}
}
else
{
bool flag11 = GUIUtility.keyboardControl == 0 && this.m_IsFocusDelegated;
if (flag11)
{
GUIUtility.SetKeyboardControlToFirstControlId();
}
}
}
bool flag12 = this.focusController != null;
if (flag12)
{
bool flag13 = this.focusController.imguiKeyboardControl != GUIUtility.keyboardControl && this.focusChangeDirection != FocusChangeDirection.unspecified;
if (flag13)
{
this.newKeyboardFocusControlID = GUIUtility.keyboardControl;
}
this.focusController.imguiKeyboardControl = GUIUtility.keyboardControl;
}
this.receivedFocus = false;
this.focusChangeDirection = FocusChangeDirection.unspecified;
}
}
EventType type = Event.current.type;
bool flag14 = false;
try
{
using (new GUIClip.ParentClipScope(parentTransform, clippingRect))
{
onGUIHandler();
}
}
catch (Exception exception)
{
bool flag15 = type == EventType.Layout;
if (!flag15)
{
throw;
}
flag14 = GUIUtility.IsExitGUIException(exception);
bool flag16 = !flag14;
if (flag16)
{
Debug.LogException(exception);
}
}
finally
{
bool flag17 = Event.current.type != EventType.Layout & canAffectFocus;
if (flag17)
{
int keyboardControl = GUIUtility.keyboardControl;
int num2 = GUIUtility.CheckForTabEvent(Event.current);
bool flag18 = this.focusController != null;
if (flag18)
{
bool flag19 = num2 < 0;
if (flag19)
{
Focusable leafFocusedElement = this.focusController.GetLeafFocusedElement();
Focusable focusable = null;
using (KeyDownEvent pooled = KeyboardEventBase <KeyDownEvent> .GetPooled('\t', KeyCode.Tab, (num2 == -1) ? EventModifiers.None : EventModifiers.Shift))
{
focusable = this.focusController.SwitchFocusOnEvent(pooled);
}
bool flag20 = leafFocusedElement == this;
if (flag20)
{
bool flag21 = focusable == this;
if (flag21)
{
bool flag22 = num2 == -2;
if (flag22)
{
GUIUtility.SetKeyboardControlToLastControlId();
}
else
{
bool flag23 = num2 == -1;
if (flag23)
{
GUIUtility.SetKeyboardControlToFirstControlId();
}
}
this.newKeyboardFocusControlID = GUIUtility.keyboardControl;
this.focusController.imguiKeyboardControl = GUIUtility.keyboardControl;
}
else
{
GUIUtility.keyboardControl = 0;
this.focusController.imguiKeyboardControl = 0;
}
}
}
else
{
bool flag24 = num2 > 0;
if (flag24)
{
this.focusController.imguiKeyboardControl = GUIUtility.keyboardControl;
this.newKeyboardFocusControlID = GUIUtility.keyboardControl;
}
else
{
bool flag25 = num2 == 0;
if (flag25)
{
bool flag26 = type == EventType.MouseDown && !this.focusOnlyIfHasFocusableControls;
if (flag26)
{
this.focusController.SyncIMGUIFocus(GUIUtility.keyboardControl, this, true);
}
else
{
bool flag27 = keyboardControl != GUIUtility.keyboardControl || type == EventType.MouseDown;
if (flag27)
{
this.focusController.SyncIMGUIFocus(GUIUtility.keyboardControl, this, false);
}
else
{
bool flag28 = GUIUtility.keyboardControl != this.focusController.imguiKeyboardControl;
if (flag28)
{
this.newKeyboardFocusControlID = GUIUtility.keyboardControl;
bool flag29 = this.focusController.GetLeafFocusedElement() == this;
if (flag29)
{
this.focusController.imguiKeyboardControl = GUIUtility.keyboardControl;
}
else
{
this.focusController.SyncIMGUIFocus(GUIUtility.keyboardControl, this, false);
}
}
}
}
}
}
}
}
this.hasFocusableControls = GUIUtility.HasFocusableControls();
}
}
UIElementsUtility.EndContainerGUI(evt, layoutSize);
this.RestoreGlobals();
bool flag30 = evt.type == EventType.Layout && (!Mathf.Approximately(layoutMeasuredWidth, this.layoutMeasuredWidth) || !Mathf.Approximately(layoutMeasuredHeight, this.layoutMeasuredHeight));
if (flag30)
{
bool flag31 = isComputingLayout && clippingRect == Rect.zero;
if (flag31)
{
base.schedule.Execute(delegate
{
base.IncrementVersion(VersionChangeType.Layout);
});
}
else
{
base.IncrementVersion(VersionChangeType.Layout);
}
}
bool flag32 = !flag14;
if (flag32)
{
bool flag33 = evt.type != EventType.Ignore && evt.type != EventType.Used;
if (flag33)
{
int num3 = GUIClip.Internal_GetCount();
bool flag34 = num3 > num;
if (flag34)
{
Debug.LogError("GUI Error: You are pushing more GUIClips than you are popping. Make sure they are balanced.");
}
else
{
bool flag35 = num3 < num;
if (flag35)
{
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();
}
bool flag36 = evt.type == EventType.Used;
if (flag36)
{
base.IncrementVersion(VersionChangeType.Repaint);
}
}
}