public void Reset()
{
touchInProgress = false;
onTouchStart = null;
onTouchMove = null;
onTouchEnd = null;
}
public virtual void OnTouchOver(TouchEvent touchEvent)
{
m_IsOver = true;
m_State = State.OVER;
NotifyObservers(m_State);
}
public virtual void OnTouchOut(TouchEvent touchEvent)
{
m_IsOver = false;
m_State = State.UP;
NotifyObservers(m_State);
}
public void MoveTouch(TouchEvent args)
{
if (playerSettings != null && playerSettings.ActiveSpell != null)
{
playerSettings.ActiveSpell.MoveTouch(args);
}
}
public virtual bool OnTouchDown(TouchEvent touchEvent)
{
m_State = State.DOWN;
NotifyObservers(m_State);
return true;
}
public virtual void OnTouchDrag(TouchEvent touchEvent)
{
if (m_IsBeingDragged && touchEvent.RawType == TouchRawType.LeftClick)
{
Vector3 position = m_Camera.ScreenToWorldPoint(Input.mousePosition) + m_MouseOffset;
transform.position = new Vector3(position.x, position.y, transform.position.z);
}
}
public virtual void OnTouchUp(TouchEvent touchEvent)
{
if (m_IsBeingDragged && touchEvent.RawType == TouchRawType.LeftClick)
{
m_IsDragging = false;
m_IsBeingDragged = false;
}
}
public virtual void OnTouchUp(TouchEvent touchEvent)
{
m_State = State.UP;
NotifyObservers(m_State);
m_State = State.FIRED;
NotifyObservers(m_State);
}
public override void OnTouchOut(TouchEvent touchEvent)
{
base.OnTouchOut(touchEvent);
if (m_Sprite != null)
{
m_Sprite.spriteId = m_Sprite.GetSpriteIdByName(m_UpSpriteName);
}
}
public override void OnTouchUp(TouchEvent touchEvent)
{
base.OnTouchUp(touchEvent);
if (!string.IsNullOrEmpty(m_ActionName))
{
FlowManager.Instance.TriggerAction(m_ActionName);
}
}
public override void OnTouchUp(TouchEvent touchEvent)
{
base.OnTouchUp(touchEvent);
if (m_IsOver)
{
OnTouchOver(touchEvent);
}
}
public override void OnTouchOver(TouchEvent touchEvent)
{
base.OnTouchOver(touchEvent);
if (m_ButtonAsset != null && m_ButtonAsset.material != null)
{
m_ButtonAsset.renderer.material.color = m_InitialColor;
}
}
public override void OnTouchOut(TouchEvent touchEvent)
{
base.OnTouchOut(touchEvent);
if (m_ButtonAsset != null && m_ButtonAsset.material != null)
{
m_ButtonAsset.renderer.material.color = BUTTON_OUT_COLOR;
}
}
private TouchEvent CreateTouchEvent(TouchEventArgs args, TouchEvent.TouchEventAction action)
{
return new TouchEvent
{
Action = action,
Id = args.Id,
TranslatedPosition = new Vector2(args.Location.X, args.Location.Y),
NonTranslatedPosition = new Vector2(args.Location.X, args.Location.Y),
TimeStamp = DateTime.Now
};
}
public override void OnTouchOver(TouchEvent touchEvent)
{
base.OnTouchOver(touchEvent);
AudioManager.Instance.PlaySFX(m_SFXClick);
if (m_Sprite != null)
{
m_Sprite.spriteId = m_Sprite.GetSpriteIdByName(m_HoverSpriteName);
}
}
public virtual bool OnTouchDown(TouchEvent touchEvent)
{
if (!m_IsDragging && touchEvent.RawType == TouchRawType.LeftClick)
{
m_IsDragging = true;
m_IsBeingDragged = true;
m_MouseOffset = transform.position - m_Camera.ScreenToWorldPoint(Input.mousePosition);
return true;
}
return false;
}
public override bool OnTouchDown(TouchEvent touchEvent)
{
if (base.OnTouchDown(touchEvent))
{
if (m_Sprite != null)
{
m_Sprite.spriteId = m_Sprite.GetSpriteIdByName(m_DownSpriteName);
}
return true;
}
return false;
}
public override void TouchesBegan (NSSet touches, UIEvent evt)
{
var touch = touches.AnyObject as UITouch;
touchStart = touch.LocationInView (this);
// If the menu is not active
if (container.MenuHostElement == null || container.MenuHostElement != container.TweetElementFromPath (IndexPathForRowAtPoint (touchStart.Value))){
if (capturedEnded != null){
TouchesCancelled (capturedEnded.Touches, capturedEnded.Event);
capturedEnded = null;
}
container.CancelMenu ();
swipeDetectionDisabled = false;
}
base.TouchesBegan (touches, evt);
}
public override void update(float deltaTime)
{
IGraphics g = game.getGraphics();
IList <TouchEvent> touchEvents = game.getInput().getTouchEvents();
int len = touchEvents.Size();
for (int i = 0; i < len; i++)
{
TouchEvent @event = touchEvents.Get(i);
if (@event.type == TouchEvent.TOUCH_UP)
{
if (inBounds(@event, 50, 350, 250, 450))
{
game.setScreen(new GameScreen(game));
}
}
}
}
public override void OnTouchDown(TouchDownEvent touchEventArgs)
{
var isInArea = IsInArea(touchEventArgs.LocationX, touchEventArgs.LocationY);
base.OnTouchDown(touchEventArgs);
// Only start handling touch if it happened inside control's area
if (!touchEventArgs.IsPrimaryContact || !isInArea)
{
return;
}
_lastTouchEvent = touchEventArgs;
IScrollViewerFocusSupport svfs = FindScrollControl() as IScrollViewerFocusSupport;
if (svfs != null)
{
svfs.BeginScroll();
}
}
public bool ProcessTouchEnd(TouchEvent touch)
{
if (m_Buttons == null)
{
return(false);
}
foreach (GUIBase_Button btn in m_Buttons)
{
if (btn.Widget.IsMouseOver(touch.Position))
{
if (m_ButtonDelegate != null)
{
m_ButtonDelegate(Id, btn.Widget, touch);
}
return(true);
}
}
return(false);
}
public override void TouchesEnded(NSSet touches, UIEvent evt)
{
if (container.MenuHostElement != null)
{
if (capturedEnded == null)
{
capturedEnded = new TouchEvent(touches, evt);
}
container.TouchesEnded(touches, evt);
return;
}
ignoreUntilLift = false;
base.TouchesEnded(touches, evt);
touchStart = null;
}
public static void TouchEnd(TouchEvent evt)
{
JsString target_id = evt.target.id;
if (movingItems[target_id].As <bool>())
{
isMoving = false;
//Deactivate the current moving object and set the zIndex to 1;
movingItems[target_id] = 1;
HtmlElement.GetById(target_id).style.zIndex = "2";
foreach (JsString j in movingItems)
{
if (j != target_id)
{
HtmlElement.GetById(j).style.zIndex = "1";
}
}
}
}
/// <summary>
/// A static method that takes the network data and dispatches events based on what was inputted on the smart device
/// </summary>
/// <param name="playerID">The device the touch input is coming from</param>
/// <param name="ts">The data from the smart device, which has been parsed into a TouchSerializer already</param>
public static void ProcessTouch(int playerID, TouchSerializer ts)
{
TouchEvent touchType = TouchPhaseLookup(ts.phase);
if (touchType != null)
{
touchType(playerID, ts.fingerID, ts.position);
}
if (OnDoubleTap != null && ts.tapCount == 2 && touchType == OnTouchUp)
{
OnDoubleTap(playerID, ts.fingerID, ts.position);
}
if (OnTripleTap != null && ts.tapCount == 3 && touchType == OnTouchUp)
{
OnTripleTap(playerID, ts.fingerID, ts.position);
}
}
private void PushTouchEvent(ref TouchLocation state, int button, ButtonState buttonState)
{
TouchEvent ev = ObtainTouchEvent(ref state);
ev.Button = button;
switch (buttonState)
{
case ButtonState.Pressed:
ev.Type = TouchEventType.Down;
break;
case ButtonState.Released:
ev.Type = TouchEventType.Up;
break;
}
_touchEvents.Add(ev);
}
private void TouchEnd(Touch touch)
{
TouchEvent touchEvent;
for (int i = 0; i < TouchEvents.Count; i++)
{
if (((TouchEvent)TouchEvents[i]).Id == touch.fingerId)
{
touchEvent = (TouchEvent)TouchEvents[i];
touchEvent.Update(touch);
SendToReceivers(touchEvent);
TouchEvents.RemoveAt(i);
TouchEvent.Return(touchEvent);
return;
}
}
}
void Update()
{
if (Input.touchCount > 0)
{
Touch touch = Input.GetTouch(0);
if (touch.phase == TouchPhase.Ended)
{
RaiseClickTap(Camera.main.ScreenToWorldPoint(touch.position));
if (Time.time < lastClickDeltaTime + DoubleTapCatchTime)
{
RaiseDoubleTap();
}
lastClickDeltaTime = Time.time;
}
TouchEvent?.Invoke(Camera.main.ScreenToWorldPoint(touch.position));
}
}
private void OnTouchEndLeaveAndCancel(TouchEvent <HTMLCanvasElement> touchEvent)
{
if (touchEvent == null)
{
throw new ArgumentNullException(nameof(touchEvent));
}
var touches = touchEvent.ChangedTouches;
foreach (var touch in touches)
{
if (_currentToucheIdentifiers.ContainsKey(touch.Identifier))
{
_currentToucheIdentifiers.Remove(touch.Identifier);
}
InputTouchUp(touch);
}
}
void TouchEnd(ref TouchEvent evt)
{
if (m_MoveJoystick.FingerID == evt.Id)
{
m_MoveJoystick.OnTouchEnd(ref evt);
return;
}
if (m_ViewJoystick.FingerID == evt.Id)
{
if (GuiHUD.Instance != null)
{
GuiHUD.Instance.AimJoystickUp(evt.Position);
}
m_ViewJoystick.OnTouchEnd(ref evt);
return;
}
}
internal override void Flush()
{
float time = Time.time;
for (int idx = 0; idx < m_Buttons.Length; ++idx)
{
TouchEvent evt = m_Buttons[idx];
if (evt.Finished == true)
{
continue;
}
evt.Phase = TouchPhase.Canceled;
evt.EndTime = time;
m_Buttons[idx] = evt;
m_Owner.Process(evt);
}
}
void TouchBegin(ref TouchEvent evt)
{
// Debug.Log("BENY: -------------------------------------------------------------------------------------------------------------------------");
// Debug.Log("BENY: " + Time.timeSinceLevelLoad + " TouchBegin : id=" + evt.Id + ", pos=" + evt.Position + ", delta=" + touch.deltaPosition);
if (FingerIdInUse(ref evt, false))
{
if (m_MoveJoystick.FingerID == evt.Id)
{
m_MoveJoystick.OnTouchEnd(ref evt);
}
else if (m_ViewJoystick.FingerID == evt.Id)
{
m_ViewJoystick.OnTouchEnd(ref evt);
}
}
/*InteractionObject touchedInteraction = TouchedInteractionIcon(evt.Position);
* if(touchedInteraction)
* {
* _States.UseObjectDelegate(touchedInteraction);
* return;
* }*/
if (m_States.Move.Enabled && m_MoveJoystick.FingerID == -1 && m_MoveJoystick.IsInside(ref evt))
{
m_MoveJoystick.OnTouchBegin(ref evt);
return;
}
if (m_States.View.Enabled && m_ViewJoystick.On == false && m_ViewJoystick.IsInside(ref evt))
{
//Debug.Log(Time.timeSinceLevelLoad + " View Joystick aquired " + evt.Id + "pos " + evt.Position);
//Debug.Log(">>>> VIEW BEGIN");
m_ViewJoystick.FingerID = evt.Id;
m_ViewJoystick.SetCenter(evt.Position);
m_ViewJoystick.Rotation = Player.LocalInstance.Owner.BlackBoard.Desires.Rotation;
m_States.View.ZeroInput();
}
}
protected override void ReadData(BinaryReader r)
{
if (Type != CurrentType)
{
throw new Exception(
"Resource have wrong type [" + TypeToString(Type) + "]. [" +
TypeToString(CurrentType) + "] required.");
}
if (Version != CurrentVersion)
{
throw new Exception(
"Resource have wrong version \"" + Version +
"]. [" + CurrentVersion + "] required.");
}
Texture.Read(r);
Properties = (Property)r.ReadUInt32();
Form = (Shape)r.ReadUInt32();
Anchors = (Anchor)r.ReadUInt32();
Reactions = (Reaction)r.ReadUInt32();
Solidity = r.ReadInt32();
Light = r.ReadUInt32();
Layer = r.ReadInt32();
PartSize = r.ReadInt32();
FramesCount = r.ReadInt32();
FrameDelay = r.ReadInt32();
OffsetX = r.ReadInt32();
OffsetY = r.ReadInt32();
SetupEvent.Read(r);
ReformEvent.Read(r);
TouchEvent.Read(r);
ActivateEvent.Read(r);
RecieveEvent.Read(r);
RemoveEvent.Read(r);
BackColor = r.ReadInt32();
GridEnabled = r.ReadBoolean();
}
// GUIBASE_CALLBACK INTERFACE
public override bool Callback(E_CallbackType type, object evt)
{
switch (type)
{
case E_CallbackType.E_CT_ON_TOUCH_END:
if (OnSelectRow != null)
{
TouchEvent touch = (TouchEvent)evt;
Vector2 point = touch.Position;
point.y = Screen.height - point.y;
for (int idx = 0; idx < m_Lines.Length; ++idx)
{
GUIBase_Widget row = m_Lines[idx];
if (row.Visible == false)
{
continue;
}
if (row.IsMouseOver(point) == false)
{
continue;
}
OnSelectRow(row, idx, m_ItemOffset + idx);
break;
}
}
if (OnProcessInput != null) //send the events to the parent
{
TouchEvent touch = (TouchEvent)evt;
if (m_Scrollbar != null) //this event probably comes from scrollbar (because scrollbar is catching all touch events)
{
touch.Id = -1; //and it doesn't have proper begin, this marks the event as 'faked'
}
IInputEvent inputEvent = (IInputEvent)touch;
return(OnProcessInput(ref inputEvent));
}
return(true);
default:
return(false);
}
}
private static void ProcessTouch(List <TouchEvent> touchList)
{
var touchState = TouchPanel.GetState();
for (var i = 0; i < touchState.Count; i++)
{
var myTouch = new TouchEvent();
if (touchState[i].State == TouchLocationState.Pressed || touchState[i].State == TouchLocationState.Moved)
{
myTouch.State = State.PressAndMove;
myTouch.ID = touchState[i].Id;
myTouch.Position = touchState[i].Position;
m_OldTouchList.Add(myTouch);
touchList.Add(myTouch);
}
}
}
private void TouchBegin(Touch touch)
{
if (TouchEvents.Count == MaxTouches)
{
return;
}
/*if (touch.position.y > 450)
* {
* // Debug.Log(touch.position.y.ToString());
* return;
* }*/
TouchEvent newtTouch = TouchEvent.Create(touch);
TouchEvents.Add(newtTouch);
SendToReceivers(newtTouch);
}
public static TouchEvent Create(Touch touch)
{
TouchEvent iEvent = null;
if (UnusedEvents.Count > 0)
{
iEvent = UnusedEvents.Dequeue();
}
else
{
iEvent = new TouchEvent();
}
iEvent.Id = touch.fingerId;
iEvent.CurrentPhase = TouchPhase.Began;
iEvent.StartTime = Time.timeSinceLevelLoad;
iEvent.Positions.Add(touch.position);
return(iEvent);
}
public bool OnTouch(View v, MotionEvent e)
{
lock (this)
{
TouchEvent te = _touchEventPool.NewObject();
switch (e.Action)
{
case MotionEventActions.Down: te.type = TouchEvent.TOUCH_DOWN; _isTouched = true; break;
case MotionEventActions.Move: te.type = TouchEvent.TOUCH_DRAGGED; break;
case MotionEventActions.Cancel:
case MotionEventActions.Up: { te.type = TouchEvent.TOUCH_UP; _isTouched = false; break; }
}
te.x = _touchX = (int)(e.GetX() * _scaleX);
te.y = _touchY = (int)(e.GetY() * _scaleY);
_touchEventBuffer.Add(te);
}
return(true);
}
public override void TouchesBegan(NSSet touches, UIEvent evt)
{
var touch = touches.AnyObject as UITouch;
touchStart = touch.LocationInView(this);
// If the menu is not active
if (container.MenuHostElement == null || container.MenuHostElement != container.TweetElementFromPath(IndexPathForRowAtPoint(touchStart.Value)))
{
if (capturedEnded != null)
{
TouchesCancelled(capturedEnded.Touches, capturedEnded.Event);
capturedEnded = null;
}
container.CancelMenu();
swipeDetectionDisabled = false;
}
base.TouchesBegan(touches, evt);
}
private void DispatchTouchEvent(TouchEventType touchEventType, List<ReactPointer> activePointers, int pointerIndex)
{
var touches = new JArray();
foreach (var pointer in activePointers)
{
touches.Add(JObject.FromObject(pointer));
}
var changedIndices = new JArray();
changedIndices.Add(JToken.FromObject(pointerIndex));
var coalescingKey = activePointers[pointerIndex].PointerId;
var touchEvent = new TouchEvent(touchEventType, touches, changedIndices, coalescingKey);
_view.GetReactContext()
.GetNativeModule<UIManagerModule>()
.EventDispatcher
.DispatchEvent(touchEvent);
}
public void OnTouchEnd(TouchEvent arg)
{
if (_xDown == null || _yDown == null)
{
return;
}
var xDiff = _xDown.Value - arg.ChangedTouches[0].ClientX;
var yDiff = _yDown.Value - arg.ChangedTouches[0].ClientY;
if (Math.Abs(xDiff) < 100 && Math.Abs(yDiff) < 100)
{
_xDown = _yDown = null;
return;
}
if (Math.Abs(xDiff) > Math.Abs(yDiff))
{
if (xDiff > 0)
{
OnSwipe.InvokeAsync(SwipeDirection.RightToLeft);
}
else
{
OnSwipe.InvokeAsync(SwipeDirection.LeftToRight);
}
}
else
{
if (yDiff > 0)
{
OnSwipe.InvokeAsync(SwipeDirection.BottomToTop);
}
else
{
OnSwipe.InvokeAsync(SwipeDirection.TopToBottom);
}
}
_xDown = _yDown = null;
}
//tuhle funkci volat jen kdyz dany fingerId jeste neni nikde v gui pouzity
public override void OnTouchBegin(ref TouchEvent evt)
{
//Debug.Log(">>>> MOVE FLOATING BEGIN");
//Debug.Log("Joystick aquired");
FingerID = evt.Id;
SetCenter(evt.Position);
Dir = Vector2.zero;
Force = 0;
Updated = true;
//update gui
if (GuiHUD.Instance)
{
GuiHUD.Instance.JoystickBaseShow(evt.Position);
GuiHUD.Instance.JoystickDown(evt.Position);
}
}
private TouchEvent CreateTouch(int touchId, Vector2 position, UnityEditor.DeviceSimulation.TouchPhase phase)
{
var touch = new TouchEvent();
var type = typeof(TouchEvent);
object touchObject = touch;
var touchIdAutoBackingField = type.GetField($"<{nameof(TouchEvent.touchId)}>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
var positionAutoBackingField = type.GetField($"<{nameof(TouchEvent.position)}>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
var phaseAutoBackingField = type.GetField($"<{nameof(TouchEvent.phase)}>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
Assert.NotNull(touchIdAutoBackingField);
Assert.NotNull(positionAutoBackingField);
Assert.NotNull(phaseAutoBackingField);
touchIdAutoBackingField.SetValue(touchObject, touchId);
positionAutoBackingField.SetValue(touchObject, position);
phaseAutoBackingField.SetValue(touchObject, phase);
touch = (TouchEvent)touchObject;
return(touch);
}
protected override void OnTouchEvent(TouchEventCollection touchEvents)
{
base.OnTouchEvent(touchEvents);
TouchEvent primaryTouchEvent = touchEvents.PrimaryTouchEvent;
if (primaryTouchEvent.Type == TouchEventType.Down)
{
this.animation = false;
this.startPos = this.panelContainer.X;
this.touchDownLocalPos = primaryTouchEvent.LocalPosition.X;
this.state = StreamPagePanel.AnimationState.None;
}
if (primaryTouchEvent.Type == TouchEventType.Up && this.state != StreamPagePanel.AnimationState.Flick)
{
this.ScrollTo(this.pageIndex, true);
}
if (this.state != StreamPagePanel.AnimationState.Drag && this.state != StreamPagePanel.AnimationState.Flick)
{
touchEvents.Forward = true;
}
}
public static void TouchStart(TouchEvent evt)
{
// With JQuery: $(document).bind("touchstart", function(e) {...}
evt.PreventDefault();
JsString target_id = evt.target.id;
if (isMoving == false && movingItems[target_id] == 1)
{
isMoving = true;
//var orig = e.originalEvent;
TouchEvent orig = evt;
int x = orig.touches[0].pageX - imgOffset;
int y = orig.touches[0].pageY - imgOffset;
//Set the item to moving, and update the position and zIndex
movingItems[target_id] = 2;
HtmlElement.GetById(target_id).style.top = y + "px";
HtmlElement.GetById(target_id).style.left = x + "px";
// With JQuery: $("#dragItem").css({top: y, left: x});
HtmlElement.GetById(target_id).style.zIndex = "2000";
}
}
private void release(TouchData activeTouch, float x, float y)
{
activeTouch.setData(x, y);
activeTouch.active = false;
TouchEvent e = new TouchEvent(touches, activeTouch);
bool isSwipe = activeTouch.isSwipe();
for (int i = 0; i < sortedLayers.Count && !e.isHandled(); i++)
{
//print("releasing on layer " + sortedLayers[i].name);
if (isSwipe)
{
sortedLayers[i].swipe(e);
}
else
{
sortedLayers[i].release(e);
}
}
}
void Update()
{
elapsed_time += Time.deltaTime;
Color temp = myRenderer.color;
if (elapsed_time >= gen_time)
{
elapsed_time -= gen_time;
Collider2D[] colls = Physics2D.OverlapAreaAll(transform.position - transform.lossyScale, transform.position + transform.lossyScale);
foreach (Collider2D coll in colls)
{
TouchEvent touch_input = coll.GetComponent <TouchEvent>();
if (touch_input != null)
{
touch_input.Active();
isActive = 2;
break;
}
}
}
if (isActive >= 1)
{
temp.a = 1;
isActive--;
}
else
{
temp.a = 0.5f;
}
myRenderer.color = temp;
if (isExpanded)
{
ExpandDisplay();
}
else
{
NormalDisplay();
}
}
KeyEvent TouchEventToKeyEvent(TouchEvent touchEvent)
{
KeyEvent keyEvent = new KeyEvent();
keyEvent.StartTime = touchEvent.StartTime;
keyEvent.State = E_KeyState.Repeating;
if (touchEvent.Started)
{
keyEvent.State = E_KeyState.Pressed;
}
else if (touchEvent.Finished)
{
keyEvent.State = E_KeyState.Released;
}
switch (touchEvent.Id)
{
default:
case 0:
keyEvent.Code = KeyCode.Mouse0;
break;
case 1:
keyEvent.Code = KeyCode.Mouse1;
break;
case 2:
keyEvent.Code = KeyCode.Mouse2;
break;
case 3:
keyEvent.Code = KeyCode.Mouse3;
break;
case 4:
keyEvent.Code = KeyCode.Mouse4;
break;
}
return(keyEvent);
}
/// <summary>
/// タッチ入力情報を基に、タッチのイベント処理を行う関数。
/// </summary>
/// <param name="touches">このフレームのタッチ情報配列</param>
private void ProcessTouches(CustomTouch[] touches)
{
if (touches == null || touches.Length == 0)
{
return;
}
foreach (CustomTouch touch in touches)
{
ManageTouch(touch);
}
// generate TouchEvent Array.
TouchEvent[] touchEvents = new TouchEvent[touches.Length];
for (int i = 0; i < touches.Length; i++)
{
touchEvents[i] = GetTouchEvent(touches[i]);
}
foreach (TouchEvent touchEvent in touchEvents)
{
ProcessSingleTouchEvent(touchEvent);
}
_prevTouchEventDict = new Dictionary <int, TouchEvent>();
foreach (TouchEvent myEvent in touchEvents)
{
if (_prevTouchEventDict.ContainsKey(myEvent.touch.fingerID))
{
_prevTouchEventDict[myEvent.touch.fingerID] = myEvent;
}
else
{
_prevTouchEventDict.Add(myEvent.touch.fingerID, myEvent);
}
}
_isTouchThisFrame = true;
}
public override void OnTouchUp(TouchEvent touchEvent)
{
if (!string.IsNullOrEmpty(m_ActionName))
{
AudioManager.Instance.PlaySFX(m_SFXClick);
}
base.OnTouchUp(touchEvent);
if (m_IsOver)
{
if (m_Sprite != null)
{
m_Sprite.spriteId = m_Sprite.GetSpriteIdByName(m_HoverSpriteName);
}
}
else
{
if (m_Sprite != null)
{
m_Sprite.spriteId = m_Sprite.GetSpriteIdByName(m_UpSpriteName);
}
}
}
public bool OnTouchDown(TouchEvent touchEvent)
{
return true;
}
public override void TouchesEnded(NSSet touches, UIEvent evt)
{
if (container.MenuHostElement != null){
if (capturedEnded == null)
capturedEnded = new TouchEvent (touches, evt);
container.TouchesEnded (touches, evt);
return;
}
if (swipeDetectionDisabled)
return;
if (container.DisableSelection)
return;
base.TouchesEnded (touches, evt);
touchStart = null;
}
public void OnTouchUp(TouchEvent touchEvent)
{
}
public void OnTouchDrag(TouchEvent touchEvent)
{
}
public void CapturePhoto(TouchEvent evt)
{
Xdk.camera.TakePicture(50, false, XdkPictureType.Jpg);
}
bool checkTouch(Rect r, EventHandler handler, TouchEvent ev)
{
if (ev.type == TouchType.Stop) {
if (handler.fingerTouching == ev.fingerId) {
handler.fingerTouching = -1;
handler.eventDelegate(ev);
return true;
}
} else {
if (r.Contains(ev.position)) {
if (handler.fingerTouching < 0) {
handler.fingerTouching = ev.fingerId;
if (ev.type == TouchType.Start) {
handler.eventDelegate(ev);
} else {
handler.eventDelegate( new TouchEvent { fingerId = ev.fingerId, type = TouchType.Focus, position = ev.position, deltaPosition = ev.deltaPosition });
}
return true;
} else if (handler.fingerTouching == ev.fingerId) {
handler.eventDelegate(ev);
return true;
}
} else if (handler.fingerTouching == ev.fingerId) {
handler.fingerTouching = -1;
handler.eventDelegate( new TouchEvent { fingerId = ev.fingerId, type = TouchType.Blur, position = ev.position, deltaPosition = ev.deltaPosition });
return true;
}
}
return false;
}
private void HandleTouchUpEvent(TouchEvent e)
{
lastMoveEvent = false;
NotifyTouchUp(new TouchEventArgs(e.Touches, e.Time));
}
private void HandleTouchMoveEvent(TouchEvent e)
{
if (lastMoveEvent && (e.Touches[0].X == lastTouchX) && (e.Touches[0].Y == lastTouchY))
{
}
else
{
lastMoveEvent = true;
lastTouchX = e.Touches[0].X;
lastTouchY = e.Touches[0].Y;
NotifyTouchMove(new TouchEventArgs(e.Touches, e.Time));
}
}
public void AddEvent(TouchEvent eventToAdd)
{
_queuedEvents.Add(eventToAdd);
}
public virtual void OnTouchDrag(TouchEvent touchEvent)
{
}
public override void TouchesEnded (NSSet touches, UIEvent evt)
{
if (container.MenuHostElement != null){
if (capturedEnded == null)
capturedEnded = new TouchEvent (touches, evt);
container.TouchesEnded (touches, evt);
return;
}
ignoreUntilLift = false;
base.TouchesEnded (touches, evt);
touchStart = null;
}
