File indexing completed on 2024-05-19 16:01:25

 /* This file is part of the KDE project
    Copyright (C) 2010 KO GmbH <jos.van.den.oever@kogmbh.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 #include "slideview.h"
 #include "slideloader.h"
 #include <QDebug>
 #include <QEvent>
 #include <QGraphicsItem>
 #include <QImage>
 #include <QVBoxLayout>
 #include <QPixmapCache>
 #include <QGraphicsSceneEvent>
 #include <QScrollBar>
 #include <QTransform>
 #include <QWheelEvent>
 #include <QGLWidget>
 #include <cmath>
 
 class GraphicsSlideItem : public QGraphicsItem {
 public:
 #ifdef QT46
     class Cache {
     private:
         QPixmapCache::Key key;
     public:
         bool find(QPixmap& pixmap) const {
             return QPixmapCache::find(key, &pixmap);
         }
         void clear() const { QPixmapCache::remove(key); }
         void add(const QPixmap& pixmap) {
             clear();
             key = QPixmapCache::insert(pixmap);
         }
     };
 #else
     class Cache {
     private:
         const QString key;
     public:
         Cache() :key(QString("%1 GraphicsSlideItem").arg((qlonglong)this)) {}
         bool find(QPixmap& pixmap) const {
             return QPixmapCache::find(key, pixmap);
         }
         void clear() const { QPixmapCache::remove(key); }
         void add(const QPixmap& pixmap) {
             clear();
             QPixmapCache::insert(key, pixmap);
         }
     };
 #endif
     Cache cache;
     QRectF rect;
     QPainterPath path;
     SlideView* const view;
     int position;
     int slideVersion;
 
     explicit GraphicsSlideItem(int pos, SlideView* v)
             :QGraphicsItem(), view(v), position(pos) {
         slideVersion = -1;
     }
     void setPosition(int pos) {
         if (position != pos) {
             position = pos;
             slideVersion = -1;
         }
         if (view->loader->slideVersion(position) != slideVersion) {
             update(rect);
         }
     } 
     void paint(QPainter* painter, const QStyleOptionGraphicsItem * /*option*/,
                QWidget * /*widget*/ = 0) {
         QPixmap pixmap;
         if (slideVersion != view->loader->slideVersion(position)
                 || !cache.find(pixmap)) {
             slideVersion = view->loader->slideVersion(position);
             pixmap = view->loader->loadSlide(position, rect.size().toSize());
             cache.add(pixmap);
         }
         if (pixmap.isNull()) {
             painter->fillRect(rect, Qt::gray);
         } else {
             painter->drawPixmap(rect.topLeft(), pixmap);
         }
     }
     QRectF boundingRect() const {
         return rect;
     }
     QPainterPath opaqueArea() const {
         return path;
     }
     void setBoundingRect(const QRectF& newrect) {
         if (rect != newrect) {
             if (rect.size() != newrect.size()) {
                 cache.clear();
             }
             prepareGeometryChange();
             rect = newrect;
             path = QPainterPath();
             path.addRect(rect);
         }
     }
     void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * /*event*/) {
         view->toggleSlideZoom(this);
     }
 };
 
 SlideView::SlideView(SlideLoader* l, QWidget* parent) :QWidget(parent),
         loader(l), zoomfactor(0.25), sendingChange(false)
 {
     // use opengl canvas
     view.setViewport(new QGLWidget(QGLFormat(QGL::SampleBuffers)));
     // listen to resize and wheel events
     view.viewport()->installEventFilter(this);
 
     connect(loader, SIGNAL(slidesChanged()), this, SLOT(slotUpdateSlides()));
     connect(view.verticalScrollBar(), SIGNAL(valueChanged(int)),
         this, SLOT(slotViewChanged()));
     connect(view.horizontalScrollBar(), SIGNAL(valueChanged(int)),
         this, SLOT(slotViewChanged()));
 
     QVBoxLayout *layout = new QVBoxLayout();
     layout->setContentsMargins(0, 0, 0, 0);
     layout->setSpacing(0);
     layout->addWidget(&view);
     layout->addWidget(&progressBar);
     setLayout(layout);
 
     progressBar.setVisible(false);
     scene.setBackgroundBrush(Qt::Dense4Pattern);
     view.setScene(&scene);
 
     slotUpdateSlides();
 }
 
 void SlideView::slotUpdateSlides() {
     int numberOfSlides = loader->numberOfSlides();
     QList<QGraphicsItem*> items = scene.items();
     if (items.size() > numberOfSlides) {
         // remove surplus items
         for (int i = numberOfSlides; i < items.size(); ++i) {
             scene.removeItem(items[i]);
         }
     } else if (numberOfSlides > items.size()) {
         // add new items
         for (int i=items.size(); i<numberOfSlides; ++i) {
             GraphicsSlideItem* item = new GraphicsSlideItem(i, this);
             item->setVisible(true);
             scene.addItem(item);
         }
     }
     items = scene.items();
     for (int i=0; i<items.size(); ++i) {
         static_cast<GraphicsSlideItem*>(items[i])->setPosition(i);
     }
     layout();
 }
 void SlideView::layout() {
     const qreal spacing = 2;
     QSizeF slidesize = loader->slideSize();
     int slidesPerRow = (zoomfactor > 1) ?1 :1/zoomfactor;
 
     if (zoomfactor <= 1) {
         view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     } else {
         view.setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     }
     qreal viewwidth = view.viewport()->width();
 
     qreal x = 0;
     qreal y = 0;
     qreal screenslidewidth = zoomfactor * viewwidth;
 
     qreal w, h, viewscale;
     if (screenslidewidth > slidesize.width()) {
         viewscale = screenslidewidth / slidesize.width();
         w = slidesize.width();
         h = slidesize.height();
     } else {
         viewscale = 1;
         qreal slidescale = screenslidewidth / slidesize.width();
         w = slidesize.width() * slidescale;
         h = slidesize.height() * slidescale;
     }
     QTransform transform;
     transform.scale(viewscale, viewscale);
     view.setTransform(transform);
 
     const QList<QGraphicsItem *> items = scene.items();
     qreal dx = w + spacing;
     qreal dy = h + spacing;
     for (int i=0; i < items.size(); ++i) {
         GraphicsSlideItem* item = static_cast<GraphicsSlideItem*>(items[i]);
         item->setBoundingRect(QRectF(x, y, w, h));
         if ((i+1) % slidesPerRow) {
             x += dx;
         } else {
             x = 0;
             y += dy;
         }
     }
     if (x == 0) {
         scene.setSceneRect(0, 0, slidesPerRow*dx, y);
     } else {
         scene.setSceneRect(0, 0, slidesPerRow*dx, y + dy);
     }
 }
 bool SlideView::eventFilter(QObject * obj, QEvent *event) {
     if (obj != view.viewport()) return false;
     if (event->type() == QEvent::Wheel) {
         const QWheelEvent* e = static_cast<QWheelEvent*>(event);
         if (e->modifiers() == Qt::ControlModifier) {
             zoomfactor *= pow(1.1, e->delta()/120.0);
             layout();
             slotViewChanged();
             return true;
         }
     } else if (event->type() == QEvent::Resize) {
         layout();
         slotViewChanged();
     }
     return false;
 }
 void
 SlideView::setView(qreal zoomfactor, int h, int v) {
     if (sendingChange) return;
     this->zoomfactor = zoomfactor;
     if (scene.items().size())
     layout();
     view.horizontalScrollBar()->setValue(h);
     view.verticalScrollBar()->setValue(v);
 }
 void SlideView::slotViewChanged() {
     sendingChange = true;
     int h = view.horizontalScrollBar()->value();
     int v = view.verticalScrollBar()->value();
     emit viewChanged(zoomfactor, h, v);
     sendingChange = false;
 }
 void SlideView::toggleSlideZoom(const GraphicsSlideItem* item) {
     // zoom to zoomfactor 1 with clicked slide on the top, unless that slide
     // is already active, then zoom to level 0.25 in the range of the clicked
     // slide
     // this function does not work well, the behavior of the scrollbar is a
     // mystery, but the magic dance seems to work ok so far
     QScrollBar* sb = view.verticalScrollBar();
     int offset = 2;
     qreal y = item->boundingRect().top();
     qDebug() << y << " " << sb->value();
     if (zoomfactor == 1
             && (qAbs(y - sb->value()) <= offset+1
                 || sb->value()+1 >= sb->maximum())) {
         zoomfactor = 0.25;
     } else {
         zoomfactor = 1;
     }
     layout();
     // magic dance
     layout();
     view.mapToScene(0, 0).y();
     // end of magic dance
     y = item->boundingRect().top();
     view.verticalScrollBar()->setValue(y - offset); // small offset looks nice
 }
 void SlideView::SlideGraphicsScene::dragEnterEvent(
         QGraphicsSceneDragDropEvent *event)
 {
     event->ignore();
 }