--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/browsercore/appfw/Common/PictureFlow.cpp Tue May 04 12:39:35 2010 +0300
@@ -0,0 +1,1637 @@
+/*
+ PictureFlow - animated image show widget
+ http://pictureflow.googlecode.com
+
+ Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ Copyright (C) 2008 Ariya Hidayat (ariya@kde.org)
+ Copyright (C) 2007 Ariya Hidayat (ariya@kde.org)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+
+#include "PictureFlow.h"
+
+// detect Qt version
+#if QT_VERSION >= 0x040000
+#define PICTUREFLOW_QT4
+#elif QT_VERSION >= 0x030000
+#define PICTUREFLOW_QT3
+#elif QT_VERSION >= 235
+#define PICTUREFLOW_QT2
+#else
+#error PictureFlow widgets need Qt 2, Qt 3 or Qt 4
+#endif
+
+#include <QGraphicsSceneResizeEvent>
+#include <QGraphicsSceneMouseEvent>
+#include <QGraphicsSceneMoveEvent>
+
+#ifdef PICTUREFLOW_QT4
+#include <QApplication>
+#include <QCache>
+#include <QHash>
+#include <QImage>
+#include <QKeyEvent>
+#include <QPainter>
+#include <QPixmap>
+#include <QTimer>
+#include <QVector>
+#include <QWidget>
+#endif
+
+#include <QDebug>
+
+#ifdef PICTUREFLOW_QT3
+#include <qapplication.h>
+#include <qcache.h>
+#include <qimage.h>
+#include <qpainter.h>
+#include <qpixmap.h>
+#include <qdatetime.h>
+#include <qtimer.h>
+#include <qvaluevector.h>
+#include <qwidget.h>
+
+#define qMax(x,y) ((x) > (y)) ? (x) : (y)
+#define qMin(x,y) ((x) < (y)) ? (x) : (y)
+
+#define QVector QValueVector
+
+#define toImage convertToImage
+#define contains find
+#define modifiers state
+#define ControlModifier ControlButton
+#endif
+
+#ifdef PICTUREFLOW_QT2
+#include <qapplication.h>
+#include <qarray.h>
+#include <qcache.h>
+#include <qimage.h>
+#include <qintdict.h>
+#include <qpainter.h>
+#include <qpixmap.h>
+#include <qdatetime.h>
+#include <qtimer.h>
+#include <qwidget.h>
+
+#define qMax(x,y) ((x) > (y)) ? (x) : (y)
+#define qMin(x,y) ((x) < (y)) ? (x) : (y)
+
+#define QVector QArray
+
+#define toImage convertToImage
+#define contains find
+#define modifiers state
+#define ControlModifier ControlButton
+#define flush flushX
+#endif
+
+// for fixed-point arithmetic, we need minimum 32-bit long
+// long long (64-bit) might be useful for multiplication and division
+typedef long PFreal;
+#define PFREAL_SHIFT 10
+#define PFREAL_ONE (1 << PFREAL_SHIFT)
+
+#define IANGLE_MAX 1024
+#define IANGLE_MASK 1023
+
+namespace WRT {
+
+const int slideRatio1 = 2;
+const int slideRatio2 = 5;
+const int KScrollTimeout = 250;
+
+inline PFreal fmul(PFreal a, PFreal b)
+{
+ return ((long long)(a))*((long long)(b)) >> PFREAL_SHIFT;
+}
+
+inline PFreal fdiv(PFreal num, PFreal den)
+{
+ long long p = (long long)(num) << (PFREAL_SHIFT*2);
+ long long q = p / (long long)den;
+ long long r = q >> PFREAL_SHIFT;
+
+ return r;
+}
+
+inline PFreal fsin(int iangle)
+{
+ // warning: regenerate the table if IANGLE_MAX and PFREAL_SHIFT are changed!
+ static const PFreal tab[] = {
+ 3, 103, 202, 300, 394, 485, 571, 652,
+ 726, 793, 853, 904, 947, 980, 1004, 1019,
+ 1023, 1018, 1003, 978, 944, 901, 849, 789,
+ 721, 647, 566, 479, 388, 294, 196, 97,
+ -4, -104, -203, -301, -395, -486, -572, -653,
+ -727, -794, -854, -905, -948, -981, -1005, -1020,
+ -1024, -1019, -1004, -979, -945, -902, -850, -790,
+ -722, -648, -567, -480, -389, -295, -197, -98,
+ 3
+ };
+
+ while(iangle < 0)
+ iangle += IANGLE_MAX;
+ iangle &= IANGLE_MASK;
+
+ int i = (iangle >> 4);
+ PFreal p = tab[i];
+ PFreal q = tab[(i+1)];
+ PFreal g = (q - p);
+ return p + g * (iangle-i*16)/16;
+}
+
+inline PFreal fcos(int iangle)
+{
+ return fsin(iangle + (IANGLE_MAX >> 2));
+}
+
+/* ----------------------------------------------------------
+
+PictureFlowState stores the state of all slides, i.e. all the necessary
+information to be able to render them.
+
+PictureFlowAnimator is responsible to move the slides during the
+transition between slides, to achieve the effect similar to Cover Flow,
+by changing the state.
+
+PictureFlowSoftwareRenderer (or PictureFlowOpenGLRenderer) is
+the actual 3-d renderer. It should render all slides given the state
+(an instance of PictureFlowState).
+
+Instances of all the above three classes are stored in
+PictureFlowPrivate.
+
+------------------------------------------------------- */
+
+struct SlideInfo
+{
+ int slideIndex;
+ int angle;
+ PFreal cx;
+ PFreal cy;
+ int blend;
+};
+
+class PictureFlowState
+{
+public:
+ PictureFlowState();
+ ~PictureFlowState();
+
+ void reposition();
+ void reset();
+
+ QRgb backgroundColor;
+ int slideWidth;
+ int slideHeight;
+ ReflectionEffect reflectionEffect;
+ QVector<QImage*> slideImages;
+
+ int angle;
+ int spacing;
+ PFreal offsetX;
+ PFreal offsetY;
+
+ SlideInfo centerSlide;
+ QVector<SlideInfo> leftSlides;
+ QVector<SlideInfo> rightSlides;
+ int centerIndex;
+};
+
+class PictureFlowAnimator
+{
+public:
+ PictureFlowAnimator();
+ PictureFlowState* state;
+
+ void start(int slide);
+ void stop(int slide);
+ void update();
+
+ int target;
+ int step;
+ int frame;
+ QTimer animateTimer;
+};
+
+class PictureFlowAbstractRenderer
+{
+public:
+ PictureFlowAbstractRenderer(): state(0), dirty(false), widget(0), gWidget(0), gPainter(0) {}
+ virtual ~PictureFlowAbstractRenderer() {}
+
+ PictureFlowState* state;
+ bool dirty;
+ QWidget* widget;
+ QGraphicsWidget* gWidget;
+ QPainter* gPainter;
+ QRect cRect; // central rect
+
+ virtual void init() = 0;
+ virtual void paint() = 0;
+};
+
+class PictureFlowSoftwareRenderer: public PictureFlowAbstractRenderer
+{
+public:
+ PictureFlowSoftwareRenderer();
+ ~PictureFlowSoftwareRenderer();
+
+ virtual void init();
+ virtual void paint();
+
+ QRect renderSlide(const SlideInfo &slide, int col1 = -1, int col2 = -1);
+private:
+ QSize size;
+ QRgb bgcolor;
+ int effect;
+ QImage buffer;
+ QVector<PFreal> rays;
+ QImage* blankSurface;
+#ifdef PICTUREFLOW_QT4
+ QCache<int,QImage> surfaceCache;
+ QHash<int,QImage*> imageHash;
+#endif
+#ifdef PICTUREFLOW_QT3
+ QCache<QImage> surfaceCache;
+ QMap<int,QImage*> imageHash;
+#endif
+#ifdef PICTUREFLOW_QT2
+ QCache<QImage> surfaceCache;
+ QIntDict<QImage> imageHash;
+#endif
+
+ void render();
+ void renderSlides();
+ QImage* surface(int slideIndex);
+};
+
+// ------------- PictureFlowState ---------------------------------------
+
+PictureFlowState::PictureFlowState():
+backgroundColor(0), slideWidth(150), slideHeight(200),
+reflectionEffect(BlurredReflection), centerIndex(0)
+{
+}
+
+PictureFlowState::~PictureFlowState()
+{
+ for(int i = 0; i < (int)slideImages.count(); i++)
+ delete slideImages[i];
+}
+
+// readjust the settings, call this when slide dimension is changed
+void PictureFlowState::reposition()
+{
+ angle = 60*IANGLE_MAX / 360;
+
+ offsetX = slideWidth/2 * (PFREAL_ONE-fcos(angle));
+ offsetY = slideWidth/2 * fsin(angle);
+ offsetX += slideWidth * PFREAL_ONE;
+ offsetY += slideWidth * PFREAL_ONE / 4;
+ spacing = 20;
+}
+
+// adjust slides so that they are in "steady state" position
+void PictureFlowState::reset()
+{
+ centerSlide.angle = 0;
+ centerSlide.cx = 0;
+ centerSlide.cy = 0;
+ centerSlide.slideIndex = centerIndex;
+ centerSlide.blend = 256;
+
+ leftSlides.resize(6);
+ for(int i = 0; i < (int)leftSlides.count(); i++)
+ {
+ SlideInfo& si = leftSlides[i];
+ si.angle = angle;
+ si.cx = -(offsetX + spacing*i*PFREAL_ONE);
+ si.cy = offsetY;
+ si.slideIndex = centerIndex-1-i;
+ si.blend = 256;
+ if(i == (int)leftSlides.count()-2)
+ si.blend = 128;
+ if(i == (int)leftSlides.count()-1)
+ si.blend = 0;
+ }
+
+ rightSlides.resize(6);
+ for(int i = 0; i < (int)rightSlides.count(); i++)
+ {
+ SlideInfo& si = rightSlides[i];
+ si.angle = -angle;
+ si.cx = offsetX + spacing*i*PFREAL_ONE;
+ si.cy = offsetY;
+ si.slideIndex = centerIndex+1+i;
+ si.blend = 256;
+ if(i == (int)rightSlides.count()-2)
+ si.blend = 128;
+ if(i == (int)rightSlides.count()-1)
+ si.blend = 0;
+ }
+}
+
+// ------------- PictureFlowAnimator ---------------------------------------
+
+PictureFlowAnimator::PictureFlowAnimator():
+state(0), target(0), step(0), frame(0)
+{
+}
+
+void PictureFlowAnimator::start(int slide)
+{
+ target = slide;
+ if(!animateTimer.isActive() && state)
+ {
+ step = (target < state->centerSlide.slideIndex) ? -1 : 1;
+ animateTimer.start(30);
+ }
+}
+
+void PictureFlowAnimator::stop(int slide)
+{
+ step = 0;
+ target = slide;
+ frame = slide << 16;
+ animateTimer.stop();
+}
+
+void PictureFlowAnimator::update()
+{
+ if(!animateTimer.isActive())
+ return;
+ if(step == 0)
+ return;
+ if(!state)
+ return;
+
+ int speed = 16384/4;
+
+#if 1
+ // deaccelerate when approaching the target
+ // we disabled clicking until the animation is done so this has to be fast enough to not annoy users
+ const int max = 65536 + 16384; // was 65536*2 but that was too slow when we disabled clicks
+
+ int fi = frame;
+ fi -= (target << 16);
+ if(fi < 0)
+ fi = -fi;
+ fi = qMin(fi, max);
+
+ int ia = IANGLE_MAX * (fi-max/2) / (max*2);
+ speed = 512 + 16384 * (PFREAL_ONE+fsin(ia))/PFREAL_ONE;
+#endif
+
+ frame += speed*step;
+
+ int index = frame >> 16;
+ int pos = frame & 0xffff;
+ int neg = 65536 - pos;
+ int tick = (step < 0) ? neg : pos;
+ PFreal ftick = (tick * PFREAL_ONE) >> 16;
+
+ if(step < 0)
+ index++;
+
+ if(state->centerIndex != index)
+ {
+ state->centerIndex = index;
+ frame = index << 16;
+ state->centerSlide.slideIndex = state->centerIndex;
+ for(int i = 0; i < (int)state->leftSlides.count(); i++)
+ state->leftSlides[i].slideIndex = state->centerIndex-1-i;
+ for(int i = 0; i < (int)state->rightSlides.count(); i++)
+ state->rightSlides[i].slideIndex = state->centerIndex+1+i;
+ }
+
+ state->centerSlide.angle = (step * tick * state->angle) >> 16;
+ state->centerSlide.cx = -step * fmul(state->offsetX, ftick);
+ state->centerSlide.cy = fmul(state->offsetY, ftick);
+
+ if(state->centerIndex == target)
+ {
+ stop(target);
+ state->reset();
+ return;
+ }
+
+ for(int i = 0; i < (int)state->leftSlides.count(); i++)
+ {
+ SlideInfo& si = state->leftSlides[i];
+ si.angle = state->angle;
+ si.cx = -(state->offsetX + state->spacing*i*PFREAL_ONE + step*state->spacing*ftick);
+ si.cy = state->offsetY;
+ }
+
+ for(int i = 0; i < (int)state->rightSlides.count(); i++)
+ {
+ SlideInfo& si = state->rightSlides[i];
+ si.angle = -state->angle;
+ si.cx = state->offsetX + state->spacing*i*PFREAL_ONE - step*state->spacing*ftick;
+ si.cy = state->offsetY;
+ }
+
+ if(step > 0)
+ {
+ PFreal ftick = (neg * PFREAL_ONE) >> 16;
+ state->rightSlides[0].angle = -(neg * state->angle) >> 16;
+ state->rightSlides[0].cx = fmul(state->offsetX, ftick);
+ state->rightSlides[0].cy = fmul(state->offsetY, ftick);
+ }
+ else
+ {
+ PFreal ftick = (pos * PFREAL_ONE) >> 16;
+ state->leftSlides[0].angle = (pos * state->angle) >> 16;
+ state->leftSlides[0].cx = -fmul(state->offsetX, ftick);
+ state->leftSlides[0].cy = fmul(state->offsetY, ftick);
+ }
+
+ // must change direction ?
+ if(target < index) if(step > 0)
+ step = -1;
+ if(target > index) if(step < 0)
+ step = 1;
+
+ // the first and last slide must fade in/fade out
+ int nleft = state->leftSlides.count();
+ int nright = state->rightSlides.count();
+ int fade = pos / 256;
+
+ for(int index = 0; index < nleft; index++)
+ {
+ int blend = 256;
+ if(index == nleft-1)
+ blend = (step > 0) ? 0 : 128-fade/2;
+ if(index == nleft-2)
+ blend = (step > 0) ? 128-fade/2 : 256-fade/2;
+ if(index == nleft-3)
+ blend = (step > 0) ? 256-fade/2 : 256;
+ state->leftSlides[index].blend = blend;
+ }
+ for(int index = 0; index < nright; index++)
+ {
+ int blend = (index < nright-2) ? 256 : 128;
+ if(index == nright-1)
+ blend = (step > 0) ? fade/2 : 0;
+ if(index == nright-2)
+ blend = (step > 0) ? 128+fade/2 : fade/2;
+ if(index == nright-3)
+ blend = (step > 0) ? 256 : 128+fade/2;
+ state->rightSlides[index].blend = blend;
+ }
+}
+
+// ------------- PictureFlowSoftwareRenderer ---------------------------------------
+
+PictureFlowSoftwareRenderer::PictureFlowSoftwareRenderer():
+PictureFlowAbstractRenderer(), size(0,0), bgcolor(0), effect(-1), blankSurface(0)
+{
+#ifdef PICTUREFLOW_QT3
+ surfaceCache.setAutoDelete(true);
+#endif
+}
+
+PictureFlowSoftwareRenderer::~PictureFlowSoftwareRenderer()
+{
+ surfaceCache.clear();
+ buffer = QImage();
+ delete blankSurface;
+}
+
+void PictureFlowSoftwareRenderer::paint()
+{
+ if(!widget && !gWidget)
+ return;
+
+ if(widget && widget->size() != size)
+ init();
+ else if (gWidget && gWidget->size().toSize() != size)
+ init();
+
+ if(state->backgroundColor != bgcolor)
+ {
+ bgcolor = state->backgroundColor;
+ surfaceCache.clear();
+ }
+
+ if((int)(state->reflectionEffect) != effect)
+ {
+ effect = (int)state->reflectionEffect;
+ surfaceCache.clear();
+ }
+
+ if(dirty)
+ render();
+
+ if (widget) {
+ QPainter painter(widget);
+ painter.drawImage(QPoint(0,0), buffer);
+ } else if (gWidget && gPainter) {
+ gPainter->drawImage(QPoint(0,0), buffer);
+ }
+}
+
+void PictureFlowSoftwareRenderer::init()
+{
+ if(!widget && !gWidget)
+ return;
+
+ surfaceCache.clear();
+ blankSurface = 0;
+
+ if (widget)
+ size = widget->size();
+ else
+ size = gWidget->size().toSize();
+
+ int ww = size.width();
+ int wh = size.height();
+ int w = (ww+1)/2;
+ int h = (wh+1)/2;
+
+#ifdef PICTUREFLOW_QT4
+ buffer = QImage(ww, wh, QImage::Format_RGB32);
+#endif
+#if defined(PICTUREFLOW_QT3) || defined(PICTUREFLOW_QT2)
+ buffer.create(ww, wh, 32);
+#endif
+ buffer.fill(bgcolor);
+
+ rays.resize(w*2);
+ for(int i = 0; i < w; i++)
+ {
+ PFreal gg = ((PFREAL_ONE >> 1) + i * PFREAL_ONE) / (2*h);
+ rays[w-i-1] = -gg;
+ rays[w+i] = gg;
+ }
+
+ dirty = true;
+}
+
+// TODO: optimize this with lookup tables
+static QRgb blendColor(QRgb c1, QRgb c2, int blend)
+{
+ int r = qRed(c1) * blend/256 + qRed(c2)*(256-blend)/256;
+ int g = qGreen(c1) * blend/256 + qGreen(c2)*(256-blend)/256;
+ int b = qBlue(c1) * blend/256 + qBlue(c2)*(256-blend)/256;
+ return qRgb(r, g, b);
+}
+
+
+static QImage* prepareSurface(const QImage* slideImage, int w, int h, QRgb bgcolor,
+ReflectionEffect reflectionEffect)
+{
+#ifdef PICTUREFLOW_QT4
+ Qt::TransformationMode mode = Qt::SmoothTransformation;
+ QImage img = slideImage->scaled(w, h, Qt::IgnoreAspectRatio, mode);
+#endif
+#if defined(PICTUREFLOW_QT3) || defined(PICTUREFLOW_QT2)
+ QImage img = slideImage->smoothScale(w, h);
+#endif
+
+ // slightly larger, to accomodate for the reflection
+ int hs = h * 2;
+ int hofs = h / 3;
+
+ // offscreen buffer: black is sweet
+#ifdef PICTUREFLOW_QT4
+ QImage* result = new QImage(hs, w, QImage::Format_RGB32);
+#endif
+#if defined(PICTUREFLOW_QT3) || defined(PICTUREFLOW_QT2)
+ QImage* result = new QImage;
+ result->create(hs, w, 32);
+#endif
+ result->fill(bgcolor);
+
+ // transpose the image, this is to speed-up the rendering
+ // because we process one column at a time
+ // (and much better and faster to work row-wise, i.e in one scanline)
+ for(int x = 0; x < w; x++)
+ for(int y = 0; y < h; y++)
+ result->setPixel(hofs + y, x, img.pixel(x, y));
+
+ if(reflectionEffect != NoReflection)
+ {
+ // create the reflection
+ int ht = hs - h - hofs;
+ int hte = ht;
+ for(int x = 0; x < w; x++)
+ for(int y = 0; y < ht; y++)
+ {
+ QRgb color = img.pixel(x, img.height()-y-1);
+ result->setPixel(h+hofs+y, x, blendColor(color,bgcolor,128*(hte-y)/hte));
+ }
+
+ if(reflectionEffect == BlurredReflection)
+ {
+ // blur the reflection everything first
+ // Based on exponential blur algorithm by Jani Huhtanen
+ QRect rect(hs/2, 0, hs/2, w);
+ rect &= result->rect();
+
+ int r1 = rect.top();
+ int r2 = rect.bottom();
+ int c1 = rect.left();
+ int c2 = rect.right();
+
+ int bpl = result->bytesPerLine();
+ int rgba[4];
+ unsigned char* p;
+
+ // how many times blur is applied?
+ // for low-end system, limit this to only 1 loop
+ for(int loop = 0; loop < 2; loop++)
+ {
+ for(int col = c1; col <= c2; col++)
+ {
+ p = result->scanLine(r1) + col*4;
+ for(int i = 0; i < 3; i++)
+ rgba[i] = p[i] << 4;
+
+ p += bpl;
+ for(int j = r1; j < r2; j++, p += bpl)
+ for(int i = 0; i < 3; i++)
+ p[i] = (rgba[i] += (((p[i]<<4)-rgba[i])) >> 1) >> 4;
+ }
+
+ for(int row = r1; row <= r2; row++)
+ {
+ p = result->scanLine(row) + c1*4;
+ for(int i = 0; i < 3; i++)
+ rgba[i] = p[i] << 4;
+
+ p += 4;
+ for(int j = c1; j < c2; j++, p+=4)
+ for(int i = 0; i < 3; i++)
+ p[i] = (rgba[i] += (((p[i]<<4)-rgba[i])) >> 1) >> 4;
+ }
+
+ for(int col = c1; col <= c2; col++)
+ {
+ p = result->scanLine(r2) + col*4;
+ for(int i = 0; i < 3; i++)
+ rgba[i] = p[i] << 4;
+
+ p -= bpl;
+ for(int j = r1; j < r2; j++, p -= bpl)
+ for(int i = 0; i < 3; i++)
+ p[i] = (rgba[i] += (((p[i]<<4)-rgba[i])) >> 1) >> 4;
+ }
+
+ for(int row = r1; row <= r2; row++)
+ {
+ p = result->scanLine(row) + c2*4;
+ for(int i = 0; i < 3; i++)
+ rgba[i] = p[i] << 4;
+
+ p -= 4;
+ for(int j = c1; j < c2; j++, p-=4)
+ for(int i = 0; i < 3; i++)
+ p[i] = (rgba[i] += (((p[i]<<4)-rgba[i])) >> 1) >> 4;
+ }
+ }
+
+ // overdraw to leave only the reflection blurred (but not the actual image)
+ for(int x = 0; x < w; x++)
+ for(int y = 0; y < h; y++)
+ result->setPixel(hofs + y, x, img.pixel(x, y));
+ }
+ }
+
+ return result;
+}
+
+QImage* PictureFlowSoftwareRenderer::surface(int slideIndex)
+{
+ if(!state)
+ return 0;
+ if(slideIndex < 0)
+ return 0;
+ if(slideIndex >= (int)state->slideImages.count())
+ return 0;
+
+#ifdef PICTUREFLOW_QT4
+ int key = slideIndex;
+#endif
+#if defined(PICTUREFLOW_QT3) || defined(PICTUREFLOW_QT2)
+ QString key = QString::number(slideIndex);
+#endif
+
+ QImage* img = state->slideImages.at(slideIndex);
+ bool empty = img ? img->isNull() : true;
+ if(empty)
+ {
+ surfaceCache.remove(key);
+ imageHash.remove(slideIndex);
+ if(!blankSurface)
+ {
+ int sw = state->slideWidth;
+ int sh = state->slideHeight;
+
+#ifdef PICTUREFLOW_QT4
+ QImage img = QImage(sw, sh, QImage::Format_RGB32);
+
+ QPainter painter(&img);
+ QPoint p1(sw*4/10, 0);
+ QPoint p2(sw*6/10, sh);
+ QLinearGradient linearGrad(p1, p2);
+ linearGrad.setColorAt(0, Qt::black);
+ linearGrad.setColorAt(1, Qt::white);
+ painter.setBrush(linearGrad);
+ painter.fillRect(0, 0, sw, sh, QBrush(linearGrad));
+
+ painter.setPen(QPen(QColor(64,64,64), 4));
+ painter.setBrush(QBrush());
+ painter.drawRect(2, 2, sw-3, sh-3);
+ painter.end();
+#endif
+#if defined(PICTUREFLOW_QT3) || defined(PICTUREFLOW_QT2)
+ QPixmap pixmap(sw, sh, 32);
+ QPainter painter(&pixmap);
+ painter.fillRect(pixmap.rect(), QColor(192,192,192));
+ painter.fillRect(5, 5, sw-10, sh-10, QColor(64,64,64));
+ painter.end();
+ QImage img = pixmap.convertToImage();
+#endif
+
+ blankSurface = prepareSurface(&img, sw, sh, bgcolor, state->reflectionEffect);
+ }
+ return blankSurface;
+ }
+
+#ifdef PICTUREFLOW_QT4
+ bool exist = imageHash.contains(slideIndex);
+ if(exist)
+ if(img == imageHash.find(slideIndex).value())
+#endif
+#ifdef PICTUREFLOW_QT3
+ bool exist = imageHash.find(slideIndex) != imageHash.end();
+ if(exist)
+ if(img == imageHash.find(slideIndex).data())
+#endif
+#ifdef PICTUREFLOW_QT2
+ if(img == imageHash[slideIndex])
+#endif
+ if(surfaceCache.contains(key))
+ return surfaceCache[key];
+
+ QImage* sr = prepareSurface(img, state->slideWidth, state->slideHeight, bgcolor, state->reflectionEffect);
+ surfaceCache.insert(key, sr);
+ imageHash.insert(slideIndex, img);
+
+ return sr;
+}
+
+// Renders a slide to offscreen buffer. Returns a rect of the rendered area.
+// col1 and col2 limit the column for rendering.
+QRect PictureFlowSoftwareRenderer::renderSlide(const SlideInfo &slide, int col1, int col2)
+{
+ int blend = slide.blend;
+ if(!blend)
+ return QRect();
+
+ QImage* src = surface(slide.slideIndex);
+ if(!src)
+ return QRect();
+
+ QRect rect(0, 0, 0, 0);
+
+ int sw = src->height();
+ int sh = src->width();
+ int h = buffer.height();
+ int w = buffer.width();
+
+ if(col1 > col2)
+ {
+ int c = col2;
+ col2 = col1;
+ col1 = c;
+ }
+
+ col1 = (col1 >= 0) ? col1 : 0;
+ col2 = (col2 >= 0) ? col2 : w-1;
+ col1 = qMin(col1, w-1);
+ col2 = qMin(col2, w-1);
+
+ int zoom = 100;
+ int distance = h * 100 / zoom;
+ PFreal sdx = fcos(slide.angle);
+ PFreal sdy = fsin(slide.angle);
+ PFreal xs = slide.cx - state->slideWidth * sdx/2;
+ PFreal ys = slide.cy - state->slideWidth * sdy/2;
+ PFreal dist = distance * PFREAL_ONE;
+ int xi = qMax((PFreal)0, (w*PFREAL_ONE/2) + fdiv(xs*h, dist+ys) >> PFREAL_SHIFT);
+ if(xi >= w)
+ return rect;
+
+ bool flag = false;
+ rect.setLeft(xi);
+
+ int centerY = 0;
+ for(int x = qMax(xi, col1); x <= col2; x++)
+ {
+ PFreal hity = 0;
+ PFreal fk = rays[x];
+ if(sdy)
+ {
+ fk = fk - fdiv(sdx,sdy);
+ hity = -fdiv((rays[x]*distance - slide.cx + slide.cy*sdx/sdy), fk);
+ }
+
+ dist = distance*PFREAL_ONE + hity;
+ if(dist < 0)
+ continue;
+
+ PFreal hitx = fmul(dist, rays[x]);
+ PFreal hitdist = fdiv(hitx - slide.cx, sdx);
+
+ int column = sw/2 + (hitdist >> PFREAL_SHIFT);
+ if(column >= sw)
+ break;
+ if(column < 0)
+ continue;
+
+ rect.setRight(x);
+ if(!flag)
+ rect.setLeft(x);
+ flag = true;
+
+ int y1 = h/2;
+ int y2 = y1+ 1;
+ centerY = y1;
+ QRgb* pixel1 = (QRgb*)(buffer.scanLine(y1)) + x;
+ QRgb* pixel2 = (QRgb*)(buffer.scanLine(y2)) + x;
+ QRgb pixelstep = pixel2 - pixel1;
+
+ int center = (sh/2);
+ int dy = dist / h;
+ int p1 = center*PFREAL_ONE - dy/2;
+ int p2 = center*PFREAL_ONE + dy/2;
+
+ const QRgb *ptr = (const QRgb*)(src->scanLine(column));
+ if(blend == 256)
+ while((y1 >= 0) && (y2 < h) && (p1 >= 0))
+ {
+ *pixel1 = ptr[p1 >> PFREAL_SHIFT];
+ *pixel2 = ptr[p2 >> PFREAL_SHIFT];
+ p1 -= dy;
+ p2 += dy;
+ y1--;
+ y2++;
+ pixel1 -= pixelstep;
+ pixel2 += pixelstep;
+ }
+ else
+ while((y1 >= 0) && (y2 < h) && (p1 >= 0))
+ {
+ QRgb c1 = ptr[p1 >> PFREAL_SHIFT];
+ QRgb c2 = ptr[p2 >> PFREAL_SHIFT];
+ *pixel1 = blendColor(c1, bgcolor, blend);
+ *pixel2 = blendColor(c2, bgcolor, blend);
+ p1 -= dy;
+ p2 += dy;
+ y1--;
+ y2++;
+ pixel1 -= pixelstep;
+ pixel2 += pixelstep;
+ }
+ }
+
+ int yTop = (3 * centerY - 2 * state->slideHeight) / 3;
+ rect.setTop(yTop);
+ rect.setBottom(state->slideHeight + yTop);
+ return rect;
+}
+
+void PictureFlowSoftwareRenderer::renderSlides()
+{
+ int nleft = state->leftSlides.count();
+ int nright = state->rightSlides.count();
+
+ QRect r = renderSlide(state->centerSlide);
+ int c1 = r.left();
+ int c2 = r.right();
+ cRect = r;
+ for(int index = 0; index < nleft; index++)
+ {
+ QRect rs = renderSlide(state->leftSlides[index], 0, c1-1);
+ if(!rs.isEmpty())
+ c1 = rs.left();
+ }
+ for(int index = 0; index < nright; index++)
+ {
+ QRect rs = renderSlide(state->rightSlides[index], c2+1, buffer.width());
+ if(!rs.isEmpty())
+ c2 = rs.right();
+ }
+}
+
+// Render the slides. Updates only the offscreen buffer.
+void PictureFlowSoftwareRenderer::render()
+{
+ buffer.fill(state->backgroundColor);
+ renderSlides();
+ dirty = false;
+}
+
+// -----------------------------------------
+
+class PictureFlowPrivate
+{
+public:
+ PictureFlowState* state;
+ PictureFlowAnimator* animator;
+ PictureFlowAbstractRenderer* renderer;
+ QTimer triggerTimer;
+ QTimer scrollTimer;
+};
+
+
+PictureFlow::PictureFlow(QWidget* parent): FlowInterface(parent)
+{
+ d = new PictureFlowPrivate;
+
+ d->state = new PictureFlowState;
+ d->state->reset();
+ d->state->reposition();
+
+ d->renderer = new PictureFlowSoftwareRenderer;
+ d->renderer->state = d->state;
+ d->renderer->widget = this;
+ d->renderer->init();
+
+ d->animator = new PictureFlowAnimator;
+ d->animator->state = d->state;
+ QObject::connect(&d->animator->animateTimer, SIGNAL(timeout()), this, SLOT(updateAnimation()));
+
+ QObject::connect(&d->triggerTimer, SIGNAL(timeout()), this, SLOT(render()));
+ QObject::connect(&d->scrollTimer, SIGNAL(timeout()), this, SLOT(scroll()));
+
+#ifdef PICTUREFLOW_QT4
+ setAttribute(Qt::WA_StaticContents, true);
+ setAttribute(Qt::WA_OpaquePaintEvent, true);
+ setAttribute(Qt::WA_NoSystemBackground, true);
+#endif
+#ifdef PICTUREFLOW_QT3
+ setWFlags(getWFlags() | Qt::WStaticContents);
+ setWFlags(getWFlags() | Qt::WNoAutoErase);
+#endif
+#ifdef PICTUREFLOW_QT2
+ setWFlags(getWFlags() | Qt::WPaintClever);
+ setWFlags(getWFlags() | Qt::WRepaintNoErase);
+ setWFlags(getWFlags() | Qt::WResizeNoErase);
+#endif
+}
+
+PictureFlow::~PictureFlow()
+{
+ delete d->renderer;
+ delete d->animator;
+ delete d->state;
+ delete d;
+}
+
+int PictureFlow::slideCount() const
+{
+ return d->state->slideImages.count();
+}
+
+QColor PictureFlow::backgroundColor() const
+{
+ return QColor(d->state->backgroundColor);
+}
+
+void PictureFlow::setBackgroundColor(const QColor& c)
+{
+ d->state->backgroundColor = c.rgb();
+ triggerRender();
+}
+
+QSize PictureFlow::slideSize() const
+{
+ return QSize(d->state->slideWidth, d->state->slideHeight);
+}
+
+void PictureFlow::setSlideSize(QSize size)
+{
+ d->state->slideWidth = size.width();
+ d->state->slideHeight = size.height();
+ d->state->reposition();
+ triggerRender();
+}
+
+ReflectionEffect PictureFlow::reflectionEffect() const
+{
+ return d->state->reflectionEffect;
+}
+
+void PictureFlow::setReflectionEffect(ReflectionEffect effect)
+{
+ d->state->reflectionEffect = effect;
+ triggerRender();
+}
+
+QImage PictureFlow::slide(int index) const
+{
+ QImage* i = 0;
+ if((index >= 0) && (index < slideCount()))
+ i = d->state->slideImages[index];
+ return i ? QImage(*i) : QImage();
+}
+
+void PictureFlow::addSlide(const QImage& image)
+{
+ int c = d->state->slideImages.count();
+ d->state->slideImages.resize(c+1);
+ d->state->slideImages[c] = new QImage(image);
+ triggerRender();
+}
+
+void PictureFlow::addSlide(const QPixmap& pixmap)
+{
+ addSlide(pixmap.toImage());
+}
+
+void PictureFlow::setSlide(int index, const QImage& image)
+{
+ if((index >= 0) && (index < slideCount()))
+ {
+ QImage* i = image.isNull() ? 0 : new QImage(image);
+ delete d->state->slideImages[index];
+ d->state->slideImages[index] = i;
+ triggerRender();
+ }
+}
+
+void PictureFlow::setSlide(int index, const QPixmap& pixmap)
+{
+ setSlide(index, pixmap.toImage());
+}
+
+int PictureFlow::centerIndex() const
+{
+ return d->state->centerIndex;
+}
+
+bool PictureFlow::slideAnimationOngoing() const
+{
+ return d->animator->animateTimer.isActive();
+}
+
+void PictureFlow::setCenterIndex(int index)
+{
+ index = qMin(index, slideCount()-1);
+ index = qMax(index, 0);
+ d->state->centerIndex = index;
+ d->state->reset();
+ d->animator->stop(index);
+ triggerRender();
+}
+
+void PictureFlow::clear()
+{
+ int c = d->state->slideImages.count();
+ for(int i = 0; i < c; i++)
+ delete d->state->slideImages[i];
+ d->state->slideImages.resize(0);
+
+ d->state->reset();
+ triggerRender();
+}
+
+void PictureFlow::render()
+{
+ d->renderer->dirty = true;
+ update();
+}
+
+void PictureFlow::triggerRender()
+{
+#ifdef PICTUREFLOW_QT4
+ d->triggerTimer.setSingleShot(true);
+ d->triggerTimer.start(0);
+#endif
+#if defined(PICTUREFLOW_QT3) || defined(PICTUREFLOW_QT2)
+ d->triggerTimer.start(0, true);
+#endif
+}
+
+void PictureFlow::showPrevious()
+{
+ int step = d->animator->step;
+ int center = d->state->centerIndex;
+
+ if(step > 0)
+ d->animator->start(center);
+
+ if(step == 0)
+ if(center > 0)
+ d->animator->start(center - 1);
+
+ if(step < 0)
+ d->animator->target = qMax(0, center - 2);
+}
+
+void PictureFlow::showNext()
+{
+ int step = d->animator->step;
+ int center = d->state->centerIndex;
+
+ if(step < 0)
+ d->animator->start(center);
+
+ if(step == 0)
+ if(center < slideCount()-1)
+ d->animator->start(center + 1);
+
+ if(step > 0)
+ d->animator->target = qMin(center + 2, slideCount()-1);
+}
+
+void PictureFlow::showSlide(int index)
+{
+ index = qMax(index, 0);
+ index = qMin(slideCount()-1, index);
+ if(index == d->state->centerSlide.slideIndex)
+ return;
+
+ d->animator->start(index);
+}
+
+void PictureFlow::keyPressEvent(QKeyEvent* event)
+{
+ switch (event->key()) {
+ case Qt::Key_Escape:
+ emit cancel();
+ return;
+
+ case Qt::Key_Enter:
+ case Qt::Key_Return:
+ case Qt::Key_Select:
+ emit ok(centerIndex());
+ return;
+ case Qt::Key_Left:
+ if(event->modifiers() == Qt::ControlModifier)
+ showSlide(centerIndex()-10);
+ else
+ showPrevious();
+ event->accept();
+ return;
+ case Qt::Key_Right:
+ if(event->modifiers() == Qt::ControlModifier)
+ showSlide(centerIndex()+10);
+ else
+ showNext();
+ event->accept();
+ return;
+ }
+ event->ignore();
+}
+
+void PictureFlow::mousePressEvent(QMouseEvent* event)
+{
+ m_lastMoveEventPos = event->pos();
+ if (d->scrollTimer.isActive())
+ d->scrollTimer.stop();
+ d->scrollTimer.start(KScrollTimeout);
+ scroll();
+}
+
+void PictureFlow::mouseMoveEvent(QMouseEvent* event)
+{
+ m_lastMoveEventPos = event->pos();
+}
+
+void PictureFlow::mouseReleaseEvent(QMouseEvent* event)
+{
+ d->scrollTimer.stop();
+ if (slideAnimationOngoing()) {
+// qDebug() << "pf:mouseReleaseEvent slideanimation running, ignoring click";
+ return;
+ }
+ if(event->x() > ((width() * (slideRatio2 - slideRatio1)) / (2 * slideRatio2)) && event->x() < ((width() * (slideRatio2 + slideRatio1)) / (2 * slideRatio2))) {
+ emit ok(centerIndex());
+ return;
+ }
+}
+
+void PictureFlow::scroll()
+{
+ if(m_lastMoveEventPos.x() < ((width() * (slideRatio2 - slideRatio1)) / (2 * slideRatio2))) {
+ showPrevious();
+ }
+ else if (m_lastMoveEventPos.x() > ((width() * (slideRatio2 + slideRatio1)) / (2 * slideRatio2))) {
+ showNext();
+ }
+}
+
+
+void PictureFlow::paintEvent(QPaintEvent* event)
+{
+ Q_UNUSED(event);
+ d->renderer->paint();
+}
+
+void PictureFlow::resizeEvent(QResizeEvent* event)
+{
+ QWidget::resizeEvent(event);
+
+ QSize s = event->size(); //parentWidget()->rect().size();
+ setSlideSize(QSize((s.width() * slideRatio1) / slideRatio2, (s.height() * slideRatio1) / slideRatio2));
+}
+
+void PictureFlow::updateAnimation()
+{
+ int old_center = d->state->centerIndex;
+ d->animator->update();
+ triggerRender();
+ if(d->state->centerIndex != old_center)
+ emit centerIndexChanged(d->state->centerIndex);
+}
+
+void PictureFlow::init()
+{
+ QSize s = size(); //parentWidget()->rect().size();
+
+ setSlideSize(QSize((s.width() * slideRatio1) / slideRatio2, (s.height() * slideRatio1) / slideRatio2));
+ //resize(s);
+//TODO: Disable refrection ?
+// setReflectionEffect(PictureFlow::NoReflection);
+ setBackgroundColor(Qt::black);
+ // ensure that system cursor is an arrow, not a random icon
+ // This is not an issue if the platform does not have a system cursor
+#ifndef __SYMBIAN32__
+ setCursor(Qt::ArrowCursor);
+#endif
+ setFocusPolicy(Qt::WheelFocus);
+ setFocus(Qt::OtherFocusReason);
+}
+
+QRect PictureFlow::centralRect() const
+{
+ if (d->renderer) {
+ /* Render the slide to get the rectangle */
+ SlideInfo s = d->state->centerSlide;
+ QRect r = ((PictureFlowSoftwareRenderer*)d->renderer)->renderSlide(s);
+ return r;
+ }
+ else
+ return QRect();
+}
+
+//-----------------------------------------------
+// GraphicsPictureFlow class
+
+GraphicsPictureFlow::GraphicsPictureFlow(QObject* parent): GraphicsFlowInterface(NULL)
+{
+ setParent(parent);
+
+ d = new PictureFlowPrivate;
+
+ d->state = new PictureFlowState;
+ d->state->reset();
+ d->state->reposition();
+
+ d->renderer = new PictureFlowSoftwareRenderer;
+ d->renderer->state = d->state;
+ d->renderer->gWidget = this;
+ d->renderer->init();
+
+ d->animator = new PictureFlowAnimator;
+ d->animator->state = d->state;
+ QObject::connect(&d->animator->animateTimer, SIGNAL(timeout()), this, SLOT(updateAnimation()));
+
+ QObject::connect(&d->triggerTimer, SIGNAL(timeout()), this, SLOT(render()));
+ QObject::connect(&d->scrollTimer, SIGNAL(timeout()), this, SLOT(scroll()));
+
+#ifdef PICTUREFLOW_QT4
+ setAttribute(Qt::WA_StaticContents, true);
+ setAttribute(Qt::WA_OpaquePaintEvent, true);
+ setAttribute(Qt::WA_NoSystemBackground, true);
+#endif
+#ifdef PICTUREFLOW_QT3
+ setWFlags(getWFlags() | Qt::WStaticContents);
+ setWFlags(getWFlags() | Qt::WNoAutoErase);
+#endif
+#ifdef PICTUREFLOW_QT2
+ setWFlags(getWFlags() | Qt::WPaintClever);
+ setWFlags(getWFlags() | Qt::WRepaintNoErase);
+ setWFlags(getWFlags() | Qt::WResizeNoErase);
+#endif
+}
+
+GraphicsPictureFlow::~GraphicsPictureFlow()
+{
+ delete d->renderer;
+ delete d->animator;
+ delete d->state;
+ delete d;
+}
+
+int GraphicsPictureFlow::slideCount() const
+{
+ return d->state->slideImages.count();
+}
+
+QColor GraphicsPictureFlow::backgroundColor() const
+{
+ return QColor(d->state->backgroundColor);
+}
+
+void GraphicsPictureFlow::setBackgroundColor(const QColor& c)
+{
+ d->state->backgroundColor = c.rgb();
+ triggerRender();
+}
+
+QSize GraphicsPictureFlow::slideSize() const
+{
+ return QSize(d->state->slideWidth, d->state->slideHeight);
+}
+
+void GraphicsPictureFlow::setSlideSize(QSize size)
+{
+ d->state->slideWidth = size.width();
+ d->state->slideHeight = size.height();
+ d->state->reposition();
+ triggerRender();
+}
+
+ReflectionEffect GraphicsPictureFlow::reflectionEffect() const
+{
+ return d->state->reflectionEffect;
+}
+
+void GraphicsPictureFlow::setReflectionEffect(ReflectionEffect effect)
+{
+ d->state->reflectionEffect = effect;
+ triggerRender();
+}
+
+QImage GraphicsPictureFlow::slide(int index) const
+{
+ QImage* i = 0;
+ if((index >= 0) && (index < slideCount()))
+ i = d->state->slideImages[index];
+ return i ? QImage(*i) : QImage();
+}
+
+void GraphicsPictureFlow::addSlide(const QImage& image)
+{
+ int c = d->state->slideImages.count();
+ d->state->slideImages.resize(c+1);
+ d->state->slideImages[c] = new QImage(image);
+ triggerRender();
+}
+
+void GraphicsPictureFlow::addSlide(const QPixmap& pixmap)
+{
+ addSlide(pixmap.toImage());
+}
+
+void GraphicsPictureFlow::setSlide(int index, const QImage& image)
+{
+ if((index >= 0) && (index < slideCount()))
+ {
+ QImage* i = image.isNull() ? 0 : new QImage(image);
+ delete d->state->slideImages[index];
+ d->state->slideImages[index] = i;
+ triggerRender();
+ }
+}
+
+void GraphicsPictureFlow::setSlide(int index, const QPixmap& pixmap)
+{
+ setSlide(index, pixmap.toImage());
+}
+
+int GraphicsPictureFlow::centerIndex() const
+{
+ return d->state->centerIndex;
+}
+
+bool GraphicsPictureFlow::slideAnimationOngoing() const
+{
+ return d->animator->animateTimer.isActive();
+}
+
+void GraphicsPictureFlow::setCenterIndex(int index)
+{
+ index = qMin(index, slideCount()-1);
+ index = qMax(index, 0);
+ d->state->centerIndex = index;
+ d->state->reset();
+ d->animator->stop(index);
+ triggerRender();
+}
+
+void GraphicsPictureFlow::clear()
+{
+ int c = d->state->slideImages.count();
+ for(int i = 0; i < c; i++)
+ delete d->state->slideImages[i];
+ d->state->slideImages.resize(0);
+
+ d->state->reset();
+ triggerRender();
+}
+
+void GraphicsPictureFlow::render()
+{
+ d->renderer->dirty = true;
+ update();
+}
+
+void GraphicsPictureFlow::triggerRender()
+{
+#ifdef PICTUREFLOW_QT4
+ d->triggerTimer.setSingleShot(true);
+ d->triggerTimer.start(0);
+#endif
+#if defined(PICTUREFLOW_QT3) || defined(PICTUREFLOW_QT2)
+ d->triggerTimer.start(0, true);
+#endif
+}
+
+void GraphicsPictureFlow::showPrevious()
+{
+ int step = d->animator->step;
+ int center = d->state->centerIndex;
+
+ if(step > 0)
+ d->animator->start(center);
+
+ if(step == 0)
+ if(center > 0)
+ d->animator->start(center - 1);
+
+ if(step < 0)
+ d->animator->target = qMax(0, center - 2);
+}
+
+void GraphicsPictureFlow::showNext()
+{
+ int step = d->animator->step;
+ int center = d->state->centerIndex;
+
+ if(step < 0)
+ d->animator->start(center);
+
+ if(step == 0)
+ if(center < slideCount()-1)
+ d->animator->start(center + 1);
+
+ if(step > 0)
+ d->animator->target = qMin(center + 2, slideCount()-1);
+}
+
+void GraphicsPictureFlow::showSlide(int index)
+{
+ index = qMax(index, 0);
+ index = qMin(slideCount()-1, index);
+ if(index == d->state->centerSlide.slideIndex)
+ return;
+
+ d->animator->start(index);
+}
+
+void GraphicsPictureFlow::keyPressEvent(QKeyEvent* event)
+{
+ switch (event->key()) {
+ case Qt::Key_Escape:
+ emit cancel();
+ return;
+
+ case Qt::Key_Enter:
+ case Qt::Key_Return:
+ case Qt::Key_Select:
+ emit ok(centerIndex());
+ return;
+ case Qt::Key_Left:
+ if(event->modifiers() == Qt::ControlModifier)
+ showSlide(centerIndex()-10);
+ else
+ showPrevious();
+ event->accept();
+ return;
+ case Qt::Key_Right:
+ if(event->modifiers() == Qt::ControlModifier)
+ showSlide(centerIndex()+10);
+ else
+ showNext();
+ event->accept();
+ return;
+ }
+ event->ignore();
+}
+
+void GraphicsPictureFlow::mousePressEvent(QGraphicsSceneMouseEvent* event)
+{
+ m_lastMoveEventPos = event->pos().toPoint();
+ if (d->scrollTimer.isActive())
+ d->scrollTimer.stop();
+ d->scrollTimer.start(KScrollTimeout);
+ scroll();
+}
+
+void GraphicsPictureFlow::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
+{
+ m_lastMoveEventPos = event->pos().toPoint();
+}
+
+void GraphicsPictureFlow::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
+{
+ d->scrollTimer.stop();
+ if (slideAnimationOngoing()) {
+// qDebug() << "pf:mouseReleaseEvent slideanimation running, ignoring click";
+ return;
+ }
+ if(event->pos().x() > ((size().width() * (slideRatio2 - slideRatio1)) / (2 * slideRatio2)) && event->pos().x() < ((size().width() * (slideRatio2 + slideRatio1)) / (2 * slideRatio2))) {
+ emit ok(centerIndex());
+ return;
+ }
+}
+
+void GraphicsPictureFlow::scroll()
+{
+ if(m_lastMoveEventPos.x() < ((size().width() * (slideRatio2 - slideRatio1)) / (2 * slideRatio2))) {
+ showPrevious();
+ }
+ else if (m_lastMoveEventPos.x() > ((size().width() * (slideRatio2 + slideRatio1)) / (2 * slideRatio2))) {
+ showNext();
+ }
+}
+
+void GraphicsPictureFlow::paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget)
+{
+ d->renderer->gPainter = painter;
+ d->renderer->paint();
+ d->renderer->gPainter = NULL;
+}
+
+void GraphicsPictureFlow::resizeEvent(QGraphicsSceneResizeEvent* event)
+{
+ QGraphicsWidget::resizeEvent(event);
+
+ QSize s = event->newSize().toSize();
+ setSlideSize(QSize((s.width() * slideRatio1) / slideRatio2, (s.height() * slideRatio1) / slideRatio2));
+}
+
+void GraphicsPictureFlow::updateAnimation()
+{
+ int old_center = d->state->centerIndex;
+ d->animator->update();
+ triggerRender();
+ if(d->state->centerIndex != old_center)
+ emit centerIndexChanged(d->state->centerIndex);
+}
+
+void GraphicsPictureFlow::init()
+{
+ QSize s = size().toSize(); //parentWidget()->rect().size();
+
+ setSlideSize(QSize((s.width() * slideRatio1) / slideRatio2, (s.height() * slideRatio1) / slideRatio2));
+ //resize(s);
+//TODO: Disable refrection ?
+// setReflectionEffect(PictureFlow::NoReflection);
+ setBackgroundColor(Qt::black);
+ // ensure that system cursor is an arrow, not a random icon
+ // This is not an issue if the platform does not have a system cursor
+#ifndef __SYMBIAN32__
+ setCursor(Qt::ArrowCursor);
+#endif
+ setFocusPolicy(Qt::WheelFocus);
+ setFocus(Qt::OtherFocusReason);
+}
+
+QRect GraphicsPictureFlow::centralRect() const
+{
+ if (d->renderer) {
+ /* Render the slide to get the rectangle */
+ SlideInfo s = d->state->centerSlide;
+ QRect r = ((PictureFlowSoftwareRenderer*)d->renderer)->renderSlide(s);
+ return r;
+ }
+ else
+ return QRect();
+}
+}