public void ScrollNoInertia()
        {
            VerifyEventsArgs verifyArgs = new VerifyEventsArgs();

            scrollInput.inertia = false;

            // Test starting to touch the object
            pointer.TouchDown.Returns(true);
            pointer.IsTouching.Returns(true);
            eventExecutor.GetEventHandler <IScrollHandler>(hitObject).Returns(hitObject);

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.Enter;
            VerifyEvents(verifyArgs);


            // Test starting to scroll the object.
            pointer.TouchDown.Returns(false);
            pointer.TouchPos.Returns(new Vector2(0.5f, 0.5f));

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.Hover | EventFlags.Scroll;
            VerifyEvents(verifyArgs);

            // Test that scrolling stops after release because inertia is off.
            pointer.TouchUp.Returns(true);
            pointer.IsTouching.Returns(false);

            ProcessMiss();

            verifyArgs.eventFlags = EventFlags.Exit;
            VerifyEvents(verifyArgs);
        }
        public void Up()
        {
            VerifyEventsArgs verifyArgs = new VerifyEventsArgs();

            verifyArgs.isPointerInteractive = true;

            pointer.TriggerDown.Returns(true);
            pointer.Triggering.Returns(true);
            eventExecutor.GetEventHandler <IPointerClickHandler>(hitObject).Returns(hitObject);
            eventExecutor.ExecuteHierarchy <IPointerClickHandler>(hitObject,
                                                                  module.CurrentEventData, ExecuteEvents.pointerClickHandler).Returns(hitObject);

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.Down | EventFlags.Enter;
            VerifyEvents(verifyArgs);

            pointer.TriggerDown.Returns(false);
            pointer.Triggering.Returns(false);

            ProcessMiss();

            verifyArgs.eventFlags = EventFlags.Up | EventFlags.Exit;
            VerifyEvents(verifyArgs);
        }
        public void EnterHoverExit()
        {
            VerifyEventsArgs verifyArgs = new VerifyEventsArgs();

            ProcessMiss();

            verifyArgs.eventFlags = EventFlags.None;
            VerifyEvents(verifyArgs);

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.Enter;
            VerifyEvents(verifyArgs);

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.Hover;
            VerifyEvents(verifyArgs);

            ProcessHit();

            VerifyEvents(verifyArgs);

            ProcessMiss();

            verifyArgs.eventFlags = EventFlags.Exit;
            VerifyEvents(verifyArgs);
        }
        private void CheckUp(VerifyEventsArgs args)
        {
            bool received = CheckFlag(args.eventFlags, EventFlags.Up);

            if (received)
            {
                pointer.Received(1).OnPointerClickUp();
            }
            else
            {
                pointer.DidNotReceiveWithAnyArgs().OnPointerClickUp();
            }

            CheckExecuteEvent(ExecuteEvents.pointerUpHandler, received, hitObject);
        }
        private void CheckHover(VerifyEventsArgs args)
        {
            bool received = CheckFlag(args.eventFlags, EventFlags.Hover);

            if (received)
            {
                pointer.Received(1).OnPointerHover(raycastResult, args.isPointerInteractive);
            }
            else
            {
                pointer.DidNotReceiveWithAnyArgs().OnPointerHover(dummyRaycastResult, false);
            }

            CheckExecuteHierarchyEvent(GvrExecuteEventsExtension.pointerHoverHandler, received, hitObject);
        }
        public void DisablePointer()
        {
            VerifyEventsArgs verifyArgs = new VerifyEventsArgs();

            ProcessHit();

            pointer.ClearReceivedCalls();
            eventExecutor.ClearReceivedCalls();

            pointer.IsAvailable.Returns(false);
            module.Process();

            verifyArgs.eventFlags = EventFlags.Exit;
            VerifyEvents(verifyArgs);
        }
        public void EnterDestroy()
        {
            VerifyEventsArgs verifyArgs = new VerifyEventsArgs();

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.Enter;
            VerifyEvents(verifyArgs);

            GameObject.DestroyImmediate(hitObject);
            ProcessHit();

            verifyArgs.eventFlags = EventFlags.Exit;
            VerifyEvents(verifyArgs);
        }
        private void VerifyEvents(VerifyEventsArgs args)
        {
            CheckEnter(args);
            CheckHover(args);
            CheckExit(args);
            CheckDown(args);
            CheckUp(args);
            CheckClick(args);
            CheckInitializeDrag(args);
            CheckBeginDrag(args);
            CheckDrag(args);
            CheckEndDrag(args);
            CheckScroll(args);

            pointer.ClearReceivedCalls();
            eventExecutor.ClearReceivedCalls();
        }
        public void Interactive()
        {
            VerifyEventsArgs verifyArgs = new VerifyEventsArgs();

            verifyArgs.isPointerInteractive = true;

            eventExecutor.GetEventHandler <IPointerClickHandler>(hitObject).Returns(hitObject);

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.Enter;
            VerifyEvents(verifyArgs);

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.Hover;
            VerifyEvents(verifyArgs);
        }
        public void Drag()
        {
            VerifyEventsArgs verifyArgs = new VerifyEventsArgs();

            verifyArgs.isPointerInteractive = true;

            pointer.TriggerDown.Returns(true);
            pointer.Triggering.Returns(true);
            eventExecutor.GetEventHandler <IDragHandler>(hitObject).Returns(hitObject);
            eventExecutor.GetEventHandler <IPointerClickHandler>(hitObject).Returns(hitObject);

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.InitializeDrag | EventFlags.Enter | EventFlags.Down;
            VerifyEvents(verifyArgs);

            pointer.TriggerDown.Returns(false);

            eventSytem.transform.Rotate(new Vector3(0.0f, 30.0f, 0.0f));
            raycastResult.worldPosition  = hitPos + new Vector3(0.0f, 1000.0f, 0.0f);
            raycastResult.screenPosition = new Vector3(0.0f, 500.0f, 0.0f);
            moduleController.FindFirstRaycast(resultCache).Returns(raycastResult);

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.BeginDrag | EventFlags.Drag | EventFlags.Hover;
            VerifyEvents(verifyArgs);

            eventSytem.transform.Rotate(new Vector3(0.0f, 30.0f, 0.0f));

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.Drag | EventFlags.Hover;
            VerifyEvents(verifyArgs);

            pointer.Triggering.Returns(false);

            ProcessHit();

            verifyArgs.eventFlags = EventFlags.EndDrag | EventFlags.Up | EventFlags.Hover | EventFlags.Click;
            VerifyEvents(verifyArgs);
        }
        public void ClearPointer()
        {
            VerifyEventsArgs verifyArgs = new VerifyEventsArgs();

            module.Pointer = null;

            VerifyEvents(verifyArgs);

            module.Pointer = pointer;

            ProcessHit();

            pointer.ClearReceivedCalls();
            eventExecutor.ClearReceivedCalls();

            module.Pointer = null;
            module.Process();

            verifyArgs.eventFlags = EventFlags.Exit;
            VerifyEvents(verifyArgs);
        }
        private void CheckScroll(VerifyEventsArgs args)
        {
            bool received = CheckFlag(args.eventFlags, EventFlags.Scroll);

            CheckExecuteHierarchyEvent(ExecuteEvents.scrollHandler, received, hitObject);
        }
        private void CheckEndDrag(VerifyEventsArgs args)
        {
            bool received = CheckFlag(args.eventFlags, EventFlags.EndDrag);

            CheckExecuteEvent(ExecuteEvents.endDragHandler, received, hitObject);
        }
        private void CheckInitializeDrag(VerifyEventsArgs args)
        {
            bool received = CheckFlag(args.eventFlags, EventFlags.InitializeDrag);

            CheckExecuteEvent(ExecuteEvents.initializePotentialDrag, received, hitObject);
        }
        private void CheckClick(VerifyEventsArgs args)
        {
            bool received = CheckFlag(args.eventFlags, EventFlags.Click);

            CheckExecuteEvent(ExecuteEvents.pointerClickHandler, received, hitObject);
        }