#include <QGraphicsSceneMouseEvent>

using namespace qstmGesture;

static Qt::GestureType s_assignedType = Qt::CustomGesture;

static int s_stmGestureEventType = QEvent::User;

static QGraphicsItem* s_gestureGrabberItem = NULL;

static QGraphicsItem* s_gestureFocusedItem = NULL;

QStm_GestureEventFilter* QStm_GestureEventFilter::m_instance = 0;

QStm_GestureEventFilter* QStm_GestureEventFilter::instance()

{

    if (!m_instance) {

        m_instance = new QStm_GestureEventFilter();

    }

    return m_instance;

}

bool QStm_GestureEventFilter::eventFilter(QObject* receiver, QEvent* evt)

{

    return qstmIsGraphicsSceneMouseEvent(evt) || qstmIsMouseEvent(evt) || 

           qstmIsTouchEvent(evt) || qstmIsContextMenuEvent(evt);

}

bool QStm_GestureEventFilter::sendGraphicsSceneMouseEvent(QEvent* event, QGraphicsObject* go)

{

    bool ret = false;

    if (event->type() == QEvent::Gesture) {

        QStm_Gesture* gesture = getQStmGesture(event);

        if (gesture) {

            ret = gesture->sendGraphicsSceneMouseEvent(go);

        }

    }

    return ret;

}

bool QStm_GestureEventFilter::event(QEvent* event)

{

    if (event->type() == QEvent::Gesture) {

        QStm_Gesture* gesture = getQStmGesture(event);

        if (gesture) {

            QStm_GestureType gtype = gesture->getGestureStmType();

            /*

             * Touch mapped to mouse press, Tap mapped to mouse release

             * UpDown, LeftRight and Pan are mapped to mouse move.

             */

            if (gtype == QStmMaybeTapGestureType) {// in case of tap send mouse release

                gesture->setGestureStmType(QStmReleaseGestureType);

            }

            bool ret = (gtype == QStmTouchGestureType ||

                        gtype == QStmMaybeTapGestureType ||

                        gtype == QStmLeftRightGestureType || 

                        gtype == QStmUpDownGestureType ||

                        gtype == QStmPanGestureType ||

                        gtype == QStmReleaseGestureType ||

                        gtype == QStmFlickGestureType ||

                        gtype == QStmUknownGestureType) ;

            if (ret) {

                gesture->sendMouseEvents();

                (static_cast<QGestureEvent*>(event))->accept(QStm_Gesture::assignedType());

                (static_cast<QGestureEvent*>(event))->accept();

            }

            if (gtype == QStmTapGestureType) {// restore gesture type. 

                gesture->setGestureStmType(QStmTapGestureType);

            }

            return ret;

        }

    }

    return false;

}

QEvent::Type QStm_GestureEvent::stmGestureEventType() 

{ 

    if (s_stmGestureEventType == QEvent::User) {

        s_stmGestureEventType = QEvent::registerEventType(QStmGestureEventType);    

    }

    return static_cast<QEvent::Type>(QStmGestureEventType); 

}

void QStm_Gesture::setAssignedGestureType(Qt::GestureType type) 

{ 

    s_assignedType = type; 

}

Qt::GestureType QStm_Gesture::assignedType() 

{ 

    return s_assignedType; 

} 

QGraphicsItem* QStm_Gesture::gestureGrabberItem()

{ 

    return s_gestureGrabberItem; 

}

void QStm_Gesture::setGestureGrabberItem(QGraphicsItem* item)

{ 

    s_gestureGrabberItem = item; 

}

QGraphicsItem* QStm_Gesture::gestureFocusedItem()

{

    return s_gestureFocusedItem;

}

void QStm_Gesture::setGestureFocusedItem(QGraphicsItem* item)

{

    s_gestureFocusedItem = item;

}

        m_pos2 = QPoint(INT_MIN,INT_MIN);

        m_timestamp = QTime::currentTime();

    m_pos2 = other.position2();

    m_target = other.target();

    m_timestamp = other.timestamp();

    setHotSpot(other.hotSpot());

QStm_GestureType  QStm_Gesture::gestureUidToStmType(QStm_GestureUid uid, int stmGestSubType)

{

    QStm_GestureType  gtype = QStmUknownGestureType;

    switch (uid) {

        case EGestureUidTap:

        {

            QStm_TapType type = qstmGesture::QStm_TapType(stmGestSubType);

            if (type == qstmGesture::ETapTypeDouble) {

                gtype = QStmDoubleTapGestureType;

            }

            else  {

                gtype = QStmTapGestureType;

            }

            break;

        }

        case EGestureUidTouch:

        {

            gtype = QStmTouchGestureType;

            break;

        }

        case EGestureUidRelease:

        {

            gtype = QStmReleaseGestureType;

            break;

        }

        case EGestureUidFlick:

        {

            gtype = QStmFlickGestureType;

            break;

        }

        case EGestureUidLeftRight:

        {

            gtype = QStmLeftRightGestureType;

            break;

        }

        case EGestureUidUpDown:

        {

            gtype = QStmUpDownGestureType;

            break;

        }

        case EGestureUidPan:

        {

            gtype = QStmPanGestureType;

            break;

        }

        case EGestureUidHover:

        {

            gtype = QStmHoverGestureType;

            break;

        }

        case EGestureUidLongPress:

        {

            gtype = QStmLongPressGestureType;

            break;

        }

        case EGestureUidEdgeScroll:

        {

            gtype = QStmEdgeScrollGestureType;

            break;

        }

        case EGestureUidCornerZoom:

        {

            gtype = QStmCornerZoomGestureType;

            break;

        }

        case EGestureUidPinch:

        {

            gtype = QStmPinchGestureType;

            break;

        }

        case EGestureUidMaybeTap:

        {

            gtype = QStmMaybeTapGestureType;

            break;

        }

        default:

        {

            gtype = QStmUknownGestureType;

            break;

        }

    }    

    return gtype;

}

		case QStmFlickGestureType:

        //case QStmMaybeTapGestureType:

        w = static_cast<QWidget*>(receiver);

        if (mtype == QEvent::None) {

            continue;

        }

        else if (mtype != QEvent::MouseButtonRelease && w) {

            QPoint wtl = w->mapToGlobal(w->pos());

            QRect wgeom = QRect(wtl, w->size());

            if (!wgeom.contains(m_pos)) {

                continue;

            }

        }

            //if (w) w->grabMouse();

            //if (w) w->releaseMouse();

    QWidget* modal = QApplication::activeModalWidget();

    if (modal) {

        target = modal;

    }

        if (modal) { //we send mouse events to modal dialogs.

            return(sendMouseEvents(w));

        }

        /*

        else if (event->type() == QStm_GestureEvent::stmGestureEventType() && 

                return(sendMouseEvents(w));

                return(QApplication::sendEvent(w, event));

        }

    }

		*/

        else {

            if (!target->hasFocus()) {

                target->setFocus(Qt::MouseFocusReason);

            }

            return(QApplication::sendEvent(w, event));

    return false;

}

bool QStm_Gesture::sendGraphicsSceneMouseEvent(QGraphicsObject* go)

{

    QEvent::Type eventType = gestureType2GraphicsSceneMouseType();

    bool ret = false;

    if (eventType != QEvent::None) {