File indexing completed on 2024-04-28 04:18:53

 /*
 Gwenview: an image viewer
 Copyright 2007 Aurélien Gâteau <agateau@kde.org>
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 */
 #include "slideshow.h"
 
 // STL
 #include <algorithm>
 #include <ctime>
 #include <random>
 
 // Qt
 #include <QAction>
 #include <QTimer>
 
 // KF
 #include <KLocalizedString>
 
 // Local
 #include "gwenview_lib_debug.h"
 #include <gwenviewconfig.h>
 #include <lib/gvdebug.h>
 
 namespace Gwenview
 {
 #undef ENABLE_LOG
 #undef LOG
 // #define ENABLE_LOG
 #ifdef ENABLE_LOG
 #define LOG(x) qCDebug(GWENVIEW_LIB_LOG) << x
 #else
 #define LOG(x) ;
 #endif
 
 enum State {
     Paused,
     Started,
     WaitForEndOfUrl,
 };
 
 struct SlideShowPrivate {
     QTimer *mTimer = nullptr;
     State mState;
     QVector<QUrl> mUrls;
     QVector<QUrl> mShuffledUrls;
     QVector<QUrl>::ConstIterator mStartIt;
     QUrl mCurrentUrl;
     QUrl mLastShuffledUrl;
 
     QAction *mLoopAction = nullptr;
     QAction *mRandomAction = nullptr;
 
     QUrl findNextUrl()
     {
         if (GwenviewConfig::random()) {
             return findNextRandomUrl();
         } else {
             return findNextOrderedUrl();
         }
     }
 
     QUrl findNextOrderedUrl()
     {
         QVector<QUrl>::ConstIterator it = std::find(mUrls.constBegin(), mUrls.constEnd(), mCurrentUrl);
         GV_RETURN_VALUE_IF_FAIL2(it != mUrls.constEnd(), QUrl(), "Current url not found in list.");
 
         ++it;
         if (GwenviewConfig::loop()) {
             // Looping, if we reach the end, start again
             if (it == mUrls.constEnd()) {
                 it = mUrls.constBegin();
             }
         } else {
             // Not looping, have we reached the end?
             // FIXME: stopAtEnd
             if (/*(it==mUrls.end() && GwenviewConfig::stopAtEnd()) ||*/ it == mStartIt) {
                 it = mUrls.constEnd();
             }
         }
 
         if (it != mUrls.constEnd()) {
             return *it;
         } else {
             return {};
         }
     }
 
     void initShuffledUrls()
     {
         mShuffledUrls = mUrls;
         std::random_device rd;
         std::mt19937 generator(rd());
         std::shuffle(mShuffledUrls.begin(), mShuffledUrls.end(), generator);
         // Ensure the first url is different from the previous last one, so that
         // last url does not stay visible twice longer than usual
         if (mLastShuffledUrl == mShuffledUrls.first() && mShuffledUrls.count() > 1) {
             std::swap(mShuffledUrls[0], mShuffledUrls[1]);
         }
         mLastShuffledUrl = mShuffledUrls.last();
     }
 
     QUrl findNextRandomUrl()
     {
         if (mShuffledUrls.empty()) {
             if (GwenviewConfig::loop()) {
                 initShuffledUrls();
             } else {
                 return {};
             }
         }
 
         const QUrl url = mShuffledUrls.last();
         mShuffledUrls.pop_back();
 
         return url;
     }
 
     void updateTimerInterval()
     {
         mTimer->setInterval(int(GwenviewConfig::interval() * 1000));
     }
 
     void doStart()
     {
         if (MimeTypeUtils::urlKind(mCurrentUrl) == MimeTypeUtils::KIND_VIDEO) {
             LOG("mState = WaitForEndOfUrl");
             // Just in case
             mTimer->stop();
             mState = WaitForEndOfUrl;
         } else {
             LOG("mState = Started");
             mTimer->start();
             mState = Started;
         }
     }
 };
 
 SlideShow::SlideShow(QObject *parent)
     : QObject(parent)
     , d(new SlideShowPrivate)
 {
     d->mState = Paused;
 
     d->mTimer = new QTimer(this);
     connect(d->mTimer, &QTimer::timeout, this, &SlideShow::goToNextUrl);
 
     d->mLoopAction = new QAction(this);
     d->mLoopAction->setText(i18nc("@item:inmenu toggle loop in slideshow", "Loop"));
     d->mLoopAction->setCheckable(true);
     connect(d->mLoopAction, &QAction::triggered, this, &SlideShow::updateConfig);
 
     d->mRandomAction = new QAction(this);
     d->mRandomAction->setText(i18nc("@item:inmenu toggle random order in slideshow", "Random"));
     d->mRandomAction->setCheckable(true);
     connect(d->mRandomAction, &QAction::toggled, this, &SlideShow::slotRandomActionToggled);
     connect(d->mRandomAction, &QAction::triggered, this, &SlideShow::updateConfig);
 
     d->mLoopAction->setChecked(GwenviewConfig::loop());
     d->mRandomAction->setChecked(GwenviewConfig::random());
 }
 
 SlideShow::~SlideShow()
 {
     GwenviewConfig::self()->save();
     delete d;
 }
 
 QAction *SlideShow::loopAction() const
 {
     return d->mLoopAction;
 }
 
 QAction *SlideShow::randomAction() const
 {
     return d->mRandomAction;
 }
 
 void SlideShow::start(const QList<QUrl> &urls)
 {
     d->mUrls.resize(urls.size());
     std::copy(urls.begin(), urls.end(), d->mUrls.begin());
 
     d->mStartIt = std::find(d->mUrls.constBegin(), d->mUrls.constEnd(), d->mCurrentUrl);
     if (d->mStartIt == d->mUrls.constEnd()) {
         qCWarning(GWENVIEW_LIB_LOG) << "Current url not found in list, aborting.\n";
         return;
     }
 
     if (GwenviewConfig::random()) {
         d->initShuffledUrls();
     }
 
     d->updateTimerInterval();
     d->mTimer->setSingleShot(false);
     d->doStart();
     Q_EMIT stateChanged(true);
 }
 
 void SlideShow::setInterval(int intervalInSeconds)
 {
     GwenviewConfig::setInterval(double(intervalInSeconds));
     d->updateTimerInterval();
     Q_EMIT intervalChanged(intervalInSeconds);
 }
 
 int SlideShow::interval() const
 {
     return GwenviewConfig::interval();
 }
 
 int SlideShow::position() const
 {
     // TODO: also support videos
 
     // QTimer::remainingTime() returns -1 if inactive
     // and there are moments where mState == Started but timer already done but not yet next url reached
     // so handle that
     if (d->mState == Started) {
         if (d->mTimer->isActive()) {
             return interval() * 1000 - d->mTimer->remainingTime();
         }
         // already timeout reached, but not yet progressed to next url
         return interval();
     }
 
     return 0;
 }
 
 void SlideShow::pause()
 {
     LOG("Stopping timer");
     d->mTimer->stop();
     d->mState = Paused;
     Q_EMIT stateChanged(false);
 }
 
 void SlideShow::resumeAndGoToNextUrl()
 {
     LOG("");
     if (d->mState == WaitForEndOfUrl) {
         goToNextUrl();
     }
 }
 
 void SlideShow::goToNextUrl()
 {
     LOG("");
     const QUrl url = d->findNextUrl();
     LOG("url:" << url);
     if (!url.isValid()) {
         pause();
         return;
     }
     Q_EMIT goToUrl(url);
 }
 
 void SlideShow::setCurrentUrl(const QUrl &url)
 {
     LOG(url);
     if (d->mCurrentUrl == url) {
         return;
     }
     d->mCurrentUrl = url;
     // Restart timer to avoid showing new url for the remaining time of the old
     // url
     if (d->mState != Paused) {
         d->doStart();
     }
 }
 
 bool SlideShow::isRunning() const
 {
     return d->mState != Paused;
 }
 
 void SlideShow::updateConfig()
 {
     GwenviewConfig::setLoop(d->mLoopAction->isChecked());
     GwenviewConfig::setRandom(d->mRandomAction->isChecked());
 }
 
 void SlideShow::slotRandomActionToggled(bool on)
 {
     if (on && d->mState != Paused) {
         d->initShuffledUrls();
     }
 }
 
 } // namespace
 
 #include "moc_slideshow.cpp"