internal new static T GetPooled(EventBase e)
{
IPointerEvent pointerEvent = e as IPointerEvent;
bool flag = pointerEvent != null;
T pooled;
if (flag)
{
pooled = PointerEventBase <T> .GetPooled(pointerEvent);
}
else
{
IMouseEvent mouseEvent = e as IMouseEvent;
bool flag2 = mouseEvent != null;
if (flag2)
{
pooled = PointerEventBase <T> .GetPooled(mouseEvent);
}
else
{
pooled = EventBase <T> .GetPooled(e);
}
}
return(pooled);
}
public void GestureMove(IPointerEvent evnt)
{
if (Update(evnt))
{
evnt.RepaintCanvas();
}
}
private void ScrollToPointer(IPointerEvent evt)
{
double xPercent = evt.localPosition.x / overviewArea.contentRect.width;
double positionInSongInMillis = songAudioPlayer.DurationOfSongInMillis * xPercent;
songAudioPlayer.PositionInSongInMillis = positionInSongInMillis;
}
public virtual void HandlePointerEvent(IPointerEvent evnt)
{
double scale = 1.0 / Zoom;
IPointerEvent subEvnt = new PointerEventAdapter(evnt,
(int)(0.5 + (evnt.RawX - Canvas.RawWidth / 2.0) * scale + CenterX),
(int)(0.5 + (evnt.RawY - Canvas.RawHeight / 2.0) * scale + CenterY));
IGesture gest = gesture;
if (gest != null)
{
switch (evnt.Type)
{
case PointerEventType.GestureStart:
gest.GestureStart(subEvnt);
break;
case PointerEventType.GestureMove:
gest.GestureMove(subEvnt);
break;
case PointerEventType.GestureEnd:
gest.GestureComplete(subEvnt);
break;
}
}
}
public static T GetPooled(IPointerEvent triggerEvent)
{
T pooled = EventBase <T> .GetPooled();
bool flag = triggerEvent != null;
if (flag)
{
pooled.pointerId = triggerEvent.pointerId;
pooled.pointerType = triggerEvent.pointerType;
pooled.isPrimary = triggerEvent.isPrimary;
pooled.button = triggerEvent.button;
pooled.pressedButtons = triggerEvent.pressedButtons;
pooled.position = triggerEvent.position;
pooled.localPosition = triggerEvent.localPosition;
pooled.deltaPosition = triggerEvent.deltaPosition;
pooled.deltaTime = triggerEvent.deltaTime;
pooled.clickCount = triggerEvent.clickCount;
pooled.pressure = triggerEvent.pressure;
pooled.tangentialPressure = triggerEvent.tangentialPressure;
pooled.altitudeAngle = triggerEvent.altitudeAngle;
pooled.azimuthAngle = triggerEvent.azimuthAngle;
pooled.twist = triggerEvent.twist;
pooled.radius = triggerEvent.radius;
pooled.radiusVariance = triggerEvent.radiusVariance;
pooled.modifiers = triggerEvent.modifiers;
IPointerEventInternal pointerEventInternal = triggerEvent as IPointerEventInternal;
bool flag2 = pointerEventInternal != null;
if (flag2)
{
pooled.triggeredByOS = pointerEventInternal.triggeredByOS;
}
}
return(pooled);
}
internal static WheelEvent GetPooled(Vector3 delta, IPointerEvent pointerEvent)
{
WheelEvent e = GetPooled(pointerEvent);
e.delta = delta;
return(e);
}
public void GestureStart(IPointerEvent evnt)
{
initX = evnt.Model.CenterX;
initY = evnt.Model.CenterY;
startX = evnt.RawX;
startY = evnt.RawY;
}
private void StartClickTracking(EventBase evt)
{
IPointerEvent pointerEvent = evt as IPointerEvent;
bool flag = pointerEvent == null;
if (!flag)
{
ClickDetector.ButtonClickStatus buttonClickStatus = this.m_ClickStatus[pointerEvent.pointerId];
VisualElement visualElement = evt.target as VisualElement;
bool flag2 = visualElement != buttonClickStatus.m_Target;
if (flag2)
{
buttonClickStatus.Reset();
}
buttonClickStatus.m_Target = visualElement;
bool flag3 = evt.timestamp - buttonClickStatus.m_LastPointerDownTime > (long)ClickDetector.s_DoubleClickTime;
if (flag3)
{
buttonClickStatus.m_ClickCount = 1;
}
else
{
buttonClickStatus.m_ClickCount++;
}
buttonClickStatus.m_LastPointerDownTime = evt.timestamp;
buttonClickStatus.m_PointerDownPosition = pointerEvent.position;
}
}
public void GestureComplete(IPointerEvent evnt)
{
Location cur = current;
if (currentValid)
{
// Console.WriteLine("**** Adding {0} ****", master.GetType().Name);
layoutModel.Execute((ILayoutAccess lo) => {
if (master is ModuleComponent)
{
ProjectModule sub = ((ModuleComponent)master).Module;
if (sub.HasDescendent(lo.Layout))
{
return;
}
}
Component clone = lo.AddComponent(master, cur.X, cur.Y);
WireTools.CheckForSplits(lo, layoutModel.WiringPoints, new Component[] { clone });
});
}
this.current = new Location(0, 0);
this.currentValid = false;
OnGestureCompleteEvent(true);
layoutModel.Gesture = null;
evnt.RepaintCanvas();
}
void StartClickTracking(EventBase evt)
{
IPointerEvent pe = evt as IPointerEvent;
if (pe == null)
{
return;
}
var clickStatus = m_ClickStatus[pe.pointerId];
var newTarget = evt.target as VisualElement;
if (newTarget != clickStatus.m_Target)
{
clickStatus.Reset();
}
clickStatus.m_Target = newTarget;
if (evt.timestamp - clickStatus.m_LastPointerDownTime > s_DoubleClickTime)
{
clickStatus.m_ClickCount = 1;
}
else
{
clickStatus.m_ClickCount++;
}
clickStatus.m_LastPointerDownTime = evt.timestamp;
clickStatus.m_PointerDownPosition = pe.position;
}
void SendClickEvent(EventBase evt)
{
IPointerEvent pe = evt as IPointerEvent;
if (pe == null)
{
return;
}
var clickStatus = m_ClickStatus[pe.pointerId];
// Filter out event where button is released outside the window.
var element = evt.target as VisualElement;
if (element != null && element.worldBound.Contains(pe.position))
{
if (clickStatus.m_Target != null && clickStatus.m_ClickCount > 0)
{
var target = clickStatus.m_Target.FindCommonAncestor(evt.target as VisualElement);
if (target != null)
{
using (var clickEvent = ClickEvent.GetPooled(evt as PointerUpEvent, clickStatus.m_ClickCount))
{
clickEvent.target = target;
target.SendEvent(clickEvent);
}
}
}
}
}
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();
}
}
}
}
// This function is protected so that only specific subclasses can offer the
// functionality from specific IPointerEvent types.
/// <summary>
/// Gets an event from the event pool and initializes it with the given values. Use this function instead of creating new events. Events obtained using this method need to be released back to the pool. You can use `Dispose()` to release them.
/// </summary>
/// <param name="pointerEvent">The pointer event that sent this event.</param>
/// <returns>An initialized event.</returns>
protected static T GetPooled(IPointerEvent pointerEvent)
{
T e = GetPooled();
e.target = (pointerEvent as EventBase)?.target;
e.imguiEvent = (pointerEvent as EventBase)?.imguiEvent;
e.modifiers = pointerEvent.modifiers;
e.mousePosition = pointerEvent.position;
e.localMousePosition = pointerEvent.position;
e.mouseDelta = pointerEvent.deltaPosition;
e.button = pointerEvent.button == -1 ? 0 : pointerEvent.button;
e.pressedButtons = pointerEvent.pressedButtons;
e.clickCount = pointerEvent.clickCount;
IPointerEventInternal pointerEventInternal = pointerEvent as IPointerEventInternal;
if (pointerEventInternal != null)
{
((IMouseEventInternal)e).triggeredByOS = pointerEventInternal.triggeredByOS;
((IMouseEventInternal)e).recomputeTopElementUnderMouse = true;
// Link the mouse event and the pointer event so we can forward
// the propagation result (for tests and for IMGUI)
((IMouseEventInternal)e).sourcePointerEvent = pointerEvent;
}
return(e);
}
public void GestureCancel(IPointerEvent evnt)
{
moving = null;
curValid = false;
layoutCanvas.Hidden = null;
evnt.RepaintCanvas();
}
public static T GetPooled(IPointerEvent triggerEvent)
{
T e = GetPooled();
if (triggerEvent != null)
{
e.pointerId = triggerEvent.pointerId;
e.pointerType = triggerEvent.pointerType;
e.isPrimary = triggerEvent.isPrimary;
e.button = triggerEvent.button;
e.pressedButtons = triggerEvent.pressedButtons;
e.position = triggerEvent.position;
e.localPosition = triggerEvent.localPosition;
e.deltaPosition = triggerEvent.deltaPosition;
e.deltaTime = triggerEvent.deltaTime;
e.clickCount = triggerEvent.clickCount;
e.pressure = triggerEvent.pressure;
e.tangentialPressure = triggerEvent.tangentialPressure;
e.altitudeAngle = triggerEvent.altitudeAngle;
e.azimuthAngle = triggerEvent.azimuthAngle;
e.twist = triggerEvent.twist;
e.radius = triggerEvent.radius;
e.radiusVariance = triggerEvent.radiusVariance;
e.modifiers = triggerEvent.modifiers;
IPointerEventInternal pointerEventInternal = triggerEvent as IPointerEventInternal;
if (pointerEventInternal != null)
{
((IPointerEventInternal)e).triggeredByOS = pointerEventInternal.triggeredByOS;
}
}
return(e);
}
public void GestureCancel(IPointerEvent evnt)
{
this.current = new Location(0, 0);
this.currentValid = false;
OnGestureCompleteEvent(false);
evnt.RepaintCanvas();
}
private void Init(EventBase evt)
{
this.eventBaseName = evt.GetType().Name;
this.eventTypeId = evt.eventTypeId;
this.eventId = evt.eventId;
this.triggerEventId = evt.triggerEventId;
this.timestamp = evt.timestamp;
this.target = evt.target;
this.skipElements = evt.skipElements;
this.isPropagationStopped = evt.isPropagationStopped;
this.isImmediatePropagationStopped = evt.isImmediatePropagationStopped;
this.isDefaultPrevented = evt.isDefaultPrevented;
IMouseEvent mouseEvent = evt as IMouseEvent;
IMouseEventInternal mouseEventInternal = evt as IMouseEventInternal;
this.hasUnderlyingPhysicalEvent = (mouseEvent != null && mouseEventInternal != null && mouseEventInternal.triggeredByOS);
this.propagationPhase = evt.propagationPhase;
this.originalMousePosition = evt.originalMousePosition;
this.currentTarget = evt.currentTarget;
this.dispatch = evt.dispatch;
bool flag = mouseEvent != null;
if (flag)
{
this.modifiers = mouseEvent.modifiers;
this.mousePosition = mouseEvent.mousePosition;
this.button = mouseEvent.button;
this.pressedButtons = mouseEvent.pressedButtons;
this.clickCount = mouseEvent.clickCount;
}
IPointerEvent pointerEvent = evt as IPointerEvent;
IPointerEventInternal pointerEventInternal = evt as IPointerEventInternal;
this.hasUnderlyingPhysicalEvent = (pointerEvent != null && pointerEventInternal != null && pointerEventInternal.triggeredByOS);
bool flag2 = pointerEvent != null;
if (flag2)
{
this.modifiers = pointerEvent.modifiers;
this.mousePosition = pointerEvent.position;
this.button = pointerEvent.button;
this.pressedButtons = pointerEvent.pressedButtons;
this.clickCount = pointerEvent.clickCount;
}
IKeyboardEvent keyboardEvent = evt as IKeyboardEvent;
bool flag3 = keyboardEvent != null;
if (flag3)
{
this.character = keyboardEvent.character;
this.keyCode = keyboardEvent.keyCode;
}
ICommandEvent commandEvent = evt as ICommandEvent;
bool flag4 = commandEvent != null;
if (flag4)
{
this.commandName = commandEvent.commandName;
}
}
public void GestureComplete(IPointerEvent evnt)
{
ComponentInstance toMove = moving;
if (toMove != null)
{
moving = null;
layoutCanvas.Execute((ILayoutAccess lo) => {
Component comp = toMove.Component;
List <Location> toCheck = new List <Location>();
foreach (ConnectionPoint conn in comp.Connections)
{
toCheck.Add(movingLocation.Translate(conn.Dx, conn.Dy));
}
if (curValid)
{
lo.MoveComponent(toMove.Component, curDx, curDy);
layoutCanvas.WiringPoints.Update();
WireTools.CheckForMerges(lo, layoutCanvas.WiringPoints, toCheck);
layoutCanvas.WiringPoints.Update();
WireTools.CheckForSplits(lo, layoutCanvas.WiringPoints, new Component[] { comp });
}
else
{
lo.RemoveComponent(toMove.Component);
layoutCanvas.WiringPoints.Update();
WireTools.CheckForMerges(lo, layoutCanvas.WiringPoints, toCheck);
}
});
layoutCanvas.Hidden = null;
layoutCanvas.Gesture = null;
evnt.RepaintCanvas();
}
}
private bool Update(IPointerEvent evnt)
{
if (moving == null)
{
return(false);
}
int dx = evnt.X - initX;
int dy = evnt.Y - initY;
Location loc = movingLocation;
if (moving.Component.ShouldSnap)
{
Location newLoc = loc.Translate(dx, dy);
newLoc = Constants.SnapToGrid(newLoc);
dx = newLoc.X - loc.X;
dy = newLoc.Y - loc.Y;
}
if (dx == curDx && dy == curDy)
{
return(false);
}
else
{
curDx = dx;
curDy = dy;
curValid = true;
return(true);
}
}
private void SendClickEvent(EventBase evt)
{
IPointerEvent pointerEvent = evt as IPointerEvent;
bool flag = pointerEvent == null;
if (!flag)
{
ClickDetector.ButtonClickStatus buttonClickStatus = this.m_ClickStatus[pointerEvent.pointerId];
VisualElement visualElement = evt.target as VisualElement;
bool flag2 = visualElement != null && visualElement.worldBound.Contains(pointerEvent.position);
if (flag2)
{
bool flag3 = buttonClickStatus.m_Target != null && buttonClickStatus.m_ClickCount > 0;
if (flag3)
{
VisualElement visualElement2 = buttonClickStatus.m_Target.FindCommonAncestor(evt.target as VisualElement);
bool flag4 = visualElement2 != null;
if (flag4)
{
using (ClickEvent pooled = ClickEvent.GetPooled(evt as PointerUpEvent, buttonClickStatus.m_ClickCount))
{
pooled.target = visualElement2;
visualElement2.SendEvent(pooled);
}
}
}
}
}
}
public DragControlPointerEvent(IPointerEvent evt)
{
Position = evt.position;
LocalPosition = evt.localPosition;
DeltaPosition = evt.deltaPosition;
PointerId = evt.pointerId;
Button = evt.button;
}
internal MyPokeEvent(PokeEventType type, int x, int y, IPointerEvent evnt)
{
this.Type = type;
this.X = x;
this.Y = y;
this.StateUpdate = null;
this.evnt = evnt;
}
static void OnClick(IPointerEvent evt, Toggle toggle)
{
if (evt.button != (int)MouseButton.LeftMouse)
{
return;
}
toggle.value = !toggle.value;
}
private static void UpdateElementUnderPointer(EventBase evt, IPanel panel, out VisualElement elementUnderPointer)
{
IPointerEvent pointerEvent = evt as IPointerEvent;
BaseVisualElementPanel baseVisualElementPanel = panel as BaseVisualElementPanel;
IPointerEventInternal expr_15 = evt as IPointerEventInternal;
elementUnderPointer = ((expr_15 == null || expr_15.recomputeTopElementUnderPointer) ? ((baseVisualElementPanel != null) ? baseVisualElementPanel.RecomputeTopElementUnderPointer(pointerEvent.position, evt) : null) : ((baseVisualElementPanel != null) ? baseVisualElementPanel.GetTopElementUnderPointer(pointerEvent.pointerId) : null));
}
public AbstractCanvasModel()
{
Zoom = 0.25;
CenterX = 5000; // coordinates after scaling
CenterY = 5000;
cancelEvent = new DummyPointerEvent(this,
PointerEventType.GestureCancel);
}
public void GestureMove(IPointerEvent evnt)
{
double scale = 1.0 / evnt.Model.Zoom;
evnt.Model.CenterX = initX - (int)(0.5 + (evnt.RawX - startX) * scale);
evnt.Model.CenterY = initY - (int)(0.5 + (evnt.RawY - startY) * scale);
evnt.RepaintCanvas();
}
/// <summary>
/// Checks whether the PointerEvent is related to this Manipulator.
/// </summary>
/// <param name="e">PointerEvent to validate.</param>
/// <returns>True if PointerEvent uses the current activator button. False otherwise.</returns>
protected bool CanStopManipulation(IPointerEvent e)
{
if (e == null)
{
return(false);
}
return(e.pointerId == m_CurrentPointerId);
}
private bool HasModifiers(IPointerEvent e)
{
if (e == null)
{
return(false);
}
return(MatchModifiers(e.altKey, e.ctrlKey, e.shiftKey, e.commandKey));
}
private static MouseDownEvent MakeFromPointerEvent(IPointerEvent pointerEvent)
{
if (pointerEvent != null && pointerEvent.button >= 0)
{
PointerDeviceState.PressButton(PointerId.mousePointerId, pointerEvent.button);
}
return(MouseEventBase <MouseDownEvent> .GetPooled(pointerEvent));
}
public void GestureCancel(IPointerEvent evnt)
{
Send(PokeEventType.PokeCancel, evnt);
if (layoutModel.Gesture == this)
{
layoutModel.Gesture = null;
}
poking = null;
}
