// Executa ao liberar o botão do mouse.
        // O evento relacionado ao Click é executado neste momento
        private void ReleaseMouseButton(PointerEventData pointerEvent, GameObject currentGo)
        {
            // Realiza evento de "soltar o botão"
            ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);

            var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentGo);

            // Se um click for realizado entra neste if
            // Em caso de um click pode ser um movimento de deslize, buscando o transido entre
            // Objetos interagíveis de forma cíclica
            // Em caso de dois clicks seguidos é uma interação
            if (pointerEvent.pointerPress == pointerUpHandler && pointerEvent.eligibleForClick)
            {
                // Verifica se o deslize foi para esquerda ou direita
                // TODO Testar a necessidade de uma margem de erro para evitar deslizes indesejados
                float diff = _LastMousePosition.x - _MousePosition.x;
                // Uma flag para indicar se o movimento foi de toque ou deslize
                bool swipe = false;
                // Se o valor for negativo é um deslize para esquerda, caso contrário para direita
                // À esquerda o item anterior é selecionado, a direita o item posterior é selecionado
                // O movimento é realizado de forma cíclica pela interface
                if (diff < 0 && !interactableList.isEmpty)
                {
                    currentGo = interactableList.Next();
                    eventSystem.SetSelectedGameObject(currentGo);
                    swipe = true;
                    ExecuteEvents.ExecuteHierarchy(currentGo, pointerEvent, pointerDescriptionHandler);
                }
                else if (diff > 0 && !interactableList.isEmpty)
                {
                    currentGo = interactableList.Previous();
                    eventSystem.SetSelectedGameObject(currentGo);
                    swipe = true;
                    ExecuteEvents.ExecuteHierarchy(currentGo, pointerEvent, pointerDescriptionHandler);
                }
                // Se o minimo de clicks para interação foi realizado, permite a interação;
                if (pointerEvent.clickCount >= minClicks)
                {
                    ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler);
                    pointerEvent.clickCount = 0;
                }
                // Se o movimento foi de toque, executa a descrição de audio
                else if (!swipe)
                {
                    ExecuteEvents.ExecuteHierarchy(currentGo, pointerEvent, pointerDescriptionHandler);
                }
            }
            // Trata eventos relacionado ao arrastar

            else if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
            {
                ExecuteEvents.ExecuteHierarchy(currentGo, pointerEvent, ExecuteEvents.dropHandler);
            }
            // Reseta variáveis do pointer
            pointerEvent.eligibleForClick = false;
            pointerEvent.pointerPress     = null;
            pointerEvent.rawPointerPress  = null;

            // Se necessário finaliza o movimento de arrastar
            if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
            {
                ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
            }

            // reseta as variaveis do pointer
            pointerEvent.dragging    = false;
            pointerEvent.pointerDrag = null;

            // redo pointer enter / exit to refresh state
            // so that if we moused over something that ignored it before
            // due to having pressed on something else
            // it now gets it.
            if (currentGo != pointerEvent.pointerEnter)
            {
                HandlePointerExitAndEnter(pointerEvent, null);
                HandlePointerExitAndEnter(pointerEvent, currentGo);
            }

            _InputPointerEvent = pointerEvent;
        }
Esempio n. 2
0
        private void ReleaseMouse(PointerEventData pointerEvent, GameObject currentOverGo)
        {
            ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);

            var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);

            // PointerClick and Drop events
            if ((pointerEvent.pointerPress == pointerUpHandler || !Input.GetKey(KeyCode.Space)) && pointerEvent.eligibleForClick)
            {
                if (useRaycastObject)
                {
                    ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler);
                }
                else
                {
                    // Verifica se o deslize foi para esquerda ou direita
                    // TODO Testar a necessidade de uma margem de erro para evitar deslizes indesejados
                    float diff = m_LastMousePosition.x - m_MousePosition.x;

                    // Uma flag para indicar se o movimento foi de toque ou deslize
                    swipe = false;
                    // Se o valor for negativo é um deslize para esquerda, caso contrário para direita
                    // À esquerda o item anterior é selecionado, a direita o item posterior é selecionado
                    // O movimento é realizado de forma cíclica pela interface
                    if (!dragging && diff < 0 && !interactableList.isEmpty)
                    {
                        currentOverGo = interactableList.Next();
                        eventSystem.SetSelectedGameObject(currentOverGo);
                        swipe = true;
                        ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, pointerDescriptionHandler);
                    }
                    else if (!dragging && diff > 0 && !interactableList.isEmpty)
                    {
                        currentOverGo = interactableList.Previous();
                        eventSystem.SetSelectedGameObject(currentOverGo);
                        swipe = true;
                        ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, pointerDescriptionHandler);
                    }
                    // Se o minimo de clicks para interação foi realizado, permite a interação;
                    if (pointerEvent.clickCount >= minClicks)
                    {
                        ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler);
                        pointerEvent.clickCount = 0;
                    }
                    // Se o movimento foi de toque, executa a descrição de audio
                    else if (!swipe)
                    {
                        ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, pointerDescriptionHandler);
                    }
                }
            }
            else if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
            {
                ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.dropHandler);
            }

            pointerEvent.eligibleForClick = false;
            pointerEvent.pointerPress     = null;
            pointerEvent.rawPointerPress  = null;

            if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
            {
                ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
            }

            pointerEvent.dragging    = false;
            pointerEvent.pointerDrag = null;

            // redo pointer enter / exit to refresh state
            // so that if we moused over something that ignored it before
            // due to having pressed on something else
            // it now gets it.
            if (currentOverGo != pointerEvent.pointerEnter)
            {
                HandlePointerExitAndEnter(pointerEvent, null);
                HandlePointerExitAndEnter(pointerEvent, currentOverGo);
            }

            m_InputPointerEvent = pointerEvent;
        }