ui/widgets/glxzoomwidget/src/glxzoomwidget.cpp
author hgs
Sat, 04 Sep 2010 11:36:24 +0530
changeset 62 36d93b4dc635
parent 58 383b67fbdb11
child 69 45459746d5e8
permissions -rw-r--r--
201035
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
43
hgs
parents:
diff changeset
     1
 /*
hgs
parents:
diff changeset
     2
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
hgs
parents:
diff changeset
     3
* All rights reserved.
hgs
parents:
diff changeset
     4
* This component and the accompanying materials are made available
hgs
parents:
diff changeset
     5
* under the terms of "Eclipse Public License v1.0"
hgs
parents:
diff changeset
     6
* which accompanies this distribution, and is available
hgs
parents:
diff changeset
     7
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
hgs
parents:
diff changeset
     8
*
hgs
parents:
diff changeset
     9
* Initial Contributors:
hgs
parents:
diff changeset
    10
* Nokia Corporation - initial contribution.
hgs
parents:
diff changeset
    11
*
hgs
parents:
diff changeset
    12
* Contributors:
hgs
parents:
diff changeset
    13
*
hgs
parents:
diff changeset
    14
* Description:   glxzoomwidget.cpp
hgs
parents:
diff changeset
    15
*               description of the class GlxGlxZoomWidget which controls the Zoom behavior of coverflow.
hgs
parents:
diff changeset
    16
*
hgs
parents:
diff changeset
    17
*/
hgs
parents:
diff changeset
    18
#include <QPinchGesture>
hgs
parents:
diff changeset
    19
#include <hbiconitem.h>
hgs
parents:
diff changeset
    20
#include <QTimeLine>
hgs
parents:
diff changeset
    21
#include <QGesture>
50
hgs
parents: 45
diff changeset
    22
#include <hbinstance.h>
43
hgs
parents:
diff changeset
    23
#include "glximagedecoderwrapper.h"
hgs
parents:
diff changeset
    24
#include "glxmodelparm.h"
hgs
parents:
diff changeset
    25
#include "glxzoomwidget.h"
hgs
parents:
diff changeset
    26
58
hgs
parents: 54
diff changeset
    27
const int MAXZVALUE = 100;
hgs
parents: 54
diff changeset
    28
const int MINZVALUE = 0;
hgs
parents: 54
diff changeset
    29
const int NOOFSTEPSZI = 24;
hgs
parents: 54
diff changeset
    30
const int NOOFSTEPSZO = 18;
hgs
parents: 54
diff changeset
    31
const float MAXDTZOOMIN = 3.5;
hgs
parents: 54
diff changeset
    32
52
hgs
parents: 50
diff changeset
    33
GlxZoomWidget::GlxZoomWidget(QGraphicsItem *parent):HbScrollArea(parent), 
hgs
parents: 50
diff changeset
    34
            mModel(NULL), mMinZValue(MINZVALUE), 
hgs
parents: 50
diff changeset
    35
            mMaxZValue(MAXZVALUE), mTimerId(0),
hgs
parents: 50
diff changeset
    36
            mImageDecodeRequestSend(false), 
hgs
parents: 50
diff changeset
    37
            mPinchGestureOngoing(false), mDecodedImageAvailable(false),
hgs
parents: 50
diff changeset
    38
            mZoomOngoing(false)
43
hgs
parents:
diff changeset
    39
{
hgs
parents:
diff changeset
    40
    grabGesture(Qt::PinchGesture);
44
hgs
parents: 43
diff changeset
    41
    grabGesture(Qt::TapGesture);
43
hgs
parents:
diff changeset
    42
    setAcceptTouchEvents(true) ;
58
hgs
parents: 54
diff changeset
    43
    setFrictionEnabled(true);
43
hgs
parents:
diff changeset
    44
    setZValue(mMinZValue);
hgs
parents:
diff changeset
    45
    //create the child items and background
hgs
parents:
diff changeset
    46
    mZoomWidget = new QGraphicsWidget(this);
hgs
parents:
diff changeset
    47
    mZoomItem = new QGraphicsPixmapItem(mZoomWidget);
hgs
parents:
diff changeset
    48
    mZoomItem->setTransformationMode(Qt::SmoothTransformation);
hgs
parents:
diff changeset
    49
    //the black background
hgs
parents:
diff changeset
    50
    //replace when a proper substitute for setting backgrounds is known
hgs
parents:
diff changeset
    51
    mBlackBackgroundItem = new HbIconItem(this);
hgs
parents:
diff changeset
    52
    mBlackBackgroundItem->setBrush(QBrush(Qt::black));
hgs
parents:
diff changeset
    53
    mBlackBackgroundItem->hide();
hgs
parents:
diff changeset
    54
    //does not work so is commented
hgs
parents:
diff changeset
    55
    //setBackgroundItem(mBlackBackgroundItem);
hgs
parents:
diff changeset
    56
hgs
parents:
diff changeset
    57
    //initializing the image decoder
hgs
parents:
diff changeset
    58
    mImageDecoder = new GlxImageDecoderWrapper;
hgs
parents:
diff changeset
    59
58
hgs
parents: 54
diff changeset
    60
    setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);
hgs
parents: 54
diff changeset
    61
    setHorizontalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);
54
hgs
parents: 52
diff changeset
    62
	//AA: signal and slot to perform double tap animation
hgs
parents: 52
diff changeset
    63
    //after every step redraw, signal is emitted to perform the next step
hgs
parents: 52
diff changeset
    64
	connect( this, SIGNAL( stepZoom() ), this, SLOT( animateDoubleTap() ), Qt::QueuedConnection );
43
hgs
parents:
diff changeset
    65
}
hgs
parents:
diff changeset
    66
hgs
parents:
diff changeset
    67
GlxZoomWidget::~GlxZoomWidget()
hgs
parents:
diff changeset
    68
{
62
hgs
parents: 58
diff changeset
    69
   
54
hgs
parents: 52
diff changeset
    70
    //AA
hgs
parents: 52
diff changeset
    71
    disconnect( this, SIGNAL( stepZoom() ), this, SLOT( animateDoubleTap()));
43
hgs
parents:
diff changeset
    72
    //no Null checks required
hgs
parents:
diff changeset
    73
    delete mZoomItem;
hgs
parents:
diff changeset
    74
//    delete mZoomWidget; //as this is a content widegt it will automatically be deleted
hgs
parents:
diff changeset
    75
    delete mBlackBackgroundItem;
hgs
parents:
diff changeset
    76
    //reset the decoder to cancel pending tasks
hgs
parents:
diff changeset
    77
    if(mImageDecoder) {
62
hgs
parents: 58
diff changeset
    78
        resetDecoder();
43
hgs
parents:
diff changeset
    79
        delete mImageDecoder;
hgs
parents:
diff changeset
    80
    }
hgs
parents:
diff changeset
    81
}
62
hgs
parents: 58
diff changeset
    82
