1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 #include <QtCore>

    19 #include "qstmfilelogger.h"

    20 #include "qstmstatemachine.h" // for qstmUiEventEngine::Distance(dx,dy)

    21 #include "qstmuievent.h"

    22 #include "qstmutils.h"

    23 

    24 using namespace qstmUiEventEngine ;

    25 

    26 static const char* const eventNames[] = {  // for debugging purposes define the names of the UI events

    27         "noEvent",

    28         "ETouch",

    29         "EHold",

    30         "EMove",

    31         "ERelease",

    32         "ENull"

    33 } ;

    34 

    35 const char* qstmUiEventEngine::event_name(qstmUiEventEngine::QStm_UiEventCode code)

    36 {

    37     return eventNames[code];

    38 }

    39 

    40 QStm_UiEvent::QStm_UiEvent(

    41     QStm_UiEventCode code,

    42     const QPoint& start, const QPoint& xy, const QPoint& previousXY,

    43     bool timerExpired, void* target, long interval,

    44     int index, QTime timestamp) :

    45     m_code(code), m_start(start), m_XY(xy), m_previousXY(previousXY),

    46     m_statetransition(interval), m_target(target), m_timerExpired(timerExpired),

    47     m_index(index), m_previousEvent(NULL), m_timestamp(timestamp)

    48 {

    49 }

    50 

    51 

    52 

    53 QStm_UiEvent::~QStm_UiEvent()

    54 {

    55     delete m_previousEvent ;

    56     m_previousEvent = NULL ;

    57 }

    58 

    59 const QPoint& QStm_UiEvent::startPos() const

    60 {

    61     return m_start ;

    62 }

    63 

    64 const QPoint& QStm_UiEvent::currentXY() const

    65 {

    66     return m_XY ;

    67 }

    68 

    69 QStm_UiEventCode QStm_UiEvent::code()const

    70 {

    71     return m_code ;

    72 }

    73 

    74 const QPoint& QStm_UiEvent::previousXY() const

    75 {

    76     return m_previousXY ;

    77 }

    78 

    79 long QStm_UiEvent::stateTransition() const

    80 {

    81     return m_statetransition ;

    82 }

    83 

    84 bool QStm_UiEvent::timerExpired() const

    85 {

    86     return m_timerExpired ;

    87 }

    88 

    89 void* QStm_UiEvent::target() const

    90 {

    91     return m_target ;

    92 }

    93 

    94 int QStm_UiEvent::index() const

    95 {

    96     return m_index ;

    97 }

    98 

    99 void QStm_UiEvent::setPrevious(QStm_UiEvent* event)

   100 {

   101     m_previousEvent = event ;

   102 }

   103 

   104 QStm_UiEventIf* QStm_UiEvent::previousEvent() const

   105 {

   106     return m_previousEvent ;

   107 }

   108 

   109 int QStm_UiEvent::countOfEvents() const

   110 {

   111     int count = 1 ;

   112     for(QStm_UiEvent* prev = m_previousEvent; prev; prev = prev->m_previousEvent)

   113         {

   114         ++count;

   115         }

   116     return count ;

   117 }

   118 

   119 QTime QStm_UiEvent::timestamp() const

   120 {

   121     return m_timestamp ;

   122 }

   123 

   124 float QStm_UiEvent::speed() const /*__SOFTFP */

   125 {

   126     int dist = QStm_Utils::distance(m_previousXY, m_XY);

   127     // now calculate speed

   128     int elapsed = m_statetransition ; // use ms as time unit

   129     float speed = float(dist)/(elapsed ? elapsed : 1) ;

   130     return speed ;

   131 }

   132 

   133 QPointF QStm_UiEvent::speedVec() const

   134 {

   135     QPointF diff(m_XY - m_previousXY);

   136     

   137     diff = diff / (m_statetransition ? m_statetransition : 1) ;

   138     

   139     return diff;

   140 }

   141 

   142 

   143 void QStm_UiEvent::logSpeed() const

   144 {

   145     int dist = QStm_Utils::distance(m_previousXY, m_XY);

   146     // now calculate speed

   147     int elapsed = m_statetransition ; // use ms as time unit

   148     double speed = double(dist)/(elapsed ? elapsed : 1) ;

   149 

   150     LOGARG("event: %s: (%d,%d), prev: (%d,%d), time %d dist %d speed %f", event_name(code()), m_XY.x(), m_XY.y(),

   151             m_previousXY.x(), m_previousXY.y(), elapsed, dist, speed);

   152 }

   153 

   154 

   155 

   156 QEvent::Type  QStm_UiEvent::mapToMouseEventType()

   157 {

   158     QEvent::Type type = QEvent::None;

   159     switch (m_code) {

   160         case ETouch:

   161         case EHold:    

   162         {

   163             type = QEvent::MouseButtonPress;

   164             break;

   165         }

   166         case EMove:

   167         {

   168             type = QEvent::MouseMove;

   169             break;

   170         }

   171         case ERelease:

   172         {

   173             type = QEvent::MouseButtonRelease;

   174             break;

   175         }

   176     }

   177     return type;

   178 }

   179 

   180 QEvent::Type  QStm_UiEvent::mapToTouchEventType()

   181 {

   182     QEvent::Type type = QEvent::None;

   183     switch (m_code) {

   184         case ETouch:

   185         case EHold:    

   186         {

   187             type = QEvent::TouchBegin;

   188             break;

   189         }

   190         case EMove:

   191         {

   192             type = QEvent::TouchUpdate;

   193             break;

   194         }

   195         case ERelease:

   196         {

   197             type = QEvent::TouchEnd;

   198             break;

   199         }

   200     }

   201     return type;

   202 }

   203