private void ProcessMouseButtonDrag(PointerEventData eventData, float pixelDragThresholdMultiplier = 1.0f)
{
if (!eventData.IsPointerMoving() ||
Cursor.lockState == CursorLockMode.Locked ||
eventData.pointerDrag == null)
{
return;
}
if (!eventData.dragging)
{
if ((eventData.pressPosition - eventData.position).sqrMagnitude >= ((eventSystem.pixelDragThreshold * eventSystem.pixelDragThreshold) * pixelDragThresholdMultiplier))
{
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.beginDragHandler);
eventData.dragging = true;
}
}
if (eventData.dragging)
{
// If we moved from our initial press object, process an up for that object.
if (eventData.pointerPress != eventData.pointerDrag)
{
ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerUpHandler);
eventData.eligibleForClick = false;
eventData.pointerPress = null;
eventData.rawPointerPress = null;
}
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.dragHandler);
}
}
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);
}
}
public void OnPointerUp(PointerEventData eventData)
{
bool isIn = rect.Contains(eventData.position, true);
bool moving = eventData.IsPointerMoving();
if (!(eventData.dragging && moving) && isIn)
{
ClickEvent(eventData);
}
if (onUp != null)
{
onUp(gameObject);
}
if (onUpDetail != null)
{
onUpDetail(gameObject, eventData);
}
if (onLongPress != null && _LongClick != null)
{
StopCoroutine(_LongClick);
_LongClick = null;
}
if (_UpdateHoldCoroutine != null)
{
StopCoroutine(_UpdateHoldCoroutine);
_UpdateHoldCoroutine = null;
}
}
private void ProcessDrag(PointerEventData eventData)
{
if (!eventData.IsPointerMoving() ||
//Cursor.lockState == CursorLockMode.Locked ||
eventData.pointerDrag == null)
{
return;
}
if (!eventData.dragging &&
ShouldStartDrag(eventData.pressPosition, eventData.position, eventSystem.pixelDragThreshold, eventData.useDragThreshold))
{
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.beginDragHandler);
eventData.dragging = true;
}
// Drag notification
if (eventData.dragging)
{
// Before doing drag we should cancel any pointer down state
// And clear selection!
if (eventData.pointerPress != eventData.pointerDrag)
{
ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerUpHandler);
eventData.eligibleForClick = false;
eventData.pointerPress = null;
eventData.rawPointerPress = null;
}
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.dragHandler);
}
}
void OnPointerExit(PointerEventData eventData)
{
if (eventData.IsPointerMoving())
{
inventoryPanel.SetActive(false);
}
}
private void AddIcon(PointerEventData eventData)
{
if (!eventData.dragging && !eventData.IsPointerMoving())
{
string addPrefabName = eventData.pointerPress.name + "i";
GameObject go = RDResManager.LoadWithCache <GameObject>("icon_addPrefabs/c_icon_selectInsAdd");
Transform goTrans = Instantiate(go).transform;
goTrans.name = addPrefabName;
int oldCount;
Transform parent;
if (shotMode == ShotMode.Jpg)
{
parent = trans_c_icon_jpg;
oldCount = parent.childCount;
}
else
{
parent = trans_c_icon_gif.GetChild(gifIndex);
oldCount = parent.childCount;
}
goTrans.SetParent(parent, false);
goTrans.GetChild(0).GetComponent <RawImage>().texture = eventData.pointerPress.transform.GetChild(0).GetComponent <RawImage>().texture;
goTrans.GetChild(0).GetComponent <RawImage>().SetNativeSize();
if (oldCount > 0)
{
goTrans.GetComponent <RectTransform>().anchoredPosition3D = goTrans.parent.GetChild(oldCount - 1).GetComponent <RectTransform>().anchoredPosition3D + new Vector3(30, 0, 0);
}
}
}
public void OnPointerEnter(PointerEventData eventData)
{
if (eventData.IsPointerMoving())
{
SelectButton();
}
}
protected virtual void ProcessMove(PointerEventData pointerEvent)
{
bool moving = pointerEvent.IsPointerMoving();
// Drag notification
if (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);
}
var targetGO = pointerEvent.pointerCurrentRaycast.gameObject;
if (lastEventData != null)
{
pointerEvent.pointerEnter = lastEventData.pointerEnter;
}
HandlePointerExitAndEnter(pointerEvent, targetGO);
lastEventData = pointerEvent;
}
private void HandleDrag()
{
//print ("drag");
bool moving = pointerData.IsPointerMoving();
if (moving && pointerData.pointerDrag != null && !pointerData.dragging)
{
ExecuteEvents.Execute(pointerData.pointerDrag, pointerData,
ExecuteEvents.beginDragHandler);
pointerData.dragging = true;
}
// Drag notification
if (pointerData.dragging && moving && pointerData.pointerDrag != null)
{
// Before doing drag we should cancel any pointer down state
// And clear selection!
if (pointerData.pointerPress != pointerData.pointerDrag)
{
ExecuteEvents.Execute(pointerData.pointerPress, pointerData, ExecuteEvents.pointerUpHandler);
pointerData.eligibleForClick = false;
pointerData.pointerPress = null;
pointerData.rawPointerPress = null;
}
ExecuteEvents.Execute(pointerData.pointerDrag, pointerData, ExecuteEvents.dragHandler);
}
}
public void OnDrag(PointerEventData eventData)
{
if (!bEnableDrag)
{
return;
}
PointerEventData pointerData = eventData as PointerEventData;
if (pointerData.IsPointerMoving() && decorationTransform != null && !decorationTransform.bDecorationTransformButtonDown)
{
bMove = true;
Vector3 s = Camera.main.ScreenToWorldPoint(Input.mousePosition) - dragOffset;
// if( transform.parent.name == "ToysHolder")
// {
// if(s.x >1.6f) s= new Vector3(1.6f,s.y,0);
// else if(s.x <-1.6f) s= new Vector3(-1.6f,s.y,0);
//
// if(s.y >2.5f) s= new Vector3(s.x,2.5f,0);
// else if(s.y <-1.1f) s= new Vector3(s.x,-1.1f,0);
// }
// decorationTransform.transform.position = new Vector3 (s.x,s.y,-5);
// transform.position = new Vector3 (s.x,s.y,0);
destintaion = new Vector3(s.x, s.y, 0);
}
}
protected override void ProcessDrag(PointerEventData pointerEvent)
{
if (!pointerEvent.IsPointerMoving() || pointerEvent.pointerDrag == null)
{
return;
}
if (!pointerEvent.dragging && ShouldStartDrag(pointerEvent))
{
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
pointerEvent.dragging = true;
}
if (pointerEvent.dragging)
{
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);
}
}
/// <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);
}
}
private void HandleDrag()
{
bool moving = pointerData.IsPointerMoving();
bool shouldStartDrag = ShouldStartDrag(pointerData.pressPosition,
pointerData.position,
eventSystem.pixelDragThreshold,
pointerData.useDragThreshold);
if (moving && shouldStartDrag && pointerData.pointerDrag != null && !pointerData.dragging)
{
ExecuteEvents.Execute(pointerData.pointerDrag, pointerData,
ExecuteEvents.beginDragHandler);
pointerData.dragging = true;
}
// Drag notification
if (pointerData.dragging && moving && pointerData.pointerDrag != null)
{
// Before doing drag we should cancel any pointer down state
// And clear selection!
if (pointerData.pointerPress != pointerData.pointerDrag)
{
ExecuteEvents.Execute(pointerData.pointerPress, pointerData, ExecuteEvents.pointerUpHandler);
pointerData.eligibleForClick = false;
pointerData.pointerPress = null;
pointerData.rawPointerPress = null;
}
ExecuteEvents.Execute(pointerData.pointerDrag, pointerData, ExecuteEvents.dragHandler);
}
}
/// <summary>
/// Copied from PointInputModule - 1 Removal
/// </summary>
protected override void ProcessDrag(PointerEventData pointerEvent)
{
if (!pointerEvent.IsPointerMoving() ||
/*REMOVED 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 MMProcessTouchDrag(PointerEventData pointerEvent)
{
bool moving = pointerEvent.IsPointerMoving();
if (moving && pointerEvent.pointerDrag != null &&
!pointerEvent.dragging &&
MMShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))
{
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
ExecuteEvents.Execute <IUIInputBeginDrag>(pointerEvent.pointerDrag, pointerEvent, (x, y) => x.OnBeginDrag(new Input_UI_OnBeginDrag(pointerEvent)));
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);
ExecuteEvents.Execute <IUIInputPointerUp>(pointerEvent.pointerPress, pointerEvent, (x, y) => x.OnPointerUp(new Input_UI_OnPointerUp(pointerEvent)));
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = null;
pointerEvent.rawPointerPress = null;
}
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
ExecuteEvents.Execute <IUIInputDrag>(pointerEvent.pointerDrag, pointerEvent, (x, y) => x.OnDrag(new Input_UI_OnDrag(pointerEvent)));
}
}
public void OnPointerEnter(PointerEventData ivykiai)
{
Debug.Log("bas");
if (!ivykiai.IsPointerMoving() && ivykiai.clickTime >= 5)
{
Debug.Log("labas");
}
}
public void OnPointerExit(PointerEventData eventData)
{
//鼠标离开范围
if (eventData.IsPointerMoving())
{
introduction3Manager.HiddenIntroduction();
}
}
private static bool UseMouse(bool pressed, bool released, PointerEventData pointerData)
{
if (pressed || released || pointerData.IsPointerMoving() || pointerData.IsScrolling())
{
return(true);
}
return(false);
}
public void OnDrag(PointerEventData eventData)
{
if (eventData.IsPointerMoving())
{
var start = Camera.allCameras[0].ScreenToWorldPoint(eventData.position - eventData.delta);
var end = Camera.allCameras[0].ScreenToWorldPoint(eventData.position);
transform.position += end - start;
}
}
static int IsPointerMoving(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 1);
PointerEventData obj = LuaScriptMgr.GetNetObject <PointerEventData>(L, 1);
bool o = obj.IsPointerMoving();
LuaScriptMgr.Push(L, o);
return(1);
}
private void Update()
{
xAxis = Input.GetAxis("Mouse X");
if (pointerData != null)
{
if (!pointerData.IsPointerMoving())
{
Xaxis = 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)
{
if (pointerEvent.IsVRPointer())
{
return(true);
}
else
{
return(pointerEvent.IsPointerMoving());
}
}
private void CallLuaFunction(EventTriggerType t, PointerEventData eventData)
{
//if (_luaFunction == null)
// return;
int type = 1 << (int)t;
if ((type & _eventTypes) == 0)
{
return;
}
if (_luaEventData == null)
{
_luaEventData = new LuaEventData();
}
_luaEventData.button = (int)eventData.button;
_luaEventData.clickCount = eventData.clickCount;
_luaEventData.clickTime = eventData.clickTime;
_luaEventData.delta_x = eventData.delta.x;
_luaEventData.delta_y = eventData.delta.y;
_luaEventData.dragging = eventData.dragging;
_luaEventData.eligibleForClick = eventData.eligibleForClick;
_luaEventData.pointerId = eventData.pointerId;
_luaEventData.position_x = eventData.position.x;
_luaEventData.position_y = eventData.position.y;
_luaEventData.pressPosition_x = eventData.pressPosition.x;
_luaEventData.pressPosition_y = eventData.pressPosition.y;
_luaEventData.scrollDelta_x = eventData.scrollDelta.x;
_luaEventData.scrollDelta_y = eventData.scrollDelta.y;
_luaEventData.SetIsPointMoving(eventData.IsPointerMoving());
_luaEventData.SetIsScrolling(eventData.IsScrolling());
_luaEventData.camera = eventData.enterEventCamera;
//_luaFunction.Call(type, _luaEventData);
if (_luaEventData.button >= 0 && _luaEventData.button <= 2)
{
eventData.button = (PointerEventData.InputButton)_luaEventData.button;
}
eventData.clickCount = _luaEventData.clickCount;
eventData.clickTime = _luaEventData.clickTime;
eventData.delta.Set(_luaEventData.delta_x, _luaEventData.delta_y);
eventData.dragging = _luaEventData.dragging;
eventData.eligibleForClick = _luaEventData.eligibleForClick;
eventData.pointerId = _luaEventData.pointerId;
eventData.position.Set(_luaEventData.position_x, _luaEventData.position_y);
eventData.pressPosition.Set(_luaEventData.pressPosition_x, _luaEventData.pressPosition_y);
eventData.scrollDelta.Set(_luaEventData.scrollDelta_x, _luaEventData.scrollDelta_y);
}
/// <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)
{
TouchUIPointerEventData rayPointerEventData = pointerEvent as TouchUIPointerEventData;
if (rayPointerEventData != null)
{
return(true);
}
else
{
return(pointerEvent.IsPointerMoving());
}
}
private void Update()
{
if (_p != null && !_p.IsPointerMoving())
{
_isdragging = false;
}
if (UseCountDown)
{
if (!_isAviable)
{
FillImage();
}
}
}
public void OnDrag(PointerEventData eventData)
{
if (eventData.IsPointerMoving())
{
m_isDraging = true;
}
else
{
m_isDraging = false;
}
m_endDragPos = eventData.position;
x = m_endDragPos.x - m_beginDragPos.x;
}
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);
}
public void OnDrag(PointerEventData eventData)
{
endHold = false;
inertsia = inertsiaPublic;
deltaX = eventData.delta.x;
deltaY = eventData.delta.y;
//print(eventData.IsPointerMoving());
movingPointer = eventData.IsPointerMoving();
pointerDelta = eventData.delta;
transform.position = new Vector2(Mathf.Lerp(transform.position.x, transform.position.x + pointerDelta.x, speed), Mathf.Lerp(transform.position.y, transform.position.y + pointerDelta.y, speed));
topPanel.transform.position = new Vector2(transform.position.x, topPanel.transform.position.y);
leftPanel.transform.position = new Vector2(leftPanel.transform.position.x, transform.position.y - constanta / deletel);
}
public static int IsPointerMoving(IntPtr l)
{
int result;
try
{
PointerEventData pointerEventData = (PointerEventData)LuaObject.checkSelf(l);
bool b = pointerEventData.IsPointerMoving();
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, b);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public virtual void OnPointerDown(PointerEventData ped)
{
OnDrag(ped);
this.isPressed = true;
this.pressedTime = Time.realtimeSinceStartup;
if (ped.IsPointerMoving())
{
// if (ped.clickCount % 2 == 0)
// pCtrl.anim.SetBool("Attack2", false);
// else
pCtrl.anim.SetBool("Attack1", false);
}
else
{
// if (ped.clickCount % 2 == 0)
// pCtrl.anim.SetBool("Attack2", true);
// else
pCtrl.anim.SetBool("Attack1", true);
}
}
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);
}
}
