protected virtual void ProcessDrag(PointerEventData pointerEvent)
{
if (!pointerEvent.IsPointerMoving() ||
Cursor.lockState == CursorLockMode.Locked ||
pointerEvent.pointerDrag == null)
{
return;
}
if (!pointerEvent.dragging &&
ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))
{
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
// Drag notification
if (pointerEvent.dragging)
{
// Before doing drag we should cancel any pointer down state
// And clear selection!
if (pointerEvent.pointerPress != pointerEvent.pointerDrag)
{
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = null;
pointerEvent.rawPointerPress = null;
}
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
private void ProcessDrag()
{
bool moving = pointerEventData.IsPointerMoving();
if (moving && pointerEventData.pointerDrag != null &&
!pointerEventData.dragging &&
ShouldStartDrag(pointerEventData.pressPosition, pointerEventData.position, eventSystem.pixelDragThreshold, pointerEventData.useDragThreshold))
{
ExecuteEvents.Execute(pointerEventData.pointerDrag, pointerEventData, ExecuteEvents.beginDragHandler);
pointerEventData.dragging = true;
}
// Drag notification
if (pointerEventData.dragging && moving && pointerEventData.pointerDrag != null)
{
// Before doing drag we should cancel any pointer down state
// And clear selection!
if (pointerEventData.pointerPress != pointerEventData.pointerDrag)
{
ExecuteEvents.Execute(pointerEventData.pointerPress, pointerEventData, ExecuteEvents.pointerUpHandler);
pointerEventData.eligibleForClick = false;
pointerEventData.pointerPress = null;
pointerEventData.rawPointerPress = null;
}
ExecuteEvents.Execute(pointerEventData.pointerDrag, pointerEventData, ExecuteEvents.dragHandler);
}
}
protected virtual void ProcessDrag(PointerEventData pointerEvent)
{ /* used in StandaloneInputModule.ProcessToucheEvents() and StandaloneInputModule.ProcessMouseEvent(int id)
* call OnBeginDrag
* call OnPointerUp, if for some reason pointerPress != pointerDrag
* call OnDrag
*/
if (pointerEvent.IsPointerMoving() && Cursor.lockState != CursorLockMode.Locked && !(pointerEvent.pointerDrag == null))
{
if (!pointerEvent.dragging && PointerInputModule.ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float)base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))
{
ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
if (pointerEvent.dragging)
{
if (pointerEvent.pointerPress != pointerEvent.pointerDrag)
{
ExecuteEvents.Execute <IPointerUpHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = null;
pointerEvent.rawPointerPress = null;
}
ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
}
/// <summary>
/// The purpose of this function is to allow us to switch between using the standard IsPointerMoving
/// method for mouse driven pointers, but to always return true when it's a ray based pointer.
/// All real-world ray-based input devices are always moving so for simplicity we just return true
/// for them.
///
/// If PointerEventData.IsPointerMoving was virtual we could just override that in
/// OVRRayPointerEventData.
/// </summary>
/// <param name="pointerEvent"></param>
/// <returns></returns>
static bool IsPointerMoving(PointerEventData pointerEvent)
{
if (pointerEvent.IsVRPointer())
return true:
else
return pointerEvent.IsPointerMoving():
}
private static bool UseMouse(bool pressed, bool released, PointerEventData pointerData)
{
if (pressed || released || pointerData.IsPointerMoving() || pointerData.IsScrolling())
{
return(true);
}
return(false);
}
/// <summary>
/// The purpose of this function is to allow us to switch between using the standard IsPointerMoving
/// method for mouse driven pointers, but to always return true when it's a ray based pointer.
/// All real-world ray-based input devices are always moving so for simplicity we just return true
/// for them.
///
/// If PointerEventData.IsPointerMoving was virtual we could just override that in
/// OVRRayPointerEventData.
/// </summary>
/// <param name="pointerEvent"></param>
/// <returns></returns>
static bool IsPointerMoving(PointerEventData pointerEvent)
{
if (pointerEvent.IsVRPointer())
{
return(true);
}
else
{
return(pointerEvent.IsPointerMoving());
}
}
static bool IsPointerMoving(PointerEventData pointerEvent)
{
if (pointerEvent.IsF3dSpacePointer())
{
return(true);
}
else
{
}
return(pointerEvent.IsPointerMoving());
}
static public int IsPointerMoving(IntPtr l)
{
try {
UnityEngine.EventSystems.PointerEventData self = (UnityEngine.EventSystems.PointerEventData)checkSelf(l);
var ret = self.IsPointerMoving();
pushValue(l, ret);
return(1);
}
catch (Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return(0);
}
}
/// <summary>
/// The purpose of this function is to allow us to switch between using the standard IsPointerMoving
/// method for mouse driven pointers, but to always return true when it's a ray based pointer.
/// All real-world ray-based input devices are always moving so for simplicity we just return true
/// for them.
///
/// If PointerEventData.IsPointerMoving was virtual we could just override that in
/// OVRRayPointerEventData.
/// </summary>
/// <param name="pointerEvent"></param>
/// <returns></returns>
static bool IsPointerMoving(PointerEventData pointerEvent)
{
OVRRayPointerEventData rayPointerEventData = pointerEvent as OVRRayPointerEventData;
if (rayPointerEventData != null)
{
return(true);
}
else
{
return(pointerEvent.IsPointerMoving());
}
}
static public int IsPointerMoving(IntPtr l)
{
try {
UnityEngine.EventSystems.PointerEventData self = (UnityEngine.EventSystems.PointerEventData)checkSelf(l);
var ret = self.IsPointerMoving();
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static int QPYX_IsPointerMoving_YXQP(IntPtr L_YXQP)
{
try
{
ToLua.CheckArgsCount(L_YXQP, 1);
UnityEngine.EventSystems.PointerEventData QPYX_obj_YXQP = (UnityEngine.EventSystems.PointerEventData)ToLua.CheckObject <UnityEngine.EventSystems.PointerEventData>(L_YXQP, 1);
bool QPYX_o_YXQP = QPYX_obj_YXQP.IsPointerMoving();
LuaDLL.lua_pushboolean(L_YXQP, QPYX_o_YXQP);
return(1);
}
catch (Exception e_YXQP) {
return(LuaDLL.toluaL_exception(L_YXQP, e_YXQP));
}
}
static int IsPointerMoving(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 1);
UnityEngine.EventSystems.PointerEventData obj = (UnityEngine.EventSystems.PointerEventData)ToLua.CheckObject(L, 1, typeof(UnityEngine.EventSystems.PointerEventData));
bool o = obj.IsPointerMoving();
LuaDLL.lua_pushboolean(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
// Token: 0x06000237 RID: 567 RVA: 0x0001E49C File Offset: 0x0001C69C
protected virtual void ProcessDrag(PointerEventData pointerEvent)
{
bool flag = pointerEvent.IsPointerMoving();
if (flag && pointerEvent.pointerDrag != null && !pointerEvent.dragging && CusPointerInputModule.ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float)base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))
{
ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
if (pointerEvent.dragging && flag && pointerEvent.pointerDrag != null)
{
if (pointerEvent.pointerPress != pointerEvent.pointerDrag)
{
ExecuteEvents.Execute <IPointerUpHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = null;
pointerEvent.rawPointerPress = null;
}
ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
/// <summary>
///
/// <para>
/// Process the drag for the current frame with the given pointer event.
/// </para>
///
/// </summary>
/// <param name="pointerEvent"/>
protected virtual void ProcessDrag(PointerEventData pointerEvent)
{
bool flag = pointerEvent.IsPointerMoving();
if (flag && (Object)pointerEvent.pointerDrag != (Object)null && (!pointerEvent.dragging && PointerInputModule.ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float)this.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold)))
{
ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, (BaseEventData)pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
if (!pointerEvent.dragging || !flag || !((Object)pointerEvent.pointerDrag != (Object)null))
{
return;
}
if ((Object)pointerEvent.pointerPress != (Object)pointerEvent.pointerDrag)
{
ExecuteEvents.Execute <IPointerUpHandler>(pointerEvent.pointerPress, (BaseEventData)pointerEvent, ExecuteEvents.pointerUpHandler);
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = (GameObject)null;
pointerEvent.rawPointerPress = (GameObject)null;
}
ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, (BaseEventData)pointerEvent, ExecuteEvents.dragHandler);
}
/// <summary>
/// <para>Process the drag for the current frame with the given pointer event.</para>
/// </summary>
/// <param name="pointerEvent"></param>
protected virtual void ProcessDrag(PointerEventData pointerEvent)
{
if ((pointerEvent.IsPointerMoving() && (Cursor.lockState != CursorLockMode.Locked)) && (pointerEvent.pointerDrag != null))
{
if (!pointerEvent.dragging && ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float)base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))
{
ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
if (pointerEvent.dragging)
{
if (pointerEvent.pointerPress != pointerEvent.pointerDrag)
{
ExecuteEvents.Execute <IPointerUpHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = null;
pointerEvent.rawPointerPress = null;
}
ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
}
protected virtual void ProcessDrag(PointerEventData pointerEvent)
{
// DOC-HINT :::::: multi event system support
// check if the event data does not belong to the eventsystem associated with the module
if (!this.CompareEventSystemID(pointerEvent))
{
// exit method execution
return;
}
bool moving = pointerEvent.IsPointerMoving();
if (moving && pointerEvent.pointerDrag != null &&
!pointerEvent.dragging &&
ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))
{
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
// Drag notification
if (pointerEvent.dragging && moving && pointerEvent.pointerDrag != null)
{
// Before doing drag we should cancel any pointer down state
// And clear selection!
if (pointerEvent.pointerPress != pointerEvent.pointerDrag)
{
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = null;
pointerEvent.rawPointerPress = null;
}
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
protected virtual void ProcessDrag(PointerEventData pointerEvent)
{
bool flag = pointerEvent.IsPointerMoving();
if ((flag && (pointerEvent.pointerDrag != null)) && (!pointerEvent.dragging && ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float) base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold)))
{
ExecuteEvents.Execute<IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
if ((pointerEvent.dragging && flag) && (pointerEvent.pointerDrag != null))
{
if (pointerEvent.pointerPress != pointerEvent.pointerDrag)
{
ExecuteEvents.Execute<IPointerUpHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = null;
pointerEvent.rawPointerPress = null;
}
ExecuteEvents.Execute<IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
private static bool UseMouse(bool pressed, bool released, PointerEventData pointerData)
{
if(pressed || released || pointerData.IsPointerMoving() || pointerData.IsScrolling())
return true;
return false;
}
/// <summary>
/// Moves injected pointer in UI.
/// </summary>
/// <param name="pointerEvent"> The pointer data. </param>
protected void movePointer(PointerEventData pointerEvent)
{
var targetGO = pointerEvent.pointerCurrentRaycast.gameObject;
HandlePointerExitAndEnter(pointerEvent, targetGO);
bool moving = pointerEvent.IsPointerMoving();
if (moving && pointerEvent.pointerDrag != null
&& !pointerEvent.dragging
&&
shouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, eventSystem.pixelDragThreshold,
pointerEvent.useDragThreshold))
{
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
// Drag notification
if (pointerEvent.dragging && moving && pointerEvent.pointerDrag != null)
{
// Before doing drag we should cancel any pointer down state
// And clear selection!
if (pointerEvent.pointerPress != pointerEvent.pointerDrag)
{
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = null;
pointerEvent.rawPointerPress = null;
}
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
// walk up the tree till a common root between the last entered and the current entered is found
// send exit events up to (including) the common root. Then send enter events up to
// (including) the common root.
// Send move events before exit, after enter, and on hovered objects when pointer data has changed.
protected void HandlePointerExitAndEnter(PointerEventData currentPointerData, GameObject newEnterTarget)
{
// if we have no target / pointerEnter has been deleted
// just send exit events to anything we are tracking
// then exit
if (newEnterTarget == null || currentPointerData.pointerEnter == null)
{
var hoveredCount = currentPointerData.hovered.Count;
for (var i = 0; i < hoveredCount; ++i)
{
ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerMoveHandler);
ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerExitHandler);
}
currentPointerData.hovered.Clear();
if (newEnterTarget == null)
{
currentPointerData.pointerEnter = null;
return;
}
}
// if we have not changed hover target
if (currentPointerData.pointerEnter == newEnterTarget && newEnterTarget)
{
if (currentPointerData.IsPointerMoving())
{
var hoveredCount = currentPointerData.hovered.Count;
for (var i = 0; i < hoveredCount; ++i)
{
ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerMoveHandler);
}
}
return;
}
GameObject commonRoot = FindCommonRoot(currentPointerData.pointerEnter, newEnterTarget);
// and we already an entered object from last time
if (currentPointerData.pointerEnter != null)
{
// send exit handler call to all elements in the chain
// until we reach the new target, or null!
Transform t = currentPointerData.pointerEnter.transform;
while (t != null)
{
ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerMoveHandler);
ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerExitHandler);
currentPointerData.hovered.Remove(t.gameObject);
// if we reach the common root break out!
if (commonRoot != null && commonRoot.transform == t)
{
break;
}
t = t.parent;
}
}
// now issue the enter call up to but not including the common root
currentPointerData.pointerEnter = newEnterTarget;
if (newEnterTarget != null)
{
Transform t = newEnterTarget.transform;
while (t != null)
{
ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerEnterHandler);
ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerMoveHandler);
currentPointerData.hovered.Add(t.gameObject);
if (commonRoot != null && commonRoot.transform == t)
{
break;
}
t = t.parent;
}
}
}
/// <summary>
///
/// <para>
/// Process the drag for the current frame with the given pointer event.
/// </para>
///
/// </summary>
/// <param name="pointerEvent"/>
protected virtual void ProcessDrag(PointerEventData pointerEvent)
{
bool flag = pointerEvent.IsPointerMoving();
if (flag && (Object) pointerEvent.pointerDrag != (Object) null && (!pointerEvent.dragging && PointerInputModule.ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float) this.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold)))
{
ExecuteEvents.Execute<IBeginDragHandler>(pointerEvent.pointerDrag, (BaseEventData) pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
if (!pointerEvent.dragging || !flag || !((Object) pointerEvent.pointerDrag != (Object) null))
return;
if ((Object) pointerEvent.pointerPress != (Object) pointerEvent.pointerDrag)
{
ExecuteEvents.Execute<IPointerUpHandler>(pointerEvent.pointerPress, (BaseEventData) pointerEvent, ExecuteEvents.pointerUpHandler);
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = (GameObject) null;
pointerEvent.rawPointerPress = (GameObject) null;
}
ExecuteEvents.Execute<IDragHandler>(pointerEvent.pointerDrag, (BaseEventData) pointerEvent, ExecuteEvents.dragHandler);
}
private static bool IsPointerMoving(PointerEventData pointerEvent)
{
return(pointerEvent.IsVRPointer() || pointerEvent.IsPointerMoving());
}
protected virtual void ProcessDrag(PointerEventData pointerEvent)
{
bool moving = pointerEvent.IsPointerMoving();
if (moving && pointerEvent.pointerDrag != null
&& !pointerEvent.dragging
&& ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))
{
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
// Drag notification
if (pointerEvent.dragging && moving && pointerEvent.pointerDrag != null)
{
// Before doing drag we should cancel any pointer down state
// And clear selection!
if (pointerEvent.pointerPress != pointerEvent.pointerDrag)
{
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = null;
pointerEvent.rawPointerPress = null;
}
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
protected override void ProcessDrag(PointerEventData pointerEvent)
{ /* used in StandaloneInputModule.ProcessToucheEvents() and StandaloneInputModule.ProcessMouseEvent(int id)
* call OnBeginDrag
* call OnPointerUp, if for some reason pointerPress != pointerDrag
* call OnDrag
*
* pointerDrag could be DragHandler, HorizontalDragHandler, or VerticalDragHandler
*/
if (pointerEvent.IsPointerMoving() && Cursor.lockState != CursorLockMode.Locked && !(pointerEvent.pointerDrag == null))
{
if (!pointerEvent.dragging && ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float)base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))
{
ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
if (pointerEvent.dragging)
{
// if (pointerEvent.pointerPress != pointerEvent.pointerDrag)
// {
// ExecuteEvents.Execute<IPointerUpHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
// pointerEvent.pointerPress = null;
// pointerEvent.eligibleForClick = false;
// pointerEvent.rawPointerPress = null;
// }
print("pointerDrag is " + pointerEvent.pointerDrag.gameObject.name);
if (!ExecuteEvents.CanHandleEvent <IHorizontalDragHandler>(pointerEvent.pointerDrag) && !ExecuteEvents.CanHandleEvent <IVerticalDragHandler>(pointerEvent.pointerDrag) && ExecuteEvents.CanHandleEvent <IDragHandler>(pointerEvent.pointerDrag))
{
ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
else
{
float thresh = (float)base.eventSystem.pixelDragThreshold;
if (pointerEvent.delta.sqrMagnitude > (thresh * thresh))
{
if (Mathf.Abs(Vector2.Dot(Vector2.right, pointerEvent.delta.normalized)) > Mathf.Cos(45f * Mathf.Deg2Rad))
{
if (ExecuteEvents.CanHandleEvent <IHorizontalDragHandler>(pointerEvent.pointerDrag))
{
ExecuteEvents.Execute <IHorizontalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.horizontalDragHandler);
}
else
{
GameObject prevPointerDrag = pointerEvent.pointerDrag;
pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler <IHorizontalDragHandler>(pointerEvent.pointerCurrentRaycast.gameObject);
if (pointerEvent.pointerDrag != null)
{
// print("switch to h");
ExecuteEvents.Execute <IEndDragHandler>(prevPointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
ExecuteEvents.Execute <IInitializePotentialDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag);
ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
ExecuteEvents.Execute <IHorizontalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.horizontalDragHandler);
}
else
{
// print("no handler for h");
pointerEvent.pointerDrag = prevPointerDrag;
ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
}
else
{
if (ExecuteEvents.CanHandleEvent <IVerticalDragHandler>(pointerEvent.pointerDrag))
{
ExecuteEvents.Execute <IVerticalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.verticalDragHandler);
}
else
{
GameObject prevPointerDrag = pointerEvent.pointerDrag;
pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler <IVerticalDragHandler>(pointerEvent.pointerCurrentRaycast.gameObject);
if (pointerEvent.pointerDrag != null)
{
// print("switch to v");
ExecuteEvents.Execute <IEndDragHandler>(prevPointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
ExecuteEvents.Execute <IInitializePotentialDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag);
ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
ExecuteEvents.Execute <IVerticalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.verticalDragHandler);
}
else
{
// print("no handler for v");
pointerEvent.pointerDrag = prevPointerDrag;
ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
}
}
else
{
// print("under thresh");
if (Mathf.Abs(Vector2.Dot(Vector2.right, pointerEvent.delta.normalized)) > Mathf.Cos(45f * Mathf.Deg2Rad))
{
if (ExecuteEvents.CanHandleEvent <IHorizontalDragHandler>(pointerEvent.pointerDrag))
{
ExecuteEvents.Execute <IHorizontalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.horizontalDragHandler);
}
else
{
ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
else
{
if (ExecuteEvents.CanHandleEvent <IVerticalDragHandler>(pointerEvent.pointerDrag))
{
ExecuteEvents.Execute <IVerticalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.verticalDragHandler);
}
else
{
ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
}
}
}
}
prevDelta = pointerEvent.delta;
}
}
}
/// <summary>
/// The purpose of this function is to allow us to switch between using the standard IsPointerMoving
/// method for mouse driven pointers, but to always return true when it's a ray based pointer.
/// All real-world ray-based input devices are always moving so for simplicity we just return true
/// for them.
///
/// If PointerEventData.IsPointerMoving was virtual we could just override that in
/// OVRRayPointerEventData.
/// </summary>
/// <param name="pointerEvent"></param>
/// <returns></returns>
static bool IsPointerMoving(PointerEventData pointerEvent)
{
OVRRayPointerEventData rayPointerEventData = pointerEvent as OVRRayPointerEventData;
if (rayPointerEventData != null)
return true;
else
return pointerEvent.IsPointerMoving();
}
static bool UseMouse( bool pressed, bool released, PointerEventData pointerData )
{
return pressed || released || pointerData.IsPointerMoving() || pointerData.IsScrolling();
}
bool UseMouse( bool pressed, bool released, PointerEventData pointerData )
{
if (currentInputSource == InputSource.Mouse)
{
return true;
}
if (pressed || released || pointerData.IsPointerMoving() || pointerData.IsScrolling())
{
currentInputSource = InputSource.Mouse;
base.eventSystem.SetSelectedGameObject( null, pointerData );
}
return currentInputSource == InputSource.Mouse;
}