void GlxZoomWidget::resetDecoder()
hgs
parents: 58
diff changeset
    83
{
hgs
parents: 58
diff changeset
    84
        mImageDecoder->resetDecoder();
hgs
parents: 58
diff changeset
    85
        mImageDecodeRequestSend = false;
hgs
parents: 58
diff changeset
    86
        mDecodedImageAvailable = false;
hgs
parents: 58
diff changeset
    87
}
43
hgs
parents:
diff changeset
    88
hgs
parents:
diff changeset
    89
void GlxZoomWidget::setModel (QAbstractItemModel *model)
hgs
parents:
diff changeset
    90
{
hgs
parents:
diff changeset
    91
    if(model)
hgs
parents:
diff changeset
    92
    {
hgs
parents:
diff changeset
    93
        mModel = model;
hgs
parents:
diff changeset
    94
        retreiveFocusedImage(); //Update mZoomItem with focused Image
hgs
parents:
diff changeset
    95
        connect( mModel, SIGNAL( dataChanged(QModelIndex,QModelIndex) ), this, SLOT( dataChanged(QModelIndex,QModelIndex) ) );
45
hgs
parents: 44
diff changeset
    96
        connect( mModel, SIGNAL( destroyed() ), this, SLOT( modelDestroyed() ) );
43
hgs
parents:
diff changeset
    97
    }
hgs
parents:
diff changeset
    98
}
hgs
parents:
diff changeset
    99
hgs
parents:
diff changeset
   100
void GlxZoomWidget::setWindowSize(QSize windowSize)
hgs
parents:
diff changeset
   101
{
hgs
parents:
diff changeset
   102
    mWindowSize = windowSize;
hgs
parents:
diff changeset
   103
    mBlackBackgroundItem->setGeometry(QRectF(QPointF(0,0), mWindowSize));
hgs
parents:
diff changeset
   104
    //try to reset the max and min zoomed size here
50
hgs
parents: 45
diff changeset
   105
    //In case the zoom widget is in background reset it
hgs
parents: 45
diff changeset
   106
    if(!mZoomOngoing && mModel) {
hgs
parents: 45
diff changeset
   107
        retreiveFocusedImage();
hgs
parents: 45
diff changeset
   108
    }
hgs
parents: 45
diff changeset
   109
    setZoomParams();
hgs
parents: 45
diff changeset
   110
}
hgs
parents: 45
diff changeset
   111
hgs
parents: 45
diff changeset
   112
void GlxZoomWidget::forceZoomToBackground()
hgs
parents: 45
diff changeset
   113
{
hgs
parents: 45
diff changeset
   114
    mBlackBackgroundItem->hide();
hgs
parents: 45
diff changeset
   115
    //push the widget back to background
hgs
parents: 45
diff changeset
   116
    setZValue(mMinZValue);
hgs
parents: 45
diff changeset
   117
    mZoomOngoing = false;
hgs
parents: 45
diff changeset
   118
    emit zoomWidgetMovedBackground(mFocusIndex);
hgs
parents: 45
diff changeset
   119
    //this actually resets the ZoomWidget and decoder
hgs
parents: 45
diff changeset
   120
    if(mImageDecoder) {
62
hgs
parents: 58
diff changeset
   121
        resetDecoder();
50
hgs
parents: 45
diff changeset
   122
    }
hgs
parents: 45
diff changeset
   123
    retreiveFocusedImage();
hgs
parents: 45
diff changeset
   124
43
hgs
parents:
diff changeset
   125
}
hgs
parents:
diff changeset
   126
hgs
parents:
diff changeset
   127
void GlxZoomWidget::indexChanged(int index)
hgs
parents:
diff changeset
   128
{
hgs
parents:
diff changeset
   129
    if(mFocusIndex != index) {
62
hgs
parents: 58
diff changeset
   130
        resetDecoder();          //reset the decoder first to cancel pending tasks
43
hgs
parents:
diff changeset
   131
        retreiveFocusedImage();  //Update mZoomItem with focused Image
hgs
parents:
diff changeset
   132
    }
hgs
parents:
diff changeset
   133
}
hgs
parents:
diff changeset
   134
hgs
parents:
diff changeset
   135
void GlxZoomWidget::cleanUp()
hgs
parents:
diff changeset
   136
{
62
hgs
parents: 58
diff changeset
   137
    disconnect(this,SIGNAL( pinchGestureReceived(int) ), this, SLOT( sendDecodeRequest(int) ) );
44
hgs
parents: 43
diff changeset
   138
    if(mModel) {
hgs
parents: 43
diff changeset
   139
        disconnect( mModel, SIGNAL( dataChanged(QModelIndex,QModelIndex) ), this, SLOT( dataChanged(QModelIndex,QModelIndex) ) );
45
hgs
parents: 44
diff changeset
   140
        disconnect( mModel, SIGNAL( destroyed() ), this, SLOT( modelDestroyed() ) );
44
hgs
parents: 43
diff changeset
   141
        mModel = NULL;
hgs
parents: 43
diff changeset
   142
    }
43
hgs
parents:
diff changeset
   143
    if(mImageDecoder) {
62
hgs
parents: 58
diff changeset
   144
        resetDecoder();
43
hgs
parents:
diff changeset
   145
    }
hgs
parents:
diff changeset
   146
    mZoomItem->setPixmap(QPixmap());
hgs
parents:
diff changeset
   147
}
hgs
parents:
diff changeset
   148
hgs
parents:
diff changeset
   149
void GlxZoomWidget::activate()
hgs
parents:
diff changeset
   150
{
hgs
parents:
diff changeset
   151
}
hgs
parents:
diff changeset
   152
hgs
parents:
diff changeset
   153
void GlxZoomWidget::setMinMaxZValue(int minZvalue, int maxZvalue)
hgs
parents:
diff changeset
   154
{
hgs
parents:
diff changeset
   155
    mMinZValue = minZvalue;
hgs
parents:
diff changeset
   156
    mMaxZValue = maxZvalue;
hgs
parents:
diff changeset
   157
}
hgs
parents:
diff changeset
   158
hgs
parents:
diff changeset
   159
void GlxZoomWidget::connectDecodeRequestToPinchEvent()
hgs
parents:
diff changeset
   160
{
hgs
parents:
diff changeset
   161
    connect(this,SIGNAL( pinchGestureReceived(int) ), this, SLOT( sendDecodeRequest(int) ), Qt::QueuedConnection );
hgs
parents:
diff changeset
   162
}
hgs
parents:
diff changeset
   163
hgs
parents:
diff changeset
   164
