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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
|
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef PAINTCOMMANDS_H
#define PAINTCOMMANDS_H
#include <qcolor.h>
#include <qmap.h>
#include <qpainterpath.h>
#include <qregion.h>
#include <qstringlist.h>
#include <qpixmap.h>
#include <qbrush.h>
QT_FORWARD_DECLARE_CLASS(QPainter)
QT_FORWARD_DECLARE_CLASS(QRegExp)
#ifndef QT_NO_OPENGL
QT_FORWARD_DECLARE_CLASS(QGLPixelBuffer)
#endif
enum DeviceType {
WidgetType,
BitmapType,
PixmapType,
ImageType,
ImageMonoType,
OpenGLType,
OpenGLPBufferType,
PictureType,
PrinterType,
PdfType,
PsType,
GrabType,
CustomDeviceType,
CustomWidgetType,
ImageWidgetType
};
/************************************************************************/
class PaintCommands
{
public:
// construction / initialization
PaintCommands(const QStringList &cmds, int w, int h)
: m_painter(0)
, m_surface_painter(0)
, m_commands(cmds)
, m_gradientSpread(QGradient::PadSpread)
, m_gradientCoordinate(QGradient::LogicalMode)
, m_width(w)
, m_height(h)
, m_verboseMode(false)
, m_type(WidgetType)
, m_checkers_background(true)
{ staticInit(); }
public:
void setCheckersBackground(bool b) { staticInit(); m_checkers_background = b; }
void setContents(const QStringList &cmds) {
staticInit();
m_blockMap.clear();
m_pathMap.clear();
m_pixmapMap.clear();
m_imageMap.clear();
m_regionMap.clear();
m_gradientStops.clear();
m_controlPoints.clear();
m_gradientSpread = QGradient::PadSpread;
m_gradientCoordinate = QGradient::LogicalMode;
m_commands = cmds;
}
void setPainter(QPainter *pt) { staticInit(); m_painter = pt; }
void setType(DeviceType t) { staticInit(); m_type = t; }
void setFilePath(const QString &path) { staticInit(); m_filepath = path; }
void setControlPoints(const QVector<QPointF> &points) { staticInit(); m_controlPoints = points; }
void setVerboseMode(bool v) { staticInit(); m_verboseMode = v; }
void insertAt(int commandIndex, const QStringList &newCommands);
// run
void runCommands();
private:
// run
void runCommand(const QString &scriptLine);
// conversion methods
int convertToInt(const QString &str);
double convertToDouble(const QString &str);
float convertToFloat(const QString &str);
QColor convertToColor(const QString &str);
// commands: comments
void command_comment(QRegExp re);
// commands: importer
void command_import(QRegExp re);
// commands: blocks
void command_begin_block(QRegExp re);
void command_end_block(QRegExp re);
void command_repeat_block(QRegExp re);
// commands: misc
void command_textlayout_draw(QRegExp re);
void command_abort(QRegExp re);
// commands: noops
void command_noop(QRegExp re);
// commands: setters
void command_setBgMode(QRegExp re);
void command_setBackground(QRegExp re);
void command_setOpacity(QRegExp re);
void command_path_setFillRule(QRegExp re);
void command_setBrush(QRegExp re);
void command_setBrushOrigin(QRegExp re);
void command_brushTranslate(QRegExp re);
void command_brushRotate(QRegExp re);
void command_brushScale(QRegExp re);
void command_brushShear(QRegExp re);
void command_setClipPath(QRegExp re);
void command_setClipRect(QRegExp re);
void command_setClipRectangle(QRegExp re);
void command_setClipRegion(QRegExp re);
void command_setClipping(QRegExp re);
void command_setCompositionMode(QRegExp re);
void command_setFont(QRegExp re);
void command_setPen(QRegExp re);
void command_setPen2(QRegExp re);
void command_pen_setDashOffset(QRegExp re);
void command_pen_setDashPattern(QRegExp re);
void command_pen_setCosmetic(QRegExp re);
void command_setRenderHint(QRegExp re);
void command_clearRenderHint(QRegExp re);
void command_gradient_appendStop(QRegExp re);
void command_gradient_clearStops(QRegExp re);
void command_gradient_setConical(QRegExp re);
void command_gradient_setLinear(QRegExp re);
void command_gradient_setRadial(QRegExp re);
void command_gradient_setLinearPen(QRegExp re);
void command_gradient_setSpread(QRegExp re);
void command_gradient_setCoordinateMode(QRegExp re);
// commands: drawing ops
#ifdef QT3_SUPPORT
void command_qt3_drawArc(QRegExp re);
void command_qt3_drawChord(QRegExp re);
void command_qt3_drawEllipse(QRegExp re);
void command_qt3_drawPie(QRegExp re);
void command_qt3_drawRect(QRegExp re);
void command_qt3_drawRoundRect(QRegExp re);
#endif
void command_drawArc(QRegExp re);
void command_drawChord(QRegExp re);
void command_drawConvexPolygon(QRegExp re);
void command_drawEllipse(QRegExp re);
void command_drawImage(QRegExp re);
void command_drawLine(QRegExp re);
void command_drawPath(QRegExp re);
void command_drawPie(QRegExp re);
void command_drawPixmap(QRegExp re);
void command_drawPoint(QRegExp re);
void command_drawPolygon(QRegExp re);
void command_drawPolyline(QRegExp re);
void command_drawRect(QRegExp re);
void command_drawRoundedRect(QRegExp re);
void command_drawRoundRect(QRegExp re);
void command_drawText(QRegExp re);
void command_drawTiledPixmap(QRegExp re);
void command_path_addEllipse(QRegExp re);
void command_path_addPolygon(QRegExp re);
void command_path_addRect(QRegExp re);
void command_path_addText(QRegExp re);
void command_path_arcTo(QRegExp re);
void command_path_closeSubpath(QRegExp re);
void command_path_createOutline(QRegExp re);
void command_path_cubicTo(QRegExp re);
void command_path_debugPrint(QRegExp re);
void command_path_lineTo(QRegExp re);
void command_path_moveTo(QRegExp re);
void command_region_addEllipse(QRegExp re);
void command_region_addRect(QRegExp re);
// getters
void command_region_getClipRegion(QRegExp re);
void command_path_getClipPath(QRegExp re);
// commands: surface begin/end
void command_surface_begin(QRegExp re);
void command_surface_end(QRegExp re);
// commands: save/restore painter state
void command_restore(QRegExp re);
void command_save(QRegExp re);
// commands: pixmap/image
void command_pixmap_load(QRegExp re);
void command_pixmap_setMask(QRegExp re);
void command_bitmap_load(QRegExp re);
void command_image_convertToFormat(QRegExp re);
void command_image_load(QRegExp re);
void command_image_setColor(QRegExp re);
void command_image_setColorCount(QRegExp re);
// commands: transformation
void command_resetMatrix(QRegExp re);
void command_translate(QRegExp re);
void command_rotate(QRegExp re);
void command_rotate_x(QRegExp re);
void command_rotate_y(QRegExp re);
void command_scale(QRegExp re);
void command_mapQuadToQuad(QRegExp re);
void command_setMatrix(QRegExp re);
// attributes
QPainter *m_painter;
QPainter *m_surface_painter;
QImage m_surface_image;
QPixmap m_surface_pixmap;
#ifndef QT_NO_OPENGL
QGLPixelBuffer *m_surface_pbuffer;
#endif
QRectF m_surface_rect;
QStringList m_commands;
QString m_currentCommand;
int m_currentCommandIndex;
QString m_filepath;
QMap<QString, QStringList> m_blockMap;
QMap<QString, QPainterPath> m_pathMap;
QMap<QString, QPixmap> m_pixmapMap;
QMap<QString, QImage> m_imageMap;
QMap<QString, QRegion> m_regionMap;
QGradientStops m_gradientStops;
QGradient::Spread m_gradientSpread;
QGradient::CoordinateMode m_gradientCoordinate;
bool m_abort;
int m_width;
int m_height;
bool m_verboseMode;
DeviceType m_type;
bool m_checkers_background;
QVector<QPointF> m_controlPoints;
// painter functionalities string tables
static const char *brushStyleTable[];
static const char *penStyleTable[];
static const char *fontWeightTable[];
static const char *clipOperationTable[];
static const char *spreadMethodTable[];
static const char *coordinateMethodTable[];
static const char *compositionModeTable[];
static const char *imageFormatTable[];
static const char *sizeModeTable[];
static int translateEnum(const char *table[], const QString &pattern, int limit);
// utility
template <typename T> T image_load(const QString &filepath);
// commands dictionary management
static void staticInit();
public:
struct PaintCommandInfos
{
PaintCommandInfos(QString id, void (PaintCommands::*p)(QRegExp), QRegExp r, QString sy, QString sa)
: identifier(id)
, regExp(r)
, syntax(sy)
, sample(sa)
, paintMethod(p)
{}
PaintCommandInfos(QString title)
: identifier(title), paintMethod(0) {}
bool isSectionHeader() const { return paintMethod == 0; }
QString identifier;
QRegExp regExp;
QString syntax;
QString sample;
void (PaintCommands::*paintMethod)(QRegExp);
};
static PaintCommandInfos *findCommandById(const QString &identifier) {
for (int i=0; i<s_commandInfoTable.size(); i++)
if (s_commandInfoTable[i].identifier == identifier)
return &s_commandInfoTable[i];
return 0;
}
static QList<PaintCommandInfos> s_commandInfoTable;
static QList<QPair<QString,QStringList> > s_enumsTable;
};
#endif // PAINTCOMMANDS_H
|
