42 

    42 #include <QGraphicsScene>

    43 #include <QGestureRecognizer>

    44 #include <hbgesturerecognizers_p.h>

    45 

    46 class HbTapDelayGesture:public HbTapGesture

    47 {

    48 public:

    49     using HbTapGesture::d_ptr;

    50     

    51     Q_DECLARE_PRIVATE_D(d_ptr, HbTapGesture);

    52 };

    53 class HbTapDelayGestureRecognizer : public HbTapGestureRecognizer

    54 {

    55 public:

    56     explicit HbTapDelayGestureRecognizer(){};

    57     virtual ~HbTapDelayGestureRecognizer()

    58     {

    59         int i = 0;

    60         i++;

    61     };

    62 

    63     QGestureRecognizer::Result recognize(QGesture *state, QObject *watched, QEvent *event)

    64     {

    65         HbTapDelayGesture* gesture = static_cast<HbTapDelayGesture *>(state);

    66         QMouseEvent* me = toMouseEvent(event);

    67         Qt::GestureState gestureState = state->state();

    68         switch(event->type())

    69         {

    70         case QEvent::MouseButtonDblClick:

    71         case QEvent::MouseButtonPress:

    72             if ( state->state() == Qt::NoGesture && me->button() == Qt::LeftButton){

    73                 

    74                 gesture->setPosition(me->globalPos());

    75                 gesture->setHotSpot(me->globalPos());

    76                 gesture->setStartPos(me->globalPos());

    77                 gesture->setScenePosition(HbGestureUtils::mapToScene(watched, me->globalPos()));

    78                 gesture->setSceneStartPos(HbGestureUtils::mapToScene(watched, me->globalPos()));

    79                 mTapRadius = (int)(HbDefaultTapRadius * HbDeviceProfile::current().ppmValue());        

    80 

    81                 HbTapGesturePrivate* d_ptr = gesture->d_func();

    82                 d_ptr->mTapStyleHint = HbTapGesture::Tap;

    83                 if ( d_ptr->mTimerId ) {

    84                     gesture->killTimer(d_ptr->mTimerId);

    85                 }

    86                 d_ptr->mTimerId = gesture->startTimer(50);

    87                 return QGestureRecognizer::MayBeGesture;

    88                 

    89             }

    90             else {

    91                 return QGestureRecognizer::Ignore;

    92             }

    93     

    94 

    95         case QEvent::MouseMove:

    96             if(gestureState != Qt::NoGesture && gestureState != Qt::GestureCanceled) { 

    97                 return handleMouseMove(gestureState, gesture, watched, toMouseEvent(event));

    98             }

    99             else{

   100                 if (gesture->d_func()->mTimerId) {

   101                     gesture->setPosition(me->globalPos());

   102                     gesture->setScenePosition(HbGestureUtils::mapToScene(watched, me->globalPos()));

   103                     gesture->setHotSpot(me->globalPos());

   104 

   105                     int tapRadiusSquare(mTapRadius * mTapRadius);

   106                     if(gesture->property(HbPrivate::TapRadius.latin1()).isValid()) {

   107                         qWarning("WARNING using widget specific properties in HbTapGestureRecognizer");

   108                         int tapRadius = gesture->property(HbPrivate::TapRadius.latin1()).toInt();

   109                         tapRadiusSquare = tapRadius * tapRadius;

   110                     }

   111                     QPointF delta = me->globalPos() - gesture->startPos();

   112 

   113                      // cancel long press with radius

   114                     if((delta.x() * delta.x() + delta.y() * delta.y()) > tapRadiusSquare) {                

   115                         gesture->killTimer(gesture->d_func()->mTimerId);

   116                         gesture->d_func()->mTimerId = 0;

   117                     }

   118 

   119                 }

   120                 return QGestureRecognizer::Ignore;

   121             }

   122 

   123         case QEvent::MouseButtonRelease:

   124             if(gestureState != Qt::NoGesture) {

   125                 return handleMouseRelease(gestureState, gesture, watched, toMouseEvent(event));

   126             }

   127             else{

   128                 

   129                 if (gesture->d_func()->mTimerId) {

   130                     gesture->killTimer(gesture->d_func()->mTimerId);

   131                     gesture->d_func()->mTimerId = 0;

   132                     return QGestureRecognizer::FinishGesture;

   133                 } else {

   134                     return QGestureRecognizer::Ignore;

   135                 }

   136             }

   137 

   138         case QEvent::Timer:

   139             {

   140             QGestureRecognizer::Result result;

   141             gesture->killTimer(gesture->d_func()->mTimerId);

   142             gesture->d_func()->mTimerId = 0;

   143             if(gestureState == Qt::NoGesture) {

   144                 result = QGestureRecognizer::TriggerGesture;        

   145                 gesture->d_func()->mTimerId = gesture->startTimer(HbTapAndHoldTimeout);

   146               

   147             } 

   148             else {

   149                 result = handleTimerEvent(gesture->state(),gesture,watched);

   150             }

   151 

   152             return result;

   153             }

   154             break;

   155 

   156         case QEvent::TouchBegin:

   157         case QEvent::TouchUpdate:        

   158             return HbTapGestureRecognizer::recognize(state, watched, event);

   159 

   160         default: break;

   161         }

   162 

   163         return QGestureRecognizer::Ignore;

   164 

   165     }

   166 };

   167 

   168 class DelayGestureInstaller

   169 {

   170 public:

   171     DelayGestureInstaller():count(0){}

   172     void install()

   173     {

   174         if(count <=0){

   175             QGestureRecognizer::unregisterRecognizer(Qt::TapGesture);

   176             QGestureRecognizer::registerRecognizer(new HbTapDelayGestureRecognizer);

   177             

   178         }

   179         count++;

   180     }

   181     void unInstall()

   182     {

   183         count--;

   184         if(count <1){

   185             QGestureRecognizer::unregisterRecognizer(Qt::TapGesture);

   186             QGestureRecognizer::registerRecognizer(new HbTapGestureRecognizer);

   187         }

   188     }

   189     int count;

   190 };

   191 static DelayGestureInstaller delayGestureInstaller;

   236     setVerticalScrollBarPolicy(ScrollBarAlwaysOff);

   385     //setVerticalScrollBarPolicy(ScrollBarAlwaysOff);