bool GlxZoomWidget::sceneEvent(QEvent *event)
hgs
parents:
diff changeset
   165
{
hgs
parents:
diff changeset
   166
    bool consume(false);
hgs
parents:
diff changeset
   167
    if (event->type() == QEvent::Gesture) {
hgs
parents:
diff changeset
   168
        consume = executeGestureEvent(this, static_cast<QGestureEvent*>(event));
hgs
parents:
diff changeset
   169
    }
hgs
parents:
diff changeset
   170
    if(!consume)
hgs
parents:
diff changeset
   171
    {
hgs
parents:
diff changeset
   172
        consume = HbScrollArea::sceneEvent(event);
hgs
parents:
diff changeset
   173
    }
hgs
parents:
diff changeset
   174
    return consume;
hgs
parents:
diff changeset
   175
}
hgs
parents:
diff changeset
   176
hgs
parents:
diff changeset
   177
bool GlxZoomWidget::sceneEventFilter(QGraphicsItem *watched,QEvent *event)
hgs
parents:
diff changeset
   178
{
54
hgs
parents: 52
diff changeset
   179
    qDebug( "GlxZoomWidget::sceneEventFilter enter event type %d ", event->type() );
43
hgs
parents:
diff changeset
   180
    bool consume = false;
hgs
parents:
diff changeset
   181
    if (event->type() == QEvent::Gesture) {
hgs
parents:
diff changeset
   182
        consume = executeGestureEvent(watched, static_cast<QGestureEvent*>(event));
hgs
parents:
diff changeset
   183
    }
hgs
parents:
diff changeset
   184
hgs
parents:
diff changeset
   185
    if(!consume) {
hgs
parents:
diff changeset
   186
        consume = HbScrollArea::sceneEventFilter(watched,event);
hgs
parents:
diff changeset
   187
    }
hgs
parents:
diff changeset
   188
    return consume;
hgs
parents:
diff changeset
   189
hgs
parents:
diff changeset
   190
}
hgs
parents:
diff changeset
   191
hgs
parents:
diff changeset
   192
bool GlxZoomWidget::executeGestureEvent(QGraphicsItem *source,QGestureEvent *event)
hgs
parents:
diff changeset
   193
{
44
hgs
parents: 43
diff changeset
   194
         if(QTapGesture *gesture = static_cast<QTapGesture *>(event->gesture(Qt::TapGesture))) {        
hgs
parents: 43
diff changeset
   195
            if (gesture->state() == Qt::GestureFinished) {
hgs
parents: 43
diff changeset
   196
                if(!mTimerId) {
58
hgs
parents: 54
diff changeset
   197
                    mTimerId = startTimer( DOUBLETAP_TIMEINTERVAL );
44
hgs
parents: 43
diff changeset
   198
                }
hgs
parents: 43
diff changeset
   199
            else {
hgs
parents: 43
diff changeset
   200
                killTimer(mTimerId);
hgs
parents: 43
diff changeset
   201
                mTimerId = 0;
50
hgs
parents: 45
diff changeset
   202
                animateZoomOut(hbInstance->allMainWindows().first()->mapToScene(gesture->position().toPoint()));
44
hgs
parents: 43
diff changeset
   203
            }
hgs
parents: 43
diff changeset
   204
        }
hgs
parents: 43
diff changeset
   205
        event->accept(gesture);
hgs
parents: 43
diff changeset
   206
        return true;
hgs
parents: 43
diff changeset
   207
    }
43
hgs
parents:
diff changeset
   208
     if (QGesture *pinch = event->gesture(Qt::PinchGesture))  {
52
hgs
parents: 50
diff changeset
   209
         if (isFocussedItemCorrupt()){
hgs
parents: 50
diff changeset
   210
         return true;
hgs
parents: 50
diff changeset
   211
         }
43
hgs
parents:
diff changeset
   212
       QPinchGesture* pinchG = static_cast<QPinchGesture *>(pinch);
hgs
parents:
diff changeset
   213
       QPinchGesture::ChangeFlags changeFlags = pinchG->changeFlags();
hgs
parents:
diff changeset
   214
       if (changeFlags & QPinchGesture::ScaleFactorChanged) {
hgs
parents:
diff changeset
   215
            mPinchGestureOngoing = true;
50
hgs
parents: 45
diff changeset
   216
            mZoomOngoing = true;
58
hgs
parents: 54
diff changeset
   217
            
43
hgs
parents:
diff changeset
   218
            //retreive the gesture values
hgs
parents:
diff changeset
   219
            qreal value = pinchG->scaleFactor() / pinchG->lastScaleFactor();
hgs
parents:
diff changeset
   220
            QPointF center = pinchG->property("centerPoint").toPointF();
hgs
parents:
diff changeset
   221
            //set the gesture center to the scene coordinates
50
hgs
parents: 45
diff changeset
   222
            QPointF sceneGestureCenter = hbInstance->allMainWindows().first()->mapToScene(center.toPoint());
43
hgs
parents:
diff changeset
   223
            zoomImage(value, sceneGestureCenter);
hgs
parents:
diff changeset
   224
hgs
parents:
diff changeset
   225
        }
hgs
parents:
diff changeset
   226
       if (pinchG->state() == Qt::GestureStarted) {
hgs
parents:
diff changeset
   227
           emit pinchGestureReceived(mFocusIndex);
58
hgs
parents: 54
diff changeset
   228
           //bring the zoom widget to foreground
62
hgs
parents: 58
diff changeset
   229
           if(zValue()!=mMaxZValue)
hgs
parents: 58
diff changeset
   230
           {
58
hgs
parents: 54
diff changeset
   231
            setZValue(mMaxZValue);
hgs
parents: 54
diff changeset
   232
            //show the black background
hgs
parents: 54
diff changeset
   233
            mBlackBackgroundItem->setParentItem(parentItem());
hgs
parents: 54
diff changeset
   234
            mBlackBackgroundItem->setZValue(mMaxZValue - 1);
hgs
parents: 54
diff changeset
   235
            mBlackBackgroundItem->show();
62
hgs
parents: 58
diff changeset
   236
           }
43
hgs
parents:
diff changeset
   237
       }
hgs
parents:
diff changeset
   238
hgs
parents:
diff changeset
   239
       if (pinchG->state() == Qt::GestureFinished) {
hgs
parents:
diff changeset
   240
               //For giving a spring effect when user has zoomed more than normal.
hgs
parents:
diff changeset
   241
               if(mStepCurrentSize.width() > mMaxScaleDecSize.width())   {
hgs
parents:
diff changeset
   242
                   //scale the image to limited size
hgs
parents:
diff changeset
   243
                   qreal value = mMaxScaleDecSize.width()/mCurrentSize.width();
hgs
parents:
diff changeset
   244
                   QPointF center(mWindowSize.width()/2, mWindowSize.height()/2);
hgs
parents:
diff changeset
   245
                   QPointF sceneGestureCenter = source->sceneTransform().map(center);
hgs
parents:
diff changeset
   246
                   zoomImage(value, sceneGestureCenter);
hgs
parents:
diff changeset
   247
               }
hgs
parents:
diff changeset
   248
               mPinchGestureOngoing = false;
hgs
parents:
diff changeset
   249
                //finalize the transforms to the geometry else panning will not work
hgs
parents:
diff changeset
   250
                finalizeWidgetTransform();
58
hgs
parents: 54
diff changeset
   251
       
43
hgs
parents:
diff changeset
   252
//push the Zoom widget to background when zoomed image size nears FS image
hgs
parents:
diff changeset
   253
           if(mStepCurrentSize.width() <= mMinDecScaleSize.width()*1.3)  {
hgs
parents:
diff changeset
   254
               mBlackBackgroundItem->hide();
hgs
parents:
diff changeset
   255
               //push the widget back to background
hgs
parents:
diff changeset
   256
               setZValue(mMinZValue);
50
hgs
parents: 45
diff changeset
   257
               mZoomOngoing = false;
43
hgs
parents:
diff changeset
   258
               emit zoomWidgetMovedBackground(mFocusIndex);
hgs
parents:
diff changeset
   259
               //do not reset the transform here as it will then zoom-in the widget to decoded image size
hgs
parents:
diff changeset
   260
           }
hgs
parents:
diff changeset
   261
       }
hgs
parents:
diff changeset
   262
       //gesture accepted
hgs
parents:
diff changeset
   263
       return true;
hgs
parents:
diff changeset
   264
     }
hgs
parents:
diff changeset
   265
     //gesture rejected
hgs
parents:
diff changeset
   266
     if(!mPinchGestureOngoing) {
hgs
parents:
diff changeset
   267
         return false; 
hgs
parents:
diff changeset
   268
     }
hgs
parents:
diff changeset
   269
     return true;
hgs
parents:
diff changeset
   270
hgs
parents:
diff changeset
   271
}
hgs
parents:
diff changeset
   272
