← Back to branch summary

~ubuntu-branches/ubuntu/precise/gwenview/precise-proposed

« back to all changes in this revision

Viewing changes to lib/documentview/svgviewadapter.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2011-12-15 14:17:54 UTC
  • mto: This revision was merged to the branch mainline in revision 12.
  • Revision ID: package-import@ubuntu.com-20111215141754-z043hyx69dulbggf
Tags: upstream-4.7.90
Import upstream version 4.7.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/documentview/svgviewadapter.cpp
1
 
// vim: set tabstop=4 shiftwidth=4 noexpandtab:
 
1
// vim: set tabstop=4 shiftwidth=4 expandtab:
2
2
/*
3
3
Gwenview: an image viewer
4
4
Copyright 2008 Aurélien Gâteau <agateau@kde.org>
22
22
#include "svgviewadapter.moc"
23
23
 
24
24
// Qt
 
25
#include <QCursor>
25
26
#include <QEvent>
26
 
#include <QGraphicsScene>
27
27
#include <QGraphicsSvgItem>
28
 
#include <QGraphicsView>
 
28
#include <QGraphicsTextItem>
 
29
#include <QGraphicsWidget>
 
30
#include <QPainter>
29
31
#include <QSvgRenderer>
30
32
 
31
33
// KDE
33
35
 
34
36
// Local
35
37
#include "document/documentfactory.h"
36
 
 
37
 
namespace Gwenview {
38
 
 
39
 
 
 
38
#include <qgraphicssceneevent.h>
 
39
 
 
40
namespace Gwenview
 
41
{
 
42
 
 
43
/// SvgImageView ////
 
44
SvgImageView::SvgImageView(QGraphicsItem* parent)
 
45
: AbstractImageView(parent)
 
46
, mSvgItem(new QGraphicsSvgItem(this))
 
47
{
 
48
}
 
49
 
 
50
void SvgImageView::loadFromDocument()
 
51
{
 
52
    QSvgRenderer* renderer = document()->svgRenderer();
 
53
    if (!renderer) {
 
54
        kWarning() << "No SVG renderer. This should not happen!";
 
55
        return;
 
56
    }
 
57
    mSvgItem->setSharedRenderer(renderer);
 
58
}
 
59
 
 
60
void SvgImageView::onZoomChanged()
 
61
{
 
62
    mSvgItem->setScale(zoom());
 
63
    adjustItemPos();
 
64
}
 
65
 
 
66
void SvgImageView::onImageOffsetChanged()
 
67
{
 
68
    adjustItemPos();
 
69
}
 
70
 
 
71
void SvgImageView::onScrollPosChanged(const QPointF& /* oldPos */)
 
72
{
 
73
    adjustItemPos();
 
74
}
 
75
 
 
76
void SvgImageView::adjustItemPos()
 
77
{
 
78
    mSvgItem->setPos(imageOffset() - scrollPos());
 
79
}
 
80
 
 
81
//// SvgViewAdapter ////
40
82
struct SvgViewAdapterPrivate {
41
 
        QSvgRenderer* mRenderer;
42
 
        QGraphicsScene* mScene;
43
 
        QGraphicsView* mView;
44
 
 
45
 
        Document::Ptr mDocument;
46
 
        QGraphicsSvgItem* mItem;
47
 
        bool mZoomToFit;
 
83
    SvgImageView* mView;
48
84
};
49
85
 
50
 
 
51
 
SvgViewAdapter::SvgViewAdapter(QWidget* parent)
52
 
: AbstractDocumentViewAdapter(parent)
53
 
, d(new SvgViewAdapterPrivate) {
54
 
        d->mRenderer = new QSvgRenderer(this);
55
 
        d->mScene = new QGraphicsScene(this);
56
 
        d->mView = new QGraphicsView(d->mScene, parent);
57
 
        d->mView->setFrameStyle(QFrame::NoFrame);
58
 
        d->mView->setDragMode(QGraphicsView::ScrollHandDrag);
59
 
        d->mView->viewport()->installEventFilter(this);
60
 
 
61
 
        d->mItem = 0;
62
 
        d->mZoomToFit = true;
63
 
 
64
 
        setWidget(d->mView);
65
 
}
66
 
 
67
 
 
68
 
void SvgViewAdapter::installEventFilterOnViewWidgets(QObject* object) {
69
 
        d->mView->viewport()->installEventFilter(object);
70
 
        // Necessary to receive key{Press,Release} events
71
 
        d->mView->installEventFilter(object);
72
 
}
73
 
 
74
 
 
75
 
SvgViewAdapter::~SvgViewAdapter() {
76
 
        delete d;
77
 
}
78
 
 
79
 
 
80
 
QCursor SvgViewAdapter::cursor() const {
81
 
        return d->mView->viewport()->cursor();
82
 
}
83
 
 
84
 
 
85
 
void SvgViewAdapter::setCursor(const QCursor& cursor) {
86
 
        d->mView->viewport()->setCursor(cursor);
87
 
}
88
 
 
89
 
 
90
 
void SvgViewAdapter::setDocument(Document::Ptr doc) {
91
 
        d->mDocument = doc;
92
 
        connect(d->mDocument.data(), SIGNAL(loaded(const KUrl&)),
93
 
                SLOT(loadFromDocument()));
94
 
        loadFromDocument();
95
 
}
96
 
 
97
 
 
98
 
