public void RegisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TCallbackArgs userArgs, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown, InvokePolicy invokePolicy = default) where TEventType : EventBase <TEventType>, new()
{
if (callback == null)
{
throw new ArgumentException("callback parameter is null");
}
long eventTypeId = EventBase <TEventType> .TypeId();
var callbackPhase = useTrickleDown == TrickleDown.TrickleDown ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp;
EventCallbackList callbackList = GetCallbackListForReading();
if (callbackList != null)
{
var functor = callbackList.Find(eventTypeId, callback, callbackPhase) as EventCallbackFunctor <TEventType, TCallbackArgs>;
if (functor != null)
{
functor.userArgs = userArgs;
return;
}
}
callbackList = GetCallbackListForWriting();
callbackList.Add(new EventCallbackFunctor <TEventType, TCallbackArgs>(callback, userArgs, callbackPhase, invokePolicy));
}
internal bool TryGetUserArgs <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TrickleDown useTrickleDown, out TCallbackArgs userArgs) where TEventType : EventBase <TEventType>, new()
{
userArgs = default(TCallbackArgs);
bool flag = callback == null;
bool result;
if (flag)
{
result = false;
}
else
{
EventCallbackList callbackListForReading = this.GetCallbackListForReading();
long eventTypeId = EventBase <TEventType> .TypeId();
CallbackPhase phase = (useTrickleDown == TrickleDown.TrickleDown) ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp;
EventCallbackFunctor <TEventType, TCallbackArgs> eventCallbackFunctor = callbackListForReading.Find(eventTypeId, callback, phase) as EventCallbackFunctor <TEventType, TCallbackArgs>;
bool flag2 = eventCallbackFunctor == null;
if (flag2)
{
result = false;
}
else
{
userArgs = eventCallbackFunctor.userArgs;
result = true;
}
}
return(result);
}
private void OnClickEvent(EventBase evt)
{
bool flag = evt.eventTypeId == EventBase <MouseUpEvent> .TypeId();
if (flag)
{
IMouseEvent mouseEvent = (IMouseEvent)evt;
bool flag2 = mouseEvent.button == 0;
if (flag2)
{
this.OnClick();
}
}
else
{
bool flag3 = evt.eventTypeId == EventBase <PointerUpEvent> .TypeId() || evt.eventTypeId == EventBase <ClickEvent> .TypeId();
if (flag3)
{
IPointerEvent pointerEvent = (IPointerEvent)evt;
bool flag4 = pointerEvent.button == 0;
if (flag4)
{
this.OnClick();
}
}
}
}
internal void Dispatch(EventBase evt, IPanel panel, DispatchMode dispatchMode)
{
evt.MarkReceivedByDispatcher();
bool flag = evt.eventTypeId == EventBase <IMGUIEvent> .TypeId();
if (flag)
{
Event imguiEvent = evt.imguiEvent;
bool flag2 = imguiEvent.rawType == EventType.Repaint;
if (flag2)
{
return;
}
}
bool flag3 = this.dispatchImmediately || dispatchMode == DispatchMode.Immediate;
if (flag3)
{
this.ProcessEvent(evt, panel);
}
else
{
evt.Acquire();
this.m_Queue.Enqueue(new EventDispatcher.EventRecord
{
m_Event = evt,
m_Panel = panel
});
}
}
private static bool SendEventToIMGUIContainer(EventBase evt, BaseVisualElementPanel panel)
{
bool flag = evt.imguiEvent == null;
bool result;
if (flag)
{
result = false;
}
else
{
IMGUIContainer rootIMGUIContainer = panel.rootIMGUIContainer;
bool flag2 = rootIMGUIContainer == null;
if (flag2)
{
result = false;
}
else
{
bool flag3 = evt.propagateToIMGUI || evt.eventTypeId == EventBase <MouseEnterWindowEvent> .TypeId() || evt.eventTypeId == EventBase <MouseLeaveWindowEvent> .TypeId();
if (flag3)
{
evt.skipElements.Add(evt.target);
EventDispatchUtilities.PropagateToIMGUIContainer(panel.visualTree, evt);
}
result = MouseEventDispatchingStrategy.IsDone(evt);
}
}
return(result);
}
internal static FocusChangeDirection GetKeyDownFocusChangeDirection(EventBase e)
{
bool flag = e.eventTypeId == EventBase <KeyDownEvent> .TypeId();
FocusChangeDirection result;
if (flag)
{
KeyDownEvent keyDownEvent = e as KeyDownEvent;
bool flag2 = keyDownEvent.character == '\u0019' || keyDownEvent.character == '\t';
if (flag2)
{
bool flag3 = keyDownEvent.modifiers == EventModifiers.Shift;
if (flag3)
{
result = VisualElementFocusChangeDirection.left;
return(result);
}
bool flag4 = keyDownEvent.modifiers == EventModifiers.None;
if (flag4)
{
result = VisualElementFocusChangeDirection.right;
return(result);
}
}
}
result = FocusChangeDirection.none;
return(result);
}
public FocusChangeDirection GetFocusChangeDirection(Focusable currentFocusable, EventBase e)
{
bool flag = e == null;
if (flag)
{
throw new ArgumentNullException("e");
}
bool flag2 = e.eventTypeId == EventBase <MouseDownEvent> .TypeId();
FocusChangeDirection result;
if (flag2)
{
Focusable focusable = e.target as Focusable;
bool flag3 = focusable != null;
if (flag3)
{
result = VisualElementFocusChangeTarget.GetPooled(focusable);
return(result);
}
}
bool flag4 = currentFocusable is IMGUIContainer && e.imguiEvent != null;
if (flag4)
{
result = FocusChangeDirection.none;
}
else
{
result = VisualElementFocusRing.GetKeyDownFocusChangeDirection(e);
}
return(result);
}
public void RegisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TCallbackArgs userArgs, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown) where TEventType : EventBase <TEventType>, new()
{
bool flag = callback == null;
if (flag)
{
throw new ArgumentException("callback parameter is null");
}
long eventTypeId = EventBase <TEventType> .TypeId();
CallbackPhase phase = (useTrickleDown == TrickleDown.TrickleDown) ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp;
EventCallbackList eventCallbackList = this.GetCallbackListForReading();
bool flag2 = eventCallbackList != null;
if (flag2)
{
EventCallbackFunctor <TEventType, TCallbackArgs> eventCallbackFunctor = eventCallbackList.Find(eventTypeId, callback, phase) as EventCallbackFunctor <TEventType, TCallbackArgs>;
bool flag3 = eventCallbackFunctor != null;
if (flag3)
{
eventCallbackFunctor.userArgs = userArgs;
return;
}
}
eventCallbackList = this.GetCallbackListForWriting();
eventCallbackList.Add(new EventCallbackFunctor <TEventType, TCallbackArgs>(callback, userArgs, phase));
}
protected override void ExecuteDefaultAction(EventBase evt)
{
bool flag = evt == null;
if (!flag)
{
bool flag2 = evt.eventTypeId == EventBase <BlurEvent> .TypeId();
if (flag2)
{
this.lostFocus = true;
base.IncrementVersion(VersionChangeType.Repaint);
}
else
{
bool flag3 = evt.eventTypeId == EventBase <FocusEvent> .TypeId();
if (flag3)
{
FocusEvent focusEvent = evt as FocusEvent;
this.receivedFocus = true;
this.focusChangeDirection = focusEvent.direction;
this.m_IsFocusDelegated = focusEvent.IsFocusDelegated;
}
else
{
bool flag4 = evt.eventTypeId == EventBase <DetachFromPanelEvent> .TypeId();
if (flag4)
{
bool flag5 = base.elementPanel != null;
if (flag5)
{
BaseVisualElementPanel expr_9F = base.elementPanel;
int iMGUIContainersCount = expr_9F.IMGUIContainersCount;
expr_9F.IMGUIContainersCount = iMGUIContainersCount - 1;
}
}
else
{
bool flag6 = evt.eventTypeId == EventBase <AttachToPanelEvent> .TypeId();
if (flag6)
{
bool flag7 = base.elementPanel != null;
if (flag7)
{
BaseVisualElementPanel expr_DF = base.elementPanel;
int iMGUIContainersCount = expr_DF.IMGUIContainersCount;
expr_DF.IMGUIContainersCount = iMGUIContainersCount + 1;
}
}
}
}
}
}
}
private static void UpdateElementUnderMouse(EventBase evt, BaseVisualElementPanel panel, out VisualElement elementUnderMouse)
{
IMouseEventInternal expr_07 = evt as IMouseEventInternal;
elementUnderMouse = ((expr_07 == null || expr_07.recomputeTopElementUnderMouse) ? panel.RecomputeTopElementUnderPointer(((IMouseEvent)evt).mousePosition, evt) : panel.GetTopElementUnderPointer(PointerId.mousePointerId));
bool flag = evt.eventTypeId == EventBase <MouseLeaveWindowEvent> .TypeId() && (evt as MouseLeaveWindowEvent).pressedButtons == 0;
if (flag)
{
panel.ClearCachedElementUnderPointer(evt);
}
}
protected override void ExecuteDefaultActionAtTarget(EventBase evt)
{
base.ExecuteDefaultActionAtTarget(evt);
bool multiline = this.multiline;
if (multiline)
{
long?num = (evt != null) ? new long?(evt.eventTypeId) : null;
long num2 = EventBase <FocusInEvent> .TypeId();
bool arg_AA_0;
if (!(num.GetValueOrDefault() == num2 & num.HasValue) || ((evt != null) ? evt.leafTarget : null) != this)
{
num = ((evt != null) ? new long?(evt.eventTypeId) : null);
num2 = EventBase <FocusInEvent> .TypeId();
arg_AA_0 = ((num.GetValueOrDefault() == num2 & num.HasValue) && ((evt != null) ? evt.leafTarget : null) == base.labelElement);
}
else
{
arg_AA_0 = true;
}
bool flag = arg_AA_0;
if (flag)
{
this.m_VisualInputTabIndex = base.visualInput.tabIndex;
base.visualInput.tabIndex = -1;
}
else
{
num = ((evt != null) ? new long?(evt.eventTypeId) : null);
num2 = EventBase <BlurEvent> .TypeId();
bool arg_166_0;
if (!(num.GetValueOrDefault() == num2 & num.HasValue) || ((evt != null) ? evt.leafTarget : null) != this)
{
num = ((evt != null) ? new long?(evt.eventTypeId) : null);
num2 = EventBase <BlurEvent> .TypeId();
arg_166_0 = ((num.GetValueOrDefault() == num2 & num.HasValue) && ((evt != null) ? evt.leafTarget : null) == base.labelElement);
}
else
{
arg_166_0 = true;
}
bool flag2 = arg_166_0;
if (flag2)
{
base.visualInput.tabIndex = this.m_VisualInputTabIndex;
}
}
}
}
protected override void ExecuteDefaultActionAtTarget(EventBase evt)
{
base.ExecuteDefaultActionAtTarget(evt);
bool flag = base.elementPanel != null && base.elementPanel.contextualMenuManager != null;
if (flag)
{
base.elementPanel.contextualMenuManager.DisplayMenuIfEventMatches(evt, this);
}
long?num = (evt != null) ? new long?(evt.eventTypeId) : null;
long num2 = EventBase <ContextualMenuPopulateEvent> .TypeId();
bool flag2 = num.GetValueOrDefault() == num2 & num.HasValue;
if (flag2)
{
ContextualMenuPopulateEvent contextualMenuPopulateEvent = evt as ContextualMenuPopulateEvent;
int count = contextualMenuPopulateEvent.menu.MenuItems().Count;
this.BuildContextualMenu(contextualMenuPopulateEvent);
bool flag3 = count > 0 && contextualMenuPopulateEvent.menu.MenuItems().Count > count;
if (flag3)
{
contextualMenuPopulateEvent.menu.InsertSeparator(null, count);
}
}
else
{
bool flag4 = evt.eventTypeId == EventBase <FocusInEvent> .TypeId();
if (flag4)
{
this.SaveValueAndText();
}
else
{
bool flag5 = evt.eventTypeId == EventBase <KeyDownEvent> .TypeId();
if (flag5)
{
KeyDownEvent keyDownEvent = evt as KeyDownEvent;
bool flag6 = keyDownEvent != null && keyDownEvent.keyCode == KeyCode.Escape;
if (flag6)
{
this.RestoreValueAndText();
base.parent.Focus();
}
}
}
}
this.editorEventHandler.ExecuteDefaultActionAtTarget(evt);
}
protected override void ExecuteDefaultAction(EventBase evt)
{
base.ExecuteDefaultAction(evt);
bool flag = evt == null;
if (!flag)
{
bool flag2 = evt.eventTypeId == EventBase <GeometryChangedEvent> .TypeId();
if (flag2)
{
this.UpdateDragElementPosition((GeometryChangedEvent)evt);
}
}
}
public virtual bool IsActivationEvent(EventBase evt)
{
bool flag = evt.eventTypeId == EventBase <KeyDownEvent> .TypeId();
bool result;
if (flag)
{
KeyDownEvent keyDownEvent = (KeyDownEvent)evt;
result = (keyDownEvent.keyCode == KeyCode.KeypadEnter || keyDownEvent.keyCode == KeyCode.Return);
}
else
{
result = false;
}
return(result);
}
public virtual bool IsCancellationEvent(EventBase evt)
{
bool flag = evt.eventTypeId == EventBase <KeyDownEvent> .TypeId();
bool result;
if (flag)
{
KeyDownEvent keyDownEvent = (KeyDownEvent)evt;
result = (keyDownEvent.keyCode == KeyCode.Escape);
}
else
{
result = false;
}
return(result);
}
public virtual bool IsNavigationEvent(EventBase evt, out NavigationDirection direction)
{
bool flag = evt.eventTypeId == EventBase <KeyDownEvent> .TypeId();
bool result;
if (flag)
{
result = ((direction = this.GetNavigationDirection((KeyDownEvent)evt)) > NavigationDirection.None);
}
else
{
direction = NavigationDirection.None;
result = false;
}
return(result);
}
public void DispatchEvent(EventBase evt, IPanel panel)
{
IPointerEvent pointerEvent = evt as IPointerEvent;
bool flag = pointerEvent == null;
if (!flag)
{
IEventHandler capturingElement = panel.GetCapturingElement(pointerEvent.pointerId);
bool flag2 = capturingElement == null;
if (!flag2)
{
VisualElement visualElement = capturingElement as VisualElement;
bool flag3 = evt.eventTypeId != EventBase <PointerCaptureOutEvent> .TypeId() && visualElement != null && visualElement.panel == null;
if (flag3)
{
panel.ReleasePointer(pointerEvent.pointerId);
}
else
{
bool flag4 = evt.target != null && evt.target != capturingElement;
if (!flag4)
{
bool flag5 = evt.eventTypeId != EventBase <PointerCaptureEvent> .TypeId() && evt.eventTypeId != EventBase <PointerCaptureOutEvent> .TypeId();
if (flag5)
{
panel.ProcessPointerCapture(pointerEvent.pointerId);
}
evt.dispatch = true;
evt.target = capturingElement;
evt.currentTarget = capturingElement;
evt.propagationPhase = PropagationPhase.AtTarget;
capturingElement.HandleEvent(evt);
evt.currentTarget = null;
evt.propagationPhase = PropagationPhase.None;
evt.dispatch = false;
evt.stopDispatch = true;
evt.propagateToIMGUI = false;
}
}
}
}
}
public void RegisterCallback <TEventType>(EventCallback <TEventType> callback, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown, InvokePolicy invokePolicy = default) where TEventType : EventBase <TEventType>, new()
{
if (callback == null)
{
throw new ArgumentException("callback parameter is null");
}
long eventTypeId = EventBase <TEventType> .TypeId();
var callbackPhase = useTrickleDown == TrickleDown.TrickleDown ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp;
EventCallbackList callbackList = GetCallbackListForReading();
if (callbackList == null || callbackList.Contains(eventTypeId, callback, callbackPhase) == false)
{
callbackList = GetCallbackListForWriting();
callbackList.Add(new EventCallbackFunctor <TEventType>(callback, callbackPhase, invokePolicy));
}
}
public virtual void ExecuteDefaultAction(EventBase evt)
{
bool flag = evt.eventTypeId == EventBase <FocusEvent> .TypeId();
if (flag)
{
this.editorEngine.OnFocus();
this.editorEngine.SelectAll();
}
else
{
bool flag2 = evt.eventTypeId == EventBase <BlurEvent> .TypeId();
if (flag2)
{
this.editorEngine.OnLostFocus();
this.editorEngine.SelectNone();
}
}
}
public void RegisterCallback <TEventType>(EventCallback <TEventType> callback, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown) where TEventType : EventBase <TEventType>, new()
{
bool flag = callback == null;
if (flag)
{
throw new ArgumentException("callback parameter is null");
}
long eventTypeId = EventBase <TEventType> .TypeId();
CallbackPhase phase = (useTrickleDown == TrickleDown.TrickleDown) ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp;
EventCallbackList eventCallbackList = this.GetCallbackListForReading();
bool flag2 = eventCallbackList == null || !eventCallbackList.Contains(eventTypeId, callback, phase);
if (flag2)
{
eventCallbackList = this.GetCallbackListForWriting();
eventCallbackList.Add(new EventCallbackFunctor <TEventType>(callback, phase));
}
}
public override void ExecuteDefaultActionAtTarget(EventBase evt)
{
base.ExecuteDefaultActionAtTarget(evt);
long num = EventBase <MouseDownEvent> .TypeId();
bool flag = !base.textInputField.isReadOnly && evt.eventTypeId == num && base.editorEngine.keyboardOnScreen == null;
if (flag)
{
base.textInputField.SyncTextEngine();
base.textInputField.UpdateText(base.editorEngine.text);
base.editorEngine.keyboardOnScreen = TouchScreenKeyboard.Open(base.textInputField.text, TouchScreenKeyboardType.Default, true, base.editorEngine.multiline, base.textInputField.isPasswordField);
bool flag2 = base.editorEngine.keyboardOnScreen != null;
if (flag2)
{
this.PollTouchScreenKeyboard();
}
base.editorEngine.UpdateScrollOffset();
evt.StopPropagation();
}
}
protected override void ExecuteDefaultActionAtTarget(EventBase evt)
{
base.ExecuteDefaultActionAtTarget(evt);
bool flag = evt == null;
if (!flag)
{
bool flag2 = evt.eventTypeId == EventBase <KeyDownEvent> .TypeId();
if (flag2)
{
KeyDownEvent keyDownEvent = evt as KeyDownEvent;
char? c = (keyDownEvent != null) ? new char?(keyDownEvent.character) : null;
int? num = c.HasValue ? new int?((int)c.GetValueOrDefault()) : null;
int num2 = 3;
bool arg_E3_0;
if (!(num.GetValueOrDefault() == num2 & num.HasValue))
{
c = ((keyDownEvent != null) ? new char?(keyDownEvent.character) : null);
num = (c.HasValue ? new int?((int)c.GetValueOrDefault()) : null);
num2 = 10;
arg_E3_0 = (num.GetValueOrDefault() == num2 & num.HasValue);
}
else
{
arg_E3_0 = true;
}
bool flag3 = arg_E3_0;
if (flag3)
{
VisualElement expr_EE = base.visualInput;
if (expr_EE != null)
{
expr_EE.Focus();
}
}
}
}
}
protected override void ExecuteDefaultAction(EventBase evt)
{
base.ExecuteDefaultAction(evt);
bool arg_4B_0;
if (this.parentTextField.isDelayed)
{
long?num = (evt != null) ? new long?(evt.eventTypeId) : null;
long num2 = EventBase <BlurEvent> .TypeId();
arg_4B_0 = (num.GetValueOrDefault() == num2 & num.HasValue);
}
else
{
arg_4B_0 = false;
}
bool flag = arg_4B_0;
if (flag)
{
this.parentTextField.value = base.text;
}
}
internal bool TryGetUserArgs <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TrickleDown useTrickleDown, out TCallbackArgs userArgs) where TEventType : EventBase <TEventType>, new()
{
userArgs = default;
if (callback == null)
{
return(false);
}
EventCallbackList list = GetCallbackListForReading();
long eventTypeId = EventBase <TEventType> .TypeId();
var callbackPhase = useTrickleDown == TrickleDown.TrickleDown ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp;
var functor = list.Find(eventTypeId, callback, callbackPhase) as EventCallbackFunctor <TEventType, TCallbackArgs>;
if (functor == null)
{
return(false);
}
userArgs = functor.userArgs;
return(true);
}
public void DispatchEvent(EventBase evt, IPanel panel)
{
bool flag = evt.target != null;
if (flag)
{
evt.propagateToIMGUI = (evt.target is IMGUIContainer);
EventDispatchUtilities.PropagateEvent(evt);
}
else
{
bool flag2 = !evt.isPropagationStopped && panel != null;
if (flag2)
{
bool flag3 = evt.propagateToIMGUI || evt.eventTypeId == EventBase <MouseEnterWindowEvent> .TypeId() || evt.eventTypeId == EventBase <MouseLeaveWindowEvent> .TypeId();
if (flag3)
{
EventDispatchUtilities.PropagateToIMGUIContainer(panel.visualTree, evt);
}
}
}
evt.stopDispatch = true;
}
internal void CommitElementUnderPointers(EventDispatcher dispatcher)
{
for (int i = 0; i < this.m_TopElementUnderPointer.Length; i++)
{
IPointerEvent pointerEvent = this.m_TriggerPointerEvent[i];
VisualElement visualElement = this.m_TopElementUnderPointer[i];
VisualElement visualElement2 = this.m_PendingTopElementUnderPointer[i];
bool flag = visualElement2 == visualElement;
if (flag)
{
bool flag2 = pointerEvent != null;
if (flag2)
{
Vector3 position = pointerEvent.position;
this.m_PickingPointerPositions[i] = new Vector2(position.x, position.y);
}
else
{
bool flag3 = this.m_TriggerMouseEvent[i] != null;
if (flag3)
{
this.m_PickingPointerPositions[i] = this.m_TriggerMouseEvent[i].mousePosition;
}
}
}
else
{
this.m_TopElementUnderPointer[i] = visualElement2;
bool flag4 = pointerEvent == null && this.m_TriggerMouseEvent[i] == null;
if (flag4)
{
using (new EventDispatcherGate(dispatcher))
{
Vector2 pointerPosition = PointerDeviceState.GetPointerPosition(i);
PointerEventsHelper.SendOverOut(visualElement, visualElement2, null, pointerPosition, i);
PointerEventsHelper.SendEnterLeave <PointerLeaveEvent, PointerEnterEvent>(visualElement, visualElement2, null, pointerPosition, i);
this.m_PickingPointerPositions[i] = pointerPosition;
bool flag5 = i == PointerId.mousePointerId;
if (flag5)
{
MouseEventsHelper.SendMouseOverMouseOut(visualElement, visualElement2, null, pointerPosition);
MouseEventsHelper.SendEnterLeave <MouseLeaveEvent, MouseEnterEvent>(visualElement, visualElement2, null, pointerPosition);
}
}
}
bool flag6 = pointerEvent != null;
if (flag6)
{
Vector3 position2 = pointerEvent.position;
this.m_PickingPointerPositions[i] = new Vector2(position2.x, position2.y);
EventBase eventBase = pointerEvent as EventBase;
bool flag7 = eventBase != null && (eventBase.eventTypeId == EventBase <PointerMoveEvent> .TypeId() || eventBase.eventTypeId == EventBase <PointerDownEvent> .TypeId() || eventBase.eventTypeId == EventBase <PointerUpEvent> .TypeId() || eventBase.eventTypeId == EventBase <PointerCancelEvent> .TypeId());
if (flag7)
{
using (new EventDispatcherGate(dispatcher))
{
PointerEventsHelper.SendOverOut(visualElement, visualElement2, pointerEvent, position2, i);
PointerEventsHelper.SendEnterLeave <PointerLeaveEvent, PointerEnterEvent>(visualElement, visualElement2, pointerEvent, position2, i);
}
}
}
this.m_TriggerPointerEvent[i] = null;
IMouseEvent mouseEvent = this.m_TriggerMouseEvent[i];
bool flag8 = mouseEvent != null;
if (flag8)
{
Vector2 mousePosition = mouseEvent.mousePosition;
this.m_PickingPointerPositions[i] = mousePosition;
EventBase eventBase2 = mouseEvent as EventBase;
bool flag9 = eventBase2 != null;
if (flag9)
{
bool flag10 = eventBase2.eventTypeId == EventBase <MouseMoveEvent> .TypeId() || eventBase2.eventTypeId == EventBase <MouseDownEvent> .TypeId() || eventBase2.eventTypeId == EventBase <MouseUpEvent> .TypeId() || eventBase2.eventTypeId == EventBase <WheelEvent> .TypeId();
if (flag10)
{
using (new EventDispatcherGate(dispatcher))
{
MouseEventsHelper.SendMouseOverMouseOut(visualElement, visualElement2, mouseEvent, mousePosition);
MouseEventsHelper.SendEnterLeave <MouseLeaveEvent, MouseEnterEvent>(visualElement, visualElement2, mouseEvent, mousePosition);
}
}
else
{
bool flag11 = eventBase2.eventTypeId == EventBase <MouseEnterWindowEvent> .TypeId() || eventBase2.eventTypeId == EventBase <MouseLeaveWindowEvent> .TypeId();
if (flag11)
{
using (new EventDispatcherGate(dispatcher))
{
PointerEventsHelper.SendOverOut(visualElement, visualElement2, null, mousePosition, i);
PointerEventsHelper.SendEnterLeave <PointerLeaveEvent, PointerEnterEvent>(visualElement, visualElement2, null, mousePosition, i);
bool flag12 = i == PointerId.mousePointerId;
if (flag12)
{
MouseEventsHelper.SendMouseOverMouseOut(visualElement, visualElement2, mouseEvent, mousePosition);
MouseEventsHelper.SendEnterLeave <MouseLeaveEvent, MouseEnterEvent>(visualElement, visualElement2, mouseEvent, mousePosition);
}
}
}
else
{
bool flag13 = eventBase2.eventTypeId == EventBase <DragUpdatedEvent> .TypeId() || eventBase2.eventTypeId == EventBase <DragExitedEvent> .TypeId();
if (flag13)
{
using (new EventDispatcherGate(dispatcher))
{
PointerEventsHelper.SendOverOut(visualElement, visualElement2, null, mousePosition, i);
PointerEventsHelper.SendEnterLeave <PointerLeaveEvent, PointerEnterEvent>(visualElement, visualElement2, null, mousePosition, i);
MouseEventsHelper.SendMouseOverMouseOut(visualElement, visualElement2, mouseEvent, mousePosition);
MouseEventsHelper.SendEnterLeave <MouseLeaveEvent, MouseEnterEvent>(visualElement, visualElement2, mouseEvent, mousePosition);
MouseEventsHelper.SendEnterLeave <DragLeaveEvent, DragEnterEvent>(visualElement, visualElement2, mouseEvent, mousePosition);
}
}
}
}
}
this.m_TriggerMouseEvent[i] = null;
}
}
}
}
public void ProcessEvent(EventBase evt)
{
IPointerEvent pointerEvent = evt as IPointerEvent;
bool flag = pointerEvent == null;
if (!flag)
{
bool flag2 = evt.eventTypeId == EventBase <PointerDownEvent> .TypeId() && pointerEvent.button == 0;
if (flag2)
{
this.StartClickTracking(evt);
}
else
{
bool flag3 = evt.eventTypeId == EventBase <PointerMoveEvent> .TypeId();
if (flag3)
{
bool flag4 = pointerEvent.button == 0 && (pointerEvent.pressedButtons & 1) == 1;
if (flag4)
{
this.StartClickTracking(evt);
}
else
{
bool flag5 = pointerEvent.button == 0 && (pointerEvent.pressedButtons & 1) == 0;
if (flag5)
{
this.SendClickEvent(evt);
}
else
{
ClickDetector.ButtonClickStatus buttonClickStatus = this.m_ClickStatus[pointerEvent.pointerId];
bool flag6 = buttonClickStatus.m_Target != null;
if (flag6)
{
buttonClickStatus.m_LastPointerDownTime = 0L;
}
}
}
}
else
{
bool flag7 = evt.eventTypeId == EventBase <PointerCancelEvent> .TypeId() || evt.eventTypeId == EventBase <PointerStationaryEvent> .TypeId() || evt.eventTypeId == EventBase <DragUpdatedEvent> .TypeId();
if (flag7)
{
this.CancelClickTracking(evt);
}
else
{
bool flag8 = evt.eventTypeId == EventBase <PointerUpEvent> .TypeId() && pointerEvent.button == 0;
if (flag8)
{
this.SendClickEvent(evt);
}
}
}
}
}
}
public override void ExecuteDefaultActionAtTarget(EventBase evt)
{
base.ExecuteDefaultActionAtTarget(evt);
bool flag = evt.eventTypeId == EventBase <FocusEvent> .TypeId();
if (flag)
{
this.OnFocus(evt as FocusEvent);
}
else
{
bool flag2 = evt.eventTypeId == EventBase <BlurEvent> .TypeId();
if (flag2)
{
this.OnBlur(evt as BlurEvent);
}
else
{
bool flag3 = evt.eventTypeId == EventBase <MouseDownEvent> .TypeId();
if (flag3)
{
this.OnMouseDown(evt as MouseDownEvent);
}
else
{
bool flag4 = evt.eventTypeId == EventBase <MouseUpEvent> .TypeId();
if (flag4)
{
this.OnMouseUp(evt as MouseUpEvent);
}
else
{
bool flag5 = evt.eventTypeId == EventBase <MouseMoveEvent> .TypeId();
if (flag5)
{
this.OnMouseMove(evt as MouseMoveEvent);
}
else
{
bool flag6 = evt.eventTypeId == EventBase <KeyDownEvent> .TypeId();
if (flag6)
{
this.OnKeyDown(evt as KeyDownEvent);
}
else
{
bool flag7 = evt.eventTypeId == EventBase <ValidateCommandEvent> .TypeId();
if (flag7)
{
this.OnValidateCommandEvent(evt as ValidateCommandEvent);
}
else
{
bool flag8 = evt.eventTypeId == EventBase <ExecuteCommandEvent> .TypeId();
if (flag8)
{
this.OnExecuteCommandEvent(evt as ExecuteCommandEvent);
}
}
}
}
}
}
}
}
}
public EventCallbackFunctor(EventCallback <TEventType> callback, CallbackPhase phase) : base(phase)
{
m_Callback = callback;
m_EventTypeId = EventBase <TEventType> .TypeId();
}
public bool UnregisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown) where TEventType : EventBase <TEventType>, new()
{
long eventTypeId = EventBase <TEventType> .TypeId();
return(UnregisterCallback(eventTypeId, callback, useTrickleDown));
}