hgs
parents:
diff changeset
   273
void GlxZoomWidget::zoomImage(qreal zoomFactor, QPointF center)
hgs
parents:
diff changeset
   274
{
50
hgs
parents: 45
diff changeset
   275
        // Pinch event filtering for very small zoom factors
hgs
parents: 45
diff changeset
   276
    if (qAbs(1.0 - zoomFactor) < 0.007) {
hgs
parents: 45
diff changeset
   277
        return;
hgs
parents: 45
diff changeset
   278
    }
43
hgs
parents:
diff changeset
   279
    adjustGestureCenter(center, zoomFactor);
hgs
parents:
diff changeset
   280
    QSizeF requiredSize(mCurrentSize.width()*zoomFactor, mCurrentSize.height()*zoomFactor);
hgs
parents:
diff changeset
   281
    limitRequiredSize(requiredSize);
hgs
parents:
diff changeset
   282
    if(requiredSize != mCurrentSize) {
hgs
parents:
diff changeset
   283
        QTransform zoomTransform = mZoomWidget->transform();
hgs
parents:
diff changeset
   284
        QPointF transformedCenter = mZoomWidget->sceneTransform().inverted().map(center);
hgs
parents:
diff changeset
   285
        zoomTransform.translate(transformedCenter.x(),transformedCenter.y());
hgs
parents:
diff changeset
   286
        zoomTransform.scale(requiredSize.width()/mCurrentSize.width(), requiredSize.height()/mCurrentSize.height());
hgs
parents:
diff changeset
   287
        zoomTransform.translate(-transformedCenter.x(),-transformedCenter.y());
hgs
parents:
diff changeset
   288
        mZoomWidget->setTransform(zoomTransform);
hgs
parents:
diff changeset
   289
        mCurrentSize = requiredSize;
hgs
parents:
diff changeset
   290
    }
hgs
parents:
diff changeset
   291
hgs
parents:
diff changeset
   292
}
hgs
parents:
diff changeset
   293
hgs
parents:
diff changeset
   294
hgs
parents:
diff changeset
   295
void GlxZoomWidget::limitRequiredSize(QSizeF &requiredSize)
hgs
parents:
diff changeset
   296
{
hgs
parents:
diff changeset
   297
    if(requiredSize.width() > mMaxScaleSize.width() ) {
hgs
parents:
diff changeset
   298
        requiredSize = mMaxScaleSize ;
hgs
parents:
diff changeset
   299
    }
hgs
parents:
diff changeset
   300
    else if(requiredSize.width() < mMinDecScaleSize.width() ) {
hgs
parents:
diff changeset
   301
        requiredSize = mMinDecScaleSize ;
hgs
parents:
diff changeset
   302
    }
hgs
parents:
diff changeset
   303
hgs
parents:
diff changeset
   304
hgs
parents:
diff changeset
   305
}
hgs
parents:
diff changeset
   306
hgs
parents:
diff changeset
   307
//makes sure that the gesture is on the screen center if the image is smaller than the screen
hgs
parents:
diff changeset
   308
