File indexing completed on 2024-04-28 15:51:56

 /*
     SPDX-FileCopyrightText: 2004 Enrico Ros <eros.kde@email.it>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "presentationwidget.h"
 #include "config-okular.h"
 
 // qt/kde includes
 #if HAVE_DBUS
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QDBusReply>
 #endif
 #include <QLoggingCategory>
 
 #include <KActionCollection>
 #include <KCursor>
 #include <KLineEdit>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSelectAction>
 #include <QAction>
 #include <QActionGroup>
 #include <QApplication>
 #include <QDialog>
 #include <QEvent>
 #include <QFontMetrics>
 #include <QGestureEvent>
 #include <QIcon>
 #include <QImage>
 #include <QLabel>
 #include <QLayout>
 #include <QPainter>
 #include <QRandomGenerator>
 #include <QScreen>
 #include <QStyle>
 #include <QStyleOption>
 #include <QTimer>
 #include <QToolBar>
 #include <QToolTip>
 #include <QValidator>
 
 #ifdef Q_OS_LINUX
 #if HAVE_DBUS
 #include <QDBusUnixFileDescriptor>
 #endif
 #include <unistd.h> // For ::close() for sleep inhibition
 #endif
 
 // system includes
 #include <math.h>
 #include <stdlib.h>
 
 // local includes
 #include "annotationtools.h"
 #include "core/action.h"
 #include "core/annotations.h"
 #include "core/audioplayer.h"
 #include "core/document.h"
 #include "core/generator.h"
 #include "core/movie.h"
 #include "core/page.h"
 #include "drawingtoolactions.h"
 #include "gui/debug_ui.h"
 #include "gui/guiutils.h"
 #include "gui/pagepainter.h"
 #include "gui/priorities.h"
 #include "presentationsearchbar.h"
 #include "settings.h"
 #include "settings_core.h"
 #include "videowidget.h"
 
 // comment this to disable the top-right progress indicator
 #define ENABLE_PROGRESS_OVERLAY
 
 // a frame contains a pointer to the page object, its geometry and the
 // transition effect to the next frame
 struct PresentationFrame {
     PresentationFrame() = default;
 
     ~PresentationFrame()
     {
         qDeleteAll(videoWidgets);
     }
 
     PresentationFrame(const PresentationFrame &) = delete;
     PresentationFrame &operator=(const PresentationFrame &) = delete;
 
     void recalcGeometry(int width, int height, float screenRatio)
     {
         // calculate frame geometry keeping constant aspect ratio
         float pageRatio = page->ratio();
         int pageWidth = width, pageHeight = height;
         if (pageRatio > screenRatio) {
             pageWidth = (int)((float)pageHeight / pageRatio);
         } else {
             pageHeight = (int)((float)pageWidth * pageRatio);
         }
         geometry.setRect((width - pageWidth) / 2, (height - pageHeight) / 2, pageWidth, pageHeight);
 
         for (VideoWidget *vw : std::as_const(videoWidgets)) {
             const Okular::NormalizedRect r = vw->normGeometry();
             QRect vwgeom = r.geometry(geometry.width(), geometry.height());
             vw->resize(vwgeom.size());
             vw->move(geometry.topLeft() + vwgeom.topLeft());
         }
     }
 
     const Okular::Page *page;
     QRect geometry;
     QHash<Okular::Movie *, VideoWidget *> videoWidgets;
     std::vector<SmoothPath> drawings;
 };
 
 // a custom QToolBar that basically does not propagate the event if the widget
 // background is not automatically filled
 class PresentationToolBar : public QToolBar
 {
     Q_OBJECT
 
 public:
     explicit PresentationToolBar(QWidget *parent = Q_NULLPTR)
         : QToolBar(parent)
     {
     }
 
 protected:
     void mousePressEvent(QMouseEvent *e) override
     {
         QToolBar::mousePressEvent(e);
         e->accept();
     }
 
     void mouseReleaseEvent(QMouseEvent *e) override
     {
         QToolBar::mouseReleaseEvent(e);
         e->accept();
     }
 };
 
 PresentationWidget::PresentationWidget(QWidget *parent, Okular::Document *doc, DrawingToolActions *drawingToolActions, KActionCollection *collection)
     : QWidget(nullptr /* must be null, to have an independent widget */, Qt::FramelessWindowHint)
     , m_pressedLink(nullptr)
     , m_handCursor(false)
     , m_drawingEngine(nullptr)
     , m_screenInhibitCookie(0)
     , m_sleepInhibitFd(-1)
     , m_parentWidget(parent)
     , m_document(doc)
     , m_frameIndex(-1)
     , m_topBar(nullptr)
     , m_pagesEdit(nullptr)
     , m_searchBar(nullptr)
     , m_ac(collection)
     , m_screenSelect(nullptr)
     , m_isSetup(false)
     , m_blockNotifications(false)
     , m_inBlackScreenMode(false)
     , m_showSummaryView(Okular::Settings::slidesShowSummary())
     , m_advanceSlides(Okular::SettingsCore::slidesAdvance())
     , m_goToPreviousPageOnRelease(false)
     , m_goToNextPageOnRelease(false)
 {
     setAttribute(Qt::WA_DeleteOnClose);
     setAttribute(Qt::WA_OpaquePaintEvent);
     setObjectName(QStringLiteral("presentationWidget"));
     QString caption = doc->metaData(QStringLiteral("DocumentTitle")).toString();
     if (caption.trimmed().isEmpty()) {
         caption = doc->currentDocument().fileName();
     }
     caption = i18nc("[document title/filename] – Presentation", "%1 – Presentation", caption);
     setWindowTitle(caption);
 
     m_width = -1;
 
     // create top toolbar
     m_topBar = new PresentationToolBar(this);
     m_topBar->setObjectName(QStringLiteral("presentationBar"));
     m_topBar->setMovable(false);
     m_topBar->layout()->setContentsMargins(0, 0, 0, 0);
     m_topBar->addAction(QIcon::fromTheme(layoutDirection() == Qt::RightToLeft ? QStringLiteral("go-next") : QStringLiteral("go-previous")), i18n("Previous Page"), this, SLOT(slotPrevPage()));
     m_pagesEdit = new KLineEdit(m_topBar);
     QSizePolicy sp = m_pagesEdit->sizePolicy();
     sp.setHorizontalPolicy(QSizePolicy::Minimum);
     m_pagesEdit->setSizePolicy(sp);
     QFontMetrics fm(m_pagesEdit->font());
     QStyleOptionFrame option;
     option.initFrom(m_pagesEdit);
     m_pagesEdit->setMaximumWidth(fm.horizontalAdvance(QString::number(m_document->pages())) + 2 * style()->pixelMetric(QStyle::PM_DefaultFrameWidth, &option, m_pagesEdit) +
                                  4); // the 4 comes from 2*horizontalMargin, horizontalMargin being a define in qlineedit.cpp
     QIntValidator *validator = new QIntValidator(1, m_document->pages(), m_pagesEdit);
     m_pagesEdit->setValidator(validator);
     m_topBar->addWidget(m_pagesEdit);
     QLabel *pagesLabel = new QLabel(m_topBar);
     pagesLabel->setText(QLatin1String(" / ") + QString::number(m_document->pages()) + QLatin1String(" "));
     m_topBar->addWidget(pagesLabel);
     connect(m_pagesEdit, &QLineEdit::returnPressed, this, &PresentationWidget::slotPageChanged);
     m_topBar->addAction(QIcon::fromTheme(layoutDirection() == Qt::RightToLeft ? QStringLiteral("go-previous") : QStringLiteral("go-next")), i18n("Next Page"), this, SLOT(slotNextPage()));
     m_topBar->addSeparator();
     QAction *playPauseAct = collection->action(QStringLiteral("presentation_play_pause"));
     playPauseAct->setEnabled(true);
     connect(playPauseAct, &QAction::triggered, this, &PresentationWidget::slotTogglePlayPause);
     m_topBar->addAction(playPauseAct);
     addAction(playPauseAct);
     m_topBar->addSeparator();
 
     const QList<QAction *> actionsList = drawingToolActions->actions();
     for (QAction *action : actionsList) {
         action->setEnabled(true);
         m_topBar->addAction(action);
         addAction(action);
     }
     connect(drawingToolActions, &DrawingToolActions::changeEngine, this, &PresentationWidget::slotChangeDrawingToolEngine);
     connect(drawingToolActions, &DrawingToolActions::actionsRecreated, this, &PresentationWidget::slotAddDrawingToolActions);
 
     QAction *eraseDrawingAct = collection->action(QStringLiteral("presentation_erase_drawings"));
     eraseDrawingAct->setEnabled(true);
     connect(eraseDrawingAct, &QAction::triggered, this, &PresentationWidget::clearDrawings);
     m_topBar->addAction(eraseDrawingAct);
     addAction(eraseDrawingAct);
 
     const int screenCount = QApplication::screens().count();
     if (screenCount > 1) {
         m_topBar->addSeparator();
         m_screenSelect = new KSelectAction(QIcon::fromTheme(QStringLiteral("video-display")), i18n("Switch Screen"), m_topBar);
         m_screenSelect->setToolBarMode(KSelectAction::MenuMode);
         m_screenSelect->setToolButtonPopupMode(QToolButton::InstantPopup);
         m_topBar->addAction(m_screenSelect);
         for (int i = 0; i < screenCount; ++i) {
             QAction *act = m_screenSelect->addAction(i18nc("%1 is the screen number (0, 1, ...)", "Screen %1", i));
             act->setData(QVariant::fromValue(i));
         }
     }
     QWidget *spacer = new QWidget(m_topBar);
     spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::MinimumExpanding);
     m_topBar->addWidget(spacer);
     m_topBar->addAction(QIcon::fromTheme(QStringLiteral("application-exit")), i18n("Exit Presentation Mode"), this, SLOT(close()));
     m_topBar->setAutoFillBackground(true);
     showTopBar(false);
     // change topbar background color
     QPalette p = m_topBar->palette();
     p.setColor(QPalette::Active, QPalette::Button, Qt::gray);
     p.setColor(QPalette::Active, QPalette::Window, Qt::darkGray);
     m_topBar->setPalette(p);
 
     // Grab swipe gestures to change pages
     grabGesture(Qt::SwipeGesture);
 
     // misc stuff
     setMouseTracking(true);
     setContextMenuPolicy(Qt::PreventContextMenu);
     m_transitionTimer = new QTimer(this);
     m_transitionTimer->setSingleShot(true);
     connect(m_transitionTimer, &QTimer::timeout, this, &PresentationWidget::slotTransitionStep);
     m_overlayHideTimer = new QTimer(this);
     m_overlayHideTimer->setSingleShot(true);
     connect(m_overlayHideTimer, &QTimer::timeout, this, &PresentationWidget::slotHideOverlay);
     m_nextPageTimer = new QTimer(this);
     m_nextPageTimer->setSingleShot(true);
     connect(m_nextPageTimer, &QTimer::timeout, this, &PresentationWidget::slotNextPage);
     setPlayPauseIcon();
 
     connect(m_document, &Okular::Document::processMovieAction, this, &PresentationWidget::slotProcessMovieAction);
     connect(m_document, &Okular::Document::processRenditionAction, this, &PresentationWidget::slotProcessRenditionAction);
 
     // handle cursor appearance as specified in configuration
     if (Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::HiddenDelay) {
         KCursor::setAutoHideCursor(this, true);
         KCursor::setHideCursorDelay(3000);
     } else if (Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::Hidden) {
         setCursor(QCursor(Qt::BlankCursor));
     }
 
     setupActions();
 
     // inhibit power management
     inhibitPowerManagement();
 
     QTimer::singleShot(0, this, &PresentationWidget::slotDelayedEvents);
 
     // setFocus() so KCursor::setAutoHideCursor() goes into effect if it's enabled
     setFocus(Qt::OtherFocusReason);
 
     // Catch TabletEnterProximity and TabletLeaveProximity events from the QApplication
     qApp->installEventFilter(this);
 }
 
 PresentationWidget::~PresentationWidget()
 {
     // allow power management saver again
     allowPowerManagement();
 
     // stop the audio playbacks
     Okular::AudioPlayer::instance()->stopPlaybacks();
 
     // remove our highlights
     if (m_searchBar) {
         m_document->resetSearch(PRESENTATION_SEARCH_ID);
     }
 
     // remove this widget from document observer
     m_document->removeObserver(this);
 
     const QList<QAction *> actionsList = actions();
     for (QAction *action : actionsList) {
         action->setChecked(false);
         action->setEnabled(false);
     }
 
     delete m_drawingEngine;
 
     // delete frames
     qDeleteAll(m_frames);
 
     qApp->removeEventFilter(this);
 }
 
 void PresentationWidget::notifySetup(const QVector<Okular::Page *> &pageSet, int setupFlags)
 {
     // same document, nothing to change - here we assume the document sets up
     // us with the whole document set as first notifySetup()
     if (!(setupFlags & Okular::DocumentObserver::DocumentChanged)) {
         return;
     }
 
     // delete previous frames (if any (shouldn't be))
     qDeleteAll(m_frames);
     if (!m_frames.isEmpty()) {
         qCWarning(OkularUiDebug) << "Frames setup changed while a Presentation is in progress.";
     }
     m_frames.clear();
 
     // create the new frames
     float screenRatio = (float)m_height / (float)m_width;
     for (const Okular::Page *page : pageSet) {
         PresentationFrame *frame = new PresentationFrame();
         frame->page = page;
         const QList<Okular::Annotation *> annotations = page->annotations();
         for (Okular::Annotation *a : annotations) {
             if (a->subType() == Okular::Annotation::AMovie) {
                 Okular::MovieAnnotation *movieAnn = static_cast<Okular::MovieAnnotation *>(a);
                 VideoWidget *vw = new VideoWidget(movieAnn, movieAnn->movie(), m_document, this);
                 frame->videoWidgets.insert(movieAnn->movie(), vw);
                 vw->pageInitialized();
             } else if (a->subType() == Okular::Annotation::ARichMedia) {
                 Okular::RichMediaAnnotation *richMediaAnn = static_cast<Okular::RichMediaAnnotation *>(a);
                 if (richMediaAnn->movie()) {
                     VideoWidget *vw = new VideoWidget(richMediaAnn, richMediaAnn->movie(), m_document, this);
                     frame->videoWidgets.insert(richMediaAnn->movie(), vw);
                     vw->pageInitialized();
                 }
             } else if (a->subType() == Okular::Annotation::AScreen) {
                 const Okular::ScreenAnnotation *screenAnn = static_cast<Okular::ScreenAnnotation *>(a);
                 Okular::Movie *movie = GuiUtils::renditionMovieFromScreenAnnotation(screenAnn);
                 if (movie) {
                     VideoWidget *vw = new VideoWidget(screenAnn, movie, m_document, this);
                     frame->videoWidgets.insert(movie, vw);
                     vw->pageInitialized();
                 }
             }
         }
         frame->recalcGeometry(m_width, m_height, screenRatio);
         // add the frame to the vector
         m_frames.push_back(frame);
     }
 
     // get metadata from the document
     m_metaStrings.clear();
     const Okular::DocumentInfo info = m_document->documentInfo(QSet<Okular::DocumentInfo::Key>() << Okular::DocumentInfo::Title << Okular::DocumentInfo::Author);
     if (!info.get(Okular::DocumentInfo::Title).isNull()) {
         m_metaStrings += i18n("Title: %1", info.get(Okular::DocumentInfo::Title));
     }
     if (!info.get(Okular::DocumentInfo::Author).isNull()) {
         m_metaStrings += i18n("Author: %1", info.get(Okular::DocumentInfo::Author));
     }
     m_metaStrings += i18n("Pages: %1", m_document->pages());
     m_metaStrings += i18n("Click to begin");
 
     m_isSetup = true;
 }
 
 void PresentationWidget::notifyViewportChanged(bool /*smoothMove*/)
 {
     // display the current page
     changePage(m_document->viewport().pageNumber);
 
     // auto advance to the next page if set
     startAutoChangeTimer();
 }
 
 void PresentationWidget::notifyPageChanged(int pageNumber, int changedFlags)
 {
     // if we are blocking the notifications, do nothing
     if (m_blockNotifications) {
         return;
     }
 
     // check if it's the last requested pixmap. if so update the widget.
     if ((changedFlags & (DocumentObserver::Pixmap | DocumentObserver::Annotations | DocumentObserver::Highlights)) && pageNumber == m_frameIndex) {
         generatePage(changedFlags & (DocumentObserver::Annotations | DocumentObserver::Highlights));
     }
 }
 
 void PresentationWidget::notifyCurrentPageChanged(int previousPage, int currentPage)
 {
     if (previousPage != -1) {
         // stop video playback
         for (VideoWidget *vw : std::as_const(m_frames[previousPage]->videoWidgets)) {
             vw->stop();
             vw->pageLeft();
         }
 
         // stop audio playback, if any
         Okular::AudioPlayer::instance()->stopPlaybacks();
 
         // perform the page closing action, if any
         if (m_document->page(previousPage)->pageAction(Okular::Page::Closing)) {
             m_document->processAction(m_document->page(previousPage)->pageAction(Okular::Page::Closing));
         }
 
         // perform the additional actions of the page's annotations, if any
         const QList<Okular::Annotation *> annotationsList = m_document->page(previousPage)->annotations();
         for (const Okular::Annotation *annotation : annotationsList) {
             Okular::Action *action = nullptr;
 
             if (annotation->subType() == Okular::Annotation::AScreen) {
                 action = static_cast<const Okular::ScreenAnnotation *>(annotation)->additionalAction(Okular::Annotation::PageClosing);
             } else if (annotation->subType() == Okular::Annotation::AWidget) {
                 action = static_cast<const Okular::WidgetAnnotation *>(annotation)->additionalAction(Okular::Annotation::PageClosing);
             }
 
             if (action) {
                 m_document->processAction(action);
             }
         }
     }
 
     if (currentPage != -1) {
         m_frameIndex = currentPage;
 
         // check if pixmap exists or else request it
         PresentationFrame *frame = m_frames[m_frameIndex];
         int pixW = frame->geometry.width();
         int pixH = frame->geometry.height();
 
         bool signalsBlocked = m_pagesEdit->signalsBlocked();
         m_pagesEdit->blockSignals(true);
         m_pagesEdit->setText(QString::number(m_frameIndex + 1));
         m_pagesEdit->blockSignals(signalsBlocked);
 
         // if pixmap not inside the Okular::Page we request it and wait for
         // notifyPixmapChanged call or else we can proceed to pixmap generation
         if (!frame->page->hasPixmap(this, ceil(pixW * devicePixelRatioF()), ceil(pixH * devicePixelRatioF()))) {
             requestPixmaps();
         } else {
             // make the background pixmap
             generatePage();
         }
 
         // perform the page opening action, if any
         if (m_document->page(m_frameIndex)->pageAction(Okular::Page::Opening)) {
             m_document->processAction(m_document->page(m_frameIndex)->pageAction(Okular::Page::Opening));
         }
 
         // perform the additional actions of the page's annotations, if any
         const QList<Okular::Annotation *> annotationsList = m_document->page(m_frameIndex)->annotations();
         for (const Okular::Annotation *annotation : annotationsList) {
             Okular::Action *action = nullptr;
 
             if (annotation->subType() == Okular::Annotation::AScreen) {
                 action = static_cast<const Okular::ScreenAnnotation *>(annotation)->additionalAction(Okular::Annotation::PageOpening);
             } else if (annotation->subType() == Okular::Annotation::AWidget) {
                 action = static_cast<const Okular::WidgetAnnotation *>(annotation)->additionalAction(Okular::Annotation::PageOpening);
             }
 
             if (action) {
                 m_document->processAction(action);
             }
         }
 
         // start autoplay video playback
         for (VideoWidget *vw : std::as_const(m_frames[m_frameIndex]->videoWidgets)) {
             vw->pageEntered();
         }
     }
 }
 
 bool PresentationWidget::canUnloadPixmap(int pageNumber) const
 {
     if (Okular::SettingsCore::memoryLevel() == Okular::SettingsCore::EnumMemoryLevel::Low || Okular::SettingsCore::memoryLevel() == Okular::SettingsCore::EnumMemoryLevel::Normal) {
         // can unload all pixmaps except for the currently visible one
         return pageNumber != m_frameIndex;
     } else {
         // can unload all pixmaps except for the currently visible one, previous and next
         return qAbs(pageNumber - m_frameIndex) <= 1;
     }
 }
 
 void PresentationWidget::setupActions()
 {
     addAction(m_ac->action(QStringLiteral("first_page")));
     addAction(m_ac->action(QStringLiteral("last_page")));
     addAction(m_ac->action(KStandardAction::name(KStandardAction::Prior)));
     addAction(m_ac->action(KStandardAction::name(KStandardAction::Next)));
     addAction(m_ac->action(KStandardAction::name(KStandardAction::DocumentBack)));
     addAction(m_ac->action(KStandardAction::name(KStandardAction::DocumentForward)));
 
     QAction *action = m_ac->action(QStringLiteral("switch_blackscreen_mode"));
     connect(action, &QAction::toggled, this, &PresentationWidget::toggleBlackScreenMode);
     action->setEnabled(true);
     addAction(action);
 }
 
 void PresentationWidget::setPlayPauseIcon()
 {
     QAction *playPauseAction = m_ac->action(QStringLiteral("presentation_play_pause"));
     if (m_nextPageTimer->isActive()) {
         playPauseAction->setIcon(QIcon::fromTheme(QStringLiteral("media-playback-pause")));
         playPauseAction->setToolTip(i18nc("For Presentation", "Pause"));
     } else {
         playPauseAction->setIcon(QIcon::fromTheme(QStringLiteral("media-playback-start")));
         playPauseAction->setToolTip(i18nc("For Presentation", "Play"));
     }
 }
 
 bool PresentationWidget::eventFilter(QObject *o, QEvent *e)
 {
     if (o == qApp) {
         if (e->type() == QTabletEvent::TabletEnterProximity) {
             setCursor(QCursor(Qt::CrossCursor));
         } else if (e->type() == QTabletEvent::TabletLeaveProximity) {
             setCursor(QCursor(Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::Hidden ? Qt::BlankCursor : Qt::ArrowCursor));
             if (Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::HiddenDelay) {
                 // Trick KCursor to hide the cursor if needed by sending an "unknown" key press event
                 // Send also the key release to make the world happy even it's probably not needed
                 QKeyEvent kp(QEvent::KeyPress, 0, Qt::NoModifier);
                 qApp->sendEvent(this, &kp);
                 QKeyEvent kr(QEvent::KeyRelease, 0, Qt::NoModifier);
                 qApp->sendEvent(this, &kr);
             }
         }
     }
     return false;
 }
 
 // <widget events>
 bool PresentationWidget::event(QEvent *e)
 {
     if (e->type() == QEvent::Gesture) {
         return gestureEvent(static_cast<QGestureEvent *>(e));
     }
 
     if (e->type() == QEvent::ToolTip) {
         QHelpEvent *he = (QHelpEvent *)e;
 
         QRect r;
         const Okular::Action *link = getLink(he->pos(), &r);
 
         if (link) {
             QString tip = link->actionTip();
             if (!tip.isEmpty()) {
                 QToolTip::showText(he->globalPos(), tip, this, r);
             }
         }
         e->accept();
         return true;
     } else {
         // do not stop the event
         return QWidget::event(e);
     }
 }
 
 bool PresentationWidget::gestureEvent(QGestureEvent *event)
 {
     // Swiping left or right on a touch screen will go to the previous or next slide, respectively.
     // The precise gesture is the standard Qt swipe: with three(!) fingers.
     if (QGesture *swipe = event->gesture(Qt::SwipeGesture)) {
         QSwipeGesture *swipeEvent = static_cast<QSwipeGesture *>(swipe);
 
         if (swipeEvent->state() == Qt::GestureFinished) {
             if (swipeEvent->horizontalDirection() == QSwipeGesture::Left) {
                 slotPrevPage();
                 event->accept();
                 return true;
             }
             if (swipeEvent->horizontalDirection() == QSwipeGesture::Right) {
                 slotNextPage();
                 event->accept();
                 return true;
             }
         }
     }
 
     return false;
 }
 void PresentationWidget::keyPressEvent(QKeyEvent *e)
 {
     if (!m_isSetup) {
         return;
     }
 
     switch (e->key()) {
     case Qt::Key_Left:
     case Qt::Key_Backspace:
     case Qt::Key_PageUp:
     case Qt::Key_Up:
         slotPrevPage();
         break;
     case Qt::Key_Right:
     case Qt::Key_Space:
     case Qt::Key_PageDown:
     case Qt::Key_Down:
         slotNextPage();
         break;
     case Qt::Key_Home:
         slotFirstPage();
         break;
     case Qt::Key_End:
         slotLastPage();
         break;
     case Qt::Key_Escape:
         if (!m_topBar->isHidden()) {
             showTopBar(false);
         } else {
             close();
         }
         break;
     }
 }
 
 void PresentationWidget::wheelEvent(QWheelEvent *e)
 {
     if (!m_isSetup) {
         return;
     }
 
     // performance note: don't remove the clipping
     int div = e->angleDelta().y() / 120;
     if (div > 0) {
         if (div > 3) {
             div = 3;
         }
         while (div--) {
             slotPrevPage();
         }
     } else if (div < 0) {
         if (div < -3) {
             div = -3;
         }
         while (div++) {
             slotNextPage();
         }
     }
 }
 
 void PresentationWidget::mousePressEvent(QMouseEvent *e)
 {
     if (!m_isSetup) {
         return;
     }
 
     if (m_drawingEngine) {
         QRect r = routeMouseDrawingEvent(e);
         if (r.isValid()) {
             m_drawingRect |= r.translated(m_frames[m_frameIndex]->geometry.topLeft());
             update(m_drawingRect);
         }
         return;
     }
 
     // pressing left button
     if (e->button() == Qt::LeftButton) {
         // if pressing on a link, skip other checks
         if ((m_pressedLink = getLink(e->position()))) {
             return;
         }
 
         const Okular::Annotation *annotation = getAnnotation(e->position());
         if (annotation) {
             if (annotation->subType() == Okular::Annotation::AMovie) {
                 const Okular::MovieAnnotation *movieAnnotation = static_cast<const Okular::MovieAnnotation *>(annotation);
 
                 VideoWidget *vw = m_frames[m_frameIndex]->videoWidgets.value(movieAnnotation->movie());
                 vw->show();
                 vw->play();
                 return;
             } else if (annotation->subType() == Okular::Annotation::ARichMedia) {
                 const Okular::RichMediaAnnotation *richMediaAnnotation = static_cast<const Okular::RichMediaAnnotation *>(annotation);
 
                 VideoWidget *vw = m_frames[m_frameIndex]->videoWidgets.value(richMediaAnnotation->movie());
                 vw->show();
                 vw->play();
                 return;
             } else if (annotation->subType() == Okular::Annotation::AScreen) {
                 m_document->processAction(static_cast<const Okular::ScreenAnnotation *>(annotation)->action());
                 return;
             }
         }
 
         // handle clicking on top-right overlay
         if (!(Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::Hidden) && m_overlayGeometry.contains(e->pos())) {
             overlayClick(e->pos());
             return;
         }
 
         // Actual mouse press events always lead to the next page page
         if (e->source() == Qt::MouseEventNotSynthesized) {
             m_goToNextPageOnRelease = true;
         }
         // Touch events may lead to the previous or next page
         else if (Okular::Settings::slidesTapNavigation() != Okular::Settings::EnumSlidesTapNavigation::Disabled) {
             switch (Okular::Settings::slidesTapNavigation()) {
             case Okular::Settings::EnumSlidesTapNavigation::ForwardBackward: {
                 if (e->position().x() < (qreal(geometry().width()) / 2)) {
                     m_goToPreviousPageOnRelease = true;
                 } else {
                     m_goToNextPageOnRelease = true;
                 }
                 break;
             }
             case Okular::Settings::EnumSlidesTapNavigation::Forward: {
                 m_goToNextPageOnRelease = true;
                 break;
             }
             case Okular::Settings::EnumSlidesTapNavigation::Disabled: {
                 // Do Nothing
             }
             }
         }
     }
     // pressing forward button
     else if (e->button() == Qt::ForwardButton) {
         m_goToNextPageOnRelease = true;
     }
     // pressing right or backward button
     else if (e->button() == Qt::RightButton || e->button() == Qt::BackButton) {
         m_goToPreviousPageOnRelease = true;
     }
 }
 
 void PresentationWidget::mouseReleaseEvent(QMouseEvent *e)
 {
     if (m_drawingEngine) {
         routeMouseDrawingEvent(e);
         return;
     }
 
     // if releasing on the same link we pressed over, execute it
     if (m_pressedLink && e->button() == Qt::LeftButton) {
         const Okular::Action *link = getLink(e->position());
         if (link == m_pressedLink) {
             m_document->processAction(link);
         }
         m_pressedLink = nullptr;
     }
 
     if (m_goToPreviousPageOnRelease) {
         slotPrevPage();
         m_goToPreviousPageOnRelease = false;
     }
 
     if (m_goToNextPageOnRelease) {
         slotNextPage();
         m_goToNextPageOnRelease = false;
     }
 }
 
 void PresentationWidget::mouseMoveEvent(QMouseEvent *e)
 {
     // safety check
     if (!m_isSetup) {
         return;
     }
 
     // update cursor and tooltip if hovering a link
     if (!m_drawingEngine && Okular::Settings::slidesCursor() != Okular::Settings::EnumSlidesCursor::Hidden) {
         testCursorOnLink(e->position());
     }
 
     if (!m_topBar->isHidden()) {
         // hide a shown bar when exiting the area
         if (e->position().y() > (m_topBar->height() + 1)) {
             showTopBar(false);
             setFocus(Qt::OtherFocusReason);
         }
     } else {
         if (m_drawingEngine && e->buttons() != Qt::NoButton) {
             QRect r = routeMouseDrawingEvent(e);
             if (r.isValid()) {
                 m_drawingRect |= r.translated(m_frames[m_frameIndex]->geometry.topLeft());
                 update(m_drawingRect);
             }
         } else {
             // show the bar if reaching top 2 pixels
             if (e->position().y() <= 1) {
                 showTopBar(true);
             } else if ((QApplication::mouseButtons() & Qt::LeftButton) && m_overlayGeometry.contains(e->pos())) {
                 // handle "dragging the wheel" if clicking on its geometry
                 overlayClick(e->pos());
             }
         }
     }
 }
 
 void PresentationWidget::paintEvent(QPaintEvent *pe)
 {
     qreal dpr = devicePixelRatioF();
 
     if (m_inBlackScreenMode) {
         QPainter painter(this);
         painter.fillRect(pe->rect(), Qt::black);
         return;
     }
 
     if (!m_isSetup) {
         m_width = width();
         m_height = height();
 
         connect(m_document, &Okular::Document::linkFind, this, &PresentationWidget::slotFind);
 
         // register this observer in document. events will come immediately
         m_document->addObserver(this);
 
         // show summary if requested
         if (Okular::Settings::slidesShowSummary()) {
             generatePage();
         }
     }
 
     // check painting rect consistency
     QRect paintRect = pe->rect().intersected(QRect(QPoint(0, 0), geometry().size()));
     if (paintRect.isNull()) {
         return;
     }
 
     if (m_lastRenderedPixmap.isNull()) {
         QPainter painter(this);
         painter.fillRect(pe->rect(), Okular::Settings::slidesBackgroundColor());
         return;
     }
 
     // blit the pixmap to the screen
     QPainter painter(this);
     for (const QRect &r : pe->region()) {
         if (!r.isValid()) {
             continue;
         }
 #ifdef ENABLE_PROGRESS_OVERLAY
         const QRect dR(QRectF(r.x() * dpr, r.y() * dpr, r.width() * dpr, r.height() * dpr).toAlignedRect());
         if (Okular::Settings::slidesShowProgress() && r.intersects(m_overlayGeometry)) {
             // backbuffer the overlay operation
             QPixmap backPixmap(dR.size());
             backPixmap.setDevicePixelRatio(dpr);
             QPainter pixPainter(&backPixmap);
 
             // first draw the background on the backbuffer
             pixPainter.drawPixmap(QPoint(0, 0), m_lastRenderedPixmap, dR);
 
             // then blend the overlay (a piece of) over the background
             QRect ovr = m_overlayGeometry.intersected(r);
             pixPainter.drawPixmap((ovr.left() - r.left()), (ovr.top() - r.top()), m_lastRenderedOverlay, (ovr.left() - m_overlayGeometry.left()) * dpr, (ovr.top() - m_overlayGeometry.top()) * dpr, ovr.width() * dpr, ovr.height() * dpr);
 
             // finally blit the pixmap to the screen
             pixPainter.end();
             const QRect backPixmapRect = backPixmap.rect();
             const QRect dBackPixmapRect(QRectF(backPixmapRect.x() * dpr, backPixmapRect.y() * dpr, backPixmapRect.width() * dpr, backPixmapRect.height() * dpr).toAlignedRect());
             painter.drawPixmap(r.topLeft(), backPixmap, dBackPixmapRect);
         } else {
 #endif
             // copy the rendered pixmap to the screen
             painter.drawPixmap(r.topLeft(), m_lastRenderedPixmap, dR);
         }
     }
 
     // paint drawings
     if (m_frameIndex != -1) {
         painter.save();
 
         const QRect &geom = m_frames[m_frameIndex]->geometry;
 
         const QSize pmSize(geom.width() * dpr, geom.height() * dpr);
         QPixmap pm(pmSize);
         pm.fill(Qt::transparent);
         QPainter pmPainter(&pm);
 
         pm.setDevicePixelRatio(dpr);
         pmPainter.setRenderHints(QPainter::Antialiasing);
 
         // Paint old paths
         for (const SmoothPath &drawing : m_frames[m_frameIndex]->drawings) {
             drawing.paint(&pmPainter, pmSize.width(), pmSize.height());
         }
 
         // Paint the path that is currently being drawn by the user
         if (m_drawingEngine && m_drawingRect.intersects(pe->rect())) {
             m_drawingEngine->paint(&pmPainter, pmSize.width(), pmSize.height(), m_drawingRect.intersected(pe->rect()));
         }
 
         painter.setRenderHints(QPainter::Antialiasing);
         painter.drawPixmap(geom.topLeft(), pm);
 
         painter.restore();
     }
     painter.end();
 }
 
 void PresentationWidget::resizeEvent(QResizeEvent *re)
 {
     m_width = width();
     m_height = height();
 
     // if by chance the new size equals the old, do not invalidate pixmaps and such..
     if (size() == re->oldSize()) {
         return;
     }
 
     // BEGIN Top toolbar
     // tool bar height in pixels, make it large enough to hold the text fields with the page numbers
     const int toolBarHeight = m_pagesEdit->height() * 1.5;
 
     m_topBar->setGeometry(0, 0, width(), toolBarHeight);
     m_topBar->setIconSize(QSize(toolBarHeight * 0.75, toolBarHeight * 0.75));
     // END Top toolbar
 
     // BEGIN Content area
     // update the frames
     const float screenRatio = (float)m_height / (float)m_width;
     for (PresentationFrame *frame : std::as_const(m_frames)) {
         frame->recalcGeometry(m_width, m_height, screenRatio);
     }
 
     if (m_frameIndex != -1) {
         // ugliness alarm!
         const_cast<Okular::Page *>(m_frames[m_frameIndex]->page)->deletePixmap(this);
         // force the regeneration of the pixmap
         m_lastRenderedPixmap = QPixmap();
         m_blockNotifications = true;
         requestPixmaps();
         m_blockNotifications = false;
     }
 
     if (m_transitionTimer->isActive()) {
         m_transitionTimer->stop();
     }
 
     generatePage(true /* no transitions */);
     // END Content area
 }
 
 void PresentationWidget::enterEvent(QEnterEvent *e)
 {
     if (!m_topBar->isHidden()) {
         // This can happen when we exited the widget via a "tooltip" and the tooltip disappears
         if (e->position().y() > (m_topBar->height() + 1)) {
             showTopBar(false);
         }
     }
     QWidget::enterEvent(e);
 }
 
 void PresentationWidget::leaveEvent(QEvent *e)
 {
     Q_UNUSED(e)
 
     if (!m_topBar->isHidden()) {
         if (QToolTip::isVisible()) {
             // make sure we're not hovering over the tooltip
             // because the world is sad, this works differently on Wayland and X11
             // on X11 the widget under the cursor is the tooltip window
             // on wayland it's the button generating the tooltip (why? no idea)
             const QWidget *widgetUnderCursor = qApp->widgetAt(QCursor::pos());
             if (widgetUnderCursor) {
                 const QWidget *widgetUnderCursorWindow = widgetUnderCursor->window();
                 if (widgetUnderCursorWindow == this) {
                     qDebug() << "Wayland";
                     return;
                 } else {
                     const QWidget *widgetUnderCursorParentWindow = widgetUnderCursorWindow->parentWidget() ? widgetUnderCursorWindow->parentWidget()->window() : nullptr;
                     if (widgetUnderCursorParentWindow == this) {
                         qDebug() << "X11";
                         return;
                     }
                 }
             }
         }
         showTopBar(false);
     }
 }
 // </widget events>
 
 const void *PresentationWidget::getObjectRect(Okular::ObjectRect::ObjectType type, QPointF point, QRect *geometry) const
 {
     // no links on invalid pages
     if (geometry && !geometry->isNull()) {
         geometry->setRect(0, 0, 0, 0);
     }
     if (m_frameIndex < 0 || m_frameIndex >= (int)m_frames.size()) {
         return nullptr;
     }
 
     // get frame, page and geometry
     const PresentationFrame *frame = m_frames[m_frameIndex];
     const Okular::Page *page = frame->page;
     const QRect &frameGeometry = frame->geometry;
 
     // compute normalized x and y
     double nx = (double)(point.x() - frameGeometry.left()) / (double)frameGeometry.width();
     double ny = (double)(point.y() - frameGeometry.top()) / (double)frameGeometry.height();
 
     // no links outside the pages
     if (nx < 0 || nx > 1 || ny < 0 || ny > 1) {
         return nullptr;
     }
 
     // check if 1) there is an object and 2) it's a link
     const QRect screenRect = oldQt_screenOf(this)->geometry();
     const Okular::ObjectRect *object = page->objectRect(type, nx, ny, screenRect.width(), screenRect.height());
     if (!object) {
         return nullptr;
     }
 
     // compute link geometry if destination rect present
     if (geometry) {
         *geometry = object->boundingRect(frameGeometry.width(), frameGeometry.height());
         geometry->translate(frameGeometry.left(), frameGeometry.top());
     }
 
     // return the link pointer
     return object->object();
 }
 
 const Okular::Action *PresentationWidget::getLink(QPointF point, QRect *geometry) const
 {
     return reinterpret_cast<const Okular::Action *>(getObjectRect(Okular::ObjectRect::Action, point, geometry));
 }
 
 const Okular::Annotation *PresentationWidget::getAnnotation(QPointF point, QRect *geometry) const
 {
     return reinterpret_cast<const Okular::Annotation *>(getObjectRect(Okular::ObjectRect::OAnnotation, point, geometry));
 }
 
 void PresentationWidget::testCursorOnLink(QPointF point)
 {
     const Okular::Action *link = getLink(point, nullptr);
     const Okular::Annotation *annotation = getAnnotation(point, nullptr);
 
     const bool needsHandCursor = ((link != nullptr) || ((annotation != nullptr) && (annotation->subType() == Okular::Annotation::AMovie)) || ((annotation != nullptr) && (annotation->subType() == Okular::Annotation::ARichMedia)) ||
                                   ((annotation != nullptr) && (annotation->subType() == Okular::Annotation::AScreen) && (GuiUtils::renditionMovieFromScreenAnnotation(static_cast<const Okular::ScreenAnnotation *>(annotation)) != nullptr)));
 
     // only react on changes (in/out from a link)
     if ((needsHandCursor && !m_handCursor) || (!needsHandCursor && m_handCursor)) {
         // change cursor shape
         m_handCursor = needsHandCursor;
         setCursor(QCursor(m_handCursor ? Qt::PointingHandCursor : Qt::ArrowCursor));
     }
 }
 
 void PresentationWidget::overlayClick(const QPoint position)
 {
     // clicking the progress indicator
     int xPos = position.x() - m_overlayGeometry.x() - m_overlayGeometry.width() / 2, yPos = m_overlayGeometry.height() / 2 - position.y();
     if (!xPos && !yPos) {
         return;
     }
 
     // compute angle relative to indicator (note coord transformation)
     float angle = 0.5 + 0.5 * atan2((double)-xPos, (double)-yPos) / M_PI;
     int pageIndex = (int)(angle * (m_frames.count() - 1) + 0.5);
 
     // go to selected page
     changePage(pageIndex);
 }
 
 void PresentationWidget::changePage(int newPage)
 {
     if (m_showSummaryView) {
         m_showSummaryView = false;
         m_frameIndex = -1;
         return;
     }
 
     if (m_frameIndex == newPage) {
         return;
     }
 
     // switch to newPage
     m_document->setViewportPage(newPage, this);
 
     if ((Okular::Settings::slidesShowSummary() && !m_showSummaryView) || m_frameIndex == -1) {
         notifyCurrentPageChanged(-1, newPage);
     }
 }
 
 void PresentationWidget::generatePage(bool disableTransition)
 {
     if (m_lastRenderedPixmap.isNull()) {
         qreal dpr = devicePixelRatioF();
         m_lastRenderedPixmap = QPixmap(m_width * dpr, m_height * dpr);
         m_lastRenderedPixmap.setDevicePixelRatio(dpr);
 
         m_previousPagePixmap = QPixmap();
     } else {
         m_previousPagePixmap = m_lastRenderedPixmap;
     }
 
     // opens the painter over the pixmap
     QPainter pixmapPainter;
     pixmapPainter.begin(&m_lastRenderedPixmap);
     // generate welcome page
     if (m_frameIndex == -1) {
         generateIntroPage(pixmapPainter);
     }
     // generate a normal pixmap with extended margin filling
     if (m_frameIndex >= 0 && m_frameIndex < (int)m_document->pages()) {
         generateContentsPage(m_frameIndex, pixmapPainter);
     }
     pixmapPainter.end();
 
     // generate the top-right corner overlay
 #ifdef ENABLE_PROGRESS_OVERLAY
     if (Okular::Settings::slidesShowProgress() && m_frameIndex != -1) {
         generateOverlay();
     }
 #endif
 
     // start transition on pages that have one
     disableTransition |= (Okular::Settings::slidesTransition() == Okular::Settings::EnumSlidesTransition::NoTransitions);
     if (!disableTransition) {
         const Okular::PageTransition *transition = m_frameIndex != -1 ? m_frames[m_frameIndex]->page->transition() : nullptr;
         if (transition) {
             initTransition(transition);
         } else {
             Okular::PageTransition trans = defaultTransition();
             initTransition(&trans);
         }
     } else {
         Okular::PageTransition trans = defaultTransition(Okular::Settings::EnumSlidesTransition::Replace);
         initTransition(&trans);
     }
 
     // update cursor + tooltip
     if (!m_drawingEngine && Okular::Settings::slidesCursor() != Okular::Settings::EnumSlidesCursor::Hidden) {
         QPoint p = mapFromGlobal(QCursor::pos());
         testCursorOnLink(p);
     }
 }
 
 void PresentationWidget::generateIntroPage(QPainter &p)
 {
     qreal dpr = devicePixelRatioF();
 
     // use a vertical gray gradient background
     int blend1 = m_height / 10, blend2 = 9 * m_height / 10;
     int baseTint = QColor(Qt::gray).red();
     for (int i = 0; i < m_height; i++) {
         int k = baseTint;
         if (i < blend1) {
             k -= (int)(baseTint * (i - blend1) * (i - blend1) / (float)(blend1 * blend1));
         }
         if (i > blend2) {
             k += (int)((255 - baseTint) * (i - blend2) * (i - blend2) / (float)(blend1 * blend1));
         }
         p.fillRect(0, i, m_width, 1, QColor(k, k, k));
     }
 
     // draw okular logo in the four corners
     QPixmap logo = QIcon::fromTheme(QStringLiteral("okular")).pixmap(64 * dpr);
     logo.setDevicePixelRatio(dpr);
     if (!logo.isNull()) {
         p.drawPixmap(5, 5, logo);
         p.drawPixmap(m_width - 5 - logo.width(), 5, logo);
         p.drawPixmap(m_width - 5 - logo.width(), m_height - 5 - logo.height(), logo);
         p.drawPixmap(5, m_height - 5 - logo.height(), logo);
     }
 
     // draw metadata text (the last line is 'click to begin')
     int strNum = m_metaStrings.count(), strHeight = m_height / (strNum + 4), fontHeight = 2 * strHeight / 3;
     QFont font(p.font());
     font.setPixelSize(fontHeight);
     QFontMetrics metrics(font);
     for (int i = 0; i < strNum; i++) {
         // set a font to fit text width
         float wScale = (float)metrics.boundingRect(m_metaStrings[i]).width() / (float)m_width;
         QFont f(font);
         if (wScale > 1.0) {
             f.setPixelSize((int)((float)fontHeight / (float)wScale));
         }
         p.setFont(f);
 
         // text shadow
         p.setPen(Qt::darkGray);
         p.drawText(2, m_height / 4 + strHeight * i + 2, m_width, strHeight, Qt::AlignHCenter | Qt::AlignVCenter, m_metaStrings[i]);
         // text body
         p.setPen(128 + (127 * i) / strNum);
         p.drawText(0, m_height / 4 + strHeight * i, m_width, strHeight, Qt::AlignHCenter | Qt::AlignVCenter, m_metaStrings[i]);
     }
 }
 
 void PresentationWidget::generateContentsPage(int pageNum, QPainter &p)
 {
     PresentationFrame *frame = m_frames[pageNum];
 
     // translate painter and contents rect
     QRect geom(frame->geometry);
     p.translate(geom.left(), geom.top());
     geom.translate(-geom.left(), -geom.top());
 
     // draw the page using the shared PagePainter class
     int flags = PagePainter::Accessibility | PagePainter::Highlights | PagePainter::Annotations;
 
     PagePainter::paintPageOnPainter(&p, frame->page, this, flags, geom.width(), geom.height(), geom);
 
     // restore painter
     p.translate(-frame->geometry.left(), -frame->geometry.top());
 
     // fill unpainted areas with background color
     const QRegion unpainted(QRect(0, 0, m_width, m_height));
     const QRegion rgn = unpainted.subtracted(frame->geometry);
     for (const QRect &r : rgn) {
         p.fillRect(r, Okular::Settings::slidesBackgroundColor());
     }
 }
 
 // from Arthur - Qt4 - (is defined elsewhere as 'qt_div_255' to not break final compilation)
 inline int qt_div255(int x)
 {
     return (x + (x >> 8) + 0x80) >> 8;
 }
 void PresentationWidget::generateOverlay()
 {
 #ifdef ENABLE_PROGRESS_OVERLAY
     qreal dpr = devicePixelRatioF();
 
     // calculate overlay geometry and resize pixmap if needed
     double side = m_width / 16.0;
     m_overlayGeometry.setRect(m_width - side - 4, 4, side, side);
 
     // note: to get a sort of antialiasing, we render the pixmap double sized
     // and the resulting image is smoothly scaled down. So here we open a
     // painter on the double sized pixmap.
     side *= 2;
 
     QPixmap doublePixmap(side * dpr, side * dpr);
     doublePixmap.setDevicePixelRatio(dpr);
     doublePixmap.fill(Qt::black);
     QPainter pixmapPainter(&doublePixmap);
     pixmapPainter.setRenderHints(QPainter::Antialiasing);
 
     // draw PIE SLICES in blue levels (the levels will then be the alpha component)
     int pages = m_document->pages();
     if (pages > 28) { // draw continuous slices
         int degrees = (int)(360 * (float)(m_frameIndex + 1) / (float)pages);
         pixmapPainter.setPen(0x05);
         pixmapPainter.setBrush(QColor(0x40));
         pixmapPainter.drawPie(2, 2, side - 4, side - 4, 90 * 16, (360 - degrees) * 16);
         pixmapPainter.setPen(0x40);
         pixmapPainter.setBrush(QColor(0xF0));
         pixmapPainter.drawPie(2, 2, side - 4, side - 4, 90 * 16, -degrees * 16);
     } else { // draw discrete slices
         float oldCoord = -90;
         for (int i = 0; i < pages; i++) {
             float newCoord = -90 + 360 * (float)(i + 1) / (float)pages;
             pixmapPainter.setPen(i <= m_frameIndex ? 0x40 : 0x05);
             pixmapPainter.setBrush(QColor(i <= m_frameIndex ? 0xF0 : 0x40));
             pixmapPainter.drawPie(2, 2, side - 4, side - 4, (int)(-16 * (oldCoord + 1)), (int)(-16 * (newCoord - (oldCoord + 2))));
             oldCoord = newCoord;
         }
     }
     int circleOut = side / 4;
     pixmapPainter.setPen(Qt::black);
     pixmapPainter.setBrush(Qt::black);
     pixmapPainter.drawEllipse(circleOut, circleOut, side - 2 * circleOut, side - 2 * circleOut);
 
     // draw TEXT using maximum opacity
     QFont f(pixmapPainter.font());
     f.setPixelSize(side / 4);
     pixmapPainter.setFont(f);
     pixmapPainter.setPen(0xFF);
     // use a little offset to prettify output
     pixmapPainter.drawText(2, 2, side, side, Qt::AlignCenter, QString::number(m_frameIndex + 1));
 
     // end drawing pixmap and halve image
     pixmapPainter.end();
     QImage image(doublePixmap.toImage().scaled((side / 2) * dpr, (side / 2) * dpr, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
     image.setDevicePixelRatio(dpr);
     image = image.convertToFormat(QImage::Format_ARGB32);
     image.setDevicePixelRatio(dpr);
 
     // draw circular shadow using the same technique
     doublePixmap.fill(Qt::black);
     pixmapPainter.begin(&doublePixmap);
     pixmapPainter.setPen(0x40);
     pixmapPainter.setBrush(QColor(0x80));
     pixmapPainter.drawEllipse(0, 0, side, side);
     pixmapPainter.end();
     QImage shadow(doublePixmap.toImage().scaled((side / 2) * dpr, (side / 2) * dpr, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
     shadow.setDevicePixelRatio(dpr);
 
     // generate a 2 colors pixmap using mixing shadow (made with highlight color)
     // and image (made with highlightedText color)
     QPalette pal = palette();
     QColor color = pal.color(QPalette::Active, QPalette::HighlightedText);
     int red = color.red(), green = color.green(), blue = color.blue();
     color = pal.color(QPalette::Active, QPalette::Highlight);
     int sRed = color.red(), sGreen = color.green(), sBlue = color.blue();
     // pointers
     unsigned int *data = reinterpret_cast<unsigned int *>(image.bits()), *shadowData = reinterpret_cast<unsigned int *>(shadow.bits()), pixels = image.width() * image.height();
     // cache data (reduce computation time to 26%!)
     int c1 = -1, c2 = -1, cR = 0, cG = 0, cB = 0, cA = 0;
     // foreach pixel
     for (unsigned int i = 0; i < pixels; ++i) {
         // alpha for shadow and image
         int shadowAlpha = shadowData[i] & 0xFF, srcAlpha = data[i] & 0xFF;
         // cache values
         if (srcAlpha != c1 || shadowAlpha != c2) {
             c1 = srcAlpha;
             c2 = shadowAlpha;
             // fuse color components and alpha value of image over shadow
             data[i] = qRgba(cR = qt_div255(srcAlpha * red + (255 - srcAlpha) * sRed),
                             cG = qt_div255(srcAlpha * green + (255 - srcAlpha) * sGreen),
                             cB = qt_div255(srcAlpha * blue + (255 - srcAlpha) * sBlue),
                             cA = qt_div255(srcAlpha * srcAlpha + (255 - srcAlpha) * shadowAlpha));
         } else {
             data[i] = qRgba(cR, cG, cB, cA);
         }
     }
     m_lastRenderedOverlay = QPixmap::fromImage(image);
     m_lastRenderedOverlay.setDevicePixelRatio(dpr);
 
     // start the autohide timer
     // repaint( m_overlayGeometry ); // toggle with next line
     update(m_overlayGeometry);
     m_overlayHideTimer->start(2500);
 #endif
 }
 
 QRect PresentationWidget::routeMouseDrawingEvent(QMouseEvent *e)
 {
     if (m_frameIndex == -1) { // Can't draw on the summary page
         return QRect();
     }
 
     const QRect &geom = m_frames[m_frameIndex]->geometry;
     const Okular::Page *page = m_frames[m_frameIndex]->page;
 
     AnnotatorEngine::EventType eventType;
     AnnotatorEngine::Button button;
     AnnotatorEngine::Modifiers modifiers;
 
     // figure out the event type and button
     AnnotatorEngine::decodeEvent(e, &eventType, &button);
 
     static bool hasclicked = false;
     if (eventType == AnnotatorEngine::Press) {
         hasclicked = true;
     }
 
     QPointF mousePos = e->position();
     double nX = (mousePos.x() - (double)geom.left()) / (double)geom.width();
     double nY = (mousePos.y() - (double)geom.top()) / (double)geom.height();
     QRect ret;
     bool isInside = nX >= 0 && nX < 1 && nY >= 0 && nY < 1;
 
     if (hasclicked && !isInside) {
         // Fake a move to the last border pos
         nX = qBound(0., nX, 1.);
         nY = qBound(0., nY, 1.);
         m_drawingEngine->event(AnnotatorEngine::Move, button, modifiers, nX, nY, geom.width(), geom.height(), page);
 
         // Fake a release in the following lines
         eventType = AnnotatorEngine::Release;
         isInside = true;
     } else if (!hasclicked && isInside) {
         // we're coming from the outside, pretend we started clicking at the closest border
         if (nX < (1 - nX) && nX < nY && nX < (1 - nY)) {
             nX = 0;
         } else if (nY < (1 - nY) && nY < nX && nY < (1 - nX)) {
             nY = 0;
         } else if ((1 - nX) < nX && (1 - nX) < nY && (1 - nX) < (1 - nY)) {
             nX = 1;
         } else {
             nY = 1;
         }
 
         hasclicked = true;
         eventType = AnnotatorEngine::Press;
     }
 
     if (hasclicked && isInside) {
         ret = m_drawingEngine->event(eventType, button, modifiers, nX, nY, geom.width(), geom.height(), page);
     }
 
     if (eventType == AnnotatorEngine::Release) {
         hasclicked = false;
     }
 
     if (m_drawingEngine->creationCompleted()) {
         // add drawing to current page
         m_frames[m_frameIndex]->drawings.emplace_back(m_drawingEngine->endSmoothPath());
 
         // remove the actual drawer and create a new one just after
         // that - that gives continuous drawing
         delete m_drawingEngine;
         m_drawingRect = QRect();
         m_drawingEngine = new SmoothPathEngine(m_currentDrawingToolElement);
 
         // schedule repaint
         update();
     }
 
     return ret;
 }
 
 void PresentationWidget::startAutoChangeTimer()
 {
     double pageDuration = m_frameIndex >= 0 && m_frameIndex < (int)m_frames.count() ? m_frames[m_frameIndex]->page->duration() : -1;
     if (m_advanceSlides || pageDuration >= 0.0) {
         double secs;
         if (pageDuration < 0.0) {
             secs = Okular::SettingsCore::slidesAdvanceTime();
         } else if (m_advanceSlides) {
             secs = qMin<double>(pageDuration, Okular::SettingsCore::slidesAdvanceTime());
         } else {
             secs = pageDuration;
         }
 
         m_nextPageTimer->start((int)(secs * 1000));
     }
     setPlayPauseIcon();
 }
 
 QScreen *PresentationWidget::defaultScreen() const
 {
     const int preferenceScreen = Okular::Settings::slidesScreen();
 
     if (preferenceScreen == -2) {
         return oldQt_screenOf(m_parentWidget);
     } else if (preferenceScreen == -1) {
         return QApplication::primaryScreen();
     } else if (preferenceScreen >= 0 && preferenceScreen < QApplication::screens().count()) {
         return QApplication::screens().at(preferenceScreen);
     } else {
         return oldQt_screenOf(m_parentWidget);
     }
 }
 
 void PresentationWidget::requestPixmaps()
 {
     const qreal dpr = devicePixelRatioF();
     PresentationFrame *frame = m_frames[m_frameIndex];
     int pixW = frame->geometry.width();
     int pixH = frame->geometry.height();
 
     // operation will take long: set busy cursor
     QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
     // request the pixmap
     QList<Okular::PixmapRequest *> requests;
     requests.push_back(new Okular::PixmapRequest(this, m_frameIndex, pixW, pixH, dpr, PRESENTATION_PRIO, Okular::PixmapRequest::NoFeature));
     // restore cursor
     QApplication::restoreOverrideCursor();
     // ask for next and previous page if not in low memory usage setting
     if (Okular::SettingsCore::memoryLevel() != Okular::SettingsCore::EnumMemoryLevel::Low) {
         int pagesToPreload = 1;
 
         // If greedy, preload everything
         if (Okular::SettingsCore::memoryLevel() == Okular::SettingsCore::EnumMemoryLevel::Greedy) {
             pagesToPreload = (int)m_document->pages();
         }
 
         Okular::PixmapRequest::PixmapRequestFeatures requestFeatures = Okular::PixmapRequest::Preload;
         requestFeatures |= Okular::PixmapRequest::Asynchronous;
 
         for (int j = 1; j <= pagesToPreload; j++) {
             int tailRequest = m_frameIndex + j;
             if (tailRequest < (int)m_document->pages()) {
                 PresentationFrame *nextFrame = m_frames[tailRequest];
                 pixW = nextFrame->geometry.width();
                 pixH = nextFrame->geometry.height();
                 if (!nextFrame->page->hasPixmap(this, pixW, pixH)) {
                     requests.push_back(new Okular::PixmapRequest(this, tailRequest, pixW, pixH, dpr, PRESENTATION_PRELOAD_PRIO, requestFeatures));
                 }
             }
 
             int headRequest = m_frameIndex - j;
             if (headRequest >= 0) {
                 PresentationFrame *prevFrame = m_frames[headRequest];
                 pixW = prevFrame->geometry.width();
                 pixH = prevFrame->geometry.height();
                 if (!prevFrame->page->hasPixmap(this, pixW, pixH)) {
                     requests.push_back(new Okular::PixmapRequest(this, headRequest, pixW, pixH, dpr, PRESENTATION_PRELOAD_PRIO, requestFeatures));
                 }
             }
 
             // stop if we've already reached both ends of the document
             if (headRequest < 0 && tailRequest >= (int)m_document->pages()) {
                 break;
             }
         }
     }
     m_document->requestPixmaps(requests);
 }
 
 void PresentationWidget::slotNextPage()
 {
     int nextIndex = m_frameIndex + 1;
 
     // loop when configured
     if (nextIndex == m_frames.count() && Okular::Settings::slidesLoop()) {
         nextIndex = 0;
     }
 
     if (nextIndex < m_frames.count()) {
         // go to next page
         changePage(nextIndex);
         // auto advance to the next page if set
         startAutoChangeTimer();
     } else {
 #ifdef ENABLE_PROGRESS_OVERLAY
         if (Okular::Settings::slidesShowProgress()) {
             generateOverlay();
         }
 #endif
         if (m_transitionTimer->isActive()) {
             m_transitionTimer->stop();
             m_lastRenderedPixmap = m_currentPagePixmap;
             update();
         }
     }
     // we need the setFocus() call here to let KCursor::autoHide() work correctly
     setFocus();
 }
 
 void PresentationWidget::slotPrevPage()
 {
     if (m_frameIndex > 0) {
         // go to previous page
         changePage(m_frameIndex - 1);
 
         // auto advance to the next page if set
         startAutoChangeTimer();
     } else {
 #ifdef ENABLE_PROGRESS_OVERLAY
         if (Okular::Settings::slidesShowProgress()) {
             generateOverlay();
         }
 #endif
         if (m_transitionTimer->isActive()) {
             m_transitionTimer->stop();
             m_lastRenderedPixmap = m_currentPagePixmap;
             update();
         }
     }
 }
 
 void PresentationWidget::slotFirstPage()
 {
     changePage(0);
 }
 
 void PresentationWidget::slotLastPage()
 {
     changePage((int)m_frames.count() - 1);
 }
 
 void PresentationWidget::slotHideOverlay()
 {
     QRect geom(m_overlayGeometry);
     m_overlayGeometry.setCoords(0, 0, -1, -1);
     update(geom);
 }
 
 void PresentationWidget::slotTransitionStep()
 {
     switch (m_currentTransition.type()) {
     case Okular::PageTransition::Fade: {
         QPainter pixmapPainter;
         m_currentPixmapOpacity += 1.0 / m_transitionSteps;
         m_lastRenderedPixmap = QPixmap(m_lastRenderedPixmap.size());
         m_lastRenderedPixmap.setDevicePixelRatio(devicePixelRatioF());
         m_lastRenderedPixmap.fill(Qt::transparent);
         pixmapPainter.begin(&m_lastRenderedPixmap);
         pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
         pixmapPainter.setOpacity(1 - m_currentPixmapOpacity);
         pixmapPainter.drawPixmap(0, 0, m_previousPagePixmap);
         pixmapPainter.setOpacity(m_currentPixmapOpacity);
         pixmapPainter.drawPixmap(0, 0, m_currentPagePixmap);
         update();
         if (m_currentPixmapOpacity >= 1) {
             return;
         }
     } break;
     default: {
         if (m_transitionRects.empty()) {
             // it's better to fix the transition to cover the whole screen than
             // enabling the following line that wastes cpu for nothing
             // update();
             return;
         }
 
         for (int i = 0; i < m_transitionMul && !m_transitionRects.empty(); i++) {
             update(m_transitionRects.first());
             m_transitionRects.pop_front();
         }
     } break;
     }
     m_transitionTimer->start(m_transitionDelay);
 }
 
 void PresentationWidget::slotDelayedEvents()
 {
     setScreen(defaultScreen());
     show();
 
     if (m_screenSelect) {
         m_screenSelect->setCurrentItem(QApplication::screens().indexOf(oldQt_screenOf(this)));
         connect(m_screenSelect->selectableActionGroup(), &QActionGroup::triggered, this, &PresentationWidget::chooseScreen);
     }
 
     // inform user on how to exit from presentation mode
     KMessageBox::information(
         this,
         i18n("There are two ways of exiting presentation mode, you can press either ESC key or click with the quit button that appears when placing the mouse in the top-right corner. Of course you can cycle windows (Alt+TAB by default)"),
         QString(),
         QStringLiteral("presentationInfo"));
 }
 
 void PresentationWidget::slotPageChanged()
 {
     bool ok = true;
     int p = m_pagesEdit->text().toInt(&ok);
     if (!ok) {
         return;
     }
 
     changePage(p - 1);
 }
 
 void PresentationWidget::slotChangeDrawingToolEngine(const QDomElement &element)
 {
     if (element.isNull()) {
         delete m_drawingEngine;
         m_drawingEngine = nullptr;
         m_drawingRect = QRect();
         setCursor(Qt::ArrowCursor);
     } else {
         m_drawingEngine = new SmoothPathEngine(element);
         setCursor(QCursor(QPixmap(QStringLiteral("pencil")), Qt::ArrowCursor));
         m_currentDrawingToolElement = element;
     }
 }
 
 void PresentationWidget::slotAddDrawingToolActions()
 {
     DrawingToolActions *drawingToolActions = qobject_cast<DrawingToolActions *>(sender());
 
     const QList<QAction *> actionsList = drawingToolActions->actions();
     for (QAction *action : actionsList) {
         action->setEnabled(true);
         m_topBar->addAction(action);
         addAction(action);
     }
 }
 
 void PresentationWidget::clearDrawings()
 {
     if (m_frameIndex != -1) {
         m_frames[m_frameIndex]->drawings.clear();
     }
     update();
 }
 
 void PresentationWidget::chooseScreen(QAction *act)
 {
     if (!act || act->data().metaType().id() != QMetaType::Int) {
         return;
     }
 
     const int newScreen = act->data().toInt();
     if (newScreen < QApplication::screens().count()) {
         setScreen(QApplication::screens().at(newScreen));
     }
 }
 
 void PresentationWidget::toggleBlackScreenMode(bool)
 {
     m_inBlackScreenMode = !m_inBlackScreenMode;
 
     update();
 }
 
 void PresentationWidget::setScreen(const QScreen *newScreen)
 {
     // To move to a new screen, need to disable fullscreen first:
     if (newScreen != screen()) {
         setWindowState(windowState() & ~Qt::WindowFullScreen);
     }
     setGeometry(newScreen->geometry());
     setWindowState(windowState() | Qt::WindowFullScreen);
 }
 
 void PresentationWidget::inhibitPowerManagement()
 {
 #if HAVE_DBUS
 #ifdef Q_OS_LINUX
     QString reason = i18nc("Reason for inhibiting the screensaver activation, when the presentation mode is active", "Giving a presentation");
 
     if (!m_screenInhibitCookie) {
         QDBusMessage message = QDBusMessage::createMethodCall(QStringLiteral("org.freedesktop.ScreenSaver"), QStringLiteral("/ScreenSaver"), QStringLiteral("org.freedesktop.ScreenSaver"), QStringLiteral("Inhibit"));
         message << QCoreApplication::applicationName();
         message << reason;
 
         QDBusPendingReply<uint> reply = QDBusConnection::sessionBus().asyncCall(message);
         reply.waitForFinished();
         if (reply.isValid()) {
             m_screenInhibitCookie = reply.value();
             qCDebug(OkularUiDebug) << "Screen inhibition cookie" << m_screenInhibitCookie;
         } else {
             qCWarning(OkularUiDebug) << "Unable to inhibit screensaver" << reply.error();
         }
     }
 
     if (m_sleepInhibitFd != -1) {
         QDBusMessage message = QDBusMessage::createMethodCall(QStringLiteral("org.freedesktop.login1"), QStringLiteral("/org/freedesktop/login1"), QStringLiteral("org.freedesktop.login1.Manager"), QStringLiteral("Inhibit"));
         message << QStringLiteral("sleep");
         message << QCoreApplication::applicationName();
         message << reason;
         message << QStringLiteral("block");
 
         QDBusPendingReply<QDBusUnixFileDescriptor> reply = QDBusConnection::systemBus().asyncCall(message);
         reply.waitForFinished();
         if (reply.isValid()) {
             m_sleepInhibitFd = dup(reply.value().fileDescriptor());
         } else {
             qCWarning(OkularUiDebug) << "Unable to inhibit sleep" << reply.error();
         }
     }
 #endif // Q_OS_LINUX
 #endif // HAVE_DBUS
 }
 
 void PresentationWidget::allowPowerManagement()
 {
 #if HAVE_DBUS
 #ifdef Q_OS_LINUX
     if (m_sleepInhibitFd != -1) {
         ::close(m_sleepInhibitFd);
         m_sleepInhibitFd = -1;
     }
 
     if (m_screenInhibitCookie) {
         QDBusMessage message = QDBusMessage::createMethodCall(QStringLiteral("org.freedesktop.ScreenSaver"), QStringLiteral("/ScreenSaver"), QStringLiteral("org.freedesktop.ScreenSaver"), QStringLiteral("UnInhibit"));
         message << m_screenInhibitCookie;
 
         QDBusPendingReply<uint> reply = QDBusConnection::sessionBus().asyncCall(message);
         reply.waitForFinished();
 
         m_screenInhibitCookie = 0;
     }
 #endif // Q_OS_LINUX
 #endif // HAVE_DBUS
 }
 
 void PresentationWidget::showTopBar(bool show)
 {
     if (show) {
         m_topBar->show();
 
         // Don't autohide the mouse cursor if it's over the toolbar
         if (Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::HiddenDelay) {
             KCursor::setAutoHideCursor(this, false);
         }
 
         // Always show a cursor when topBar is visible
         if (!m_drawingEngine) {
             setCursor(QCursor(Qt::ArrowCursor));
         }
     } else {
         m_topBar->hide();
 
         // Reenable autohide if need be when leaving the toolbar
         if (Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::HiddenDelay) {
             KCursor::setAutoHideCursor(this, true);
         }
 
         // Or hide the cursor again if hidden cursor is enabled
         else if (Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::Hidden) {
             // Don't hide the cursor if drawing mode is on
             if (!m_drawingEngine) {
                 setCursor(QCursor(Qt::BlankCursor));
             }
         }
     }
 
     // Make sure mouse tracking isn't off after the KCursor::setAutoHideCursor() calls
     setMouseTracking(true);
 }
 
 void PresentationWidget::slotFind()
 {
     if (!m_searchBar) {
         m_searchBar = new PresentationSearchBar(m_document, this, this);
         m_searchBar->forceSnap();
     }
     m_searchBar->focusOnSearchEdit();
     m_searchBar->show();
 }
 
 const Okular::PageTransition PresentationWidget::defaultTransition() const
 {
     return defaultTransition(Okular::Settings::slidesTransition());
 }
 
 const Okular::PageTransition PresentationWidget::defaultTransition(int type) const
 {
     switch (type) {
     case Okular::Settings::EnumSlidesTransition::BlindsHorizontal: {
         Okular::PageTransition transition(Okular::PageTransition::Blinds);
         transition.setAlignment(Okular::PageTransition::Horizontal);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::BlindsVertical: {
         Okular::PageTransition transition(Okular::PageTransition::Blinds);
         transition.setAlignment(Okular::PageTransition::Vertical);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::BoxIn: {
         Okular::PageTransition transition(Okular::PageTransition::Box);
         transition.setDirection(Okular::PageTransition::Inward);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::BoxOut: {
         Okular::PageTransition transition(Okular::PageTransition::Box);
         transition.setDirection(Okular::PageTransition::Outward);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::Dissolve: {
         return Okular::PageTransition(Okular::PageTransition::Dissolve);
     }
     case Okular::Settings::EnumSlidesTransition::GlitterDown: {
         Okular::PageTransition transition(Okular::PageTransition::Glitter);
         transition.setAngle(270);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::GlitterRight: {
         Okular::PageTransition transition(Okular::PageTransition::Glitter);
         transition.setAngle(0);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::GlitterRightDown: {
         Okular::PageTransition transition(Okular::PageTransition::Glitter);
         transition.setAngle(315);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::Random: {
         return defaultTransition(QRandomGenerator::global()->bounded(18));
     }
     case Okular::Settings::EnumSlidesTransition::SplitHorizontalIn: {
         Okular::PageTransition transition(Okular::PageTransition::Split);
         transition.setAlignment(Okular::PageTransition::Horizontal);
         transition.setDirection(Okular::PageTransition::Inward);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::SplitHorizontalOut: {
         Okular::PageTransition transition(Okular::PageTransition::Split);
         transition.setAlignment(Okular::PageTransition::Horizontal);
         transition.setDirection(Okular::PageTransition::Outward);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::SplitVerticalIn: {
         Okular::PageTransition transition(Okular::PageTransition::Split);
         transition.setAlignment(Okular::PageTransition::Vertical);
         transition.setDirection(Okular::PageTransition::Inward);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::SplitVerticalOut: {
         Okular::PageTransition transition(Okular::PageTransition::Split);
         transition.setAlignment(Okular::PageTransition::Vertical);
         transition.setDirection(Okular::PageTransition::Outward);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::WipeDown: {
         Okular::PageTransition transition(Okular::PageTransition::Wipe);
         transition.setAngle(270);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::WipeRight: {
         Okular::PageTransition transition(Okular::PageTransition::Wipe);
         transition.setAngle(0);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::WipeLeft: {
         Okular::PageTransition transition(Okular::PageTransition::Wipe);
         transition.setAngle(180);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::WipeUp: {
         Okular::PageTransition transition(Okular::PageTransition::Wipe);
         transition.setAngle(90);
         return transition;
     }
     case Okular::Settings::EnumSlidesTransition::Fade: {
         return Okular::PageTransition(Okular::PageTransition::Fade);
     }
     case Okular::Settings::EnumSlidesTransition::NoTransitions:
     case Okular::Settings::EnumSlidesTransition::Replace:
     default:
         return Okular::PageTransition(Okular::PageTransition::Replace);
     }
     // should not happen, just make gcc happy
     return Okular::PageTransition();
 }
 
 /** ONLY the TRANSITIONS GENERATION function from here on **/
 void PresentationWidget::initTransition(const Okular::PageTransition *transition)
 {
     // if it's just a 'replace' transition, repaint the screen
     if (transition->type() == Okular::PageTransition::Replace) {
         update();
         return;
     }
 
     const bool isInward = transition->direction() == Okular::PageTransition::Inward;
     const bool isHorizontal = transition->alignment() == Okular::PageTransition::Horizontal;
     const float totalTime = transition->duration();
 
     m_transitionRects.clear();
     m_currentTransition = *transition;
     m_currentPagePixmap = m_lastRenderedPixmap;
 
     switch (transition->type()) {
         // split: horizontal / vertical and inward / outward
     case Okular::PageTransition::Split: {
         const int steps = isHorizontal ? 100 : 75;
         if (isHorizontal) {
             if (isInward) {
                 int xPosition = 0;
                 for (int i = 0; i < steps; i++) {
                     int xNext = ((i + 1) * m_width) / (2 * steps);
                     m_transitionRects.push_back(QRect(xPosition, 0, xNext - xPosition, m_height));
                     m_transitionRects.push_back(QRect(m_width - xNext, 0, xNext - xPosition, m_height));
                     xPosition = xNext;
                 }
             } else {
                 int xPosition = m_width / 2;
                 for (int i = 0; i < steps; i++) {
                     int xNext = ((steps - (i + 1)) * m_width) / (2 * steps);
                     m_transitionRects.push_back(QRect(xNext, 0, xPosition - xNext, m_height));
                     m_transitionRects.push_back(QRect(m_width - xPosition, 0, xPosition - xNext, m_height));
                     xPosition = xNext;
                 }
             }
         } else {
             if (isInward) {
                 int yPosition = 0;
                 for (int i = 0; i < steps; i++) {
                     int yNext = ((i + 1) * m_height) / (2 * steps);
                     m_transitionRects.push_back(QRect(0, yPosition, m_width, yNext - yPosition));
                     m_transitionRects.push_back(QRect(0, m_height - yNext, m_width, yNext - yPosition));
                     yPosition = yNext;
                 }
             } else {
                 int yPosition = m_height / 2;
                 for (int i = 0; i < steps; i++) {
                     int yNext = ((steps - (i + 1)) * m_height) / (2 * steps);
                     m_transitionRects.push_back(QRect(0, yNext, m_width, yPosition - yNext));
                     m_transitionRects.push_back(QRect(0, m_height - yPosition, m_width, yPosition - yNext));
                     yPosition = yNext;
                 }
             }
         }
         m_transitionMul = 2;
         m_transitionDelay = (int)((totalTime * 1000) / steps);
     } break;
 
         // blinds: horizontal(l-to-r) / vertical(t-to-b)
     case Okular::PageTransition::Blinds: {
         const int blinds = isHorizontal ? 8 : 6;
         const int steps = m_width / (4 * blinds);
         if (isHorizontal) {
             int xPosition[8];
             for (int b = 0; b < blinds; b++) {
                 xPosition[b] = (b * m_width) / blinds;
             }
 
             for (int i = 0; i < steps; i++) {
                 int stepOffset = (int)(((float)i * (float)m_width) / ((float)blinds * (float)steps));
                 for (int b = 0; b < blinds; b++) {
                     m_transitionRects.push_back(QRect(xPosition[b], 0, stepOffset, m_height));
                     xPosition[b] = stepOffset + (b * m_width) / blinds;
                 }
             }
         } else {
             int yPosition[6];
             for (int b = 0; b < blinds; b++) {
                 yPosition[b] = (b * m_height) / blinds;
             }
 
             for (int i = 0; i < steps; i++) {
                 int stepOffset = (int)(((float)i * (float)m_height) / ((float)blinds * (float)steps));
                 for (int b = 0; b < blinds; b++) {
                     m_transitionRects.push_back(QRect(0, yPosition[b], m_width, stepOffset));
                     yPosition[b] = stepOffset + (b * m_height) / blinds;
                 }
             }
         }
         m_transitionMul = blinds;
         m_transitionDelay = (int)((totalTime * 1000) / steps);
     } break;
 
         // box: inward / outward
     case Okular::PageTransition::Box: {
         const int steps = m_width / 10;
         if (isInward) {
             int L = 0, T = 0, R = m_width, B = m_height;
             for (int i = 0; i < steps; i++) {
                 // compute shrunk box coords
                 int newL = ((i + 1) * m_width) / (2 * steps);
                 int newT = ((i + 1) * m_height) / (2 * steps);
                 int newR = m_width - newL;
                 int newB = m_height - newT;
                 // add left, right, topcenter, bottomcenter rects
                 m_transitionRects.push_back(QRect(L, T, newL - L, B - T));
                 m_transitionRects.push_back(QRect(newR, T, R - newR, B - T));
                 m_transitionRects.push_back(QRect(newL, T, newR - newL, newT - T));
                 m_transitionRects.push_back(QRect(newL, newB, newR - newL, B - newB));
                 L = newL;
                 T = newT;
                 R = newR, B = newB;
             }
         } else {
             int L = m_width / 2, T = m_height / 2, R = L, B = T;
             for (int i = 0; i < steps; i++) {
                 // compute shrunk box coords
                 int newL = ((steps - (i + 1)) * m_width) / (2 * steps);
                 int newT = ((steps - (i + 1)) * m_height) / (2 * steps);
                 int newR = m_width - newL;
                 int newB = m_height - newT;
                 // add left, right, topcenter, bottomcenter rects
                 m_transitionRects.push_back(QRect(newL, newT, L - newL, newB - newT));
                 m_transitionRects.push_back(QRect(R, newT, newR - R, newB - newT));
                 m_transitionRects.push_back(QRect(L, newT, R - L, T - newT));
                 m_transitionRects.push_back(QRect(L, B, R - L, newB - B));
                 L = newL;
                 T = newT;
                 R = newR, B = newB;
             }
         }
         m_transitionMul = 4;
         m_transitionDelay = (int)((totalTime * 1000) / steps);
     } break;
 
         // wipe: implemented for 4 canonical angles
     case Okular::PageTransition::Wipe: {
         const int angle = transition->angle();
         const int steps = (angle == 0) || (angle == 180) ? m_width / 8 : m_height / 8;
         if (angle == 0) {
             int xPosition = 0;
             for (int i = 0; i < steps; i++) {
                 int xNext = ((i + 1) * m_width) / steps;
                 m_transitionRects.push_back(QRect(xPosition, 0, xNext - xPosition, m_height));
                 xPosition = xNext;
             }
         } else if (angle == 90) {
             int yPosition = m_height;
             for (int i = 0; i < steps; i++) {
                 int yNext = ((steps - (i + 1)) * m_height) / steps;
                 m_transitionRects.push_back(QRect(0, yNext, m_width, yPosition - yNext));
                 yPosition = yNext;
             }
         } else if (angle == 180) {
             int xPosition = m_width;
             for (int i = 0; i < steps; i++) {
                 int xNext = ((steps - (i + 1)) * m_width) / steps;
                 m_transitionRects.push_back(QRect(xNext, 0, xPosition - xNext, m_height));
                 xPosition = xNext;
             }
         } else if (angle == 270) {
             int yPosition = 0;
             for (int i = 0; i < steps; i++) {
                 int yNext = ((i + 1) * m_height) / steps;
                 m_transitionRects.push_back(QRect(0, yPosition, m_width, yNext - yPosition));
                 yPosition = yNext;
             }
         } else {
             update();
             return;
         }
         m_transitionMul = 1;
         m_transitionDelay = (int)((totalTime * 1000) / steps);
     } break;
 
         // dissolve: replace 'random' rects
     case Okular::PageTransition::Dissolve: {
         const int gridXsteps = 50;
         const int gridYsteps = 38;
         const int steps = gridXsteps * gridYsteps;
         int oldX = 0;
         int oldY = 0;
         // create a grid of gridXstep by gridYstep QRects
         for (int y = 0; y < gridYsteps; y++) {
             int newY = (int)(m_height * ((float)(y + 1) / (float)gridYsteps));
             for (int x = 0; x < gridXsteps; x++) {
                 int newX = (int)(m_width * ((float)(x + 1) / (float)gridXsteps));
                 m_transitionRects.push_back(QRect(oldX, oldY, newX - oldX, newY - oldY));
                 oldX = newX;
             }
             oldX = 0;
             oldY = newY;
         }
         // randomize the grid
         for (int i = 0; i < steps; i++) {
 #ifndef Q_OS_WIN
             int n1 = (int)(steps * drand48());
             int n2 = (int)(steps * drand48());
 #else
             int n1 = (int)(steps * (std::rand() / RAND_MAX));
             int n2 = (int)(steps * (std::rand() / RAND_MAX));
 #endif
             // swap items if index differs
             if (n1 != n2) {
                 QRect r = m_transitionRects[n2];
                 m_transitionRects[n2] = m_transitionRects[n1];
                 m_transitionRects[n1] = r;
             }
         }
         // set global transition parameters
         m_transitionMul = 40;
         m_transitionDelay = (int)((m_transitionMul * 1000 * totalTime) / steps);
     } break;
 
         // glitter: similar to dissolve but has a direction
     case Okular::PageTransition::Glitter: {
         const int gridXsteps = 50;
         const int gridYsteps = 38;
         const int steps = gridXsteps * gridYsteps;
         const int angle = transition->angle();
         // generate boxes using a given direction
         if (angle == 90) {
             int yPosition = m_height;
             for (int i = 0; i < gridYsteps; i++) {
                 int yNext = ((gridYsteps - (i + 1)) * m_height) / gridYsteps;
                 int xPosition = 0;
                 for (int j = 0; j < gridXsteps; j++) {
                     int xNext = ((j + 1) * m_width) / gridXsteps;
                     m_transitionRects.push_back(QRect(xPosition, yNext, xNext - xPosition, yPosition - yNext));
                     xPosition = xNext;
                 }
                 yPosition = yNext;
             }
         } else if (angle == 180) {
             int xPosition = m_width;
             for (int i = 0; i < gridXsteps; i++) {
                 int xNext = ((gridXsteps - (i + 1)) * m_width) / gridXsteps;
                 int yPosition = 0;
                 for (int j = 0; j < gridYsteps; j++) {
                     int yNext = ((j + 1) * m_height) / gridYsteps;
                     m_transitionRects.push_back(QRect(xNext, yPosition, xPosition - xNext, yNext - yPosition));
                     yPosition = yNext;
                 }
                 xPosition = xNext;
             }
         } else if (angle == 270) {
             int yPosition = 0;
             for (int i = 0; i < gridYsteps; i++) {
                 int yNext = ((i + 1) * m_height) / gridYsteps;
                 int xPosition = 0;
                 for (int j = 0; j < gridXsteps; j++) {
                     int xNext = ((j + 1) * m_width) / gridXsteps;
                     m_transitionRects.push_back(QRect(xPosition, yPosition, xNext - xPosition, yNext - yPosition));
                     xPosition = xNext;
                 }
                 yPosition = yNext;
             }
         } else // if angle is 0 or 315
         {
             int xPosition = 0;
             for (int i = 0; i < gridXsteps; i++) {
                 int xNext = ((i + 1) * m_width) / gridXsteps;
                 int yPosition = 0;
                 for (int j = 0; j < gridYsteps; j++) {
                     int yNext = ((j + 1) * m_height) / gridYsteps;
                     m_transitionRects.push_back(QRect(xPosition, yPosition, xNext - xPosition, yNext - yPosition));
                     yPosition = yNext;
                 }
                 xPosition = xNext;
             }
         }
         // add a 'glitter' (1 over 10 pieces is randomized)
         int randomSteps = steps / 20;
         for (int i = 0; i < randomSteps; i++) {
 #ifndef Q_OS_WIN
             int n1 = (int)(steps * drand48());
             int n2 = (int)(steps * drand48());
 #else
             int n1 = (int)(steps * (std::rand() / RAND_MAX));
             int n2 = (int)(steps * (std::rand() / RAND_MAX));
 #endif
             // swap items if index differs
             if (n1 != n2) {
                 QRect r = m_transitionRects[n2];
                 m_transitionRects[n2] = m_transitionRects[n1];
                 m_transitionRects[n1] = r;
             }
         }
         // set global transition parameters
         m_transitionMul = (angle == 90) || (angle == 270) ? gridYsteps : gridXsteps;
         m_transitionMul /= 2;
         m_transitionDelay = (int)((m_transitionMul * 1000 * totalTime) / steps);
     } break;
 
     case Okular::PageTransition::Fade: {
         enum { FADE_TRANSITION_FPS = 20 };
         const int steps = totalTime * FADE_TRANSITION_FPS;
         m_transitionSteps = steps;
         QPainter pixmapPainter;
         m_currentPixmapOpacity = (double)1 / steps;
         m_transitionDelay = (int)(totalTime * 1000) / steps;
         m_lastRenderedPixmap = QPixmap(m_lastRenderedPixmap.size());
         m_lastRenderedPixmap.fill(Qt::transparent);
         pixmapPainter.begin(&m_lastRenderedPixmap);
         pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
         pixmapPainter.setOpacity(1 - m_currentPixmapOpacity);
         pixmapPainter.drawPixmap(0, 0, m_previousPagePixmap);
         pixmapPainter.setOpacity(m_currentPixmapOpacity);
         pixmapPainter.drawPixmap(0, 0, m_currentPagePixmap);
         pixmapPainter.end();
         update();
     } break;
     // implement missing transitions (a binary raster engine needed here)
     case Okular::PageTransition::Fly:
 
     case Okular::PageTransition::Push:
 
     case Okular::PageTransition::Cover:
 
     case Okular::PageTransition::Uncover:
 
     default:
         update();
         return;
     }
 
     // send the first start to the timer
     m_transitionTimer->start(0);
 }
 
 void PresentationWidget::slotProcessMovieAction(const Okular::MovieAction *action)
 {
     const Okular::MovieAnnotation *movieAnnotation = action->annotation();
     if (!movieAnnotation) {
         return;
     }
 
     Okular::Movie *movie = movieAnnotation->movie();
     if (!movie) {
         return;
     }
 
     VideoWidget *vw = m_frames[m_frameIndex]->videoWidgets.value(movieAnnotation->movie());
     if (!vw) {
         return;
     }
 
     vw->show();
 
     switch (action->operation()) {
     case Okular::MovieAction::Play:
         vw->stop();
         vw->play();
         break;
     case Okular::MovieAction::Stop:
         vw->stop();
         break;
     case Okular::MovieAction::Pause:
         vw->pause();
         break;
     case Okular::MovieAction::Resume:
         vw->play();
         break;
     };
 }
 
 void PresentationWidget::slotProcessRenditionAction(const Okular::RenditionAction *action)
 {
     Okular::Movie *movie = action->movie();
     if (!movie) {
         return;
     }
 
     VideoWidget *vw = m_frames[m_frameIndex]->videoWidgets.value(movie);
     if (!vw) {
         return;
     }
 
     if (action->operation() == Okular::RenditionAction::None) {
         return;
     }
 
     vw->show();
 
     switch (action->operation()) {
     case Okular::RenditionAction::Play:
         vw->stop();
         vw->play();
         break;
     case Okular::RenditionAction::Stop:
         vw->stop();
         break;
     case Okular::RenditionAction::Pause:
         vw->pause();
         break;
     case Okular::RenditionAction::Resume:
         vw->play();
         break;
     default:
         return;
     };
 }
 
 void PresentationWidget::slotTogglePlayPause()
 {
     if (!m_nextPageTimer->isActive()) {
         m_advanceSlides = true;
         startAutoChangeTimer();
     } else {
         m_nextPageTimer->stop();
         m_advanceSlides = false;
         setPlayPauseIcon();
     }
 }
 
 #include "presentationwidget.moc"