1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
/* This file is part of the KDE project
* Copyright (C) 2007, 2009 Thomas Zander <zander@kde.org>
* Copyright (C) 2007 Jan Hambrecht <jaham@gmx.net>
* Copyright (C) 2008 Thorsten Zachmann <zachmann@kde.org>
*
* 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.
*/
#ifndef KOIMAGEDATA_H
#define KOIMAGEDATA_H
#include "flake_export.h"
#include <QSize>
#include <QMetaType>
#include <KoShapeUserData.h>
class QIODevice;
class QPixmap;
class QImage;
class QSizeF;
class QUrl;
class KoImageCollection;
class KoImageDataPrivate;
class KoStore;
/**
* This class is meant to represent the image data so it can be shared between image shapes.
* In Calligra there is a picture shape and a krita shape which both can both show
* an image. To allow smooth transition of image data between shapes, as well as allowing
* lower-resolution data to be shown this class will actually be the backing store of
* the image data and it can create a pre-rendered QPixmap without deminishing the backing-store
* data.
* This class inherits from KoShapeUserData which means you can set it on any KoShape using
* KoShape::setUserData() and get it using KoShape::userData(). The pictureshape plugin
* uses this class to show its image data.
* Such plugins are suggested to not make a copy of the pixmap data, but use the fact that this
* image data caches one for every request to pixmap()
*/
class FLAKE_EXPORT KoImageData : public KoShapeUserData
{
Q_OBJECT
public:
/// Various error codes representing what has gone wrong
enum ErrorCode {
Success,
OpenFailed,
StorageFailed, ///< This is set if the image data has to be stored on disk in a temporary file, but we failed to do so
LoadFailed
};
/// default constructor, creates an invalid imageData object
KoImageData();
/**
* copy constructor
* @param imageData the other one.
*/
KoImageData(const KoImageData &imageData);
/// destructor
virtual ~KoImageData();
/**
* Renders a pixmap the first time you request it is called and returns it.
* @returns the cached pixmap
* @see isValid(), hasCachedPixmap()
*/
QPixmap pixmap(const QSize &targetSize = QSize());
/// returns true only if pixmap() would return immediately with a cached pixmap
bool hasCachedPixmap() const;
void setImage(const QImage &image, KoImageCollection *collection = 0);
void setImage(const QByteArray &imageData, KoImageCollection *collection = 0);
void setExternalImage(const QUrl &location, KoImageCollection *collection = 0);
void setImage(const QString &location, KoStore *store, KoImageCollection *collection = 0);
/**
* Save the image data to the param device.
* The full file is saved.
* @param device the device that is used to get the data from.
* @return returns true if load was successful.
*/
bool saveData(QIODevice &device);
/**
* Return the internal store of the image.
* @see isValid(), hasCachedImage()
*/
QImage image() const;
/// returns true only if image() would return immediately with a cached image
bool hasCachedImage() const;
/**
* The size of the image in points
*/
QSizeF imageSize();
KoImageData &operator=(const KoImageData &other);
inline bool operator!=(const KoImageData &other) const { return !operator==(other); }
bool operator==(const KoImageData &other) const;
/**
* Get a unique key of the image data
*/
qint64 key() const;
QString suffix() const;
ErrorCode errorCode() const;
/// returns if this is a valid imageData with actual image data present on it.
bool isValid() const;
/// \internal
KoImageDataPrivate *priv() { return d; }
protected:
friend class KoImageCollection;
/// \internal
KoImageData(KoImageDataPrivate *priv);
private:
KoImageDataPrivate *d;
Q_PRIVATE_SLOT(d, void cleanupImageCache())
};
Q_DECLARE_METATYPE(KoImageData*)
#endif
|