void GlxZoomWidget::adjustGestureCenter(QPointF & gestureCenter, qreal& zoomFactor)
hgs
parents:
diff changeset
   309
{
58
hgs
parents: 54
diff changeset
   310
    
hgs
parents: 54
diff changeset
   311
    //clip zoom factor for pinch zoom. Double tap zoomfactor should never exceed
hgs
parents: 54
diff changeset
   312
    //1.2 or 0.8 in any given step  
hgs
parents: 54
diff changeset
   313
/*    if(zoomFactor > 1.2 )  {
43
hgs
parents:
diff changeset
   314
        zoomFactor = 1.2;
hgs
parents:
diff changeset
   315
    }
58
hgs
parents: 54
diff changeset
   316
    if(zoomFactor < 0.7 )   {
43
hgs
parents:
diff changeset
   317
        zoomFactor = 0.8;
58
hgs
parents: 54
diff changeset
   318
    }*/
hgs
parents: 54
diff changeset
   319
hgs
parents: 54
diff changeset
   320
    qDebug("AA::adjustGestureCenter::ZoomFactor (%f)",zoomFactor);
hgs
parents: 54
diff changeset
   321
    QPointF itemOriginPos = mZoomWidget->sceneTransform().map(QPointF(0,0)); 
hgs
parents: 54
diff changeset
   322
    QPointF gesCenter = mZoomWidget->sceneTransform().map(gestureCenter); 
43
hgs
parents:
diff changeset
   323
58
hgs
parents: 54
diff changeset
   324
    
hgs
parents: 54
diff changeset
   325
    //keep smaller image centered irrespective of zoomin or zoom out
hgs
parents: 54
diff changeset
   326
    //note, only if the image is smaller than window size, else preserve the 
hgs
parents: 54
diff changeset
   327
    //gesture center. Adjustments need to be done for both height/width
hgs
parents: 54
diff changeset
   328
    //only one of them will be applicable, unless the image is smaller than
hgs
parents: 54
diff changeset
   329
    //fullscreen size on both dimensions
hgs
parents: 54
diff changeset
   330
    if( (mCurrentSize.width() <= mWindowSize.width()))  {
hgs
parents: 54
diff changeset
   331
       //requires adjustment only in portrait orientation 
hgs
parents: 54
diff changeset
   332
       if(mWindowSize.width() > mWindowSize.height())
hgs
parents: 54
diff changeset
   333
           gestureCenter.setX(mWindowSize.width()/2);
43
hgs
parents:
diff changeset
   334
    }
58
hgs
parents: 54
diff changeset
   335
    //handle the case when CurrentSize is grater than window size
hgs
parents: 54
diff changeset
   336
    //this applies to zoomout flow
hgs
parents: 54
diff changeset
   337
    else  {
hgs
parents: 54
diff changeset
   338
        //when the image is positioned beyond the left edge of the window
hgs
parents: 54
diff changeset
   339
        //clamp the image to left edge
hgs
parents: 54
diff changeset
   340
        if(itemOriginPos.x() >= 0) {
hgs
parents: 54
diff changeset
   341
            gestureCenter.setX(itemOriginPos.x());    
hgs
parents: 54
diff changeset
   342
        }
hgs
parents: 54
diff changeset
   343
        //same applies when the image needs clamping on right edge
hgs
parents: 54
diff changeset
   344
        else if(itemOriginPos.x()+ mCurrentSize.width() <= mWindowSize.width()){
hgs
parents: 54
diff changeset
   345
            gestureCenter.setX(itemOriginPos.x() + mCurrentSize.width());
hgs
parents: 54
diff changeset
   346
        }
hgs
parents: 54
diff changeset
   347
        //else no clamping is required, theg esture center can be preserved
hgs
parents: 54
diff changeset
   348
        //as is for the zoom step
hgs
parents: 54
diff changeset
   349
   }
hgs
parents: 54
diff changeset
   350
        
hgs
parents: 54
diff changeset
   351
    //same logic applied for Y axis
hgs
parents: 54
diff changeset
   352
    if( (mCurrentSize.height() <= mWindowSize.height())  )  {
hgs
parents: 54
diff changeset
   353
        //requires adjustment only in landscape orientation
hgs
parents: 54
diff changeset
   354
        if(mWindowSize.width() < mWindowSize.height())
hgs
parents: 54
diff changeset
   355
                   gestureCenter.setY(mWindowSize.height()/2);
hgs
parents: 54
diff changeset
   356
    }     
hgs
parents: 54
diff changeset
   357
    else  {
hgs
parents: 54
diff changeset
   358
            if(itemOriginPos.y() >= 0) {
hgs
parents: 54
diff changeset
   359
               gestureCenter.setY(itemOriginPos.y());    
50
hgs
parents: 45
diff changeset
   360
            }
58
hgs
parents: 54
diff changeset
   361
            else if(itemOriginPos.y()+ mCurrentSize.height() <= mWindowSize.height()){
hgs
parents: 54
diff changeset
   362
                gestureCenter.setY(itemOriginPos.y() + mCurrentSize.height());
43
hgs
parents:
diff changeset
   363
            }
hgs
parents:
diff changeset
   364
        }
58
hgs
parents: 54
diff changeset
   365
    
hgs
parents: 54
diff changeset
   366
    //special case for images that are smaller on both sides
hgs
parents: 54
diff changeset
   367
    //centering of the gesture is important to prevent movement of the image
hgs
parents: 54
diff changeset
   368
    //while zoom in or out
hgs
parents: 54
diff changeset
   369
    if( (mCurrentSize.height() <= mWindowSize.height()) && (mCurrentSize.width() <= mWindowSize.width()) ) {
hgs
parents: 54
diff changeset
   370
        gestureCenter.setX(mWindowSize.width()/2);
hgs
parents: 54
diff changeset
   371
        gestureCenter.setY(mWindowSize.height()/2);
43
hgs
parents:
diff changeset
   372
    }
58
hgs
parents: 54
diff changeset
   373
        
43
hgs
parents:
diff changeset
   374
    //reduce the ZF so as to show a decelerated effect at max/min levels
58
hgs
parents: 54
diff changeset
   375
/*
43
hgs
parents:
diff changeset
   376
    if(mCurrentSize.width() > mMaxScaleDecSize.width() && zoomFactor > 1 ) {
hgs
parents:
diff changeset
   377
        zoomFactor = 1.0 + ((zoomFactor-1.0)/6) ;
hgs
parents:
diff changeset
   378
    }
hgs
parents:
diff changeset
   379
        if(mCurrentSize.width() < mMinDecScaleSize.width() && zoomFactor < 1 ) {
hgs
parents:
diff changeset
   380
        zoomFactor = 1.0 - ((1.0-zoomFactor)/6) ;
hgs
parents:
diff changeset
   381
    }
58
hgs
parents: 54
diff changeset
   382
*/
43
hgs
parents:
diff changeset
   383
hgs
parents:
diff changeset
   384
}
hgs
parents:
diff changeset
   385
hgs
parents:
diff changeset
   386
//get the latest focused image and set it to mZoomItem
hgs
parents:
diff changeset
   387
void GlxZoomWidget::retreiveFocusedImage()
hgs
parents:
diff changeset
   388
{
hgs
parents:
diff changeset
   389
hgs
parents:
diff changeset
   390
    QPixmap targetPixmap(getFocusedImage());
hgs
parents:
diff changeset
   391
    //initialize all the variables wrt the focussed pixmap
hgs
parents:
diff changeset
   392
    mZoomWidget->resetTransform();
hgs
parents:
diff changeset
   393
    mItemSize = targetPixmap.size();
hgs
parents:
diff changeset
   394
    mMaxScaleSize = mItemSize;
hgs
parents:
diff changeset
   395
    mMaxScaleSize.scale(mWindowSize*13, Qt::KeepAspectRatio);
hgs
parents:
diff changeset
   396
    mMaxScaleDecSize = mItemSize;
hgs
parents:
diff changeset
   397
    mMaxScaleDecSize.scale(mWindowSize*7, Qt::KeepAspectRatio);
hgs
parents:
diff changeset
   398
    mMinScaleSize = mItemSize* 0.7;
hgs
parents:
diff changeset
   399
    mMinDecScaleSize = mItemSize;
hgs
parents:
diff changeset
   400
    QPointF originPos = sceneTransform().map(QPointF(0,0));
hgs
parents:
diff changeset
   401
    mZoomWidget->setGeometry(QRectF(QPointF(mWindowSize.width()/2 - mItemSize.width()/2,mWindowSize.height()/2 - mItemSize.height()/2),mItemSize )); //chk this
hgs
parents:
diff changeset
   402
    mZoomWidget->setPreferredSize(mItemSize);
hgs
parents:
diff changeset
   403
    mZoomItem->setPixmap(targetPixmap);
hgs
parents:
diff changeset
   404
    mCurrentSize = mItemSize;
hgs
parents:
diff changeset
   405
    mStepCurrentSize = mItemSize;
hgs
parents:
diff changeset
   406
    setContentWidget(mZoomWidget);
hgs
parents:
diff changeset
   407
    show();
hgs
parents:
diff changeset
   408
}
hgs
parents:
diff changeset
   409