void SvgViewAdapter::loadFromDocument() {
99
 
        delete d->mItem;
100
 
        d->mItem = 0;
101
 
 
102
 
        if (!d->mRenderer->load(d->mDocument->rawData())) {
103
 
                kWarning() << "Decoding SVG failed";
104
 
                return;
105
 
        }
106
 
        d->mItem = new QGraphicsSvgItem();
107
 
        d->mItem->setSharedRenderer(d->mRenderer);
108
 
        d->mScene->addItem(d->mItem);
109
 
 
110
 
        if (d->mZoomToFit) {
111
 
                setZoom(computeZoomToFit());
112
 
        }
113
 
}
114
 
 
115
 
 
116
 
Document::Ptr SvgViewAdapter::document() const {
117
 
        return d->mDocument;
118
 
}
119
 
 
120
 
 
121
 
void SvgViewAdapter::setZoomToFit(bool on) {
122
 
        if (d->mZoomToFit == on) {
123
 
                return;
124
 
        }
125
 
        d->mZoomToFit = on;
126
 
        if (d->mZoomToFit) {
127
 
                setZoom(computeZoomToFit());
128
 
        }
129
 
        zoomToFitChanged(on);
130
 
}
131
 
 
132
 
 
133
 
bool SvgViewAdapter::zoomToFit() const {
134
 
        return d->mZoomToFit;
135
 
}
136
 
 
137
 
 
138
 
qreal SvgViewAdapter::zoom() const {
139
 
        return d->mView->matrix().m11();
140
 
}
141
 
 
142
 
 
143
 
void SvgViewAdapter::setZoom(qreal zoom, const QPoint& /*center*/) {
144
 
        QMatrix matrix;
145
 
        matrix.scale(zoom, zoom);
146
 
        d->mView->setMatrix(matrix);
147
 
        emit zoomChanged(zoom);
148
 
}
149
 
 
150
 
 
151
 
qreal SvgViewAdapter::computeZoomToFit() const {
152
 
        return qMin(computeZoomToFitWidth(), computeZoomToFitHeight());
153
 
}
154
 
 
155
 
 
156
 
qreal SvgViewAdapter::computeZoomToFitWidth() const {
157
 
        int width = d->mScene->width();
158
 
        return width != 0 ? (qreal(d->mView->viewport()->width()) / width) : 1;
159
 
}
160
 
 
161
 
 
162
 
qreal SvgViewAdapter::computeZoomToFitHeight() const {
163
 
        int height = d->mScene->height();
164
 
        return height != 0 ? (qreal(d->mView->viewport()->height()) / height) : 1;
165
 
}
166
 
 
167
 
 
168
 
bool SvgViewAdapter::eventFilter(QObject*, QEvent* event) {
169
 
        if (event->type() == QEvent::Resize) {
170
 
                if (d->mZoomToFit) {
171
 
                        setZoom(computeZoomToFit());
172
 
                }
173
 
        }
174
 
        return false;
175
 
}
176
 
 
 
86
SvgViewAdapter::SvgViewAdapter()
 
87
: d(new SvgViewAdapterPrivate)
 
88
{
 
89
    d->mView = new SvgImageView;
 
90
    setWidget(d->mView);
 
91
    connect(d->mView, SIGNAL(zoomChanged(qreal)), SIGNAL(zoomChanged(qreal)));
 
92
    connect(d->mView, SIGNAL(zoomToFitChanged(bool)), SIGNAL(zoomToFitChanged(bool)));
 
93
    connect(d->mView, SIGNAL(scrollPosChanged()), SIGNAL(scrollPosChanged()));
 
94
}
 
95
 
 
96
SvgViewAdapter::~SvgViewAdapter()
 
97
{
 
98
    delete d;
 
99
}
 
100
 
 
101
QCursor SvgViewAdapter::cursor() const
 
102
{
 
103
    return widget()->cursor();
 
104
}
 
105
 
 
106
void SvgViewAdapter::setCursor(const QCursor& cursor)
 
107
{
 
108
    widget()->setCursor(cursor);
 
109
}
 
110
 
 
111
void SvgViewAdapter::setDocument(Document::Ptr doc)
 
112
{
 
113
    d->mView->setDocument(doc);
 
114
}
 
115
 
 
116
Document::Ptr SvgViewAdapter::document() const
 
117
{
 
118
    return d->mView->document();
 
119
}
 
120
 
 
121
void SvgViewAdapter::setZoomToFit(bool on)
 
122
{
 
123
    d->mView->setZoomToFit(on);
 
124
}
 
125
 
 
126
bool SvgViewAdapter::zoomToFit() const
 
127
{
 
128
    return d->mView->zoomToFit();
 
129
}
 
130
 
 
131
qreal SvgViewAdapter::zoom() const
 
132
{
 
133
    return d->mView->zoom();
 
134
}
 
135
 
 
136
void SvgViewAdapter::setZoom(qreal zoom, const QPointF& center)
 
137
{
 
138
    d->mView->setZoom(zoom, center);
 
139
}
 
140
 
 
141
qreal SvgViewAdapter::computeZoomToFit() const
 
142
{
 
143
    return d->mView->computeZoomToFit();
 
144
}
 
145
 
 
146
QPointF SvgViewAdapter::scrollPos() const
 
147
{
 
148
    return d->mView->scrollPos();
 
149
}
 
150
 
 
151
void SvgViewAdapter::setScrollPos(const QPointF& pos)
 
152
{
 
153
    d->mView->setScrollPos(pos);
 
154
}
177
155
 
178
156
} // namespace