diff -r e4ebb16b39ea -r 603d3f8b6302 examples/sensors/panoramaWithSense/view.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/examples/sensors/panoramaWithSense/view.cpp	Mon Oct 04 01:37:06 2010 +0300
@@ -0,0 +1,362 @@
+#include "view.h"
+#include "accelerometercontroller.h"
+#include "magnetometercontroller.h"
+#include "rotationcontroller.h"
+#include "orientationcontroller.h"
+#include "compasscontroller.h"
+#include "tapcontroller.h"
+#include <QDebug>
+#include <iostream>
+
+
+
+int View::m_imageWidth;
+int View::m_imageHeight;
+QString View::m_currentSensor;
+bool View::m_isStarted = true;
+
+
+
+View::View(QGraphicsScene *scene) :
+        QGraphicsView(scene), m_timer(this) ,m_delay(30){
+
+    qDebug()<<"in View now";
+
+    QPixmap bgPix(":/images/koskipuisto_pieni.jpg");
+    m_pix = bgPix;
+
+    setupWindow();
+
+    int h = height();
+    int y = qAbs(m_imageHeight-h)/2;
+    setSceneRect(0, y, width(), h);
+
+
+    m_sensors.append(InputController::QACCELEROMETER);
+    m_sensors.append(InputController::QORIENTATIONSENSOR);
+    m_sensors.append(InputController::QMAGNETOMETER);
+    m_sensors.append(InputController::QROTATIONSENSOR);
+    m_sensors.append(InputController::QTAPSENSOR);
+    m_sensors.append(InputController::QCOMPASS);
+    m_sensors.append(InputController::QKEYS);
+
+
+    m_menu = new QMenu(this);
+    createActions();
+    handleAction(NULL,InputController::QACCELEROMETER);
+
+    m_timer.setSingleShot(false);
+    m_timer.start(m_delay);
+
+    connect(&m_timer, SIGNAL(timeout()), this, SLOT(update()));
+    connect(this,SIGNAL(sceneRectChanged(QRectF)), this, SLOT(checkSensors(QRectF)));
+
+}
+
+
+View::~View(){
+    m_timer.stop();
+    if (m_controller) delete m_controller;
+    if (m_exController) delete m_exController;
+}
+
+
+void View::resizeEvent(QResizeEvent *event)
+{
+    QGraphicsView::resizeEvent(event);
+    fitInView(sceneRect(), Qt::KeepAspectRatio);
+}
+
+
+
+void View::handleAction(QString oldSensor, QString newSensor){
+
+    m_menu->setVisible(false);
+
+    if (oldSensor==newSensor) return;
+
+
+    QList<QAction*> tmpActions = m_menu->actions();
+    for (int i=0; i<tmpActions.length(); i++){
+        if (tmpActions.at(i)->text() ==  oldSensor){
+            tmpActions.at(i)->setEnabled(true);
+            continue;
+        }
+        if (tmpActions.at(i)->text() == newSensor){
+            tmpActions.at(i)->setEnabled(false);
+        }
+    }
+    m_currentSensor = newSensor;
+    switchController(m_currentSensor);
+
+}
+
+
+
+void View::createActions()
+{
+
+    for (int i=0; i<m_sensors.length();i++){
+        QAction* tmp = new QAction(m_sensors.at(i), this);
+
+        const QString sensor = m_sensors.at(i);
+        do{
+            if (sensor==InputController::QACCELEROMETER){
+                connect(tmp, SIGNAL(triggered()), this, SLOT(startAccelerometer()));
+                break;
+            }
+            if (sensor==InputController::QORIENTATIONSENSOR){
+                connect(tmp, SIGNAL(triggered()), this, SLOT(startOrientationSensor()));
+                break;
+            }
+            if (sensor==InputController::QROTATIONSENSOR){
+                connect(tmp, SIGNAL(triggered()), this, SLOT(startRotationSensor()));
+                break;
+            }
+            if (sensor==InputController::QMAGNETOMETER){
+                connect(tmp, SIGNAL(triggered()), this, SLOT(startMagnetometer()));
+                break;
+            }
+            if (sensor==InputController::QTAPSENSOR){
+                connect(tmp, SIGNAL(triggered()), this, SLOT(startTapSensor()));
+                break;
+            }
+            if (sensor==InputController::QCOMPASS){
+                connect(tmp, SIGNAL(triggered()), this, SLOT(startCompass()));
+                break;
+            }
+            if (sensor==InputController::QKEYS){
+                connect(tmp, SIGNAL(triggered()), this, SLOT(startKeys()));
+                break;
+            }
+        }while (true);
+        m_menu->addAction(tmp);
+    }
+
+}
+
+void View::startAccelerometer(){
+    handleAction(m_currentSensor, InputController::QACCELEROMETER);
+}
+
+void View::startOrientationSensor(){
+    handleAction(m_currentSensor, InputController::QORIENTATIONSENSOR);
+}
+
+void View::startTapSensor(){
+    handleAction(m_currentSensor, InputController::QTAPSENSOR);
+}
+
+void View::startMagnetometer(){
+    handleAction(m_currentSensor, InputController::QMAGNETOMETER);
+}
+
+void View::startRotationSensor(){
+    handleAction(m_currentSensor, InputController::QROTATIONSENSOR);
+}
+
+void View::startKeys(){
+    handleAction(m_currentSensor, InputController::QKEYS);
+}
+
+void View::startCompass(){
+    handleAction(m_currentSensor, InputController::QCOMPASS);
+}
+
+
+
+
+void View::keyPressEvent(QKeyEvent *e)
+{
+    if (m_currentSensor!=InputController::QKEYS) return;
+
+    if (m_controller) m_controller->keyPressEvent(e);
+}
+
+
+void View::switchController(QString sensor){
+
+    if (m_controller){
+        delete m_controller;
+        m_controller =0;
+    }
+
+    if (sensor==InputController::QACCELEROMETER){
+        m_controller = new AccelerometerController();
+        return;
+    }
+    if (sensor==InputController::QROTATIONSENSOR){
+        m_controller = new RotationController();
+        return;
+    }
+    if (sensor==InputController::QMAGNETOMETER){
+        m_controller = new MagnetometerController();
+        return;
+    }
+    if (sensor==InputController::QORIENTATIONSENSOR){
+        m_controller = new OrientationController();
+        return;
+    }
+    if (sensor==InputController::QTAPSENSOR){
+        m_controller = new TapController();
+        return;
+    }
+    if (sensor==InputController::QCOMPASS){
+        m_controller = new CompassController();
+        return;
+    }
+    if (sensor==InputController::QKEYS){
+        m_controller = new KeyController();
+        return;
+    }
+
+
+
+}
+
+
+int View::checkX(int x){
+    int tmpX = qAbs(x) < m_imageWidth ? x : x % m_imageWidth;
+    m_mouseMode?m_exController->setX(tmpX):m_controller->setX(tmpX);
+    return tmpX;
+
+}
+
+int View::checkY(int y){
+    int limit = m_imageHeight-height();
+    if (y<0){
+        y = limit<0?-limit/2:0;
+    }
+    else if (limit<0){
+        y=-limit/2;
+    }
+    else if (y > limit){y=limit;}
+
+    m_mouseMode?m_exController->setY(y):m_controller->setY(y);
+    return y;
+}
+
+
+
+void View::mousePressEvent ( QMouseEvent* ){
+    m_mousePressTime = QTime::currentTime();
+    m_exController = m_controller;
+    m_mouseMode = false;
+}
+
+
+void View::mouseMoveEvent(QMouseEvent* event){
+
+    // first time
+    if (!m_mouseMode){
+        m_mouseMode = true;
+        m_eventX = event->x();
+        m_eventY = event->y();
+        return;
+    }
+
+    if (m_menu->isVisible()){
+        if (m_mousePressTime.msecsTo(QTime::currentTime())>300)
+            m_menu->setVisible(false);
+    }
+
+    int cur_x = event->x();
+    int cur_y = event->y();
+
+    m_dx = m_eventX - cur_x;
+    m_dy = m_eventY - cur_y;
+
+    m_eventX = cur_x;
+    m_eventY = cur_y;
+
+    update();
+
+}
+
+
+
+void View::mouseReleaseEvent(QMouseEvent* event){
+    m_controller = m_exController;
+    m_exController = 0;
+    m_mouseMode = false;
+
+
+    if (m_menu->isVisible()){
+        m_menu->setVisible(false);
+        return;
+    }
+
+    // slow press -> move
+    if (m_mousePressTime.msecsTo(QTime::currentTime())>300) return;
+
+    // quick press -> show menu
+    int x = event->x();
+    int y = event->y();
+    m_menu->move(x, y);
+    m_menu->setVisible(true);
+
+}
+
+
+void View::update(){
+
+    if (!m_isStarted) return;
+
+    if (!m_mouseMode && m_controller)
+        m_controller->updateCoordinates();
+
+    if (m_menu->isVisible()){
+        if (m_mousePressTime.msecsTo(QTime::currentTime())>5000)
+            m_menu->setVisible(false);
+    }
+
+
+    int x = m_mouseMode?m_exController->getX():m_controller->getX();
+    int y = m_mouseMode?m_exController->getY():m_controller->getY();
+
+    x = checkX(m_mouseMode?x+m_dx:x);
+    y = checkY(m_mouseMode?y+m_dy:y);
+
+    setSceneRect(x, y, width(), height());
+}
+
+
+
+
+void View::setupWindow(){
+    int w = m_pix.width();
+    int h = m_pix.height();
+
+    if (m_imageWidth>0 && m_imageHeight > 0){
+        int x = m_controller? m_controller->getX(): (m_exController?m_exController->getX():0);
+        int y = m_controller? m_controller->getY(): (m_exController?m_exController->getY():0);
+
+        checkX(x*w/m_imageWidth);
+        checkY(y*h/m_imageHeight);
+    }
+
+
+    m_imageWidth = w;
+    m_imageHeight = h;
+
+
+    setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
+    setBackgroundBrush(m_pix);
+    setCacheMode(QGraphicsView::CacheBackground);
+    setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
+    setWindowTitle("PanoramaWithSense");
+
+}
+
+
+ void View::focusInEvent(QFocusEvent*) {
+    if (m_controller) m_controller->doStart();
+    m_isStarted = true;
+}
+
+ void View::focusOutEvent(QFocusEvent*) {
+    if (m_controller) m_controller->doStop();
+    m_isStarted = false;
+}
+
+