hgs
parents:
diff changeset
   410
hgs
parents:
diff changeset
   411
void GlxZoomWidget::dataChanged(QModelIndex startIndex, QModelIndex endIndex)
hgs
parents:
diff changeset
   412
{
hgs
parents:
diff changeset
   413
    if(mFocusIndex >= startIndex.row() && mFocusIndex <= endIndex.row()) {
hgs
parents:
diff changeset
   414
        //get the latest image from the model
hgs
parents:
diff changeset
   415
        //will replace a decoded image if callback is received after decoded image is received so a fix is required
hgs
parents:
diff changeset
   416
        //retreiveFocusedImage();
hgs
parents:
diff changeset
   417
        if(!mDecodedImageAvailable)  {
hgs
parents:
diff changeset
   418
        QPixmap targetPixmap(getFocusedImage());
44
hgs
parents: 43
diff changeset
   419
        mItemSize = targetPixmap.size();
hgs
parents: 43
diff changeset
   420
        mMaxScaleSize = mItemSize;
hgs
parents: 43
diff changeset
   421
        mMaxScaleSize.scale(mWindowSize*13, Qt::KeepAspectRatio);
hgs
parents: 43
diff changeset
   422
        mMaxScaleDecSize = mItemSize;
hgs
parents: 43
diff changeset
   423
        mMaxScaleDecSize.scale(mWindowSize*7, Qt::KeepAspectRatio);
hgs
parents: 43
diff changeset
   424
        mMinScaleSize = mItemSize* 0.7;
hgs
parents: 43
diff changeset
   425
        mMinDecScaleSize = mItemSize;
58
hgs
parents: 54
diff changeset
   426
        mCurrentSize = mItemSize;
43
hgs
parents:
diff changeset
   427
        mZoomItem->setPixmap(targetPixmap);
hgs
parents:
diff changeset
   428
        finalizeWidgetTransform();
hgs
parents:
diff changeset
   429
        }
hgs
parents:
diff changeset
   430
    }
hgs
parents:
diff changeset
   431
}
hgs
parents:
diff changeset
   432
45
hgs
parents: 44
diff changeset
   433
void GlxZoomWidget::modelDestroyed()
hgs
parents: 44
diff changeset
   434
{
hgs
parents: 44
diff changeset
   435
    mModel = NULL ;    
hgs
parents: 44
diff changeset
   436
}
hgs
parents: 44
diff changeset
   437
hgs
parents: 44
diff changeset
   438
void GlxZoomWidget::indexChanged()
hgs
parents: 44
diff changeset
   439
    {
hgs
parents: 44
diff changeset
   440
    retreiveFocusedImage();
hgs
parents: 44
diff changeset
   441
    }
hgs
parents: 44
diff changeset
   442
43
hgs
parents:
diff changeset
   443
void GlxZoomWidget::decodedImageAvailable()
hgs
parents:
diff changeset
   444
{
hgs
parents:
diff changeset
   445
    //new bitmap with better resolution is available
hgs
parents:
diff changeset
   446
    //so set it to the item
hgs
parents:
diff changeset
   447
    QPixmap decodedPixmap = mImageDecoder->getPixmap();
hgs
parents:
diff changeset
   448
    disconnect(mImageDecoder, SIGNAL(pixmapDecoded()), this, SLOT(decodedImageAvailable()));
hgs
parents:
diff changeset
   449
    if(decodedPixmap.isNull()){
hgs
parents:
diff changeset
   450
        return;
hgs
parents:
diff changeset
   451
    }
hgs
parents:
diff changeset
   452
    mDecodedImageAvailable = true;
hgs
parents:
diff changeset
   453
    mZoomItem->setPixmap(decodedPixmap);
hgs
parents:
diff changeset
   454
    mItemSize = decodedPixmap.size();
hgs
parents:
diff changeset
   455
    //this is important if not done then old transforms will be applied on the new image
hgs
parents:
diff changeset
   456
    finalizeWidgetTransform();
hgs
parents:
diff changeset
   457
}
hgs
parents:
diff changeset
   458
hgs
parents:
diff changeset
   459
void GlxZoomWidget::sendDecodeRequest(int index)
hgs
parents:
diff changeset
   460
{
hgs
parents:
diff changeset
   461
    if(!mImageDecodeRequestSend) {
hgs
parents:
diff changeset
   462
        QString imagePath = (mModel->data(mModel->index(index,0),GlxUriRole)).value<QString>();
hgs
parents:
diff changeset
   463
        mImageDecoder->decodeImage(imagePath);
hgs
parents:
diff changeset
   464
        connect(mImageDecoder, SIGNAL(pixmapDecoded()), this, SLOT(decodedImageAvailable()));
hgs
parents:
diff changeset
   465
        mImageDecodeRequestSend = true;
hgs
parents:
diff changeset
   466
    }
hgs
parents:
diff changeset
   467
}
hgs
parents:
diff changeset
   468
hgs
parents:
diff changeset
   469
hgs
parents:
diff changeset
   470
void GlxZoomWidget::finalizeWidgetTransform()
hgs
parents:
diff changeset
   471
{
hgs
parents:
diff changeset
   472
    QPointF widgetPos = mZoomWidget->sceneTransform().map(QPointF(0,0)); //Map the origin wrt scene
hgs
parents:
diff changeset
   473
    mZoomWidget->resetTransform();
hgs
parents:
diff changeset
   474
    mZoomWidget->scale(mCurrentSize.width()/mItemSize.width(), mCurrentSize.height()/mItemSize.height());
hgs
parents:
diff changeset
   475
    mZoomWidget->setGeometry(QRectF(widgetPos , mCurrentSize));
hgs
parents:
diff changeset
   476
    // this updates HbScrollArea on the sizeHint of ZoomWidget
hgs
parents:
diff changeset
   477
    mZoomWidget->setPreferredSize(mCurrentSize);
hgs
parents:
diff changeset
   478
    mStepCurrentSize = mCurrentSize;
hgs
parents:
diff changeset
   479
}
hgs
parents:
diff changeset
   480
hgs
parents:
diff changeset
   481
