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