diff options
author | toma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da> | 2009-11-25 17:56:58 +0000 |
---|---|---|
committer | toma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da> | 2009-11-25 17:56:58 +0000 |
commit | 47d455dd55be855e4cc691c32f687f723d9247ee (patch) | |
tree | 52e236aaa2576bdb3840ebede26619692fed6d7d /kpdf/ui/presentationwidget.cpp | |
download | tdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.tar.gz tdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.zip |
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923
git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kpdf/ui/presentationwidget.cpp')
-rw-r--r-- | kpdf/ui/presentationwidget.cpp | 1330 |
1 files changed, 1330 insertions, 0 deletions
diff --git a/kpdf/ui/presentationwidget.cpp b/kpdf/ui/presentationwidget.cpp new file mode 100644 index 00000000..c57e2f95 --- /dev/null +++ b/kpdf/ui/presentationwidget.cpp @@ -0,0 +1,1330 @@ +/*************************************************************************** + * Copyright (C) 2004 by Enrico Ros <[email protected]> * + * * + * 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. * + ***************************************************************************/ + +// qt/kde includes +#include <qtimer.h> +#include <qimage.h> +#include <qpainter.h> +#include <qapplication.h> +#include <qdesktopwidget.h> +#include <qtooltip.h> +#include <kaccel.h> +#include <kactioncollection.h> +#include <kapplication.h> +#include <kcursor.h> +#include <ktoolbar.h> +#include <kdebug.h> +#include <klocale.h> +#include <kiconloader.h> +#include <kimageeffect.h> +#include <kmessagebox.h> +#include <kwin.h> + +// system includes +#include <stdlib.h> +#include <math.h> + +// local includes +#include "presentationwidget.h" +#include "pagepainter.h" +#include "core/generator.h" +#include "core/page.h" +#include "core/link.h" +#include "conf/settings.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 +{ + const KPDFPage * page; + QRect geometry; +}; + + +PresentationWidget::PresentationWidget( QWidget * parent, KPDFDocument * doc ) + : QDialog( parent, "presentationWidget", true, WDestructiveClose | WStyle_NoBorder), + m_pressedLink( 0 ), m_handCursor( false ), m_document( doc ), m_frameIndex( -1 ) +{ + // set look and geometry + setBackgroundMode( Qt::NoBackground ); + + m_width = -1; + + m_accel = new KAccel( this, this, "presentationmode-accel" ); + + // show widget and take control + showFullScreen(); + + // misc stuff + setMouseTracking( true ); + m_transitionTimer = new QTimer( this ); + connect( m_transitionTimer, SIGNAL( timeout() ), this, SLOT( slotTransitionStep() ) ); + m_overlayHideTimer = new QTimer( this ); + connect( m_overlayHideTimer, SIGNAL( timeout() ), this, SLOT( slotHideOverlay() ) ); + m_nextPageTimer = new QTimer( this ); + connect( m_nextPageTimer, SIGNAL( timeout() ), this, SLOT( slotNextPage() ) ); + + // handle cursor appearance as specified in configuration + if ( KpdfSettings::slidesCursor() == KpdfSettings::EnumSlidesCursor::HiddenDelay ) + { + KCursor::setAutoHideCursor( this, true ); + KCursor::setHideCursorDelay( 3000 ); + } + else if ( KpdfSettings::slidesCursor() == KpdfSettings::EnumSlidesCursor::Hidden ) + { + setCursor( KCursor::blankCursor() ); + } +} + +PresentationWidget::~PresentationWidget() +{ + // remove this widget from document observer + m_document->removeObserver( this ); + + // delete frames + QValueVector< PresentationFrame * >::iterator fIt = m_frames.begin(), fEnd = m_frames.end(); + for ( ; fIt != fEnd; ++fIt ) + delete *fIt; +} + +void PresentationWidget::setupActions( KActionCollection * ac ) +{ + m_accel->insert( "previous_page", ac->action( "previous_page" )->shortcut(), this, SLOT( slotPrevPage() ), false, true ); + m_accel->insert( "next_page", ac->action( "next_page" )->shortcut(), this, SLOT( slotNextPage() ), false, true ); + m_accel->insert( "first_page", ac->action( "first_page" )->shortcut(), this, SLOT( slotFirstPage() ), false, true ); + m_accel->insert( "last_page", ac->action( "last_page" )->shortcut(), this, SLOT( slotLastPage() ), false, true ); + m_accel->insert( "presentation", ac->action( "presentation" )->shortcut(), this, SLOT( close() ), false, true ); +} + +void PresentationWidget::notifySetup( const QValueVector< KPDFPage * > & pageSet, bool /*documentChanged*/ ) +{ + // delete previous frames (if any (shouldn't be)) + QValueVector< PresentationFrame * >::iterator fIt = m_frames.begin(), fEnd = m_frames.end(); + for ( ; fIt != fEnd; ++fIt ) + delete *fIt; + if ( !m_frames.isEmpty() ) + kdWarning() << "Frames setup changed while a Presentation is in progress." << endl; + m_frames.clear(); + + // create the new frames + QValueVector< KPDFPage * >::const_iterator setIt = pageSet.begin(), setEnd = pageSet.end(); + float screenRatio = (float)m_height / (float)m_width; + for ( ; setIt != setEnd; ++setIt ) + { + PresentationFrame * frame = new PresentationFrame(); + frame->page = *setIt; + // calculate frame geometry keeping constant aspect ratio + float pageRatio = frame->page->ratio(); + int pageWidth = m_width, + pageHeight = m_height; + if ( pageRatio > screenRatio ) + pageWidth = (int)( (float)pageHeight / pageRatio ); + else + pageHeight = (int)( (float)pageWidth * pageRatio ); + frame->geometry.setRect( (m_width - pageWidth) / 2, + (m_height - pageHeight) / 2, + pageWidth, pageHeight ); + // add the frame to the vector + m_frames.push_back( frame ); + } + + // get metadata from the document + m_metaStrings.clear(); + const DocumentInfo * info = m_document->documentInfo(); + if ( info ) + { + if ( !info->get( "title" ).isNull() ) + m_metaStrings += i18n( "Title: %1" ).arg( info->get( "title" ) ); + if ( !info->get( "author" ).isNull() ) + m_metaStrings += i18n( "Author: %1" ).arg( info->get( "author" ) ); + } + m_metaStrings += i18n( "Pages: %1" ).arg( m_document->pages() ); + m_metaStrings += i18n( "Click to begin" ); +} + +void PresentationWidget::notifyViewportChanged( bool /*smoothMove*/ ) +{ + // discard notifications if displaying the summary + if ( m_frameIndex == -1 && KpdfSettings::slidesShowSummary() ) + return; + + // display the current page + changePage( m_document->viewport().pageNumber ); + + // auto advance to the next page if set + if ( KpdfSettings::slidesAdvance() ) + m_nextPageTimer->start( KpdfSettings::slidesAdvanceTime() * 1000 ); +} + +void PresentationWidget::notifyPageChanged( int pageNumber, int changedFlags ) +{ + // check if it's the last requested pixmap. if so update the widget. + if ( (changedFlags & DocumentObserver::Pixmap) && pageNumber == m_frameIndex ) + generatePage(); +} + +bool PresentationWidget::canUnloadPixmap( int pageNumber ) +{ + // can unload all pixmaps except for the currently visible one + return pageNumber != m_frameIndex; +} + + +// <widget events> +/* This hack was here to fix 103718 but it's no longer necessary on KDE 3.5 and Lubos asked me to remove it +bool PresentationWidget::event ( QEvent * e ) +{ + if (e -> type() == QEvent::WindowDeactivate) KWin::clearState(winId(), NET::StaysOnTop); + else if (e -> type() == QEvent::WindowActivate) KWin::setState(winId(), NET::StaysOnTop); + return QDialog::event(e); +} +*/ + +void PresentationWidget::keyPressEvent( QKeyEvent * e ) +{ + if (m_width == -1) return; + + if ( e->key() == Key_Left || e->key() == Key_Backspace || e->key() == Key_Prior ) + slotPrevPage(); + else if ( e->key() == Key_Right || e->key() == Key_Space || e->key() == Key_Next ) + slotNextPage(); + else if ( e->key() == Key_Home ) + slotFirstPage(); + else if ( e->key() == Key_End ) + slotLastPage(); + else if ( e->key() == Key_Escape ) + { + if ( m_topBar->isShown() ) + m_topBar->hide(); + else + close(); + } +} + +void PresentationWidget::wheelEvent( QWheelEvent * e ) +{ + // performance note: don't remove the clipping + int div = e->delta() / 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 ) +{ + // pressing left button + if ( e->button() == Qt::LeftButton ) + { + // if pressing on a link, skip other checks + if ( ( m_pressedLink = getLink( e->x(), e->y() ) ) ) + return; + + // handle clicking on top-right overlay + if ( m_overlayGeometry.contains( e->pos() ) ) + { + overlayClick( e->pos() ); + return; + } + + // if no other actions, go to next page + slotNextPage(); + } + // pressing right button + else if ( e->button() == Qt::RightButton ) + slotPrevPage(); +} + +void PresentationWidget::mouseReleaseEvent( QMouseEvent * e ) +{ + // if releasing on the same link we pressed over, execute it + if ( m_pressedLink && e->button() == Qt::LeftButton ) + { + const KPDFLink * link = getLink( e->x(), e->y() ); + if ( link == m_pressedLink ) + m_document->processLink( link ); + m_pressedLink = 0; + } +} + +void PresentationWidget::mouseMoveEvent( QMouseEvent * e ) +{ + // safety check + if ( m_width == -1 ) + return; + + // update cursor and tooltip if hovering a link + if ( KpdfSettings::slidesCursor() != KpdfSettings::EnumSlidesCursor::Hidden ) + testCursorOnLink( e->x(), e->y() ); + + if ( m_topBar->isShown() ) + { + // hide a shown bar when exiting the area + if ( e->y() > ( m_topBar->height() + 1 ) ) + m_topBar->hide(); + } + else + { + // show the bar if reaching top 2 pixels + if ( e->y() <= (geometry().top() + 1) ) + m_topBar->show(); + // handle "dragging the wheel" if clicking on its geometry + else if ( e->state() == Qt::LeftButton && m_overlayGeometry.contains( e->pos() ) ) + overlayClick( e->pos() ); + } +} + +void PresentationWidget::paintEvent( QPaintEvent * pe ) +{ + if (m_width == -1) + { + QRect d = KGlobalSettings::desktopGeometry(this); + m_width = d.width(); + m_height = d.height(); + + // create top toolbar + m_topBar = new KToolBar( this, "presentationBar" ); + m_topBar->setIconSize( 32 ); + m_topBar->setMovingEnabled( false ); + m_topBar->insertButton( QApplication::reverseLayout() ? "1rightarrow" : "1leftarrow", 2, SIGNAL( clicked() ), this, SLOT( slotPrevPage() ) ); + m_topBar->insertButton( QApplication::reverseLayout() ? "1leftarrow" : "1rightarrow", 3, SIGNAL( clicked() ), this, SLOT( slotNextPage() ) ); + m_topBar->insertButton( "exit", 1, SIGNAL( clicked() ), this, SLOT( close() ) ); + m_topBar->setGeometry( 0, 0, m_width, 32 + 10 ); + m_topBar->alignItemRight( 1 ); + m_topBar->hide(); + // change topbar background color + QPalette p = m_topBar->palette(); + p.setColor( QPalette::Active, QColorGroup::Button, Qt::gray ); + p.setColor( QPalette::Active, QColorGroup::Background, Qt::darkGray ); + m_topBar->setPalette( p ); + + // register this observer in document. events will come immediately + m_document->addObserver( this ); + + // show summary if requested + if ( KpdfSettings::slidesShowSummary() ) + generatePage(); + + 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::null, "presentationInfo"); + } + + // check painting rect consistancy + QRect r = pe->rect().intersect( geometry() ); + if ( r.isNull() || m_lastRenderedPixmap.isNull() ) + return; + + // blit the pixmap to the screen + QMemArray<QRect> allRects = pe->region().rects(); + uint numRects = allRects.count(); + for ( uint i = 0; i < numRects; i++ ) + { + const QRect & r = allRects[i]; + if ( !r.isValid() ) + continue; +#ifdef ENABLE_PROGRESS_OVERLAY + if ( KpdfSettings::slidesShowProgress() && r.intersects( m_overlayGeometry ) ) + { + // backbuffer the overlay operation + QPixmap backPixmap( r.size() ); + QPainter pixPainter( &backPixmap ); + + // first draw the background on the backbuffer + pixPainter.drawPixmap( QPoint(0,0), m_lastRenderedPixmap, r ); + + // then blend the overlay (a piece of) over the background + QRect ovr = m_overlayGeometry.intersect( r ); + pixPainter.drawPixmap( ovr.left() - r.left(), ovr.top() - r.top(), + m_lastRenderedOverlay, ovr.left() - m_overlayGeometry.left(), + ovr.top() - m_overlayGeometry.top(), ovr.width(), ovr.height() ); + + // finally blit the pixmap to the screen + pixPainter.end(); + bitBlt( this, r.topLeft(), &backPixmap, backPixmap.rect() ); + } else +#endif + // copy the rendered pixmap to the screen + bitBlt( this, r.topLeft(), &m_lastRenderedPixmap, r ); + } +} +// </widget events> + + +const KPDFLink * PresentationWidget::getLink( int x, int y, QRect * geometry ) const +{ + // no links on invalid pages + if ( geometry && !geometry->isNull() ) + geometry->setRect( 0, 0, -1, -1 ); + if ( m_frameIndex < 0 || m_frameIndex >= (int)m_frames.size() ) + return 0; + + // get frame, page and geometry + const PresentationFrame * frame = m_frames[ m_frameIndex ]; + const KPDFPage * page = frame->page; + const QRect & frameGeometry = frame->geometry; + + // compute normalized x and y + double nx = (double)(x - frameGeometry.left()) / (double)frameGeometry.width(); + double ny = (double)(y - frameGeometry.top()) / (double)frameGeometry.height(); + + // no links outside the pages + if ( nx < 0 || nx > 1 || ny < 0 || ny > 1 ) + return 0; + + // check if 1) there is an object and 2) it's a link + const ObjectRect * object = page->hasObject( ObjectRect::Link, nx, ny ); + if ( !object ) + return 0; + + // compute link geometry if destination rect present + if ( geometry ) + { + *geometry = object->geometry( frameGeometry.width(), frameGeometry.height() ); + geometry->moveBy( frameGeometry.left(), frameGeometry.top() ); + } + + // return the link pointer + return (KPDFLink *)object->pointer(); +} + +void PresentationWidget::testCursorOnLink( int x, int y ) +{ + // get rect + QRect linkRect; + const KPDFLink * link = getLink( x, y, &linkRect ); + + // only react on changes (in/out from a link) + if ( (link && !m_handCursor) || (!link && m_handCursor) ) + { + // change cursor shape + m_handCursor = link != 0; + setCursor( m_handCursor ? KCursor::handCursor() : KCursor::arrowCursor()); + + // set tooltip over link's rect + QString tip = link ? link->linkTip() : QString::null; + if ( m_handCursor && !tip.isEmpty() ) + QToolTip::add( this, linkRect, tip ); + } +} + +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( -xPos, -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_frameIndex == newPage ) + return; + + // check if pixmap exists or else request it + m_frameIndex = newPage; + PresentationFrame * frame = m_frames[ m_frameIndex ]; + int pixW = frame->geometry.width(); + int pixH = frame->geometry.height(); + + // if pixmap not inside the KPDFPage we request it and wait for + // notifyPixmapChanged call or else we can proceed to pixmap generation + if ( !frame->page->hasPixmap( PRESENTATION_ID, pixW, pixH ) ) + { + // operation will take long: set busy cursor + QApplication::setOverrideCursor( KCursor::workingCursor() ); + // request the pixmap + QValueList< PixmapRequest * > requests; + requests.push_back( new PixmapRequest( PRESENTATION_ID, m_frameIndex, pixW, pixH, PRESENTATION_PRIO ) ); + // restore cursor + QApplication::restoreOverrideCursor(); + // ask for next and previous page if not in low memory usage setting + if (KpdfSettings::memoryLevel() != KpdfSettings::EnumMemoryLevel::Low && KpdfSettings::enableThreading()) { + if (newPage + 1 < (int)m_document->pages()) + { + PresentationFrame *nextFrame = m_frames[ newPage + 1 ]; + pixW = nextFrame->geometry.width(); + pixH = nextFrame->geometry.height(); + if ( !nextFrame->page->hasPixmap( PRESENTATION_ID, pixW, pixH ) ) + requests.push_back( new PixmapRequest( PRESENTATION_ID, newPage + 1, pixW, pixH, PRESENTATION_PRELOAD_PRIO, true ) ); + } + if (newPage - 1 >= 0) + { + PresentationFrame *prevFrame = m_frames[ newPage - 1 ]; + pixW = prevFrame->geometry.width(); + pixH = prevFrame->geometry.height(); + if ( !prevFrame->page->hasPixmap( PRESENTATION_ID, pixW, pixH ) ) + requests.push_back( new PixmapRequest( PRESENTATION_ID, newPage - 1, pixW, pixH, PRESENTATION_PRELOAD_PRIO, true ) ); + } + } + m_document->requestPixmaps( requests ); + } + else + { + // make the background pixmap + generatePage(); + } + + // set a new viewport in document if page number differs + if ( m_frameIndex != -1 && m_frameIndex != m_document->viewport().pageNumber ) + m_document->setViewportPage( m_frameIndex, PRESENTATION_ID ); +} + +void PresentationWidget::generatePage() +{ + if ( m_lastRenderedPixmap.isNull() ) + m_lastRenderedPixmap.resize( m_width, m_height ); + + // 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 ( KpdfSettings::slidesShowProgress() && m_frameIndex != -1 ) + generateOverlay(); +#endif + + // start transition on pages that have one + const KPDFPageTransition * transition = m_frameIndex != -1 ? + m_frames[ m_frameIndex ]->page->getTransition() : 0; + if ( transition ) + initTransition( transition ); + else { + KPDFPageTransition trans = defaultTransition(); + initTransition( &trans ); + } + + // update cursor + tooltip + if ( KpdfSettings::slidesCursor() != KpdfSettings::EnumSlidesCursor::Hidden ) + { + QPoint p = mapFromGlobal( QCursor::pos() ); + testCursorOnLink( p.x(), p.y() ); + } +} + +void PresentationWidget::generateIntroPage( QPainter & p ) +{ + // use a vertical gray gradient background + int blend1 = m_height / 10, + blend2 = 9 * m_height / 10; + int baseTint = 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 kpdf logo in the four corners + QPixmap logo = DesktopIcon( "kpdf", 64 ); + 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, + AlignHCenter | AlignVCenter, m_metaStrings[i] ); + // text body + p.setPen( 128 + (127 * i) / strNum ); + p.drawText( 0, m_height / 4 + strHeight * i, m_width, strHeight, + AlignHCenter | 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.moveBy( -geom.left(), -geom.top() ); + + // draw the page using the shared PagePainter class + int flags = PagePainter::Accessibility; + PagePainter::paintPageOnPainter( frame->page, PRESENTATION_ID, flags, + &p, geom, geom.width(), geom.height() ); + + // restore painter + p.translate( -frame->geometry.left(), -frame->geometry.top() ); + + // fill unpainted areas with background color + QRegion unpainted( QRect( 0, 0, m_width, m_height ) ); + QMemArray<QRect> rects = unpainted.subtract( frame->geometry ).rects(); + for ( uint i = 0; i < rects.count(); i++ ) + { + const QRect & r = rects[i]; + p.fillRect( r, KpdfSettings::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 + // calculate overlay geometry and resize pixmap if needed + int side = m_width / 16; + m_overlayGeometry.setRect( m_width - side - 4, 4, side, side ); + if ( m_lastRenderedOverlay.width() != side ) + m_lastRenderedOverlay.resize( 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, side ); + doublePixmap.fill( Qt::black ); + QPainter pixmapPainter( &doublePixmap ); + + // 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( 0x40 ); + pixmapPainter.drawPie( 2, 2, side - 4, side - 4, 90*16, (360-degrees)*16 ); + pixmapPainter.setPen( 0x40 ); + pixmapPainter.setBrush( 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( 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.convertToImage().smoothScale( side / 2, side / 2 ) ); + image.setAlphaBuffer( true ); + + // draw circular shadow using the same technique + doublePixmap.fill( Qt::black ); + pixmapPainter.begin( &doublePixmap ); + pixmapPainter.setPen( 0x40 ); + pixmapPainter.setBrush( 0x80 ); + pixmapPainter.drawEllipse( 0, 0, side, side ); + pixmapPainter.end(); + QImage shadow( doublePixmap.convertToImage().smoothScale( side / 2, side / 2 ) ); + + // generate a 2 colors pixmap using mixing shadow (made with highlight color) + // and image (made with highlightedText color) + QColor color = palette().active().highlightedText(); + int red = color.red(), green = color.green(), blue = color.blue(); + color = palette().active().highlight(); + int sRed = color.red(), sGreen = color.green(), sBlue = color.blue(); + // pointers + unsigned int * data = (unsigned int *)image.bits(), + * shadowData = (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.convertFromImage( image ); + + // start the autohide timer + repaint( m_overlayGeometry, false /*clear*/ ); // toggle with next line + //update( m_overlayGeometry ); + m_overlayHideTimer->start( 2500, true ); +#endif +} + + + +void PresentationWidget::slotNextPage() +{ + // loop when configured + if ( m_frameIndex == (int)m_frames.count() - 1 && KpdfSettings::slidesLoop() ) + m_frameIndex = -1; + + if ( m_frameIndex < (int)m_frames.count() - 1 ) + { + // go to next page + changePage( m_frameIndex + 1 ); + + // auto advance to the next page if set + if ( KpdfSettings::slidesAdvance() ) + m_nextPageTimer->start( KpdfSettings::slidesAdvanceTime() * 1000 ); + } + else + { +#ifdef ENABLE_PROGRESS_OVERLAY + if ( KpdfSettings::slidesShowProgress() ) + generateOverlay(); +#endif + if ( m_transitionTimer->isActive() ) + { + m_transitionTimer->stop(); + 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 + if ( KpdfSettings::slidesAdvance() ) + m_nextPageTimer->start( KpdfSettings::slidesAdvanceTime() * 1000 ); + } + else + { +#ifdef ENABLE_PROGRESS_OVERLAY + if ( KpdfSettings::slidesShowProgress() ) + generateOverlay(); +#endif + if ( m_transitionTimer->isActive() ) + { + m_transitionTimer->stop(); + 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() +{ + 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(); + } + m_transitionTimer->start( m_transitionDelay, true ); +} + +const KPDFPageTransition PresentationWidget::defaultTransition() const +{ + return defaultTransition( KpdfSettings::slidesTransition() ); +} + +const KPDFPageTransition PresentationWidget::defaultTransition( int type ) const +{ + switch ( type ) + { + case KpdfSettings::EnumSlidesTransition::BlindsHorizontal: + { + KPDFPageTransition transition( KPDFPageTransition::Blinds ); + transition.setAlignment( KPDFPageTransition::Horizontal ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::BlindsVertical: + { + KPDFPageTransition transition( KPDFPageTransition::Blinds ); + transition.setAlignment( KPDFPageTransition::Vertical ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::BoxIn: + { + KPDFPageTransition transition( KPDFPageTransition::Box ); + transition.setDirection( KPDFPageTransition::Inward ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::BoxOut: + { + KPDFPageTransition transition( KPDFPageTransition::Box ); + transition.setDirection( KPDFPageTransition::Outward ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::Dissolve: + { + return KPDFPageTransition( KPDFPageTransition::Dissolve ); + break; + } + case KpdfSettings::EnumSlidesTransition::GlitterDown: + { + KPDFPageTransition transition( KPDFPageTransition::Glitter ); + transition.setAngle( 270 ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::GlitterRight: + { + KPDFPageTransition transition( KPDFPageTransition::Glitter ); + transition.setAngle( 0 ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::GlitterRightDown: + { + KPDFPageTransition transition( KPDFPageTransition::Glitter ); + transition.setAngle( 315 ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::Random: + { + return defaultTransition( KApplication::random() % 18 ); + break; + } + case KpdfSettings::EnumSlidesTransition::SplitHorizontalIn: + { + KPDFPageTransition transition( KPDFPageTransition::Split ); + transition.setAlignment( KPDFPageTransition::Horizontal ); + transition.setDirection( KPDFPageTransition::Inward ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::SplitHorizontalOut: + { + KPDFPageTransition transition( KPDFPageTransition::Split ); + transition.setAlignment( KPDFPageTransition::Horizontal ); + transition.setDirection( KPDFPageTransition::Outward ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::SplitVerticalIn: + { + KPDFPageTransition transition( KPDFPageTransition::Split ); + transition.setAlignment( KPDFPageTransition::Vertical ); + transition.setDirection( KPDFPageTransition::Inward ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::SplitVerticalOut: + { + KPDFPageTransition transition( KPDFPageTransition::Split ); + transition.setAlignment( KPDFPageTransition::Vertical ); + transition.setDirection( KPDFPageTransition::Outward ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::WipeDown: + { + KPDFPageTransition transition( KPDFPageTransition::Wipe ); + transition.setAngle( 270 ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::WipeRight: + { + KPDFPageTransition transition( KPDFPageTransition::Wipe ); + transition.setAngle( 0 ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::WipeLeft: + { + KPDFPageTransition transition( KPDFPageTransition::Wipe ); + transition.setAngle( 180 ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::WipeUp: + { + KPDFPageTransition transition( KPDFPageTransition::Wipe ); + transition.setAngle( 90 ); + return transition; + break; + } + case KpdfSettings::EnumSlidesTransition::Replace: + default: + return KPDFPageTransition( KPDFPageTransition::Replace ); + break; + } +} + +/** ONLY the TRANSITIONS GENERATION function from here on **/ +void PresentationWidget::initTransition( const KPDFPageTransition *transition ) +{ + // if it's just a 'replace' transition, repaint the screen + if ( transition->type() == KPDFPageTransition::Replace ) + { + update(); + return; + } + + const bool isInward = transition->direction() == KPDFPageTransition::Inward; + const bool isHorizontal = transition->alignment() == KPDFPageTransition::Horizontal; + const float totalTime = transition->duration(); + + m_transitionRects.clear(); + + switch( transition->type() ) + { + // split: horizontal / vertical and inward / outward + case KPDFPageTransition::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 KPDFPageTransition::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 KPDFPageTransition::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++ ) + { + // compure shrinked 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++ ) + { + // compure shrinked 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 KPDFPageTransition::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 KPDFPageTransition::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++ ) + { + int n1 = (int)(steps * drand48()); + int n2 = (int)(steps * drand48()); + // 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 KPDFPageTransition::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++ ) + { + int n1 = (int)(steps * drand48()); + int n2 = (int)(steps * drand48()); + // 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; + + // implement missing transitions (a binary raster engine needed here) + case KPDFPageTransition::Fly: + + case KPDFPageTransition::Push: + + case KPDFPageTransition::Cover: + + case KPDFPageTransition::Uncover: + + case KPDFPageTransition::Fade: + + default: + update(); + return; + } + + // send the first start to the timer + m_transitionTimer->start( 0, true ); +} + + +#include "presentationwidget.moc" |