1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the demonstration applications of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QBasicTimer>

    43 #include <QList>

    44 #include <QImage>

    45 #include <QDir>

    46 #include <QPainter>

    47 #include <QPaintEvent>

    48 

    49 #include <QDebug>

    50 

    51 

    52 #include "slideshow.h"

    53 

    54 

    55 class SlideShowPrivate

    56 {

    57 public:

    58     SlideShowPrivate();

    59 

    60     int currentSlide;

    61     int slideInterval;

    62     QBasicTimer interSlideTimer;

    63     QStringList imagePaths;

    64 

    65     void showNextSlide();

    66 };

    67 

    68 

    69 

    70 SlideShowPrivate::SlideShowPrivate()

    71 {

    72     currentSlide = 0;

    73     slideInterval = 10000; // Default to 10 sec interval

    74 }

    75 

    76 

    77 void SlideShowPrivate::showNextSlide()

    78 {

    79     currentSlide++;

    80     if (currentSlide >= imagePaths.size())

    81       currentSlide = 0;

    82 }

    83 

    84 

    85 

    86 SlideShow::SlideShow(QWidget* parent) :

    87     QWidget(parent)

    88 {

    89     d = new SlideShowPrivate;

    90 

    91     setAttribute(Qt::WA_StaticContents, true);

    92     setAttribute(Qt::WA_OpaquePaintEvent, true);

    93     setAttribute(Qt::WA_NoSystemBackground, true);

    94 

    95     setMouseTracking(true);

    96 }

    97 

    98 

    99 SlideShow::~SlideShow()

   100 {

   101     delete d;

   102 }

   103 

   104 

   105 void SlideShow::addImageDir(QString dirName)

   106 {

   107     QDir dir(dirName);

   108 

   109     QStringList fileNames = dir.entryList(QDir::Files | QDir::Readable, QDir::Name);

   110 

   111     for (int i=0; i<fileNames.count(); i++)

   112         d->imagePaths << dir.absoluteFilePath(fileNames[i]);

   113 }

   114 

   115 void SlideShow::addImage(QString filename)

   116 {

   117     d->imagePaths << filename;

   118 }

   119 

   120 

   121 void SlideShow::clearImages()

   122 {

   123     d->imagePaths.clear();

   124 }

   125 

   126 

   127 void SlideShow::startShow()

   128 {

   129     d->interSlideTimer.start(d->slideInterval, this);

   130     d->showNextSlide();

   131     update();

   132 }

   133 

   134 

   135 void SlideShow::stopShow()

   136 {

   137     d->interSlideTimer.stop();

   138 }

   139 

   140 

   141 int SlideShow::slideInterval()

   142 {

   143     return d->slideInterval;

   144 }

   145 

   146 void SlideShow::setSlideInterval(int val)

   147 {

   148     d->slideInterval = val;

   149 }

   150 

   151 

   152 void SlideShow::timerEvent(QTimerEvent* event)

   153 {

   154     Q_UNUSED(event);

   155     d->showNextSlide();

   156     update();

   157 }

   158 

   159 

   160 void SlideShow::paintEvent(QPaintEvent *event)

   161 {

   162     QPainter painter(this);

   163     painter.setRenderHint(QPainter::Antialiasing, false);

   164 

   165     if (d->imagePaths.size() > 0) {

   166         QPixmap slide = QPixmap(d->imagePaths[d->currentSlide]);

   167         QSize slideSize = slide.size();

   168         QSize scaledSize = QSize(qMin(slideSize.width(), size().width()),

   169             qMin(slideSize.height(), size().height()));

   170         if (slideSize != scaledSize)

   171             slide = slide.scaled(scaledSize, Qt::KeepAspectRatio);

   172 

   173         QRect pixmapRect(qMax( (size().width() - slide.width())/2, 0),

   174                          qMax( (size().height() - slide.height())/2, 0),

   175                          slide.width(),

   176                          slide.height());

   177 

   178         if (pixmapRect.top() > 0) {

   179             // Fill in top & bottom rectangles:

   180             painter.fillRect(0, 0, size().width(), pixmapRect.top(), Qt::black);

   181             painter.fillRect(0, pixmapRect.bottom(), size().width(), size().height(), Qt::black);

   182         }

   183 

   184         if (pixmapRect.left() > 0) {

   185             // Fill in left & right rectangles:

   186             painter.fillRect(0, 0, pixmapRect.left(), size().height(), Qt::black);

   187             painter.fillRect(pixmapRect.right(), 0, size().width(), size().height(), Qt::black);

   188         }

   189 

   190         painter.drawPixmap(pixmapRect, slide);

   191 

   192     } else

   193         painter.fillRect(event->rect(), Qt::black);

   194 }

   195 

   196 

   197 void SlideShow::keyPressEvent(QKeyEvent* event)

   198 {

   199     Q_UNUSED(event);

   200     emit inputReceived();

   201 }

   202 

   203 

   204 void SlideShow::mouseMoveEvent(QMouseEvent* event)

   205 {

   206     Q_UNUSED(event);

   207     emit inputReceived();

   208 }

   209 

   210 

   211 void SlideShow::mousePressEvent(QMouseEvent* event)

   212 {

   213     Q_UNUSED(event);

   214     emit inputReceived();

   215 }

   216 

   217 

   218 void SlideShow::mouseReleaseEvent(QMouseEvent* event)

   219 {

   220     Q_UNUSED(event);

   221     emit inputReceived();

   222 }

   223 

   224 

   225 void SlideShow::showEvent(QShowEvent * event )

   226 {

   227     Q_UNUSED(event);

   228 #ifndef QT_NO_CURSOR

   229     setCursor(Qt::BlankCursor);

   230 #endif

   231 }

   232