diff -r 000000000000 -r 1450b09d0cfd qstmgesturelib/qstmgestureevent.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/qstmgesturelib/qstmgestureevent.cpp	Tue May 04 12:39:35 2010 +0300
@@ -0,0 +1,296 @@
+/*
+* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+
+#include <QWidget>
+#include <QApplication>
+#include "qstmgestureevent.h"
+#include "qstmuievent_if.h"
+
+using namespace qstmUiEventEngine;
+
+Qt::GestureType QStm_Gesture::s_assignedType = Qt::CustomGesture;
+
+QStm_GestureEvent::QStm_GestureEvent():
+                   QEvent(QStm_GestureEvent::stmGestureEventType())
+
+{
+}
+
+QStm_GestureEvent::~QStm_GestureEvent()
+{
+}
+
+
+
+
+
+QStm_Gesture::QStm_Gesture(QObject* parent) : QGesture(parent)
+{
+	    m_speed = 0.0;    
+	    m_direction = -1;
+	    m_vector = QPoint(0,0);
+	    m_gstType = QStmUknownGestureType; 
+	    m_state = Qt::NoGesture;
+	    m_gstSubType = 0;
+	    m_pos = QPoint(INT_MIN,INT_MIN);
+	    m_details = NULL;
+	    m_speedVec = QPointF(0.0, 0.0);
+	    m_target = NULL;
+};
+
+
+QStm_Gesture& QStm_Gesture::operator=(QStm_Gesture& other)
+{
+    m_speed = other.getSpeed();    
+    m_direction = other.getDirection();
+    m_vector = other.getLengthAndDirection();
+    m_gstType = other.getGestureStmType(); 
+    m_state = other.gestureState();
+    m_gstSubType = other.getGestureSubType();
+    m_pos = other.position();
+    m_details = other.getDetails();
+    m_speedVec = other.getSpeedVec();
+    m_target = other.m_target;
+	return *this;
+}
+
+
+QString  QStm_Gesture::gestureName()
+{
+    switch (m_gstType) {
+        case QStmUknownGestureType:
+            return QString("QStmUknownGestureType");    
+        case QStmTouchGestureType:
+            return QString("QStmTouchGestureType");
+        case QStmTapGestureType:
+            return QString("QStmTapGestureType");
+        case QStmDoubleTapGestureType:
+            return QString("QStmDoubleTapGestureType");
+        case QStmLongPressGestureType:
+            return QString("QStmLongPressGestureType");
+        case QStmHoverGestureType:
+            return QString("QStmHoverGestureType");
+        case QStmPanGestureType:
+            return QString("QStmPanGestureType");
+        case QStmReleaseGestureType:
+            return QString("QStmReleaseGestureType");
+        case QStmLeftRightGestureType:
+            return QString("QStmLeftRightGestureType");
+        case QStmUpDownGestureType:
+            return QString("QString");
+        case QStmFlickGestureType:
+            return QString("QStmFlickGestureType");
+        case QStmEdgeScrollGestureType:
+            return QString("QStmEdgeScrollGestureType");
+        case QStmPinchGestureType:
+            return QString("QStmPinchGestureType");
+        case QStmCornerZoomGestureType:
+            return QString("QStmCornerZoomGestureType");
+        default:
+            return QString("XZ Gesture");
+    }	
+}
+
+void QStm_Gesture::gestureTypeToMouseTypes(QVarLengthArray<int, 4>& types)
+{
+	switch (m_gstType) {
+		case QStmTouchGestureType:
+		{
+			types.append(QEvent::MouseButtonPress);
+			break;
+		}
+		case QStmDoubleTapGestureType:
+		{
+			types.append(QEvent::MouseButtonDblClick);
+			break;
+		}
+
+		case QStmHoverGestureType:
+		case QStmPanGestureType:
+		case QStmLeftRightGestureType:
+		case QStmUpDownGestureType:
+		case QStmCornerZoomGestureType:
+		{
+			types.append(QEvent::MouseMove);
+			break;
+		}
+		case QStmReleaseGestureType:
+		{
+			types.append(QEvent::MouseButtonRelease);
+			break;
+		}
+		case QStmTapGestureType:
+		{
+			types.append(QEvent::MouseButtonPress);
+			types.append(QEvent::MouseButtonRelease); 
+			break;
+		}
+		case QStmUknownGestureType:
+		{
+		    QStm_UiEventIf* uiEvent = static_cast<QStm_UiEventIf*>(m_details);
+		    if (uiEvent) {
+		        QEvent::Type evType = uiEvent->mapToMouseEventType();
+		        types.append(evType);
+		    }
+		    break;
+		}
+		case QStmFlickGestureType:
+		case QStmEdgeScrollGestureType:
+		case QStmPinchGestureType:
+		case QStmLongPressGestureType:
+		default:
+			break;
+	}
+	return;
+}
+
+bool QStm_Gesture::sendOrPostMouseEvents(QObject* receiver, Qt::KeyboardModifier modifier, bool send)
+{
+    bool ret = false;
+    QPoint pos = position();
+    QPoint gpos = pos;
+    QWidget* w = NULL;
+    Qt::MouseButtons buttons = Qt::LeftButton;
+    
+    
+    buttons &= ~Qt::RightButton;
+    buttons &= ~Qt::MidButton; 
+    buttons &= Qt::MouseButtonMask;
+    
+    if (receiver->isWidgetType()) {
+    	QWidget* w = static_cast<QWidget*>(receiver);
+    	pos = w->mapFromGlobal(gpos);
+    }    
+    
+    QVarLengthArray<int, 4> mouseTypes;
+    gestureTypeToMouseTypes(mouseTypes);   
+    
+    for (int i = 0; i < mouseTypes.size(); i++) {
+    	QEvent::Type mtype = static_cast<QEvent::Type>(mouseTypes[i]);
+    	
+    	if (mtype == QEvent::MouseButtonRelease) {
+    		buttons = 0;
+    	}
+    	
+    	if (send) {
+    	    QMouseEvent evt(mtype, pos, gpos, Qt::LeftButton, buttons, modifier);
+    	    if (w) w->grabMouse();
+    	    QApplication::sendEvent(receiver, &evt);
+    	    if (w) w->releaseMouse();
+    	}
+    	else {
+    		QMouseEvent* evt = new QMouseEvent(mtype, pos, gpos, Qt::LeftButton, buttons, modifier);
+    		QApplication::postEvent(receiver, evt);
+    	}
+    }
+    
+    return ret;
+}
+
+
+bool QStm_Gesture::sendEvent(QEvent* event)
+{
+    QWidget* target = static_cast<QWidget*>(m_target);
+    QWidget* w = NULL;
+    
+    if (target) {
+        QPoint pos = target->mapFromGlobal(m_pos);
+        w = target->childAt(pos);
+        if (!w) {
+            w = target;
+        }
+    }
+    
+    if (w) {
+        if (event->type() == QStm_GestureEvent::stmGestureEventType() && 
+            m_gstType == QStmUknownGestureType) {
+            QStm_UiEventIf* uiEvent = static_cast<QStm_UiEventIf*>(m_details);
+            QWidget* modal = QApplication::activeModalWidget();
+            if (uiEvent && m_target == modal) {
+            //re-generate mouse events
+                sendMouseEvents(w);
+            }
+        }        
+        else {
+            QApplication::sendEvent(w, event);
+        }
+    }
+}
+
+
+bool QStm_Gesture::sendMouseEvents(Qt::KeyboardModifier modifier)
+{
+    Q_ASSERT(m_target);
+    QWidget* target = static_cast<QWidget*>(m_target);
+    QPoint pos = target->mapFromGlobal(m_pos);
+    QWidget* w = target->childAt(pos);
+    if (!w) {
+        w = target;
+    }
+    
+    return sendMouseEvents(w);
+}
+
+bool QStm_Gesture::sendMouseEvents(QObject* receiver, Qt::KeyboardModifier modifier)
+{
+	return sendOrPostMouseEvents(receiver, modifier, true);
+}
+
+bool QStm_Gesture::postMouseEvents(QObject* receiver, Qt::KeyboardModifier modifier)
+{
+	return sendOrPostMouseEvents(receiver, modifier, false);
+}
+
+QList<QMouseEvent*>   QStm_Gesture::getMouseEvents()
+{
+	QList<QMouseEvent*> mouseEventsList;
+    QPoint pos = position(); 
+    QPoint gpos = pos;
+    Qt::MouseButtons buttons = Qt::LeftButton;        
+    buttons &= ~Qt::RightButton;
+    buttons &= ~Qt::MidButton; 
+    buttons &= Qt::MouseButtonMask;
+        
+    
+    
+    QVarLengthArray<int, 4> mouseTypes;
+    gestureTypeToMouseTypes(mouseTypes);
+    
+    for (int i = 0; i < mouseTypes.size(); i++) {
+        QMouseEvent* evt = new QMouseEvent(static_cast<QEvent::Type>(mouseTypes[i]), 
+        		               pos, gpos, Qt::LeftButton, buttons, Qt::NoModifier);
+        mouseEventsList.append(evt);
+    }
+	return mouseEventsList;
+}
+
+
+QSTMGESTURELIB_EXPORT QStm_Gesture*  getQStmGesture(QEvent* event)
+{	
+	QStm_Gesture* gesture = NULL;
+	if (event->type() == QEvent::Gesture) {
+	    QGestureEvent* ge = static_cast<QGestureEvent*>(event);
+	    QList<QGesture*> l = ge->gestures();
+	    QGesture* g = !l.isEmpty() ? l.at(0) : NULL;
+	    if (g && g->gestureType() == QStm_Gesture::assignedType()) {
+	        gesture = static_cast<QStm_Gesture*>(g);
+	    }
+	}
+	return gesture;
+}
+