/// <summary>
        ///
        /// </summary>
        /// <param name="gameObject"></param>
        /// <param name="includeChildren"></param>
        /// <param name="callback"></param>
        public void RegisterDraggableUI(GameObject gameObject, bool includeChildren, OnTouchDelegate callback)
        {
            LeanDragTranslate drag       = gameObject.AddComponent <LeanDragTranslate>();
            LeanSelectable    selectable = AddSelectableComponent(gameObject);

            if (includeChildren)
            {
                HandleIncludeChildren(gameObject, selectable);
            }
            selectable.OnSelect.AddListener((LeanFinger finger) =>
            {
                drag.AddFinger(finger);
            });
            selectable.OnDeselect.AddListener(() =>
            {
                drag.RemoveAllFingers();
            });


            drag.Inertia                  = .2f;
            drag.Dampening                = 10.0f;
            drag.RequiredSelectable       = selectable;
            drag.Use.IgnoreStartedOverGui = false;
            selectable.DeselectOnUp       = true;
            drag.OnDrag += (Vector3 delta) =>
            {
                callback?.Invoke(new TouchCallbackVO()
                {
                    gameObject     = gameObject,
                    delta          = delta,
                    screenPosition = gameObject.transform.position
                });
            };
        }
Exemple #2
0
        public void RemoveTouchListener(OnTouchDelegate onTouchDelegate, SGTouchPhase phase)
        {
            switch (phase)
            {
            case SGTouchPhase.Began:
            {
                if (_onTouchBegan != null)
                {
                    _onTouchBegan -= onTouchDelegate;
                }
            }
            break;

            case SGTouchPhase.Stationary:
            {
                if (_onTouchStationary != null)
                {
                    _onTouchStationary -= onTouchDelegate;
                }
            }
            break;

            case SGTouchPhase.End:
            {
                if (_onTouchEnd != null)
                {
                    _onTouchEnd -= onTouchDelegate;
                }
            }
            break;
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="gameObject"></param>
        /// <param name="includeChildren"></param>
        /// <param name="callback"></param>
        public void RegisterTouchUp(GameObject gameObject, bool includeChildren, OnTouchDelegate callback)
        {
            if (gameObject == null)
            {
                RegisterTouchUp(callback);
                return;
            }

            Collider collider = gameObject.GetComponentInChildren <Collider>();

            if (collider == null)
            {
                DebugLogger.LogWarning("Touch : Could not register tap. No Collider found on {0}", gameObject.name);
                return;
            }

            LeanFingerUp   up         = collider.gameObject.AddComponent <LeanFingerUp>();
            LeanSelectable selectable = AddSelectableComponent(gameObject);

            selectable.DeselectOnUp = true;
            up.RequiredSelectable   = selectable;
            up.OnFinger.AddListener((LeanFinger leanFinger) =>
            {
                callback?.Invoke(new TouchCallbackVO
                {
                    gameObject = gameObject
                });
            });
        }
Exemple #4
0
        void OnTouch(NSSet touches, OnTouchDelegate onTouch)
        {
            foreach (var touch in touches)
            {
                var uitouch  = (touch as UITouch);
                var location = uitouch.LocationInView(_view);

                float posx = Platform.PointsToPixels((float)location.X);
                float posy = Platform.PointsToPixels((float)location.Y);

                Vector2 position = new Vector2(posx, posy);

                int id;

                if (!_touchIds.TryGetValue(uitouch.Handle, out id))
                {
                    id = _nextTouchId;
                    _nextTouchId++;

                    _touchIds.Add(uitouch.Handle, id);
                }

                onTouch(position, id, uitouch.Handle);
            }
        }
 internal SandboxedObject(IObject obj, ISponsor sponsor)
     : base(sponsor)
 {
     if (obj == null)
         throw new ArgumentException("Cannot instantiate an XObject with a null IObject.");
     _obj = obj;
     _touchListener = new OnTouchDelegate(TriggerTouch);
 }
        /// <summary>
        /// Registers a Tap event on a specific object
        /// </summary>
        /// <param name="gameObject"></param>
        /// <param name="includeChildren"></param>
        /// <param name="callback"></param>
        public void RegisterTap(GameObject gameObject, bool includeChildren, OnTouchDelegate callback)
        {
            if (gameObject == null)
            {
                // Register a global tap event
                RegisterTap(callback);
                return;
            }

            GameObject target = gameObject;

            if (gameObject.transform is RectTransform)
            {
            }
            else
            {
                Collider collider = gameObject.GetComponentInChildren <Collider>();

                if (collider == null)
                {
                    DebugLogger.LogWarning("Touch : Could not register tap. No Collider found on {0}", gameObject.name);
                    return;
                }
                target = collider.gameObject;
            }


            LeanFingerTap tap = target.GetComponent <LeanFingerTap>();

            if (tap == null)
            {
                tap = target.AddComponent <LeanFingerTap>();
            }

            tap.IgnoreStartedOverGui = false;

            LeanSelectable selectable = AddSelectableComponent(target);

            // Check if it exists in the dictionary
            if (registeredTapCallbacks.ContainsKey(tap))
            {
                // Check if this particular callback is already registered
                if (registeredTapCallbacks[tap].Contains(callback))
                {
                    return;
                }
            }
            else
            {
                registeredTapCallbacks.Add(tap, new List <OnTouchDelegate>());
            }

            registeredTapCallbacks[tap].Add(callback);

            selectable.DeselectOnUp = true;
            tap.RequiredSelectable  = selectable;
            tap.OnFinger.AddListener(OnTap);
        }
 /// <summary>
 ///
 /// </summary>
 /// <param name="callback"></param>
 private void RegisterTouchUp(OnTouchDelegate callback)
 {
     leanFingerUp.OnFinger.AddListener((LeanFinger leanFinger) =>
     {
         callback?.Invoke(new TouchCallbackVO
         {
             screenPosition = leanFinger.ScreenPosition
         });
     });
 }
        /// <summary>
        /// Constructor. Takes as a parameter the configuration file which defines how the system is to be initialised.
        /// </summary>
        /// <param name="configFile">The configuration file with all the details of how the system is to be loaded and any parameters that are relevant</param>
        public EntryPoint(string configFile)
        {
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(uncaughtException);
            this.configFile = configFile;

            listening = new HashSet<UUID>();
            touchListeners = new HashSet<UUID>();
            touchDelegate = touchListener;
            chatDelegate = chatListener;

            init();
        }
        /// <summary>
        /// Constructor. Takes as a parameter the configuration file which defines how the system is to be initialised.
        /// </summary>
        /// <param name="configFile">The configuration file with all the details of how the system is to be loaded and any parameters that are relevant</param>
        public EntryPoint(string configFile)
        {
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(uncaughtException);
            this.configFile = configFile;

            listening      = new HashSet <UUID>();
            touchListeners = new HashSet <UUID>();
            touchDelegate  = touchListener;
            chatDelegate   = chatListener;

            init();
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="gameObject"></param>
        /// <param name="includeChildren"></param>
        /// <param name="callback"></param>
        public void RegisterSwipeDelta(GameObject gameObject, bool includeChildren, OnTouchDelegate callback)
        {
            if (gameObject == null)
            {
                // Register a global swipe delta event
                RegisterSwipeDelta(callback);
                return;
            }

            LeanFingerMove move       = gameObject.AddComponent <LeanFingerMove>();
            LeanSelectable selectable = AddSelectableComponent(gameObject);

            selectable.DeselectOnUp       = true;
            move.RequiredSelectable       = selectable;
            move.Use.IgnoreStartedOverGui = false;

            selectable.OnSelect.AddListener((LeanFinger finger) =>
            {
                move.AddFinger(finger);
            });
            selectable.OnDeselect.AddListener(() =>
            {
                move.RemoveAllFingers();
            });

            move.OnDrag += (Vector3 delta, Vector3 position) =>
            {
                callback?.Invoke(new TouchCallbackVO()
                {
                    gameObject     = gameObject,
                    delta          = delta,
                    objectPosition = position
                });
            };

            // Check if it exists in the dictionary
            if (registeredSwipeDeltaCallbacks.ContainsKey(gameObject))
            {
                // Check if this particular callback is already registered
                if (registeredSwipeDeltaCallbacks[gameObject].Contains(callback))
                {
                    return;
                }
            }
            else
            {
                registeredSwipeDeltaCallbacks.Add(gameObject, new List <OnTouchDelegate>());
            }

            registeredSwipeDeltaCallbacks[gameObject].Add(callback);
        }
 protected override void OnDestroySingleton()
 {
     OnTap            = null;
     OnDoubleTap      = null;
     OnStick          = null;
     OnLongTouch      = null;
     OnFlick          = null;
     OnTouchOn        = null;
     OnTouchOff       = null;
     OnDrag           = null;
     OnDoubleDrag     = null;
     OnPinch          = null;
     OnTouchOnAlways  = null;
     OnTouchOffAlways = null;
     OnDragAlways     = null;
 }
        /// <summary>
        ///
        /// </summary>
        /// <param name="gameObject"></param>
        /// <param name="callback"></param>
        public void UnRegisterTap(GameObject gameObject, OnTouchDelegate callback)
        {
            LeanFingerTap tap = gameObject.GetComponent <LeanFingerTap>();

            if (tap == null)
            {
                return;
            }

            if (registeredTapCallbacks.ContainsKey(tap))
            {
                if (registeredTapCallbacks[tap].Contains(callback))
                {
                    registeredTapCallbacks[tap].Remove(callback);
                }
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="gameObject"></param>
        /// <param name="includeChildren"></param>
        /// <param name="callback"></param>
        public void RegisterTouchDown(GameObject gameObject, bool includeChildren, OnTouchDelegate callback)
        {
            if (gameObject == null)
            {
                RegisterTouchDown(callback);
                return;
            }

            GameObject target = gameObject;

            if (gameObject.transform is RectTransform)
            {
            }
            else
            {
                Collider collider = gameObject.GetComponentInChildren <Collider>();

                if (collider == null)
                {
                    DebugLogger.LogWarning("Touch : Could not register touch down. No Collider found on {0}", gameObject.name);
                    return;
                }
                target = collider.gameObject;
            }

            LeanFingerDown down = target.AddComponent <LeanFingerDown>();

            down.IgnoreStartedOverGui = false;

            LeanSelectable selectable = AddSelectableComponent(gameObject);

            selectable.DeselectOnUp = true;
            down.RequiredSelectable = selectable;
            down.OnFinger.AddListener((LeanFinger leanFinger) =>
            {
                Vector3 pos = leanFinger.ScreenPosition;
                callback?.Invoke(new TouchCallbackVO
                {
                    gameObject     = gameObject,
                    screenPosition = leanFinger.ScreenPosition
                });
            });
        }
Exemple #14
0
        public void AddTouchListener(OnTouchDelegate onTouchDelegate, SGTouchPhase phase)
        {
            switch (phase)
            {
            case SGTouchPhase.Began:
            {
                _onTouchBegan += onTouchDelegate;
            }
            break;

            case SGTouchPhase.Stationary:
            {
                _onTouchStationary += onTouchDelegate;
            }
            break;

            case SGTouchPhase.End:
            {
                _onTouchEnd += onTouchDelegate;
            }
            break;
            }
        }
 /// <summary>
 /// Registers a global Tap event
 /// </summary>
 /// <param name="callback"></param>
 private void RegisterTap(OnTouchDelegate callback)
 {
     RegisterTap(gameObject, false, callback);
 }
 /// <summary>
 ///
 /// </summary>
 /// <param name="callback"></param>
 private void RegisterSwipeDelta(OnTouchDelegate callback)
 {
     RegisterSwipeDelta(gameObject, false, callback);
 }
 /// <summary>
 ///
 /// </summary>
 /// <param name="callback"></param>
 public void UnRegisterTap(OnTouchDelegate callback)
 {
     UnRegisterTap(gameObject, callback);
 }