QPixmap GlxZoomWidget::getFocusedImage()
hgs
parents:
diff changeset
   482
{
hgs
parents:
diff changeset
   483
    mFocusIndex = mModel->data(mModel->index(0,0),GlxFocusIndexRole).value<int>();
hgs
parents:
diff changeset
   484
    QVariant iconVariant = mModel->data(mModel->index(mFocusIndex,0),GlxFsImageRole);
hgs
parents:
diff changeset
   485
    QVariant sizeVariant = mModel->data(mModel->index(mFocusIndex,0),GlxDimensionsRole);
hgs
parents:
diff changeset
   486
    QPixmap targetPixmap;
hgs
parents:
diff changeset
   487
    //retreive pixmap from the HbIcon received from model
hgs
parents:
diff changeset
   488
    //should change the model to return and save pixmaps and convert to HbIcons Instead
hgs
parents:
diff changeset
   489
    if ( iconVariant.isValid() &&  iconVariant.canConvert<HbIcon> () ) {
hgs
parents:
diff changeset
   490
         QIcon itemIcon = iconVariant.value<HbIcon>().qicon();
hgs
parents:
diff changeset
   491
         QSize itemSize = itemIcon.actualSize(mWindowSize);
hgs
parents:
diff changeset
   492
         QSize scaleSize;
hgs
parents:
diff changeset
   493
         if(sizeVariant.isValid() &&  sizeVariant.canConvert<QSize> ()) {
hgs
parents:
diff changeset
   494
             scaleSize = sizeVariant.toSize();
hgs
parents:
diff changeset
   495
             if(!(scaleSize.width() < mWindowSize.width() && scaleSize.height() < mWindowSize.height()))  {
hgs
parents:
diff changeset
   496
                 scaleSize = mWindowSize;
hgs
parents:
diff changeset
   497
             }
hgs
parents:
diff changeset
   498
         }
hgs
parents:
diff changeset
   499
         targetPixmap = itemIcon.pixmap(itemSize).scaled(scaleSize, Qt::KeepAspectRatio);
hgs
parents:
diff changeset
   500
         mItemSize = targetPixmap.size();
hgs
parents:
diff changeset
   501
    }
hgs
parents:
diff changeset
   502
    return targetPixmap;
hgs
parents:
diff changeset
   503
hgs
parents:
diff changeset
   504
}
hgs
parents:
diff changeset
   505
50
hgs
parents: 45
diff changeset
   506
void GlxZoomWidget::setZoomParams()
hgs
parents: 45
diff changeset
   507
{
hgs
parents: 45
diff changeset
   508
    if (mModel)  {
hgs
parents: 45
diff changeset
   509
        QVariant sizeVariant = mModel->data(mModel->index(mFocusIndex,0),GlxDimensionsRole);
hgs
parents: 45
diff changeset
   510
        QSize fsSize;
hgs
parents: 45
diff changeset
   511
        if(sizeVariant.isValid() &&  sizeVariant.canConvert<QSize> ()) {
hgs
parents: 45
diff changeset
   512
            fsSize = sizeVariant.toSize();
hgs
parents: 45
diff changeset
   513
            if(!(fsSize.width() < mWindowSize.width() && fsSize.height() < mWindowSize.height()))  {
hgs
parents: 45
diff changeset
   514
                fsSize.scale( mWindowSize, Qt::KeepAspectRatio);
hgs
parents: 45
diff changeset
   515
            }
hgs
parents: 45
diff changeset
   516
            mMaxScaleSize = fsSize;
hgs
parents: 45
diff changeset
   517
            mMaxScaleSize.scale(mWindowSize*13, Qt::KeepAspectRatio);
hgs
parents: 45
diff changeset
   518
            mMaxScaleDecSize = fsSize;
hgs
parents: 45
diff changeset
   519
            mMaxScaleDecSize.scale(mWindowSize*7, Qt::KeepAspectRatio);
hgs
parents: 45
diff changeset
   520
            mMinScaleSize = fsSize* 0.7;
hgs
parents: 45
diff changeset
   521
            mMinDecScaleSize = fsSize;
hgs
parents: 45
diff changeset
   522
        }
hgs
parents: 45
diff changeset
   523
    }
43
hgs
parents:
diff changeset
   524
hgs
parents:
diff changeset
   525
50
hgs
parents: 45
diff changeset
   526
}
hgs
parents: 45
diff changeset
   527
43
hgs
parents:
diff changeset
   528
hgs
parents:
diff changeset
   529
hgs
parents:
diff changeset
   530
void GlxZoomWidget::animateZoomIn(QPointF animRefPoint)
hgs
parents:
diff changeset
   531
{
52
hgs
parents: 50
diff changeset
   532
    if (isFocussedItemCorrupt()){
hgs
parents: 50
diff changeset
   533
    return;
hgs
parents: 50
diff changeset
   534
    }
hgs
parents: 50
diff changeset
   535
    emit pinchGestureReceived(mFocusIndex);
hgs
parents: 50
diff changeset
   536
    //bring the zoom widget to foreground
hgs
parents: 50
diff changeset
   537
    mZoomOngoing = true;
hgs
parents: 50
diff changeset
   538
    setZValue(mMaxZValue);
hgs
parents: 50
diff changeset
   539
    //show the black background
hgs
parents: 50
diff changeset
   540
    mBlackBackgroundItem->setParentItem(parentItem());
hgs
parents: 50
diff changeset
   541
    mBlackBackgroundItem->setZValue(mMaxZValue - 1);
hgs
parents: 50
diff changeset
   542
    mBlackBackgroundItem->show();
hgs
parents: 50
diff changeset
   543
    m_AnimRefPoint = animRefPoint;
58
hgs
parents: 54
diff changeset
   544
    QSizeF requiredSize = mMinDecScaleSize;
54
hgs
parents: 52
diff changeset
   545
    //MAXDTZOOMIN size is set to 3.5 times window size
hgs
parents: 52
diff changeset
   546
    requiredSize.scale(mWindowSize*MAXDTZOOMIN, Qt::KeepAspectRatio);
44
hgs
parents: 43
diff changeset
   547
	m_FinalAnimatedScaleFactor = requiredSize.width()/mMinDecScaleSize.width();
54
hgs
parents: 52
diff changeset
   548
	//initiale variable for double tap animation
hgs
parents: 52
diff changeset
   549
    mIncSF = 1;
hgs
parents: 52
diff changeset
   550
    //preserve the size when zoom out was initiated, requried for calculates applicable/req scale factor
hgs
parents: 52
diff changeset
   551
    //SF has to always greater than 1 for upscaling, hence range for zoomout is [1,m_FinalAnimatedScaleFactor]
58
hgs
parents: 54
diff changeset
   552
    msfInc = (m_FinalAnimatedScaleFactor-1)/(NOOFSTEPSZI);
hgs
parents: 54
diff changeset
   553
    //preserve the size when zoom out was initiated, requried for calculates applicable/req scale factor
hgs
parents: 54
diff changeset
   554
    minitSize = mCurrentSize;
54
hgs
parents: 52
diff changeset
   555
    //set the no. of steps for double tap animation 
58
hgs
parents: 54
diff changeset
   556
    mdoubletapSteps = NOOFSTEPSZI;
54
hgs
parents: 52
diff changeset
   557
    animateDoubleTap();
43
hgs
parents:
diff changeset
   558
hgs
parents:
diff changeset
   559
}
hgs
parents:
diff changeset
   560
