1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 #include <QDebug>

    19 #include <QImage>

    20 #include <QPainter>

    21 #include <QResizeEvent>

    22 #include <QTimeLine>

    23 #include <QGraphicsSceneResizeEvent>

    24 #include <QGraphicsSceneMouseEvent>

    25 #include <QGraphicsSceneMoveEvent>

    26 #include <QGraphicsDropShadowEffect>

    27 #include "linearflowsnippet.h"

    28 

    29 #define SAFE_DELETE(p) if(p) delete p;

    30 

    31 #define SNIPPET_AUTOHIDE_TIMEOUT 5000 //5secs

    32 

    33 #define CALL_ON_PREV_PREV_FILM_STRIP(func) if (d->m_centerIndex - 2 >= 0) d->m_films[d->m_centerIndex - 2]->func; else if(d->m_centerIndex == 1) d->m_films[d->m_films.size() - 1]->func; else d->m_films[d->m_films.size() - 2]->func;

    34 #define CALL_ON_CENTER_FILM_STRIP(func) if (d->m_centerIndex >= 0 && d->m_centerIndex < d->m_films.size()) d->m_films[d->m_centerIndex]->func; else if(d->m_centerIndex < 0) d->m_films[d->m_films.size() + d->m_centerIndex]->func; else d->m_films[(d->m_centerIndex)%d->m_films.size()]->func; 

    35 #define CALL_ON_PREV_PREV_PREV_FILM_STRIP(func) if (d->m_centerIndex - 3 >= 0) d->m_films[d->m_centerIndex - 3]->func; else if(d->m_centerIndex == 1) d->m_films[d->m_films.size() - 2]->func; else if(d->m_centerIndex == 2) d->m_films[d->m_films.size() - 1]->func; else d->m_films[d->m_films.size() - 3]->func;

    36 #define CALL_ON_NEXT_NEXT_NEXT_FILM_STRIP(func) if (d->m_centerIndex + 3 < d->m_films.size()) d->m_films[d->m_centerIndex + 3]->func; else d->m_films[(d->m_centerIndex + 3)%d->m_films.size()]->func; 

    37 #define CALL_ON_NEXT_NEXT_FILM_STRIP(func) if (d->m_centerIndex + 2 < d->m_films.size()) d->m_films[d->m_centerIndex + 2]->func; else d->m_films[(d->m_centerIndex + 2)%d->m_films.size()]->func; 

    38 #define CALL_ON_PREV_FILM_STRIP(func) if (d->m_centerIndex - 1 >= 0) d->m_films[d->m_centerIndex - 1]->func; else d->m_films[d->m_films.size() - 1]->func;

    39 #define CALL_ON_NEXT_FILM_STRIP(func) if (d->m_centerIndex + 1 < d->m_films.size()) d->m_films[d->m_centerIndex + 1]->func; else d->m_films[(d->m_centerIndex + 1)%d->m_films.size()]->func; 

    40 

    41 

    42 #define INVALID_INDEX -1

    43 

    44 #define L_CENTER_WIDTH_P_C 0.27

    45 #define L_CENTER_HEIGHT_P_C 0.70

    46 #define L_SIDE_WIDTH_P_C 0.27

    47 #define L_SIDE_HEIGHT_P_C 0.70

    48 

    49 #define L_CENTER_TOP_SPACE_P_C 0.15

    50 #define L_SIDE_TOP_SPACE_P_C 0.15

    51 

    52 #define L_SPACE_P_C 0.05

    53 

    54 #define SPACE_P_C 0.11

    55 #define CLOSE_ICON_ADJUST_SIZE 5

    56 #define TITLE_SPACE 10

    57 #define FRAME_WIDTH 4

    58 

    59 #define ANIMATION_DURATION 300

    60 #define ANIMATION_MAX_FRAME 20.0

    61 #define NEW_FILM_TITLE ""

    62 

    63 #define WIDTH 360

    64 #define TITLE_HEIGHT 0.15

    65 #define FILM_HEIGHT 0.85

    66 #define P_MAX_SLIDE 3

    67 #define L_MAX_SLIDE 5

    68 #define MAX_FLICK_SPEED 500

    69 #define THRESHOLD_FLICK_SPEED 400

    70 #define THRESHOLD_FLICK_TIME 75

    71 

    72 namespace GVA {

    73 

    74 // movies (animation) name

    75 const QString BreakinLeft   = "bil";//"breakin - left";

    76 const QString BreakinRight  = "bir";//"breakin - right";

    77 const QString BreakoutLeft  = "bol";//"breakout - left";

    78 const QString BreakoutRight = "bor";//"breakout - right";

    79 

    80 const QString BreakinLeftLeft = "bill";//"breakin - leftleft"

    81 const QString BreakinRightRight = "birr";//"breakin - rightright"

    82 const QString BreakoutLeftLeft = "boll";//"breakout - leftleft"

    83 const QString BreakoutRightRight = "borr";//"breakout rightright"

    84 

    85 const QString RightToCenter = "rc";//"right - center";

    86 const QString LeftToCenter  = "lc";//"left - center";

    87 const QString CenterToRight = "cr";//"center - right";

    88 const QString CenterToLeft  = "cl";//"center - left";

    89 

    90 const QString LeftLeftToLeft = "lltl"; //"leftLft - left"

    91 const QString LeftToLeftLeft = "ltll";//left - leftleft"

    92 const QString RightToRightRight = "rtrr";//"right - rightright"

    93 const QString RightRightToRight = "rrtr";//"rightright - right"

    94 

    95 const QString FadeOut       = "fo";//"fadeout";

    96 const QString ZoomIn        = "zi";//"zoomin";

    97 const QString ZoomOut       = "zo";//"zoomto";

    98 // -------------------------------------------------------

    99 // Help functions

   100 

   101 //static QImage* createFilmstrip(const QImage& img, QSize

   102 

   103 // -------------------------------------------------------

   104 // Help classes

   105 class FilmstripMovieFactory;

   106 

   107 class FilmstripMovie

   108 {

   109 friend class FilmstripMovieFactory;

   110 

   111 public:

   112 

   113 enum MovieType

   114 {

   115 FADE_IN,

   116 FADE_OUT,

   117 TRANSLATE

   118 };

   119 

   120 public:

   121     FilmstripMovie(const QString& name) { m_name = name; m_movieType = TRANSLATE;}

   122     ~FilmstripMovie() {m_movieClips.clear();}

   123     QRectF& movieClip(int frame);

   124 

   125 public:

   126     MovieType m_movieType;

   127 

   128 private:

   129     QString m_name;

   130     QList<QRectF> m_movieClips;

   131 };

   132 

   133 class FilmstripMovieFactory

   134 {

   135 public:

   136     FilmstripMovieFactory(FilmstripFlowPrivate* filmstripFlowData = NULL): m_filmstripFlowData(filmstripFlowData) {}

   137     ~FilmstripMovieFactory();

   138 

   139     FilmstripMovie* createMovie(const QString& name);

   140 

   141     void updateAllMovie();

   142     void setFilmstripFlowData(FilmstripFlowPrivate* filmstripFlowData) { m_filmstripFlowData = filmstripFlowData; }

   143 

   144 protected:

   145     void addRectByFrame(FilmstripMovie* movie, QRectF& startRect, QRectF& endRect, qreal x1, qreal y1, qreal x2, qreal y2, bool debug = false);

   146     void createRightOutMovie(FilmstripMovie* movie);

   147     void createRightInMovie(FilmstripMovie* movie);

   148     void createLeftInMovie(FilmstripMovie* movie);

   149     void createLeftOutMovie(FilmstripMovie* movie);

   150     void createRightToCenterMovie(FilmstripMovie* movie);

   151     void createLeftToCenterMovie(FilmstripMovie* movie);

   152     void createCenterToLeftMovie(FilmstripMovie* movie);

   153     void createCenterToRightMovie(FilmstripMovie* movie);

   154     void createFadeOutMovie(FilmstripMovie* movie);

   155     void createZoomInMovie(FilmstripMovie* movie);

   156     void createZoomOutMovie(FilmstripMovie* movie);

   157     void createLeftLeftInMovie(FilmstripMovie* movie);

   158     void createRightRightInMovie(FilmstripMovie* movie);

   159     void createLeftLeftOutMovie(FilmstripMovie* movie);

   160     void createRightRightOutMovie(FilmstripMovie* movie);

   161     void createLeftLeftToLeftMovie(FilmstripMovie* movie);

   162     void createLeftToLeftLeftMovie(FilmstripMovie* movie);

   163     void createRightToRightRightMovie(FilmstripMovie* movie);

   164     void createRightRightToRightMovie(FilmstripMovie* movie);

   165 

   166 private:

   167     FilmstripFlowPrivate* m_filmstripFlowData;

   168     QHash<QString, FilmstripMovie*> m_moviesCache;

   169 };

   170 

   171 class Filmstrip

   172 {

   173 public:

   174     Filmstrip(const QImage& img, FilmstripFlowPrivate* filmstripFlowData): m_img(img), m_frozen(false), m_movieFrame(0), m_movie(NULL), m_filmstripFlowData(filmstripFlowData) {}

   175     ~Filmstrip() {}

   176 

   177     void paint(QPainter* painter);

   178     void paintName(QPainter* painter);

   179 

   180     void freeze() {m_frozen = true;}

   181     void updateMovie(FilmstripMovie* movie) {m_movie = movie; m_movieFrame = 0; m_frozen = false;}

   182     void updateMovieFrame(int frame) { if(!m_frozen) m_movieFrame = frame;}

   183     void setName(const QString& name) {m_name = name;}

   184     QImage& image() {return m_img;}

   185     QString& name() {return m_name;}

   186 private:

   187     void createEmptyImage();

   188 

   189 public:

   190     QImage m_img;

   191     bool m_frozen;

   192     int m_movieFrame;

   193     QString m_name;

   194     FilmstripMovie* m_movie;

   195     FilmstripFlowPrivate* m_filmstripFlowData;

   196 };

   197 

   198 class FilmstripFlowPrivate

   199 {

   200 public:

   201     FilmstripFlowPrivate(): m_bgColor(QColor(99,105,115).rgb()), m_buffer(NULL), m_titleBuffer(NULL),m_closeIcon(NULL), m_centerTopSpace(0), m_sideTopSpace(0), m_space(0), m_incIndex(0), m_centerIndex(INVALID_INDEX) {}

   202 

   203     ~FilmstripFlowPrivate() {

   204         for (int i = 0; i < m_films.size(); i++)

   205             SAFE_DELETE(m_films[i]);

   206         m_films.clear();

   207         SAFE_DELETE(m_buffer);

   208         SAFE_DELETE(m_titleBuffer);

   209         SAFE_DELETE(m_closeIcon);

   210     }

   211 

   212     void clear() {

   213         m_centerIndex = INVALID_INDEX;

   214         for (int i = 0; i < m_films.size(); i++)

   215             SAFE_DELETE(m_films[i]);

   216         m_films.clear();

   217     }

   218 

   219 public:

   220     QRgb m_bgColor;

   221     QImage* m_buffer;

   222     QImage *m_titleBuffer;

   223     QImage* m_closeIcon;

   224     QList<Filmstrip*> m_films;

   225     QSize m_centerWindowSize;

   226     QSize m_sideWindowSize;

   227     QSize m_widgetSize;

   228     qreal m_centerTopSpace;

   229     qreal m_sideTopSpace;

   230     qreal m_space;

   231     QTimeLine m_movieTimer;

   232     FilmstripMovieFactory m_movieFactory;

   233     QPoint m_closeIconPos;

   234     QPoint m_lastMoveEventPos;

   235     int m_incIndex;

   236     int m_centerIndex;

   237 };

   238 

   239 // -------------------------------------------------------

   240 // Filmstrip

   241 void Filmstrip::createEmptyImage()

   242 {

   243     QRectF target = m_movie->movieClip(0);

   244     int w = target.width();

   245     int h = target.height();

   246     m_name = NEW_FILM_TITLE;

   247     m_img = QImage(w, h, QImage::Format_RGB32);

   248 

   249     QPainter painter(&m_img);

   250     painter.fillRect(0, 0, w, h, Qt::white);

   251     painter.end();

   252 }

   253 

   254 void Filmstrip::paint(QPainter* painter)

   255 {

   256     Q_ASSERT(painter);

   257 

   258     if (!m_movie)

   259         return;

   260     

   261     QRectF target;

   262 

   263     bool needFade = (m_movie->m_movieType == FilmstripMovie::FADE_OUT);

   264     if (needFade) // FIXME: no fade out support now

   265         target = m_movie->movieClip(0);

   266     else

   267         target = m_movie->movieClip(m_movieFrame);

   268     

   269     if(target.right() > 0 || target.left() < m_filmstripFlowData->m_widgetSize.width()) {

   270         if (needFade)

   271             painter->setOpacity((ANIMATION_MAX_FRAME - m_movieFrame) / ANIMATION_MAX_FRAME);

   272 

   273         painter->fillRect(target.adjusted(-FRAME_WIDTH,-FRAME_WIDTH,FRAME_WIDTH,FRAME_WIDTH), QColor(Qt::gray));

   274         

   275         if(!m_img.isNull())

   276             painter->drawImage(target, m_img);

   277     

   278         else {

   279             painter->save();

   280             painter->setPen(QColor(Qt::black));

   281             painter->setFont(QFont("Arial", 4));

   282             painter->drawText(target, Qt::AlignVCenter,m_name);

   283             painter->restore();

   284         }

   285 

   286         if (needFade) 

   287             painter->setOpacity(1); // restore opacity 

   288     }

   289 }

   290 

   291 void Filmstrip::paintName(QPainter* painter)

   292 {

   293     Q_ASSERT(painter);

   294     if (!m_name.isEmpty()) {

   295         QPoint startPoint;

   296         QString name = m_name;

   297         QFontMetrics fm = painter->fontMetrics();

   298         int pixelWidth = fm.width(name);

   299         int filmstripWidth = m_filmstripFlowData->m_centerWindowSize.width();

   300         if (pixelWidth > filmstripWidth) {

   301             qreal letterWidth = pixelWidth / (qreal)name.size();

   302             name = name.leftJustified(filmstripWidth / letterWidth - 3, '.', true) + "...";

   303             startPoint = QPoint((m_filmstripFlowData->m_widgetSize.width() - filmstripWidth) /2, m_filmstripFlowData->m_centerTopSpace - TITLE_SPACE);

   304         }

   305         else

   306             startPoint = QPoint((m_filmstripFlowData->m_widgetSize.width() - pixelWidth) /2, m_filmstripFlowData->m_centerTopSpace - TITLE_SPACE);

   307 

   308         painter->save();

   309         painter->setPen(QColor(Qt::black));

   310         painter->drawText(startPoint, name);

   311         painter->restore();

   312     }

   313 }

   314 

   315 // -------------------------------------------------------

   316 // FilmstripMovie

   317 QRectF& FilmstripMovie::movieClip(int frame)

   318 {

   319     Q_ASSERT(frame >= 0 && frame < m_movieClips.size());

   320     return m_movieClips[frame];

   321 }

   322 

   323 // -------------------------------------------------------

   324 // FilmstripMovieFactory

   325 FilmstripMovieFactory::~FilmstripMovieFactory() 

   326 {

   327     QHashIterator<QString, FilmstripMovie*> i(m_moviesCache);

   328     while (i.hasNext()) {

   329         i.next();

   330         delete i.value();

   331     }

   332     m_moviesCache.clear();

   333 }

   334 

   335 FilmstripMovie* FilmstripMovieFactory::createMovie(const QString& name)

   336 {

   337     FilmstripMovie* movie = NULL;

   338     QHash<QString, FilmstripMovie*>::const_iterator i = m_moviesCache.find(name);

   339     if (i == m_moviesCache.end()) {

   340         //qDebug() << "create a new movie: " << name;

   341         movie = new FilmstripMovie(name);

   342 

   343         if (name == BreakoutRight)

   344             createRightOutMovie(movie);

   345         else if (name == BreakoutLeft)

   346             createLeftOutMovie(movie);

   347         else if (name == BreakinLeft)

   348             createLeftInMovie(movie);

   349         else if (name == BreakinRight)

   350             createRightInMovie(movie);

   351         else if (name == CenterToRight)

   352             createCenterToRightMovie(movie);

   353         else if (name == CenterToLeft)

   354             createCenterToLeftMovie(movie);

   355         else if (name == RightToCenter)

   356             createRightToCenterMovie(movie);

   357         else if (name == LeftToCenter)

   358             createLeftToCenterMovie(movie);

   359         else if (name == FadeOut)

   360             createFadeOutMovie(movie);

   361         else if (name == ZoomIn)

   362             createZoomInMovie(movie);

   363         else if (name == ZoomOut)

   364             createZoomOutMovie(movie);

   365         else if (name == BreakinLeftLeft)

   366             createLeftLeftInMovie(movie);

   367         else if (name == BreakinRightRight)

   368             createRightRightInMovie(movie);

   369         else if (name == BreakoutLeftLeft)

   370             createLeftLeftOutMovie(movie);

   371         else if (name == BreakoutRightRight)    

   372             createRightRightOutMovie(movie);

   373         else if (name == LeftLeftToLeft)

   374             createLeftLeftToLeftMovie(movie);

   375         else if (name == LeftToLeftLeft)

   376             createLeftToLeftLeftMovie(movie);

   377         else if (name == RightToRightRight)

   378             createRightToRightRightMovie(movie);

   379         else if(name == RightRightToRight)

   380             createRightRightToRightMovie(movie);

   381 

   382         m_moviesCache[name] = movie;

   383     } else {

   384         movie =  m_moviesCache.value(name);

   385     }

   386     return movie;

   387 }

   388 

   389 void FilmstripMovieFactory::createLeftLeftInMovie(FilmstripMovie* movie) 

   390 {

   391     movie->m_movieClips.clear();

   392     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   393     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   394     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   395     int w = m_filmstripFlowData->m_widgetSize.width();

   396     int h = m_filmstripFlowData->m_widgetSize.height();

   397 

   398     qreal cx = ((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0 - sw + m_filmstripFlowData->m_space; 

   399     qreal sx = ((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0 - 2 * sw; 

   400     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   401     qreal stepx = (cx - sx) / ANIMATION_MAX_FRAME;

   402 

   403     QRectF startRect = QRectF( 2 *  sx - cx , sy, sw, sh);

   404     QRectF endRect = QRectF(sx, sy, sw, sh);

   405 

   406     addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

   407 }

   408 

   409 void FilmstripMovieFactory::createRightRightInMovie(FilmstripMovie* movie)

   410 {

   411     movie->m_movieClips.clear();

   412     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   413     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   414     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   415     int w = m_filmstripFlowData->m_widgetSize.width();

   416     int h = m_filmstripFlowData->m_widgetSize.height();

   417 

   418     qreal cx = (w + 4 * m_filmstripFlowData->m_space + cw) / 2.0 - m_filmstripFlowData->m_space;

   419     qreal sx = ((w + 4 * m_filmstripFlowData->m_space + cw) / 2.0) + sw ; 

   420     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   421     qreal stepx = (cx - sx) / ANIMATION_MAX_FRAME;

   422 

   423     QRectF startRect = QRectF(2 * sx - cx, sy, sw, sh);

   424     QRectF endRect = QRectF(sx , sy, sw, sh);

   425 

   426     addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

   427 }

   428 

   429 void FilmstripMovieFactory::createLeftLeftOutMovie(FilmstripMovie* movie)

   430 {

   431     movie->m_movieClips.clear();

   432     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   433     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   434     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   435     int w = m_filmstripFlowData->m_widgetSize.width();

   436     int h = m_filmstripFlowData->m_widgetSize.height();

   437 

   438     qreal cx = ((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0 - sw + m_filmstripFlowData->m_space; 

   439     qreal sx = (((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0) - (2 *sw); 

   440     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   441     qreal stepx = (sx -cx) / ANIMATION_MAX_FRAME;

   442 

   443     QRectF startRect = QRectF(sx, sy, sw, sh);

   444     QRectF endRect = QRectF(2 * sx - cx , sy, sw, sh);

   445 

   446     addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

   447 }

   448 

   449 void FilmstripMovieFactory::createRightRightOutMovie(FilmstripMovie* movie)

   450 {

   451     movie->m_movieClips.clear();

   452     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   453     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   454     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   455     int w = m_filmstripFlowData->m_widgetSize.width();

   456     int h = m_filmstripFlowData->m_widgetSize.height();

   457 

   458     qreal cx = (w + 4 * m_filmstripFlowData->m_space + cw) / 2.0 - m_filmstripFlowData->m_space;

   459     qreal sx = ((w + 4 * m_filmstripFlowData->m_space + cw) / 2.0) + sw ; 

   460     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   461     qreal stepx = (sx - cx) / ANIMATION_MAX_FRAME;

   462 

   463     QRectF startRect = QRectF(sx, sy, sw, sh);

   464     QRectF endRect = QRectF(2 * sx - cx, sy, sw, sh);

   465     addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

   466 }

   467 

   468 void FilmstripMovieFactory::createLeftLeftToLeftMovie(FilmstripMovie* movie)

   469 {

   470     movie->m_movieClips.clear();

   471     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   472     int ch = m_filmstripFlowData->m_centerWindowSize.height();

   473     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   474     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   475     int w = m_filmstripFlowData->m_widgetSize.width();

   476     int h = m_filmstripFlowData->m_widgetSize.height();

   477 

   478     qreal step = ANIMATION_MAX_FRAME;

   479     qreal cx = ((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0 - sw + m_filmstripFlowData->m_space; 

   480     qreal cy = m_filmstripFlowData->m_centerTopSpace;

   481     qreal sx = (((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0) - (2 *sw); 

   482     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   483     qreal stepx = (cx - sx) / step;

   484     qreal stepy = (cy - sy) / step;

   485     qreal stepx2 = stepx + (cw - sw) / step;

   486     qreal stepy2 = stepy + (ch - sh) / step;

   487  

   488     QRectF startRect = QRectF(sx, sy, sw, sh);

   489     QRectF endRect = QRectF(cx, cy, cw, ch);

   490 

   491     addRectByFrame(movie, startRect, endRect, stepx, stepy, stepx2, stepy2);

   492 }

   493 

   494 void FilmstripMovieFactory::createLeftToLeftLeftMovie(FilmstripMovie* movie)

   495 {

   496     movie->m_movieClips.clear();

   497     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   498     int ch = m_filmstripFlowData->m_centerWindowSize.height();

   499     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   500     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   501     int w = m_filmstripFlowData->m_widgetSize.width();

   502     int h = m_filmstripFlowData->m_widgetSize.height();

   503 

   504     qreal step = ANIMATION_MAX_FRAME;

   505     qreal cx = ((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0 - sw + m_filmstripFlowData->m_space; 

   506     qreal cy = m_filmstripFlowData->m_centerTopSpace;

   507     qreal sx = (((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0) - (2 *sw); 

   508     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   509     qreal stepx = (sx - cx) / step;

   510     qreal stepy = (sy - cy) / step;

   511     qreal stepx2 = stepx + (sw - cw) / step;

   512     qreal stepy2 = stepy + (sh - ch) / step;

   513  

   514     QRectF startRect = QRectF(cx, cy, cw, ch);

   515     QRectF endRect = QRectF(sx, sy, sw, sh);

   516     addRectByFrame(movie, startRect, endRect, stepx, stepy, stepx2, stepy2);

   517 }

   518 

   519 void FilmstripMovieFactory::createRightToRightRightMovie(FilmstripMovie* movie)

   520 {

   521     movie->m_movieClips.clear();

   522     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   523     int ch = m_filmstripFlowData->m_centerWindowSize.height();

   524     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   525     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   526     int w = m_filmstripFlowData->m_widgetSize.width();

   527     int h = m_filmstripFlowData->m_widgetSize.height();

   528 

   529     qreal step = ANIMATION_MAX_FRAME;

   530     qreal cx = (w + 4 * m_filmstripFlowData->m_space + cw) / 2.0 - m_filmstripFlowData->m_space;

   531     qreal cy = m_filmstripFlowData->m_centerTopSpace;

   532     qreal sx = (((w + 4 * m_filmstripFlowData->m_space) + cw) / 2.0) + sw; 

   533     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   534     qreal stepx = (sx - cx) / step;

   535     qreal stepy = (sy - cy) / step;

   536     qreal stepx2 = stepx + (sw - cw) / step;

   537     qreal stepy2 = stepy + (sh - ch) / step;

   538   

   539     QRectF startRect = QRectF(cx, cy, cw, ch);

   540     QRectF endRect = QRectF(sx, sy, sw, sh);

   541     addRectByFrame(movie, startRect, endRect, stepx, stepy, stepx2, stepy2);

   542    

   543 }

   544 

   545 void FilmstripMovieFactory::createRightRightToRightMovie(FilmstripMovie* movie)

   546 {

   547     movie->m_movieClips.clear();

   548     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   549     int ch = m_filmstripFlowData->m_centerWindowSize.height();

   550     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   551     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   552     int w = m_filmstripFlowData->m_widgetSize.width();

   553     int h = m_filmstripFlowData->m_widgetSize.height();

   554 

   555     qreal step = ANIMATION_MAX_FRAME;

   556     qreal cx = (w + 4 * m_filmstripFlowData->m_space + cw) / 2.0 - m_filmstripFlowData->m_space;

   557     qreal cy = m_filmstripFlowData->m_centerTopSpace;

   558     qreal sx = ((w + 4 * m_filmstripFlowData->m_space) + cw) / 2.0 + sw; 

   559     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   560     qreal stepx = (cx - sx) / step;

   561     qreal stepy = (cy - sy) / step;

   562     qreal stepx2 = stepx + (cw - sw) / step;

   563     qreal stepy2 = stepy + (ch - sh) / step;

   564  

   565     QRectF startRect = QRectF(sx, sy, sw, sh);

   566     QRectF endRect = QRectF(cx, cy, cw, ch);

   567 

   568     addRectByFrame(movie, startRect, endRect, stepx, stepy, stepx2, stepy2);

   569 }

   570 

   571 

   572 void FilmstripMovieFactory::addRectByFrame(FilmstripMovie* movie, QRectF& startRect, QRectF& endRect, qreal x1, qreal y1, qreal x2, qreal y2, bool debug)

   573 {

   574     movie->m_movieClips.append(startRect);

   575     if (debug)

   576         qDebug() << "0:" << startRect;

   577     for (int i = 1; i < ANIMATION_MAX_FRAME; i++) {

   578         if (debug)

   579             qDebug() << i << ":" << movie->m_movieClips[i - 1].adjusted(x1, y1, x2, y2);

   580         movie->m_movieClips.append(movie->m_movieClips[i - 1].adjusted(x1, y1, x2, y2));

   581     }

   582     movie->m_movieClips.append(endRect);

   583     if (debug)

   584         qDebug() << movie->m_movieClips.size() - 1 << ":"  << endRect;

   585 }

   586 

   587 void FilmstripMovieFactory::createLeftToCenterMovie(FilmstripMovie* movie)

   588 {

   589     movie->m_movieClips.clear();

   590     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   591     int ch = m_filmstripFlowData->m_centerWindowSize.height();

   592     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   593     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   594     int w = m_filmstripFlowData->m_widgetSize.width();

   595     int h = m_filmstripFlowData->m_widgetSize.height();

   596 

   597     qreal step = ANIMATION_MAX_FRAME;

   598     qreal cx = (w - cw) / 2.0;

   599     qreal cy = m_filmstripFlowData->m_centerTopSpace;

   600     qreal sx = (((w  - 4 * m_filmstripFlowData->m_space) - cw) / 2.0) - sw + m_filmstripFlowData->m_space;

   601     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   602     qreal stepx = (cx - sx) / step;

   603     qreal stepy = (cy - sy) / step;

   604     qreal stepx2 = stepx + (cw - sw) / step;

   605     qreal stepy2 = stepy + (ch - sh) / step;

   606 

   607     QRectF startRect = QRectF(sx, sy, sw, sh);

   608     QRectF endRect = QRectF(cx, cy, cw, ch);

   609 

   610     addRectByFrame(movie, startRect, endRect, stepx, stepy, stepx2, stepy2);

   611 }

   612 

   613 void FilmstripMovieFactory::createRightToCenterMovie(FilmstripMovie* movie)

   614 {

   615     movie->m_movieClips.clear();

   616     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   617     int ch = m_filmstripFlowData->m_centerWindowSize.height();

   618     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   619     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   620     int w = m_filmstripFlowData->m_widgetSize.width();

   621     int h = m_filmstripFlowData->m_widgetSize.height();

   622 

   623     qreal step = ANIMATION_MAX_FRAME;

   624     qreal cx = (w - cw) / 2.0;

   625     qreal cy = m_filmstripFlowData->m_centerTopSpace;

   626     qreal sx = ((w + 4 * m_filmstripFlowData->m_space) + cw) / 2.0 - m_filmstripFlowData->m_space; 

   627     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   628     qreal stepx = (cx - sx) / step;

   629     qreal stepy = (cy - sy) / step;

   630     qreal stepx2 = stepx + (cw - sw) / step;

   631     qreal stepy2 = stepy + (ch - sh) / step;

   632 

   633     QRectF startRect = QRectF(sx, sy, sw, sh);

   634     QRectF endRect = QRectF(cx, cy, cw, ch);

   635 

   636     addRectByFrame(movie, startRect, endRect, stepx, stepy, stepx2, stepy2);

   637 }

   638 

   639 void FilmstripMovieFactory::createCenterToLeftMovie(FilmstripMovie* movie)

   640 {

   641     movie->m_movieClips.clear();

   642     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   643     int ch = m_filmstripFlowData->m_centerWindowSize.height();

   644     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   645     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   646     int w = m_filmstripFlowData->m_widgetSize.width();

   647     int h = m_filmstripFlowData->m_widgetSize.height();

   648 

   649     qreal step = ANIMATION_MAX_FRAME;

   650     qreal cx = (w - cw) / 2.0;

   651     qreal cy = m_filmstripFlowData->m_centerTopSpace;

   652     qreal sx = (((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0) - sw + m_filmstripFlowData->m_space; 

   653     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   654     qreal stepx = (sx - cx) / step;

   655     qreal stepy = (sy - cy) / step;

   656     qreal stepx2 = stepx + (sw - cw) / step;

   657     qreal stepy2 = stepy + (sh - ch) / step;

   658 

   659     QRectF startRect = QRectF(cx, cy, cw, ch);

   660     QRectF endRect = QRectF(sx, sy, sw, sh);

   661     addRectByFrame(movie, startRect, endRect, stepx, stepy, stepx2, stepy2);

   662   }

   663 

   664 void FilmstripMovieFactory::createCenterToRightMovie(FilmstripMovie* movie)

   665 {

   666     movie->m_movieClips.clear();

   667     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   668     int ch = m_filmstripFlowData->m_centerWindowSize.height();

   669     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   670     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   671     int w = m_filmstripFlowData->m_widgetSize.width();

   672     int h = m_filmstripFlowData->m_widgetSize.height();

   673 

   674     qreal step = ANIMATION_MAX_FRAME;

   675     qreal cx = (w - cw) / 2.0;

   676     qreal cy = m_filmstripFlowData->m_centerTopSpace;

   677     qreal sx = (((w + 4 * m_filmstripFlowData->m_space) + cw) / 2.0) - m_filmstripFlowData->m_space;

   678     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   679     qreal stepx = (sx - cx) / step;

   680     qreal stepy = (sy - cy) / step;

   681     qreal stepx2 = stepx + (sw - cw) / step;

   682     qreal stepy2 = stepy + (sh - ch) / step;

   683 

   684     QRectF startRect = QRectF(cx, cy, cw, ch);

   685     QRectF endRect = QRectF(sx, sy, sw, sh);

   686     addRectByFrame(movie, startRect, endRect, stepx, stepy, stepx2, stepy2);

   687 }

   688 

   689 void FilmstripMovieFactory::createLeftOutMovie(FilmstripMovie* movie)

   690 {

   691     movie->m_movieClips.clear();

   692     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   693     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   694     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   695     int w = m_filmstripFlowData->m_widgetSize.width();

   696     int h = m_filmstripFlowData->m_widgetSize.height();

   697 

   698     qreal cx = (w - cw) / 2.0;

   699     qreal sx = (w * (1 - 2 * m_filmstripFlowData->m_space) - cw) / 2.0 - sw;

   700     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   701     qreal stepx = (sx -cx) / ANIMATION_MAX_FRAME;

   702  

   703     QRectF startRect = QRectF(sx, sy, sw, sh);

   704     QRectF endRect = QRectF(2 * sx - cx , sy, sw, sh);

   705 

   706     addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

   707 }

   708 

   709 void FilmstripMovieFactory::createLeftInMovie(FilmstripMovie* movie)

   710 {

   711     movie->m_movieClips.clear();

   712     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   713     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   714     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   715     int w = m_filmstripFlowData->m_widgetSize.width();

   716     int h = m_filmstripFlowData->m_widgetSize.height();

   717 

   718     qreal cx = (w - cw) / 2.0;

   719     qreal sx = (w * (1 - 2 * m_filmstripFlowData->m_space) - cw) / 2.0 - sw; 

   720     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   721     qreal stepx = (cx - sx) / ANIMATION_MAX_FRAME;

   722     

   723     QRectF startRect = QRectF(2 * sx - cx , sy, sw, sh);

   724     QRectF endRect = QRectF(sx, sy, sw, sh);

   725 

   726     addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

   727 }

   728 

   729 void FilmstripMovieFactory::createRightOutMovie(FilmstripMovie* movie)

   730 {

   731     movie->m_movieClips.clear();

   732     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   733     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   734     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   735     int w = m_filmstripFlowData->m_widgetSize.width();

   736     int h = m_filmstripFlowData->m_widgetSize.height();

   737 

   738     qreal cx = (w - cw) / 2.0;

   739     qreal sx = (w * (1 + 2 * m_filmstripFlowData->m_space) + cw) / 2.0; 

   740     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   741     qreal stepx = (sx - cx) / ANIMATION_MAX_FRAME;

   742 

   743     QRectF startRect = QRectF(sx, sy, sw, sh);

   744     QRectF endRect = QRectF(sx + sx -cx, sy, sw, sh);

   745     addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

   746 }

   747 

   748 void FilmstripMovieFactory::createRightInMovie(FilmstripMovie* movie)

   749 {

   750     movie->m_movieClips.clear();

   751     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   752     int sw = m_filmstripFlowData->m_sideWindowSize.width();

   753     int sh = m_filmstripFlowData->m_sideWindowSize.height();

   754     int w = m_filmstripFlowData->m_widgetSize.width();

   755     int h = m_filmstripFlowData->m_widgetSize.height();

   756 

   757     qreal cx = (w - cw) / 2.0;

   758     qreal sx = (w * (1 + 2 * m_filmstripFlowData->m_space) + cw) / 2.0; 

   759     qreal sy = m_filmstripFlowData->m_sideTopSpace;

   760     qreal stepx = (cx - sx) / ANIMATION_MAX_FRAME;

   761 

   762     QRectF startRect = QRectF(sx + sx -cx, sy, sw, sh);

   763     QRectF endRect = QRectF(sx, sy, sw, sh);

   764 

   765     addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

   766 }

   767 

   768 void FilmstripMovieFactory::createFadeOutMovie(FilmstripMovie* movie)

   769 {

   770     movie->m_movieClips.clear();

   771     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   772     int ch = m_filmstripFlowData->m_centerWindowSize.height();

   773     int w = m_filmstripFlowData->m_widgetSize.width();

   774 

   775     qreal cx = (w - cw) / 2.0;

   776     qreal cy = m_filmstripFlowData->m_centerTopSpace;

   777 

   778     QRectF startRect = QRectF(cx, cy, cw, ch);

   779     movie->m_movieClips.append(startRect);

   780     

   781     movie->m_movieType = FilmstripMovie::FADE_OUT;

   782 }

   783 

   784 void FilmstripMovieFactory::createZoomInMovie(FilmstripMovie* movie)

   785 {

   786     movie->m_movieClips.clear();

   787     int w = m_filmstripFlowData->m_widgetSize.width();

   788     int h = m_filmstripFlowData->m_widgetSize.height();

   789     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   790     int ch = m_filmstripFlowData->m_centerWindowSize.height();

   791 

   792     qreal step = ANIMATION_MAX_FRAME;

   793     qreal cx = (w - cw) / 2.0;

   794     qreal cy = m_filmstripFlowData->m_centerTopSpace;

   795 

   796     qreal stepx = - cx / step;

   797     qreal stepy = - cy / step;

   798     qreal stepx2 = - stepx;

   799     qreal stepy2 = (h - cy - ch) / step;

   800  

   801     QRectF startRect = QRectF(cx, cy, cw, ch);

   802     QRectF endRect = QRectF(0, 0, w, h);

   803 

   804     addRectByFrame(movie, startRect, endRect, stepx, stepy, stepx2, stepy2);

   805 }

   806 

   807 void FilmstripMovieFactory::createZoomOutMovie(FilmstripMovie* movie)

   808 {

   809     movie->m_movieClips.clear();

   810     int w = m_filmstripFlowData->m_widgetSize.width();

   811     int h = m_filmstripFlowData->m_widgetSize.height();

   812     int cw = m_filmstripFlowData->m_centerWindowSize.width();

   813     int ch = m_filmstripFlowData->m_centerWindowSize.height();

   814     qreal cx = (w - cw) / 2.0;

   815 

   816     qreal step = ANIMATION_MAX_FRAME;

   817     qreal cy = m_filmstripFlowData->m_centerTopSpace;

   818 

   819     qreal stepx = cx / step;

   820     qreal stepy = cy / step;

   821     qreal stepx2 = -stepx;

   822     qreal stepy2 = (cy + ch - h) / step;

   823 

   824     QRectF startRect = QRectF(0, 0, w, h);

   825     QRectF endRect = QRectF(cx, cy, cw, ch);

   826 

   827     addRectByFrame(movie, startRect, endRect, 0, stepy, 0, stepy);

   828 }

   829 

   830 void FilmstripMovieFactory::updateAllMovie()

   831 {

   832     QHash<QString, FilmstripMovie*>::const_iterator i = m_moviesCache.find(BreakoutRightRight);

   833 

   834     if (i != m_moviesCache.end()) {

   835         FilmstripMovie* movie =  m_moviesCache.value(BreakoutRightRight);

   836         createRightRightOutMovie(movie);

   837     }

   838 

   839     i = m_moviesCache.find(CenterToLeft);

   840     if (i != m_moviesCache.end()) {

   841         FilmstripMovie* movie =  m_moviesCache.value(CenterToLeft);

   842         createCenterToLeftMovie(movie);

   843     }

   844 

   845     i = m_moviesCache.find(CenterToRight);

   846     if (i != m_moviesCache.end()) {

   847         FilmstripMovie* movie =  m_moviesCache.value(CenterToRight);

   848         createCenterToRightMovie(movie);

   849     }

   850 

   851     i = m_moviesCache.find(LeftToCenter);

   852     if (i != m_moviesCache.end()) {

   853         FilmstripMovie* movie =  m_moviesCache.value(LeftToCenter);

   854         createLeftToCenterMovie(movie);

   855     }

   856 

   857     i = m_moviesCache.find(RightToCenter);

   858     if (i != m_moviesCache.end()) {

   859         FilmstripMovie* movie =  m_moviesCache.value(RightToCenter);

   860         createRightToCenterMovie(movie);

   861     }

   862 

   863     i = m_moviesCache.find(FadeOut);

   864     if (i != m_moviesCache.end()) {

   865         FilmstripMovie* movie =  m_moviesCache.value(FadeOut);

   866         createFadeOutMovie(movie);

   867     }

   868 

   869     i = m_moviesCache.find(ZoomIn);

   870     if (i != m_moviesCache.end()) {

   871         FilmstripMovie* movie =  m_moviesCache.value(ZoomIn);

   872         createZoomInMovie(movie);

   873     }

   874 

   875     i = m_moviesCache.find(ZoomOut);

   876     if (i != m_moviesCache.end()) {

   877         FilmstripMovie* movie =  m_moviesCache.value(ZoomOut);

   878         createZoomOutMovie(movie);

   879     }

   880 

   881     i = m_moviesCache.find(BreakinLeftLeft);

   882     if (i != m_moviesCache.end()) {

   883         FilmstripMovie* movie =  m_moviesCache.value(BreakinLeftLeft);

   884         createLeftLeftInMovie(movie);

   885     }

   886 

   887     

   888     i = m_moviesCache.find(BreakinRightRight);

   889     if (i != m_moviesCache.end()) {

   890         FilmstripMovie* movie =  m_moviesCache.value(BreakinRightRight);

   891         createRightRightInMovie(movie);

   892     }

   893     

   894     i = m_moviesCache.find(BreakoutLeftLeft);

   895     if (i != m_moviesCache.end()) {

   896         FilmstripMovie* movie =  m_moviesCache.value(BreakoutLeftLeft);

   897         createLeftLeftOutMovie(movie);

   898     }

   899     

   900     i = m_moviesCache.find(BreakoutRightRight);

   901     if (i != m_moviesCache.end()) {

   902         FilmstripMovie* movie =  m_moviesCache.value(BreakoutRightRight);

   903         createRightRightOutMovie(movie);

   904     }

   905     

   906     i = m_moviesCache.find(LeftLeftToLeft);

   907     if (i != m_moviesCache.end()) {

   908         FilmstripMovie* movie =  m_moviesCache.value(LeftLeftToLeft);

   909         createLeftLeftToLeftMovie(movie);

   910     } 

   911     

   912     i = m_moviesCache.find(LeftToLeftLeft);

   913     if (i != m_moviesCache.end()) {

   914         FilmstripMovie* movie =  m_moviesCache.value(LeftToLeftLeft);

   915         createLeftToLeftLeftMovie(movie);

   916     } 

   917     

   918     i = m_moviesCache.find(RightToRightRight);

   919     if (i != m_moviesCache.end()) {

   920         FilmstripMovie* movie =  m_moviesCache.value(RightToRightRight);

   921         createRightToRightRightMovie(movie);

   922     } 

   923     

   924     i = m_moviesCache.find(RightRightToRight);

   925     if (i != m_moviesCache.end()) {

   926         FilmstripMovie* movie =  m_moviesCache.value(RightRightToRight);

   927         createRightRightToRightMovie(movie);

   928     }

   929 }

   930 

   931 // -------------------------------------------------------

   932 // LinearFlowSnippet.

   933 /*!

   934   Creates a new LinearFlowSnippet.

   935 */  

   936 LinearFlowSnippet::LinearFlowSnippet(QGraphicsWidget* parent): QGraphicsWidget(parent), d(new FilmstripFlowPrivate())

   937 {

   938     setParent(parent);

   939     m_scrolled = false;

   940     m_displayMode = "";

   941     m_titleName = "";

   942     m_countFlicks = 0;

   943 }

   944 

   945 /*!

   946   Destroys the widget.

   947 */

   948 LinearFlowSnippet::~LinearFlowSnippet()

   949 {

   950     delete d;

   951 }

   952 

   953 /*!

   954   Init the FilmstripFlow

   955 */

   956 void LinearFlowSnippet::init(QString displayMode, QString titleName)

   957 {

   958     Q_UNUSED(displayMode);

   959     Q_UNUSED(titleName);

   960 

   961     m_displayMode = displayMode;

   962     m_titleName = titleName;

   963 

   964     if (!d->m_closeIcon) {

   965         d->m_closeIcon = new QImage("./chrome/close.png");

   966     }

   967     d->m_movieFactory.setFilmstripFlowData(d);

   968 

   969     d->m_movieTimer.setDuration(ANIMATION_DURATION);

   970     d->m_movieTimer.setCurveShape(QTimeLine::EaseOutCurve);

   971     d->m_movieTimer.setFrameRange(0, ANIMATION_MAX_FRAME);

   972     QObject::connect(&d->m_movieTimer, SIGNAL(frameChanged(int)), this, SLOT(playMovie(int)));

   973     QObject::connect(&d->m_movieTimer, SIGNAL(finished()), this, SLOT(stopMovie()));

   974 

   975     QSize s = size().toSize();

   976     d->m_widgetSize = s;

   977     adjustFilmstripSize(s);

   978     // ensure that system cursor is an arrow, not a random icon

   979     // This is not an issue if the platform does not have a system cursor

   980 #ifndef __SYMBIAN32__

   981     setCursor(Qt::ArrowCursor);

   982 #endif

   983     setFocusPolicy(Qt::WheelFocus);

   984     setFocus(Qt::OtherFocusReason);

   985 }

   986 

   987 /*!

   988   Set center index

   989 */

   990 void LinearFlowSnippet::setCenterIndex(int i) 

   991 {

   992     Q_ASSERT(d);

   993     if (!d->m_films.size())

   994         return;

   995     

   996     if(d->m_centerIndex == i)

   997         return;

   998 

   999     if(i < 0)

  1000         i = (d->m_films.size() + i);

  1001     else if(d->m_centerIndex >= d->m_films.size() - 1)

  1002         i = i % d->m_films.size();

  1003 

  1004     d->m_centerIndex = i;

  1005   

  1006     CALL_ON_PREV_PREV_PREV_FILM_STRIP(updateMovie(NULL));

  1007     CALL_ON_NEXT_NEXT_NEXT_FILM_STRIP(updateMovie(NULL));

  1008     d->m_films[d->m_centerIndex]->updateMovie(d->m_movieFactory.createMovie(CenterToRight));

  1009     CALL_ON_PREV_FILM_STRIP(updateMovie(d->m_movieFactory.createMovie(LeftToCenter)));

  1010     CALL_ON_PREV_PREV_FILM_STRIP(updateMovie(d->m_movieFactory.createMovie(LeftLeftToLeft))); 

  1011     CALL_ON_NEXT_FILM_STRIP(updateMovie(d->m_movieFactory.createMovie(RightToRightRight)));

  1012     CALL_ON_NEXT_NEXT_FILM_STRIP(updateMovie(d->m_movieFactory.createMovie(BreakoutRightRight))); 

  1013 

  1014     emit centerIndexChanged(i);

  1015 }

  1016 

  1017 /*!

  1018   add slide

  1019 */

  1020 void LinearFlowSnippet::addSlide(const QImage& image)

  1021 {

  1022     Q_ASSERT(d);

  1023     Filmstrip* filmstrip = new Filmstrip(image, d);

  1024     d->m_films.append(filmstrip);

  1025 }

  1026 

  1027 /*!

  1028   add slide

  1029 */

  1030 void LinearFlowSnippet::addSlide(const QImage& image, const QString& title)

  1031 {

  1032     Q_ASSERT(d);

  1033     Filmstrip* filmstrip = new Filmstrip(image, d);

  1034     filmstrip->setName(title);

  1035     d->m_films.append(filmstrip);

  1036 }

  1037 

  1038 /*!

  1039   Inserts filmstrip at index position i.

  1040   If i is 0, the filmstrip is prepended to the film list. 

  1041   If i is size(), the value is appended to the film list.

  1042 */

  1043 void LinearFlowSnippet::insert(int i, const QImage& image, const QString& title)

  1044 {

  1045     Q_ASSERT(d);

  1046     Q_ASSERT(i >= 0 && i <= d->m_films.size());

  1047 

  1048     Filmstrip* filmstrip = new Filmstrip(image, d);

  1049     filmstrip->setName(title);

  1050     d->m_films.insert(i, filmstrip);

  1051     

  1052     if (isVisible()) {

  1053         Q_ASSERT(d->m_movieTimer.state() != QTimeLine::Running);

  1054         if (i == d->m_centerIndex + 1)  // insert on right

  1055             showInsertOnRight();

  1056         else if (i == d->m_centerIndex) // insert on left

  1057             showInsertOnLeft();

  1058     }

  1059 }

  1060 

  1061 /*!

  1062   Removes filmstrip at index position i.

  1063 */

  1064 void LinearFlowSnippet::removeAt (int i)

  1065 {

  1066     Q_ASSERT(d);

  1067     Q_ASSERT(i >= 0 && i < d->m_films.size());

  1068 

  1069 

  1070     if (isVisible()) {

  1071         // Not use Q_ASSERT here because the deletion-op is UI buildin -- tap the close button

  1072         if (d->m_movieTimer.state() == QTimeLine::Running)

  1073             return;

  1074 

  1075         d->m_films[d->m_centerIndex]->updateMovie(d->m_movieFactory.createMovie(FadeOut)); // move center slide to left            

  1076         CALL_ON_PREV_FILM_STRIP(freeze()); // no movement for left slide

  1077         CALL_ON_NEXT_FILM_STRIP(freeze()); // no movement for right slide

  1078 

  1079         QObject::disconnect(&d->m_movieTimer, SIGNAL(finished()), this, SLOT(stopMovie()));

  1080         QObject::connect(&d->m_movieTimer, SIGNAL(finished()), this, SLOT(closeAnimation()));

  1081         d->m_movieTimer.start();

  1082     }

  1083     else {

  1084         Filmstrip* f = d->m_films.at(i);

  1085         d->m_films.removeAt(i);

  1086         SAFE_DELETE(f);

  1087         d->m_centerIndex = d->m_films.size() - 1;

  1088     }

  1089 }

  1090 

  1091 /*!

  1092   Return the index of the current center slide

  1093 */

  1094 int LinearFlowSnippet::centerIndex() const 

  1095 {

  1096     Q_ASSERT(d);

  1097     return d->m_centerIndex;

  1098 }

  1099 

  1100 /*! Clear all slides

  1101 */

  1102 void LinearFlowSnippet::clear() 

  1103 {

  1104     Q_ASSERT(d);

  1105     d->clear();

  1106 }

  1107 

  1108 void LinearFlowSnippet::backgroundColor(const QRgb& c)

  1109 {

  1110     Q_ASSERT(d);

  1111     d->m_bgColor = c;

  1112 }

  1113 

  1114 int LinearFlowSnippet::slideCount() const 

  1115 {

  1116     return d ? d->m_films.size() : 0;

  1117 }

  1118 

  1119 //! Returns QImage of specified slide.

  1120 QImage LinearFlowSnippet::slide(int i) const

  1121 {

  1122     Q_ASSERT(d);

  1123     Q_ASSERT( i >=0 && i < d->m_films.size());

  1124     return d->m_films.at(i)->image();

  1125 }

  1126 

  1127 //! return true if slide animation is ongoing

  1128 bool LinearFlowSnippet::slideAnimationOngoing() const 

  1129 {

  1130     Q_ASSERT(d);

  1131     return d->m_movieTimer.state() == QTimeLine::Running;

  1132 }

  1133 

  1134 //! return center slide's rect