void GlxZoomWidget::animateZoomOut(QPointF animRefPoint)
hgs
parents:
diff changeset
   561
{
54
hgs
parents: 52
diff changeset
   562
    m_AnimRefPoint = animRefPoint;
hgs
parents: 52
diff changeset
   563
    //Zoom out to FS (mMinDecScaleSize) from the currentsize
hgs
parents: 52
diff changeset
   564
    m_FinalAnimatedScaleFactor = mMinDecScaleSize.width()/mCurrentSize.width();
hgs
parents: 52
diff changeset
   565
    //initiale variable for double tap animation
hgs
parents: 52
diff changeset
   566
    mIncSF = 1;
hgs
parents: 52
diff changeset
   567
    //calculate the step increment SF for each step
58
hgs
parents: 54
diff changeset
   568
    msfInc = (1 - m_FinalAnimatedScaleFactor)/(NOOFSTEPSZO);
54
hgs
parents: 52
diff changeset
   569
    //preserve the size when zoom out was initiated, requried for calculates applicable/req scale factor
58
hgs
parents: 54
diff changeset
   570
    minitSize = mCurrentSize;
54
hgs
parents: 52
diff changeset
   571
    //set the no. of steps for double tap animation 
hgs
parents: 52
diff changeset
   572
    //AA:: the no.of steps are kept the same for zoomin/zoomout, however tweaking them can be considered
58
hgs
parents: 54
diff changeset
   573
    mdoubletapSteps = NOOFSTEPSZO;
54
hgs
parents: 52
diff changeset
   574
    animateDoubleTap();
hgs
parents: 52
diff changeset
   575
    //AA
hgs
parents: 52
diff changeset
   576
   
43
hgs
parents:
diff changeset
   577
}
54
hgs
parents: 52
diff changeset
   578
43
hgs
parents:
diff changeset
   579
54
hgs
parents: 52
diff changeset
   580
void GlxZoomWidget::animateDoubleTap()
hgs
parents: 52
diff changeset
   581
    {
hgs
parents: 52
diff changeset
   582
    //calculate increamental scale factor based on the step and then calculate the applicable scale factor this step
hgs
parents: 52
diff changeset
   583
    //increamental SF works on the ImageSize when double tap started, applicable(required) SF calculates the delate SF
hgs
parents: 52
diff changeset
   584
    if(m_FinalAnimatedScaleFactor > 1) {
hgs
parents: 52
diff changeset
   585
        //AA::zoomin case
hgs
parents: 52
diff changeset
   586
        mIncSF += msfInc;
58
hgs
parents: 54
diff changeset
   587
        qreal reqSF = (minitSize.width()*(mIncSF))/mCurrentSize.width();
54
hgs
parents: 52
diff changeset
   588
        zoomImage(reqSF, m_AnimRefPoint);
hgs
parents: 52
diff changeset
   589
        }
hgs
parents: 52
diff changeset
   590
    if(m_FinalAnimatedScaleFactor < 1) {
hgs
parents: 52
diff changeset
   591
        //AA::zoomout case
hgs
parents: 52
diff changeset
   592
        mIncSF -= msfInc;
58
hgs
parents: 54
diff changeset
   593
        qreal reqSF = (minitSize.width()* mIncSF)/mCurrentSize.width();
54
hgs
parents: 52
diff changeset
   594
        zoomImage(reqSF, m_AnimRefPoint);
hgs
parents: 52
diff changeset
   595
        }   
hgs
parents: 52
diff changeset
   596
    //check if all steps are done,if not emit signal to continue the animation
58
hgs
parents: 54
diff changeset
   597
    if(mdoubletapSteps > 1 ){
54
hgs
parents: 52
diff changeset
   598
        mdoubletapSteps -= 1;
hgs
parents: 52
diff changeset
   599
        emit stepZoom();    
hgs
parents: 52
diff changeset
   600
        }
hgs
parents: 52
diff changeset
   601
    else {
hgs
parents: 52
diff changeset
   602
        //animation is complete, finalize the widget transform using setgeometry
hgs
parents: 52
diff changeset
   603
        //reset the counter
hgs
parents: 52
diff changeset
   604
        mdoubletapSteps = 0;
hgs
parents: 52
diff changeset
   605
        animationTimeLineFinished();
hgs
parents: 52
diff changeset
   606
        }
hgs
parents: 52
diff changeset
   607
        
hgs
parents: 52
diff changeset
   608
    }
43
hgs
parents:
diff changeset
   609
void GlxZoomWidget::animationTimeLineFinished()
hgs
parents:
diff changeset
   610
{
hgs
parents:
diff changeset
   611
	finalizeWidgetTransform();
hgs
parents:
diff changeset
   612
//push the Zoom widget to background when zoomed image size nears FS image
hgs
parents:
diff changeset
   613
           if(mStepCurrentSize.width() <= mMinDecScaleSize.width()*1.3)  {
hgs
parents:
diff changeset
   614
               mBlackBackgroundItem->hide();
hgs
parents:
diff changeset
   615
               //push the widget back to background
hgs
parents:
diff changeset
   616
               setZValue(mMinZValue);
50
hgs
parents: 45
diff changeset
   617
               mZoomOngoing = false;
43
hgs
parents:
diff changeset
   618
               emit zoomWidgetMovedBackground(mFocusIndex);
hgs
parents:
diff changeset
   619
               //do not reset the transform here as it will then zoom-in the widget to decoded image size
hgs
parents:
diff changeset
   620
           }
hgs
parents:
diff changeset
   621
}
hgs
parents:
diff changeset
   622
44
hgs
parents: 43
diff changeset
   623
hgs
parents: 43
diff changeset
   624
void GlxZoomWidget::timerEvent(QTimerEvent *event)
hgs
parents: 43
diff changeset
   625
{
hgs
parents: 43
diff changeset
   626
    if(mTimerId == event->timerId())
hgs
parents: 43
diff changeset
   627
    {
hgs
parents: 43
diff changeset
   628
        killTimer(mTimerId);
hgs
parents: 43
diff changeset
   629
        mTimerId = 0;
hgs
parents: 43
diff changeset
   630
    }
58
hgs
parents: 54
diff changeset
   631
    else {
hgs
parents: 54
diff changeset
   632
        HbScrollArea::timerEvent( event );
hgs
parents: 54
diff changeset
   633
    }
44
hgs
parents: 43
diff changeset
   634
}
52
hgs
parents: 50
diff changeset
   635
hgs
parents: 50
diff changeset
   636
bool GlxZoomWidget::isFocussedItemCorrupt()
hgs
parents: 50
diff changeset
   637
{
hgs
parents: 50
diff changeset
   638
    QVariant variant = mModel->data( mModel->index( mFocusIndex, 0 ), GlxImageCorruptRole );
hgs
parents: 50
diff changeset
   639
    if ( variant.isValid() && variant.canConvert< bool> () ) {
hgs
parents: 50
diff changeset
   640
        return variant.value< bool > () ;
hgs
parents: 50
diff changeset
   641
    }
hgs
parents: 50
diff changeset
   642
    return false ;    
hgs
parents: 50
diff changeset
   643
}
hgs
parents: 50
diff changeset
   644