← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to tools/designer/src/lib/uilib/ui4.h

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/designer/src/lib/uilib/ui4.h
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 1992-2005 Trolltech AS. All rights reserved.
 
4
**
 
5
** This file is part of the designer application of the Qt Toolkit.
 
6
**
 
7
** This file may be distributed under the terms of the Q Public License
 
8
** as defined by Trolltech AS of Norway and appearing in the file
 
9
** LICENSE.QPL included in the packaging of this file.
 
10
**
 
11
** This file may be distributed and/or modified under the terms of the
 
12
** GNU General Public License version 2 as published by the Free Software
 
13
** Foundation and appearing in the file LICENSE.GPL included in the
 
14
** packaging of this file.
 
15
**
 
16
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 
17
**   information about Qt Commercial License Agreements.
 
18
** See http://www.trolltech.com/qpl/ for QPL licensing information.
 
19
** See http://www.trolltech.com/gpl/ for GPL licensing information.
 
20
**
 
21
** Contact info@trolltech.com if any conditions of this licensing are
 
22
** not clear to you.
 
23
**
 
24
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 
25
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
26
**
 
27
****************************************************************************/
 
28
#ifndef UI4_H
 
29
#define UI4_H
 
30
 
 
31
#include <QtCore/QList>
 
32
#include <QtCore/QString>
 
33
#include <QtCore/QStringList>
 
34
 
 
35
class QDomDocument;
 
36
class QDomElement;
 
37
 
 
38
#include <QtCore/qglobal.h>
 
39
#if defined(QT_DESIGNER) && defined(Q_OS_WIN)
 
40
#    ifdef QT_UILIB_LIBRARY
 
41
#        define QT_UI4_EXPORT __declspec(dllexport)
 
42
#    else
 
43
#        define QT_UI4_EXPORT __declspec(dllimport)
 
44
#    endif
 
45
#endif
 
46
 
 
47
#ifndef QT_UI4_EXPORT
 
48
#    define QT_UI4_EXPORT
 
49
#endif
 
50
 
 
51
/*******************************************************************************
 
52
** Forward declarations
 
53
*/
 
54
 
 
55
class DomUI;
 
56
class DomIncludes;
 
57
class DomInclude;
 
58
class DomResources;
 
59
class DomResource;
 
60
class DomActionGroup;
 
61
class DomAction;
 
62
class DomActionRef;
 
63
class DomImages;
 
64
class DomImage;
 
65
class DomImageData;
 
66
class DomCustomWidgets;
 
67
class DomHeader;
 
68
class DomCustomWidget;
 
69
class DomProperties;
 
70
class DomPropertyData;
 
71
class DomSizePolicyData;
 
72
class DomLayoutDefault;
 
73
class DomLayoutFunction;
 
74
class DomTabStops;
 
75
class DomLayout;
 
76
class DomLayoutItem;
 
77
class DomRow;
 
78
class DomColumn;
 
79
class DomItem;
 
80
class DomWidget;
 
81
class DomSpacer;
 
82
class DomColor;
 
83
class DomColorGroup;
 
84
class DomPalette;
 
85
class DomFont;
 
86
class DomPoint;
 
87
class DomRect;
 
88
class DomSizePolicy;
 
89
class DomSize;
 
90
class DomDate;
 
91
class DomTime;
 
92
class DomDateTime;
 
93
class DomStringList;
 
94
class DomResourcePixmap;
 
95
class DomString;
 
96
class DomProperty;
 
97
class DomConnections;
 
98
class DomConnection;
 
99
class DomConnectionHints;
 
100
class DomConnectionHint;
 
101
 
 
102
/*******************************************************************************
 
103
** Declarations
 
104
*/
 
105
 
 
106
class QT_UI4_EXPORT DomUI {
 
107
public:
 
108
    DomUI();
 
109
    ~DomUI();
 
110
 
 
111
    void read(const QDomElement &node);
 
112
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
113
    inline QString text() const { return m_text; }
 
114
    inline void setText(const QString &s) { m_text = s; }
 
115
 
 
116
    // attribute accessors
 
117
    inline bool hasAttributeVersion() { return m_has_attr_version; }
 
118
    inline QString attributeVersion() { return m_attr_version; }
 
119
    inline void setAttributeVersion(const QString& a) { m_attr_version = a; m_has_attr_version = true; }
 
120
    inline void clearAttributeVersion() { m_has_attr_version = false; }
 
121
 
 
122
    inline bool hasAttributeStdSetDef() { return m_has_attr_stdSetDef; }
 
123
    inline int attributeStdSetDef() { return m_attr_stdSetDef; }
 
124
    inline void setAttributeStdSetDef(int a) { m_attr_stdSetDef = a; m_has_attr_stdSetDef = true; }
 
125
    inline void clearAttributeStdSetDef() { m_has_attr_stdSetDef = false; }
 
126
 
 
127
    // child element accessors
 
128
    inline QString elementAuthor() { return m_author; }
 
129
    void setElementAuthor(const QString& a);
 
130
 
 
131
    inline QString elementComment() { return m_comment; }
 
132
    void setElementComment(const QString& a);
 
133
 
 
134
    inline QString elementExportMacro() { return m_exportMacro; }
 
135
    void setElementExportMacro(const QString& a);
 
136
 
 
137
    inline QString elementClass() { return m_class; }
 
138
    void setElementClass(const QString& a);
 
139
 
 
140
    inline DomWidget* elementWidget() { return m_widget; }
 
141
    void setElementWidget(DomWidget* a);
 
142
 
 
143
    inline DomLayoutDefault* elementLayoutDefault() { return m_layoutDefault; }
 
144
    void setElementLayoutDefault(DomLayoutDefault* a);
 
145
 
 
146
    inline DomLayoutFunction* elementLayoutFunction() { return m_layoutFunction; }
 
147
    void setElementLayoutFunction(DomLayoutFunction* a);
 
148
 
 
149
    inline QString elementPixmapFunction() { return m_pixmapFunction; }
 
150
    void setElementPixmapFunction(const QString& a);
 
151
 
 
152
    inline DomCustomWidgets* elementCustomWidgets() { return m_customWidgets; }
 
153
    void setElementCustomWidgets(DomCustomWidgets* a);
 
154
 
 
155
    inline DomTabStops* elementTabStops() { return m_tabStops; }
 
156
    void setElementTabStops(DomTabStops* a);
 
157
 
 
158
    inline DomImages* elementImages() { return m_images; }
 
159
    void setElementImages(DomImages* a);
 
160
 
 
161
    inline DomIncludes* elementIncludes() { return m_includes; }
 
162
    void setElementIncludes(DomIncludes* a);
 
163
 
 
164
    inline DomResources* elementResources() { return m_resources; }
 
165
    void setElementResources(DomResources* a);
 
166
 
 
167
    inline DomConnections* elementConnections() { return m_connections; }
 
168
    void setElementConnections(DomConnections* a);
 
169
 
 
170
private:
 
171
    QString m_text;
 
172
    void clear(bool clear_all = true);
 
173
 
 
174
    // attribute data
 
175
    QString m_attr_version;
 
176
    bool m_has_attr_version;
 
177
 
 
178
    int m_attr_stdSetDef;
 
179
    bool m_has_attr_stdSetDef;
 
180
 
 
181
    // child element data
 
182
    QString m_author;
 
183
    QString m_comment;
 
184
    QString m_exportMacro;
 
185
    QString m_class;
 
186
    DomWidget* m_widget;
 
187
    DomLayoutDefault* m_layoutDefault;
 
188
    DomLayoutFunction* m_layoutFunction;
 
189
    QString m_pixmapFunction;
 
190
    DomCustomWidgets* m_customWidgets;
 
191
    DomTabStops* m_tabStops;
 
192
    DomImages* m_images;
 
193
    DomIncludes* m_includes;
 
194
    DomResources* m_resources;
 
195
    DomConnections* m_connections;
 
196
 
 
197
    DomUI(const DomUI &other);
 
198
    void operator = (const DomUI&other);
 
199
};
 
200
 
 
201
class QT_UI4_EXPORT DomIncludes {
 
202
public:
 
203
    DomIncludes();
 
204
    ~DomIncludes();
 
205
 
 
206
    void read(const QDomElement &node);
 
207
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
208
    inline QString text() const { return m_text; }
 
209
    inline void setText(const QString &s) { m_text = s; }
 
210
 
 
211
    // attribute accessors
 
212
    // child element accessors
 
213
    inline QList<DomInclude*> elementInclude() { return m_include; }
 
214
    void setElementInclude(const QList<DomInclude*>& a);
 
215
 
 
216
private:
 
217
    QString m_text;
 
218
    void clear(bool clear_all = true);
 
219
 
 
220
    // attribute data
 
221
    // child element data
 
222
    QList<DomInclude*> m_include;
 
223
 
 
224
    DomIncludes(const DomIncludes &other);
 
225
    void operator = (const DomIncludes&other);
 
226
};
 
227
 
 
228
class QT_UI4_EXPORT DomInclude {
 
229
public:
 
230
    DomInclude();
 
231
    ~DomInclude();
 
232
 
 
233
    void read(const QDomElement &node);
 
234
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
235
    inline QString text() const { return m_text; }
 
236
    inline void setText(const QString &s) { m_text = s; }
 
237
 
 
238
    // attribute accessors
 
239
    inline bool hasAttributeLocation() { return m_has_attr_location; }
 
240
    inline QString attributeLocation() { return m_attr_location; }
 
241
    inline void setAttributeLocation(const QString& a) { m_attr_location = a; m_has_attr_location = true; }
 
242
    inline void clearAttributeLocation() { m_has_attr_location = false; }
 
243
 
 
244
    inline bool hasAttributeImpldecl() { return m_has_attr_impldecl; }
 
245
    inline QString attributeImpldecl() { return m_attr_impldecl; }
 
246
    inline void setAttributeImpldecl(const QString& a) { m_attr_impldecl = a; m_has_attr_impldecl = true; }
 
247
    inline void clearAttributeImpldecl() { m_has_attr_impldecl = false; }
 
248
 
 
249
    // child element accessors
 
250
private:
 
251
    QString m_text;
 
252
    void clear(bool clear_all = true);
 
253
 
 
254
    // attribute data
 
255
    QString m_attr_location;
 
256
    bool m_has_attr_location;
 
257
 
 
258
    QString m_attr_impldecl;
 
259
    bool m_has_attr_impldecl;
 
260
 
 
261
    // child element data
 
262
 
 
263
    DomInclude(const DomInclude &other);
 
264
    void operator = (const DomInclude&other);
 
265
};
 
266
 
 
267
class QT_UI4_EXPORT DomResources {
 
268
public:
 
269
    DomResources();
 
270
    ~DomResources();
 
271
 
 
272
    void read(const QDomElement &node);
 
273
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
274
    inline QString text() const { return m_text; }
 
275
    inline void setText(const QString &s) { m_text = s; }
 
276
 
 
277
    // attribute accessors
 
278
    inline bool hasAttributeName() { return m_has_attr_name; }
 
279
    inline QString attributeName() { return m_attr_name; }
 
280
    inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; }
 
281
    inline void clearAttributeName() { m_has_attr_name = false; }
 
282
 
 
283
    // child element accessors
 
284
    inline QList<DomResource*> elementInclude() { return m_include; }
 
285
    void setElementInclude(const QList<DomResource*>& a);
 
286
 
 
287
private:
 
288
    QString m_text;
 
289
    void clear(bool clear_all = true);
 
290
 
 
291
    // attribute data
 
292
    QString m_attr_name;
 
293
    bool m_has_attr_name;
 
294
 
 
295
    // child element data
 
296
    QList<DomResource*> m_include;
 
297
 
 
298
    DomResources(const DomResources &other);
 
299
    void operator = (const DomResources&other);
 
300
};
 
301
 
 
302
class QT_UI4_EXPORT DomResource {
 
303
public:
 
304
    DomResource();
 
305
    ~DomResource();
 
306
 
 
307
    void read(const QDomElement &node);
 
308
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
309
    inline QString text() const { return m_text; }
 
310
    inline void setText(const QString &s) { m_text = s; }
 
311
 
 
312
    // attribute accessors
 
313
    inline bool hasAttributeLocation() { return m_has_attr_location; }
 
314
    inline QString attributeLocation() { return m_attr_location; }
 
315
    inline void setAttributeLocation(const QString& a) { m_attr_location = a; m_has_attr_location = true; }
 
316
    inline void clearAttributeLocation() { m_has_attr_location = false; }
 
317
 
 
318
    // child element accessors
 
319
private:
 
320
    QString m_text;
 
321
    void clear(bool clear_all = true);
 
322
 
 
323
    // attribute data
 
324
    QString m_attr_location;
 
325
    bool m_has_attr_location;
 
326
 
 
327
    // child element data
 
328
 
 
329
    DomResource(const DomResource &other);
 
330
    void operator = (const DomResource&other);
 
331
};
 
332
 
 
333
class QT_UI4_EXPORT DomActionGroup {
 
334
public:
 
335
    DomActionGroup();
 
336
    ~DomActionGroup();
 
337
 
 
338
    void read(const QDomElement &node);
 
339
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
340
    inline QString text() const { return m_text; }
 
341
    inline void setText(const QString &s) { m_text = s; }
 
342
 
 
343
    // attribute accessors
 
344
    inline bool hasAttributeName() { return m_has_attr_name; }
 
345
    inline QString attributeName() { return m_attr_name; }
 
346
    inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; }
 
347
    inline void clearAttributeName() { m_has_attr_name = false; }
 
348
 
 
349
    // child element accessors
 
350
    inline QList<DomAction*> elementAction() { return m_action; }
 
351
    void setElementAction(const QList<DomAction*>& a);
 
352
 
 
353
    inline QList<DomActionGroup*> elementActionGroup() { return m_actionGroup; }
 
354
    void setElementActionGroup(const QList<DomActionGroup*>& a);
 
355
 
 
356
    inline QList<DomProperty*> elementProperty() { return m_property; }
 
357
    void setElementProperty(const QList<DomProperty*>& a);
 
358
 
 
359
    inline QList<DomProperty*> elementAttribute() { return m_attribute; }
 
360
    void setElementAttribute(const QList<DomProperty*>& a);
 
361
 
 
362
private:
 
363
    QString m_text;
 
364
    void clear(bool clear_all = true);
 
365
 
 
366
    // attribute data
 
367
    QString m_attr_name;
 
368
    bool m_has_attr_name;
 
369
 
 
370
    // child element data
 
371
    QList<DomAction*> m_action;
 
372
    QList<DomActionGroup*> m_actionGroup;
 
373
    QList<DomProperty*> m_property;
 
374
    QList<DomProperty*> m_attribute;
 
375
 
 
376
    DomActionGroup(const DomActionGroup &other);
 
377
    void operator = (const DomActionGroup&other);
 
378
};
 
379
 
 
380
class QT_UI4_EXPORT DomAction {
 
381
public:
 
382
    DomAction();
 
383
    ~DomAction();
 
384
 
 
385
    void read(const QDomElement &node);
 
386
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
387
    inline QString text() const { return m_text; }
 
388
    inline void setText(const QString &s) { m_text = s; }
 
389
 
 
390
    // attribute accessors
 
391
    inline bool hasAttributeName() { return m_has_attr_name; }
 
392
    inline QString attributeName() { return m_attr_name; }
 
393
    inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; }
 
394
    inline void clearAttributeName() { m_has_attr_name = false; }
 
395
 
 
396
    inline bool hasAttributeMenu() { return m_has_attr_menu; }
 
397
    inline QString attributeMenu() { return m_attr_menu; }
 
398
    inline void setAttributeMenu(const QString& a) { m_attr_menu = a; m_has_attr_menu = true; }
 
399
    inline void clearAttributeMenu() { m_has_attr_menu = false; }
 
400
 
 
401
    // child element accessors
 
402
    inline QList<DomProperty*> elementProperty() { return m_property; }
 
403
    void setElementProperty(const QList<DomProperty*>& a);
 
404
 
 
405
    inline QList<DomProperty*> elementAttribute() { return m_attribute; }
 
406
    void setElementAttribute(const QList<DomProperty*>& a);
 
407
 
 
408
private:
 
409
    QString m_text;
 
410
    void clear(bool clear_all = true);
 
411
 
 
412
    // attribute data
 
413
    QString m_attr_name;
 
414
    bool m_has_attr_name;
 
415
 
 
416
    QString m_attr_menu;
 
417
    bool m_has_attr_menu;
 
418
 
 
419
    // child element data
 
420
    QList<DomProperty*> m_property;
 
421
    QList<DomProperty*> m_attribute;
 
422
 
 
423
    DomAction(const DomAction &other);
 
424
    void operator = (const DomAction&other);
 
425
};
 
426
 
 
427
class QT_UI4_EXPORT DomActionRef {
 
428
public:
 
429
    DomActionRef();
 
430
    ~DomActionRef();
 
431
 
 
432
    void read(const QDomElement &node);
 
433
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
434
    inline QString text() const { return m_text; }
 
435
    inline void setText(const QString &s) { m_text = s; }
 
436
 
 
437
    // attribute accessors
 
438
    inline bool hasAttributeName() { return m_has_attr_name; }
 
439
    inline QString attributeName() { return m_attr_name; }
 
440
    inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; }
 
441
    inline void clearAttributeName() { m_has_attr_name = false; }
 
442
 
 
443
    // child element accessors
 
444
private:
 
445
    QString m_text;
 
446
    void clear(bool clear_all = true);
 
447
 
 
448
    // attribute data
 
449
    QString m_attr_name;
 
450
    bool m_has_attr_name;
 
451
 
 
452
    // child element data
 
453
 
 
454
    DomActionRef(const DomActionRef &other);
 
455
    void operator = (const DomActionRef&other);
 
456
};
 
457
 
 
458
class QT_UI4_EXPORT DomImages {
 
459
public:
 
460
    DomImages();
 
461
    ~DomImages();
 
462
 
 
463
    void read(const QDomElement &node);
 
464
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
465
    inline QString text() const { return m_text; }
 
466
    inline void setText(const QString &s) { m_text = s; }
 
467
 
 
468
    // attribute accessors
 
469
    // child element accessors
 
470
    inline QList<DomImage*> elementImage() { return m_image; }
 
471
    void setElementImage(const QList<DomImage*>& a);
 
472
 
 
473
private:
 
474
    QString m_text;
 
475
    void clear(bool clear_all = true);
 
476
 
 
477
    // attribute data
 
478
    // child element data
 
479
    QList<DomImage*> m_image;
 
480
 
 
481
    DomImages(const DomImages &other);
 
482
    void operator = (const DomImages&other);
 
483
};
 
484
 
 
485
class QT_UI4_EXPORT DomImage {
 
486
public:
 
487
    DomImage();
 
488
    ~DomImage();
 
489
 
 
490
    void read(const QDomElement &node);
 
491
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
492
    inline QString text() const { return m_text; }
 
493
    inline void setText(const QString &s) { m_text = s; }
 
494
 
 
495
    // attribute accessors
 
496
    inline bool hasAttributeName() { return m_has_attr_name; }
 
497
    inline QString attributeName() { return m_attr_name; }
 
498
    inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; }
 
499
    inline void clearAttributeName() { m_has_attr_name = false; }
 
500
 
 
501
    // child element accessors
 
502
    inline DomImageData* elementData() { return m_data; }
 
503
    void setElementData(DomImageData* a);
 
504
 
 
505
private:
 
506
    QString m_text;
 
507
    void clear(bool clear_all = true);
 
508
 
 
509
    // attribute data
 
510
    QString m_attr_name;
 
511
    bool m_has_attr_name;
 
512
 
 
513
    // child element data
 
514
    DomImageData* m_data;
 
515
 
 
516
    DomImage(const DomImage &other);
 
517
    void operator = (const DomImage&other);
 
518
};
 
519
 
 
520
class QT_UI4_EXPORT DomImageData {
 
521
public:
 
522
    DomImageData();
 
523
    ~DomImageData();
 
524
 
 
525
    void read(const QDomElement &node);
 
526
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
527
    inline QString text() const { return m_text; }
 
528
    inline void setText(const QString &s) { m_text = s; }
 
529
 
 
530
    // attribute accessors
 
531
    inline bool hasAttributeFormat() { return m_has_attr_format; }
 
532
    inline QString attributeFormat() { return m_attr_format; }
 
533
    inline void setAttributeFormat(const QString& a) { m_attr_format = a; m_has_attr_format = true; }
 
534
    inline void clearAttributeFormat() { m_has_attr_format = false; }
 
535
 
 
536
    inline bool hasAttributeLength() { return m_has_attr_length; }
 
537
    inline int attributeLength() { return m_attr_length; }
 
538
    inline void setAttributeLength(int a) { m_attr_length = a; m_has_attr_length = true; }
 
539
    inline void clearAttributeLength() { m_has_attr_length = false; }
 
540
 
 
541
    // child element accessors
 
542
private:
 
543
    QString m_text;
 
544
    void clear(bool clear_all = true);
 
545
 
 
546
    // attribute data
 
547
    QString m_attr_format;
 
548
    bool m_has_attr_format;
 
549
 
 
550
    int m_attr_length;
 
551
    bool m_has_attr_length;
 
552
 
 
553
    // child element data
 
554
 
 
555
    DomImageData(const DomImageData &other);
 
556
    void operator = (const DomImageData&other);
 
557
};
 
558
 
 
559
class QT_UI4_EXPORT DomCustomWidgets {
 
560
public:
 
561
    DomCustomWidgets();
 
562
    ~DomCustomWidgets();
 
563
 
 
564
    void read(const QDomElement &node);
 
565
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
566
    inline QString text() const { return m_text; }
 
567
    inline void setText(const QString &s) { m_text = s; }
 
568
 
 
569
    // attribute accessors
 
570
    // child element accessors
 
571
    inline QList<DomCustomWidget*> elementCustomWidget() { return m_customWidget; }
 
572
    void setElementCustomWidget(const QList<DomCustomWidget*>& a);
 
573
 
 
574
private:
 
575
    QString m_text;
 
576
    void clear(bool clear_all = true);
 
577
 
 
578
    // attribute data
 
579
    // child element data
 
580
    QList<DomCustomWidget*> m_customWidget;
 
581
 
 
582
    DomCustomWidgets(const DomCustomWidgets &other);
 
583
    void operator = (const DomCustomWidgets&other);
 
584
};
 
585
 
 
586
class QT_UI4_EXPORT DomHeader {
 
587
public:
 
588
    DomHeader();
 
589
    ~DomHeader();
 
590
 
 
591
    void read(const QDomElement &node);
 
592
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
593
    inline QString text() const { return m_text; }
 
594
    inline void setText(const QString &s) { m_text = s; }
 
595
 
 
596
    // attribute accessors
 
597
    inline bool hasAttributeLocation() { return m_has_attr_location; }
 
598
    inline QString attributeLocation() { return m_attr_location; }
 
599
    inline void setAttributeLocation(const QString& a) { m_attr_location = a; m_has_attr_location = true; }
 
600
    inline void clearAttributeLocation() { m_has_attr_location = false; }
 
601
 
 
602
    // child element accessors
 
603
private:
 
604
    QString m_text;
 
605
    void clear(bool clear_all = true);
 
606
 
 
607
    // attribute data
 
608
    QString m_attr_location;
 
609
    bool m_has_attr_location;
 
610
 
 
611
    // child element data
 
612
 
 
613
    DomHeader(const DomHeader &other);
 
614
    void operator = (const DomHeader&other);
 
615
};
 
616
 
 
617
class QT_UI4_EXPORT DomCustomWidget {
 
618
public:
 
619
    DomCustomWidget();
 
620
    ~DomCustomWidget();
 
621
 
 
622
    void read(const QDomElement &node);
 
623
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
624
    inline QString text() const { return m_text; }
 
625
    inline void setText(const QString &s) { m_text = s; }
 
626
 
 
627
    // attribute accessors
 
628
    // child element accessors
 
629
    inline QString elementClass() { return m_class; }
 
630
    void setElementClass(const QString& a);
 
631
 
 
632
    inline QString elementExtends() { return m_extends; }
 
633
    void setElementExtends(const QString& a);
 
634
 
 
635
    inline DomHeader* elementHeader() { return m_header; }
 
636
    void setElementHeader(DomHeader* a);
 
637
 
 
638
    inline DomSize* elementSizeHint() { return m_sizeHint; }
 
639
    void setElementSizeHint(DomSize* a);
 
640
 
 
641
    inline int elementContainer() { return m_container; }
 
642
    void setElementContainer(int a);
 
643
 
 
644
    inline DomSizePolicyData* elementSizePolicy() { return m_sizePolicy; }
 
645
    void setElementSizePolicy(DomSizePolicyData* a);
 
646
 
 
647
    inline QString elementPixmap() { return m_pixmap; }
 
648
    void setElementPixmap(const QString& a);
 
649
 
 
650
    inline DomProperties* elementProperties() { return m_properties; }
 
651
    void setElementProperties(DomProperties* a);
 
652
 
 
653
private:
 
654
    QString m_text;
 
655
    void clear(bool clear_all = true);
 
656
 
 
657
    // attribute data
 
658
    // child element data
 
659
    QString m_class;
 
660
    QString m_extends;
 
661
    DomHeader* m_header;
 
662
    DomSize* m_sizeHint;
 
663
    int m_container;
 
664
    DomSizePolicyData* m_sizePolicy;
 
665
    QString m_pixmap;
 
666
    DomProperties* m_properties;
 
667
 
 
668
    DomCustomWidget(const DomCustomWidget &other);
 
669
    void operator = (const DomCustomWidget&other);
 
670
};
 
671
 
 
672
class QT_UI4_EXPORT DomProperties {
 
673
public:
 
674
    DomProperties();
 
675
    ~DomProperties();
 
676
 
 
677
    void read(const QDomElement &node);
 
678
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
679
    inline QString text() const { return m_text; }
 
680
    inline void setText(const QString &s) { m_text = s; }
 
681
 
 
682
    // attribute accessors
 
683
    // child element accessors
 
684
    inline QList<DomPropertyData*> elementProperty() { return m_property; }
 
685
    void setElementProperty(const QList<DomPropertyData*>& a);
 
686
 
 
687
private:
 
688
    QString m_text;
 
689
    void clear(bool clear_all = true);
 
690
 
 
691
    // attribute data
 
692
    // child element data
 
693
    QList<DomPropertyData*> m_property;
 
694
 
 
695
    DomProperties(const DomProperties &other);
 
696
    void operator = (const DomProperties&other);
 
697
};
 
698
 
 
699
class QT_UI4_EXPORT DomPropertyData {
 
700
public:
 
701
    DomPropertyData();
 
702
    ~DomPropertyData();
 
703
 
 
704
    void read(const QDomElement &node);
 
705
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
706
    inline QString text() const { return m_text; }
 
707
    inline void setText(const QString &s) { m_text = s; }
 
708
 
 
709
    // attribute accessors
 
710
    inline bool hasAttributeType() { return m_has_attr_type; }
 
711
    inline QString attributeType() { return m_attr_type; }
 
712
    inline void setAttributeType(const QString& a) { m_attr_type = a; m_has_attr_type = true; }
 
713
    inline void clearAttributeType() { m_has_attr_type = false; }
 
714
 
 
715
    // child element accessors
 
716
private:
 
717
    QString m_text;
 
718
    void clear(bool clear_all = true);
 
719
 
 
720
    // attribute data
 
721
    QString m_attr_type;
 
722
    bool m_has_attr_type;
 
723
 
 
724
    // child element data
 
725
 
 
726
    DomPropertyData(const DomPropertyData &other);
 
727
    void operator = (const DomPropertyData&other);
 
728
};
 
729
 
 
730
class QT_UI4_EXPORT DomSizePolicyData {
 
731
public:
 
732
    DomSizePolicyData();
 
733
    ~DomSizePolicyData();
 
734
 
 
735
    void read(const QDomElement &node);
 
736
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
737
    inline QString text() const { return m_text; }
 
738
    inline void setText(const QString &s) { m_text = s; }
 
739
 
 
740
    // attribute accessors
 
741
    // child element accessors
 
742
    inline int elementHorData() { return m_horData; }
 
743
    void setElementHorData(int a);
 
744
 
 
745
    inline int elementVerData() { return m_verData; }
 
746
    void setElementVerData(int a);
 
747
 
 
748
private:
 
749
    QString m_text;
 
750
    void clear(bool clear_all = true);
 
751
 
 
752
    // attribute data
 
753
    // child element data
 
754
    int m_horData;
 
755
    int m_verData;
 
756
 
 
757
    DomSizePolicyData(const DomSizePolicyData &other);
 
758
    void operator = (const DomSizePolicyData&other);
 
759
};
 
760
 
 
761
class QT_UI4_EXPORT DomLayoutDefault {
 
762
public:
 
763
    DomLayoutDefault();
 
764
    ~DomLayoutDefault();
 
765
 
 
766
    void read(const QDomElement &node);
 
767
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
768
    inline QString text() const { return m_text; }
 
769
    inline void setText(const QString &s) { m_text = s; }
 
770
 
 
771
    // attribute accessors
 
772
    inline bool hasAttributeSpacing() { return m_has_attr_spacing; }
 
773
    inline int attributeSpacing() { return m_attr_spacing; }
 
774
    inline void setAttributeSpacing(int a) { m_attr_spacing = a; m_has_attr_spacing = true; }
 
775
    inline void clearAttributeSpacing() { m_has_attr_spacing = false; }
 
776
 
 
777
    inline bool hasAttributeMargin() { return m_has_attr_margin; }
 
778
    inline int attributeMargin() { return m_attr_margin; }
 
779
    inline void setAttributeMargin(int a) { m_attr_margin = a; m_has_attr_margin = true; }
 
780
    inline void clearAttributeMargin() { m_has_attr_margin = false; }
 
781
 
 
782
    // child element accessors
 
783
private:
 
784
    QString m_text;
 
785
    void clear(bool clear_all = true);
 
786
 
 
787
    // attribute data
 
788
    int m_attr_spacing;
 
789
    bool m_has_attr_spacing;
 
790
 
 
791
    int m_attr_margin;
 
792
    bool m_has_attr_margin;
 
793
 
 
794
    // child element data
 
795
 
 
796
    DomLayoutDefault(const DomLayoutDefault &other);
 
797
    void operator = (const DomLayoutDefault&other);
 
798
};
 
799
 
 
800
class QT_UI4_EXPORT DomLayoutFunction {
 
801
public:
 
802
    DomLayoutFunction();
 
803
    ~DomLayoutFunction();
 
804
 
 
805
    void read(const QDomElement &node);
 
806
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
807
    inline QString text() const { return m_text; }
 
808
    inline void setText(const QString &s) { m_text = s; }
 
809
 
 
810
    // attribute accessors
 
811
    inline bool hasAttributeSpacing() { return m_has_attr_spacing; }
 
812
    inline QString attributeSpacing() { return m_attr_spacing; }
 
813
    inline void setAttributeSpacing(const QString& a) { m_attr_spacing = a; m_has_attr_spacing = true; }
 
814
    inline void clearAttributeSpacing() { m_has_attr_spacing = false; }
 
815
 
 
816
    inline bool hasAttributeMargin() { return m_has_attr_margin; }
 
817
    inline QString attributeMargin() { return m_attr_margin; }
 
818
    inline void setAttributeMargin(const QString& a) { m_attr_margin = a; m_has_attr_margin = true; }
 
819
    inline void clearAttributeMargin() { m_has_attr_margin = false; }
 
820
 
 
821
    // child element accessors
 
822
private:
 
823
    QString m_text;
 
824
    void clear(bool clear_all = true);
 
825
 
 
826
    // attribute data
 
827
    QString m_attr_spacing;
 
828
    bool m_has_attr_spacing;
 
829
 
 
830
    QString m_attr_margin;
 
831
    bool m_has_attr_margin;
 
832
 
 
833
    // child element data
 
834
 
 
835
    DomLayoutFunction(const DomLayoutFunction &other);
 
836
    void operator = (const DomLayoutFunction&other);
 
837
};
 
838
 
 
839
class QT_UI4_EXPORT DomTabStops {
 
840
public:
 
841
    DomTabStops();
 
842
    ~DomTabStops();
 
843
 
 
844
    void read(const QDomElement &node);
 
845
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
846
    inline QString text() const { return m_text; }
 
847
    inline void setText(const QString &s) { m_text = s; }
 
848
 
 
849
    // attribute accessors
 
850
    // child element accessors
 
851
    inline QStringList elementTabStop() { return m_tabStop; }
 
852
    void setElementTabStop(const QStringList& a);
 
853
 
 
854
private:
 
855
    QString m_text;
 
856
    void clear(bool clear_all = true);
 
857
 
 
858
    // attribute data
 
859
    // child element data
 
860
    QStringList m_tabStop;
 
861
 
 
862
    DomTabStops(const DomTabStops &other);
 
863
    void operator = (const DomTabStops&other);
 
864
};
 
865
 
 
866
class QT_UI4_EXPORT DomLayout {
 
867
public:
 
868
    DomLayout();
 
869
    ~DomLayout();
 
870
 
 
871
    void read(const QDomElement &node);
 
872
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
873
    inline QString text() const { return m_text; }
 
874
    inline void setText(const QString &s) { m_text = s; }
 
875
 
 
876
    // attribute accessors
 
877
    inline bool hasAttributeClass() { return m_has_attr_class; }
 
878
    inline QString attributeClass() { return m_attr_class; }
 
879
    inline void setAttributeClass(const QString& a) { m_attr_class = a; m_has_attr_class = true; }
 
880
    inline void clearAttributeClass() { m_has_attr_class = false; }
 
881
 
 
882
    // child element accessors
 
883
    inline QList<DomProperty*> elementProperty() { return m_property; }
 
884
    void setElementProperty(const QList<DomProperty*>& a);
 
885
 
 
886
    inline QList<DomProperty*> elementAttribute() { return m_attribute; }
 
887
    void setElementAttribute(const QList<DomProperty*>& a);
 
888
 
 
889
    inline QList<DomLayoutItem*> elementItem() { return m_item; }
 
890
    void setElementItem(const QList<DomLayoutItem*>& a);
 
891
 
 
892
private:
 
893
    QString m_text;
 
894
    void clear(bool clear_all = true);
 
895
 
 
896
    // attribute data
 
897
    QString m_attr_class;
 
898
    bool m_has_attr_class;
 
899
 
 
900
    // child element data
 
901
    QList<DomProperty*> m_property;
 
902
    QList<DomProperty*> m_attribute;
 
903
    QList<DomLayoutItem*> m_item;
 
904
 
 
905
    DomLayout(const DomLayout &other);
 
906
    void operator = (const DomLayout&other);
 
907
};
 
908
 
 
909
class QT_UI4_EXPORT DomLayoutItem {
 
910
public:
 
911
    DomLayoutItem();
 
912
    ~DomLayoutItem();
 
913
 
 
914
    void read(const QDomElement &node);
 
915
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
916
    inline QString text() const { return m_text; }
 
917
    inline void setText(const QString &s) { m_text = s; }
 
918
 
 
919
    // attribute accessors
 
920
    inline bool hasAttributeRow() { return m_has_attr_row; }
 
921
    inline int attributeRow() { return m_attr_row; }
 
922
    inline void setAttributeRow(int a) { m_attr_row = a; m_has_attr_row = true; }
 
923
    inline void clearAttributeRow() { m_has_attr_row = false; }
 
924
 
 
925
    inline bool hasAttributeColumn() { return m_has_attr_column; }
 
926
    inline int attributeColumn() { return m_attr_column; }
 
927
    inline void setAttributeColumn(int a) { m_attr_column = a; m_has_attr_column = true; }
 
928
    inline void clearAttributeColumn() { m_has_attr_column = false; }
 
929
 
 
930
    inline bool hasAttributeRowSpan() { return m_has_attr_rowSpan; }
 
931
    inline int attributeRowSpan() { return m_attr_rowSpan; }
 
932
    inline void setAttributeRowSpan(int a) { m_attr_rowSpan = a; m_has_attr_rowSpan = true; }
 
933
    inline void clearAttributeRowSpan() { m_has_attr_rowSpan = false; }
 
934
 
 
935
    inline bool hasAttributeColSpan() { return m_has_attr_colSpan; }
 
936
    inline int attributeColSpan() { return m_attr_colSpan; }
 
937
    inline void setAttributeColSpan(int a) { m_attr_colSpan = a; m_has_attr_colSpan = true; }
 
938
    inline void clearAttributeColSpan() { m_has_attr_colSpan = false; }
 
939
 
 
940
    // child element accessors
 
941
    enum Kind { Unknown = 0, Widget, Layout, Spacer };
 
942
    inline Kind kind() { return m_kind; }
 
943
 
 
944
    inline DomWidget* elementWidget() { return m_widget; }
 
945
    void setElementWidget(DomWidget* a);
 
946
 
 
947
    inline DomLayout* elementLayout() { return m_layout; }
 
948
    void setElementLayout(DomLayout* a);
 
949
 
 
950
    inline DomSpacer* elementSpacer() { return m_spacer; }
 
951
    void setElementSpacer(DomSpacer* a);
 
952
 
 
953
private:
 
954
    QString m_text;
 
955
    void clear(bool clear_all = true);
 
956
 
 
957
    // attribute data
 
958
    int m_attr_row;
 
959
    bool m_has_attr_row;
 
960
 
 
961
    int m_attr_column;
 
962
    bool m_has_attr_column;
 
963
 
 
964
    int m_attr_rowSpan;
 
965
    bool m_has_attr_rowSpan;
 
966
 
 
967
    int m_attr_colSpan;
 
968
    bool m_has_attr_colSpan;
 
969
 
 
970
    // child element data
 
971
    Kind m_kind;
 
972
    DomWidget* m_widget;
 
973
    DomLayout* m_layout;
 
974
    DomSpacer* m_spacer;
 
975
 
 
976
    DomLayoutItem(const DomLayoutItem &other);
 
977
    void operator = (const DomLayoutItem&other);
 
978
};
 
979
 
 
980
class QT_UI4_EXPORT DomRow {
 
981
public:
 
982
    DomRow();
 
983
    ~DomRow();
 
984
 
 
985
    void read(const QDomElement &node);
 
986
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
987
    inline QString text() const { return m_text; }
 
988
    inline void setText(const QString &s) { m_text = s; }
 
989
 
 
990
    // attribute accessors
 
991
    // child element accessors
 
992
    inline QList<DomProperty*> elementProperty() { return m_property; }
 
993
    void setElementProperty(const QList<DomProperty*>& a);
 
994
 
 
995
private:
 
996
    QString m_text;
 
997
    void clear(bool clear_all = true);
 
998
 
 
999
    // attribute data
 
1000
    // child element data
 
1001
    QList<DomProperty*> m_property;
 
1002
 
 
1003
    DomRow(const DomRow &other);
 
1004
    void operator = (const DomRow&other);
 
1005
};
 
1006
 
 
1007
class QT_UI4_EXPORT DomColumn {
 
1008
public:
 
1009
    DomColumn();
 
1010
    ~DomColumn();
 
1011
 
 
1012
    void read(const QDomElement &node);
 
1013
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1014
    inline QString text() const { return m_text; }
 
1015
    inline void setText(const QString &s) { m_text = s; }
 
1016
 
 
1017
    // attribute accessors
 
1018
    // child element accessors
 
1019
    inline QList<DomProperty*> elementProperty() { return m_property; }
 
1020
    void setElementProperty(const QList<DomProperty*>& a);
 
1021
 
 
1022
private:
 
1023
    QString m_text;
 
1024
    void clear(bool clear_all = true);
 
1025
 
 
1026
    // attribute data
 
1027
    // child element data
 
1028
    QList<DomProperty*> m_property;
 
1029
 
 
1030
    DomColumn(const DomColumn &other);
 
1031
    void operator = (const DomColumn&other);
 
1032
};
 
1033
 
 
1034
class QT_UI4_EXPORT DomItem {
 
1035
public:
 
1036
    DomItem();
 
1037
    ~DomItem();
 
1038
 
 
1039
    void read(const QDomElement &node);
 
1040
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1041
    inline QString text() const { return m_text; }
 
1042
    inline void setText(const QString &s) { m_text = s; }
 
1043
 
 
1044
    // attribute accessors
 
1045
    // child element accessors
 
1046
    inline QList<DomProperty*> elementProperty() { return m_property; }
 
1047
    void setElementProperty(const QList<DomProperty*>& a);
 
1048
 
 
1049
    inline QList<DomItem*> elementItem() { return m_item; }
 
1050
    void setElementItem(const QList<DomItem*>& a);
 
1051
 
 
1052
private:
 
1053
    QString m_text;
 
1054
    void clear(bool clear_all = true);
 
1055
 
 
1056
    // attribute data
 
1057
    // child element data
 
1058
    QList<DomProperty*> m_property;
 
1059
    QList<DomItem*> m_item;
 
1060
 
 
1061
    DomItem(const DomItem &other);
 
1062
    void operator = (const DomItem&other);
 
1063
};
 
1064
 
 
1065
class QT_UI4_EXPORT DomWidget {
 
1066
public:
 
1067
    DomWidget();
 
1068
    ~DomWidget();
 
1069
 
 
1070
    void read(const QDomElement &node);
 
1071
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1072
    inline QString text() const { return m_text; }
 
1073
    inline void setText(const QString &s) { m_text = s; }
 
1074
 
 
1075
    // attribute accessors
 
1076
    inline bool hasAttributeClass() { return m_has_attr_class; }
 
1077
    inline QString attributeClass() { return m_attr_class; }
 
1078
    inline void setAttributeClass(const QString& a) { m_attr_class = a; m_has_attr_class = true; }
 
1079
    inline void clearAttributeClass() { m_has_attr_class = false; }
 
1080
 
 
1081
    inline bool hasAttributeName() { return m_has_attr_name; }
 
1082
    inline QString attributeName() { return m_attr_name; }
 
1083
    inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; }
 
1084
    inline void clearAttributeName() { m_has_attr_name = false; }
 
1085
 
 
1086
    // child element accessors
 
1087
    inline QStringList elementClass() { return m_class; }
 
1088
    void setElementClass(const QStringList& a);
 
1089
 
 
1090
    inline QList<DomProperty*> elementProperty() { return m_property; }
 
1091
    void setElementProperty(const QList<DomProperty*>& a);
 
1092
 
 
1093
    inline QList<DomProperty*> elementAttribute() { return m_attribute; }
 
1094
    void setElementAttribute(const QList<DomProperty*>& a);
 
1095
 
 
1096
    inline QList<DomRow*> elementRow() { return m_row; }
 
1097
    void setElementRow(const QList<DomRow*>& a);
 
1098
 
 
1099
    inline QList<DomColumn*> elementColumn() { return m_column; }
 
1100
    void setElementColumn(const QList<DomColumn*>& a);
 
1101
 
 
1102
    inline QList<DomItem*> elementItem() { return m_item; }
 
1103
    void setElementItem(const QList<DomItem*>& a);
 
1104
 
 
1105
    inline QList<DomLayout*> elementLayout() { return m_layout; }
 
1106
    void setElementLayout(const QList<DomLayout*>& a);
 
1107
 
 
1108
    inline QList<DomWidget*> elementWidget() { return m_widget; }
 
1109
    void setElementWidget(const QList<DomWidget*>& a);
 
1110
 
 
1111
    inline QList<DomAction*> elementAction() { return m_action; }
 
1112
    void setElementAction(const QList<DomAction*>& a);
 
1113
 
 
1114
    inline QList<DomActionGroup*> elementActionGroup() { return m_actionGroup; }
 
1115
    void setElementActionGroup(const QList<DomActionGroup*>& a);
 
1116
 
 
1117
    inline QList<DomActionRef*> elementAddAction() { return m_addAction; }
 
1118
    void setElementAddAction(const QList<DomActionRef*>& a);
 
1119
 
 
1120
private:
 
1121
    QString m_text;
 
1122
    void clear(bool clear_all = true);
 
1123
 
 
1124
    // attribute data
 
1125
    QString m_attr_class;
 
1126
    bool m_has_attr_class;
 
1127
 
 
1128
    QString m_attr_name;
 
1129
    bool m_has_attr_name;
 
1130
 
 
1131
    // child element data
 
1132
    QStringList m_class;
 
1133
    QList<DomProperty*> m_property;
 
1134
    QList<DomProperty*> m_attribute;
 
1135
    QList<DomRow*> m_row;
 
1136
    QList<DomColumn*> m_column;
 
1137
    QList<DomItem*> m_item;
 
1138
    QList<DomLayout*> m_layout;
 
1139
    QList<DomWidget*> m_widget;
 
1140
    QList<DomAction*> m_action;
 
1141
    QList<DomActionGroup*> m_actionGroup;
 
1142
    QList<DomActionRef*> m_addAction;
 
1143
 
 
1144
    DomWidget(const DomWidget &other);
 
1145
    void operator = (const DomWidget&other);
 
1146
};
 
1147
 
 
1148
class QT_UI4_EXPORT DomSpacer {
 
1149
public:
 
1150
    DomSpacer();
 
1151
    ~DomSpacer();
 
1152
 
 
1153
    void read(const QDomElement &node);
 
1154
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1155
    inline QString text() const { return m_text; }
 
1156
    inline void setText(const QString &s) { m_text = s; }
 
1157
 
 
1158
    // attribute accessors
 
1159
    inline bool hasAttributeName() { return m_has_attr_name; }
 
1160
    inline QString attributeName() { return m_attr_name; }
 
1161
    inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; }
 
1162
    inline void clearAttributeName() { m_has_attr_name = false; }
 
1163
 
 
1164
    // child element accessors
 
1165
    inline QList<DomProperty*> elementProperty() { return m_property; }
 
1166
    void setElementProperty(const QList<DomProperty*>& a);
 
1167
 
 
1168
private:
 
1169
    QString m_text;
 
1170
    void clear(bool clear_all = true);
 
1171
 
 
1172
    // attribute data
 
1173
    QString m_attr_name;
 
1174
    bool m_has_attr_name;
 
1175
 
 
1176
    // child element data
 
1177
    QList<DomProperty*> m_property;
 
1178
 
 
1179
    DomSpacer(const DomSpacer &other);
 
1180
    void operator = (const DomSpacer&other);
 
1181
};
 
1182
 
 
1183
class QT_UI4_EXPORT DomColor {
 
1184
public:
 
1185
    DomColor();
 
1186
    ~DomColor();
 
1187
 
 
1188
    void read(const QDomElement &node);
 
1189
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1190
    inline QString text() const { return m_text; }
 
1191
    inline void setText(const QString &s) { m_text = s; }
 
1192
 
 
1193
    // attribute accessors
 
1194
    // child element accessors
 
1195
    inline int elementRed() { return m_red; }
 
1196
    void setElementRed(int a);
 
1197
 
 
1198
    inline int elementGreen() { return m_green; }
 
1199
    void setElementGreen(int a);
 
1200
 
 
1201
    inline int elementBlue() { return m_blue; }
 
1202
    void setElementBlue(int a);
 
1203
 
 
1204
private:
 
1205
    QString m_text;
 
1206
    void clear(bool clear_all = true);
 
1207
 
 
1208
    // attribute data
 
1209
    // child element data
 
1210
    int m_red;
 
1211
    int m_green;
 
1212
    int m_blue;
 
1213
 
 
1214
    DomColor(const DomColor &other);
 
1215
    void operator = (const DomColor&other);
 
1216
};
 
1217
 
 
1218
class QT_UI4_EXPORT DomColorGroup {
 
1219
public:
 
1220
    DomColorGroup();
 
1221
    ~DomColorGroup();
 
1222
 
 
1223
    void read(const QDomElement &node);
 
1224
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1225
    inline QString text() const { return m_text; }
 
1226
    inline void setText(const QString &s) { m_text = s; }
 
1227
 
 
1228
    // attribute accessors
 
1229
    // child element accessors
 
1230
    inline QList<DomColor*> elementColor() { return m_color; }
 
1231
    void setElementColor(const QList<DomColor*>& a);
 
1232
 
 
1233
private:
 
1234
    QString m_text;
 
1235
    void clear(bool clear_all = true);
 
1236
 
 
1237
    // attribute data
 
1238
    // child element data
 
1239
    QList<DomColor*> m_color;
 
1240
 
 
1241
    DomColorGroup(const DomColorGroup &other);
 
1242
    void operator = (const DomColorGroup&other);
 
1243
};
 
1244
 
 
1245
class QT_UI4_EXPORT DomPalette {
 
1246
public:
 
1247
    DomPalette();
 
1248
    ~DomPalette();
 
1249
 
 
1250
    void read(const QDomElement &node);
 
1251
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1252
    inline QString text() const { return m_text; }
 
1253
    inline void setText(const QString &s) { m_text = s; }
 
1254
 
 
1255
    // attribute accessors
 
1256
    // child element accessors
 
1257
    inline DomColorGroup* elementActive() { return m_active; }
 
1258
    void setElementActive(DomColorGroup* a);
 
1259
 
 
1260
    inline DomColorGroup* elementInactive() { return m_inactive; }
 
1261
    void setElementInactive(DomColorGroup* a);
 
1262
 
 
1263
    inline DomColorGroup* elementDisabled() { return m_disabled; }
 
1264
    void setElementDisabled(DomColorGroup* a);
 
1265
 
 
1266
private:
 
1267
    QString m_text;
 
1268
    void clear(bool clear_all = true);
 
1269
 
 
1270
    // attribute data
 
1271
    // child element data
 
1272
    DomColorGroup* m_active;
 
1273
    DomColorGroup* m_inactive;
 
1274
    DomColorGroup* m_disabled;
 
1275
 
 
1276
    DomPalette(const DomPalette &other);
 
1277
    void operator = (const DomPalette&other);
 
1278
};
 
1279
 
 
1280
class QT_UI4_EXPORT DomFont {
 
1281
public:
 
1282
    DomFont();
 
1283
    ~DomFont();
 
1284
 
 
1285
    void read(const QDomElement &node);
 
1286
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1287
    inline QString text() const { return m_text; }
 
1288
    inline void setText(const QString &s) { m_text = s; }
 
1289
 
 
1290
    // attribute accessors
 
1291
    // child element accessors
 
1292
    inline QString elementFamily() { return m_family; }
 
1293
    void setElementFamily(const QString& a);
 
1294
 
 
1295
    inline int elementPointSize() { return m_pointSize; }
 
1296
    void setElementPointSize(int a);
 
1297
 
 
1298
    inline int elementWeight() { return m_weight; }
 
1299
    void setElementWeight(int a);
 
1300
 
 
1301
    inline bool elementItalic() { return m_italic; }
 
1302
    void setElementItalic(bool a);
 
1303
 
 
1304
    inline bool elementBold() { return m_bold; }
 
1305
    void setElementBold(bool a);
 
1306
 
 
1307
    inline bool elementUnderline() { return m_underline; }
 
1308
    void setElementUnderline(bool a);
 
1309
 
 
1310
    inline bool elementStrikeOut() { return m_strikeOut; }
 
1311
    void setElementStrikeOut(bool a);
 
1312
 
 
1313
private:
 
1314
    QString m_text;
 
1315
    void clear(bool clear_all = true);
 
1316
 
 
1317
    // attribute data
 
1318
    // child element data
 
1319
    QString m_family;
 
1320
    int m_pointSize;
 
1321
    int m_weight;
 
1322
    bool m_italic;
 
1323
    bool m_bold;
 
1324
    bool m_underline;
 
1325
    bool m_strikeOut;
 
1326
 
 
1327
    DomFont(const DomFont &other);
 
1328
    void operator = (const DomFont&other);
 
1329
};
 
1330
 
 
1331
class QT_UI4_EXPORT DomPoint {
 
1332
public:
 
1333
    DomPoint();
 
1334
    ~DomPoint();
 
1335
 
 
1336
    void read(const QDomElement &node);
 
1337
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1338
    inline QString text() const { return m_text; }
 
1339
    inline void setText(const QString &s) { m_text = s; }
 
1340
 
 
1341
    // attribute accessors
 
1342
    // child element accessors
 
1343
    inline int elementX() { return m_x; }
 
1344
    void setElementX(int a);
 
1345
 
 
1346
    inline int elementY() { return m_y; }
 
1347
    void setElementY(int a);
 
1348
 
 
1349
private:
 
1350
    QString m_text;
 
1351
    void clear(bool clear_all = true);
 
1352
 
 
1353
    // attribute data
 
1354
    // child element data
 
1355
    int m_x;
 
1356
    int m_y;
 
1357
 
 
1358
    DomPoint(const DomPoint &other);
 
1359
    void operator = (const DomPoint&other);
 
1360
};
 
1361
 
 
1362
class QT_UI4_EXPORT DomRect {
 
1363
public:
 
1364
    DomRect();
 
1365
    ~DomRect();
 
1366
 
 
1367
    void read(const QDomElement &node);
 
1368
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1369
    inline QString text() const { return m_text; }
 
1370
    inline void setText(const QString &s) { m_text = s; }
 
1371
 
 
1372
    // attribute accessors
 
1373
    // child element accessors
 
1374
    inline int elementX() { return m_x; }
 
1375
    void setElementX(int a);
 
1376
 
 
1377
    inline int elementY() { return m_y; }
 
1378
    void setElementY(int a);
 
1379
 
 
1380
    inline int elementWidth() { return m_width; }
 
1381
    void setElementWidth(int a);
 
1382
 
 
1383
    inline int elementHeight() { return m_height; }
 
1384
    void setElementHeight(int a);
 
1385
 
 
1386
private:
 
1387
    QString m_text;
 
1388
    void clear(bool clear_all = true);
 
1389
 
 
1390
    // attribute data
 
1391
    // child element data
 
1392
    int m_x;
 
1393
    int m_y;
 
1394
    int m_width;
 
1395
    int m_height;
 
1396
 
 
1397
    DomRect(const DomRect &other);
 
1398
    void operator = (const DomRect&other);
 
1399
};
 
1400
 
 
1401
class QT_UI4_EXPORT DomSizePolicy {
 
1402
public:
 
1403
    DomSizePolicy();
 
1404
    ~DomSizePolicy();
 
1405
 
 
1406
    void read(const QDomElement &node);
 
1407
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1408
    inline QString text() const { return m_text; }
 
1409
    inline void setText(const QString &s) { m_text = s; }
 
1410
 
 
1411
    // attribute accessors
 
1412
    // child element accessors
 
1413
    inline int elementHSizeType() { return m_hSizeType; }
 
1414
    void setElementHSizeType(int a);
 
1415
 
 
1416
    inline int elementVSizeType() { return m_vSizeType; }
 
1417
    void setElementVSizeType(int a);
 
1418
 
 
1419
    inline int elementHorStretch() { return m_horStretch; }
 
1420
    void setElementHorStretch(int a);
 
1421
 
 
1422
    inline int elementVerStretch() { return m_verStretch; }
 
1423
    void setElementVerStretch(int a);
 
1424
 
 
1425
private:
 
1426
    QString m_text;
 
1427
    void clear(bool clear_all = true);
 
1428
 
 
1429
    // attribute data
 
1430
    // child element data
 
1431
    int m_hSizeType;
 
1432
    int m_vSizeType;
 
1433
    int m_horStretch;
 
1434
    int m_verStretch;
 
1435
 
 
1436
    DomSizePolicy(const DomSizePolicy &other);
 
1437
    void operator = (const DomSizePolicy&other);
 
1438
};
 
1439
 
 
1440
class QT_UI4_EXPORT DomSize {
 
1441
public:
 
1442
    DomSize();
 
1443
    ~DomSize();
 
1444
 
 
1445
    void read(const QDomElement &node);
 
1446
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1447
    inline QString text() const { return m_text; }
 
1448
    inline void setText(const QString &s) { m_text = s; }
 
1449
 
 
1450
    // attribute accessors
 
1451
    // child element accessors
 
1452
    inline int elementWidth() { return m_width; }
 
1453
    void setElementWidth(int a);
 
1454
 
 
1455
    inline int elementHeight() { return m_height; }
 
1456
    void setElementHeight(int a);
 
1457
 
 
1458
private:
 
1459
    QString m_text;
 
1460
    void clear(bool clear_all = true);
 
1461
 
 
1462
    // attribute data
 
1463
    // child element data
 
1464
    int m_width;
 
1465
    int m_height;
 
1466
 
 
1467
    DomSize(const DomSize &other);
 
1468
    void operator = (const DomSize&other);
 
1469
};
 
1470
 
 
1471
class QT_UI4_EXPORT DomDate {
 
1472
public:
 
1473
    DomDate();
 
1474
    ~DomDate();
 
1475
 
 
1476
    void read(const QDomElement &node);
 
1477
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1478
    inline QString text() const { return m_text; }
 
1479
    inline void setText(const QString &s) { m_text = s; }
 
1480
 
 
1481
    // attribute accessors
 
1482
    // child element accessors
 
1483
    inline int elementYear() { return m_year; }
 
1484
    void setElementYear(int a);
 
1485
 
 
1486
    inline int elementMonth() { return m_month; }
 
1487
    void setElementMonth(int a);
 
1488
 
 
1489
    inline int elementDay() { return m_day; }
 
1490
    void setElementDay(int a);
 
1491
 
 
1492
private:
 
1493
    QString m_text;
 
1494
    void clear(bool clear_all = true);
 
1495
 
 
1496
    // attribute data
 
1497
    // child element data
 
1498
    int m_year;
 
1499
    int m_month;
 
1500
    int m_day;
 
1501
 
 
1502
    DomDate(const DomDate &other);
 
1503
    void operator = (const DomDate&other);
 
1504
};
 
1505
 
 
1506
class QT_UI4_EXPORT DomTime {
 
1507
public:
 
1508
    DomTime();
 
1509
    ~DomTime();
 
1510
 
 
1511
    void read(const QDomElement &node);
 
1512
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1513
    inline QString text() const { return m_text; }
 
1514
    inline void setText(const QString &s) { m_text = s; }
 
1515
 
 
1516
    // attribute accessors
 
1517
    // child element accessors
 
1518
    inline int elementHour() { return m_hour; }
 
1519
    void setElementHour(int a);
 
1520
 
 
1521
    inline int elementMinute() { return m_minute; }
 
1522
    void setElementMinute(int a);
 
1523
 
 
1524
    inline int elementSecond() { return m_second; }
 
1525
    void setElementSecond(int a);
 
1526
 
 
1527
private:
 
1528
    QString m_text;
 
1529
    void clear(bool clear_all = true);
 
1530
 
 
1531
    // attribute data
 
1532
    // child element data
 
1533
    int m_hour;
 
1534
    int m_minute;
 
1535
    int m_second;
 
1536
 
 
1537
    DomTime(const DomTime &other);
 
1538
    void operator = (const DomTime&other);
 
1539
};
 
1540
 
 
1541
class QT_UI4_EXPORT DomDateTime {
 
1542
public:
 
1543
    DomDateTime();
 
1544
    ~DomDateTime();
 
1545
 
 
1546
    void read(const QDomElement &node);
 
1547
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1548
    inline QString text() const { return m_text; }
 
1549
    inline void setText(const QString &s) { m_text = s; }
 
1550
 
 
1551
    // attribute accessors
 
1552
    // child element accessors
 
1553
    inline int elementHour() { return m_hour; }
 
1554
    void setElementHour(int a);
 
1555
 
 
1556
    inline int elementMinute() { return m_minute; }
 
1557
    void setElementMinute(int a);
 
1558
 
 
1559
    inline int elementSecond() { return m_second; }
 
1560
    void setElementSecond(int a);
 
1561
 
 
1562
    inline int elementYear() { return m_year; }
 
1563
    void setElementYear(int a);
 
1564
 
 
1565
    inline int elementMonth() { return m_month; }
 
1566
    void setElementMonth(int a);
 
1567
 
 
1568
    inline int elementDay() { return m_day; }
 
1569
    void setElementDay(int a);
 
1570
 
 
1571
private:
 
1572
    QString m_text;
 
1573
    void clear(bool clear_all = true);
 
1574
 
 
1575
    // attribute data
 
1576
    // child element data
 
1577
    int m_hour;
 
1578
    int m_minute;
 
1579
    int m_second;
 
1580
    int m_year;
 
1581
    int m_month;
 
1582
    int m_day;
 
1583
 
 
1584
    DomDateTime(const DomDateTime &other);
 
1585
    void operator = (const DomDateTime&other);
 
1586
};
 
1587
 
 
1588
class QT_UI4_EXPORT DomStringList {
 
1589
public:
 
1590
    DomStringList();
 
1591
    ~DomStringList();
 
1592
 
 
1593
    void read(const QDomElement &node);
 
1594
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1595
    inline QString text() const { return m_text; }
 
1596
    inline void setText(const QString &s) { m_text = s; }
 
1597
 
 
1598
    // attribute accessors
 
1599
    // child element accessors
 
1600
    inline QStringList elementString() { return m_string; }
 
1601
    void setElementString(const QStringList& a);
 
1602
 
 
1603
private:
 
1604
    QString m_text;
 
1605
    void clear(bool clear_all = true);
 
1606
 
 
1607
    // attribute data
 
1608
    // child element data
 
1609
    QStringList m_string;
 
1610
 
 
1611
    DomStringList(const DomStringList &other);
 
1612
    void operator = (const DomStringList&other);
 
1613
};
 
1614
 
 
1615
class QT_UI4_EXPORT DomResourcePixmap {
 
1616
public:
 
1617
    DomResourcePixmap();
 
1618
    ~DomResourcePixmap();
 
1619
 
 
1620
    void read(const QDomElement &node);
 
1621
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1622
    inline QString text() const { return m_text; }
 
1623
    inline void setText(const QString &s) { m_text = s; }
 
1624
 
 
1625
    // attribute accessors
 
1626
    inline bool hasAttributeResource() { return m_has_attr_resource; }
 
1627
    inline QString attributeResource() { return m_attr_resource; }
 
1628
    inline void setAttributeResource(const QString& a) { m_attr_resource = a; m_has_attr_resource = true; }
 
1629
    inline void clearAttributeResource() { m_has_attr_resource = false; }
 
1630
 
 
1631
    // child element accessors
 
1632
private:
 
1633
    QString m_text;
 
1634
    void clear(bool clear_all = true);
 
1635
 
 
1636
    // attribute data
 
1637
    QString m_attr_resource;
 
1638
    bool m_has_attr_resource;
 
1639
 
 
1640
    // child element data
 
1641
 
 
1642
    DomResourcePixmap(const DomResourcePixmap &other);
 
1643
    void operator = (const DomResourcePixmap&other);
 
1644
};
 
1645
 
 
1646
class QT_UI4_EXPORT DomString {
 
1647
public:
 
1648
    DomString();
 
1649
    ~DomString();
 
1650
 
 
1651
    void read(const QDomElement &node);
 
1652
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1653
    inline QString text() const { return m_text; }
 
1654
    inline void setText(const QString &s) { m_text = s; }
 
1655
 
 
1656
    // attribute accessors
 
1657
    inline bool hasAttributeNotr() { return m_has_attr_notr; }
 
1658
    inline QString attributeNotr() { return m_attr_notr; }
 
1659
    inline void setAttributeNotr(const QString& a) { m_attr_notr = a; m_has_attr_notr = true; }
 
1660
    inline void clearAttributeNotr() { m_has_attr_notr = false; }
 
1661
 
 
1662
    // child element accessors
 
1663
private:
 
1664
    QString m_text;
 
1665
    void clear(bool clear_all = true);
 
1666
 
 
1667
    // attribute data
 
1668
    QString m_attr_notr;
 
1669
    bool m_has_attr_notr;
 
1670
 
 
1671
    // child element data
 
1672
 
 
1673
    DomString(const DomString &other);
 
1674
    void operator = (const DomString&other);
 
1675
};
 
1676
 
 
1677
class QT_UI4_EXPORT DomProperty {
 
1678
public:
 
1679
    DomProperty();
 
1680
    ~DomProperty();
 
1681
 
 
1682
    void read(const QDomElement &node);
 
1683
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1684
    inline QString text() const { return m_text; }
 
1685
    inline void setText(const QString &s) { m_text = s; }
 
1686
 
 
1687
    // attribute accessors
 
1688
    inline bool hasAttributeName() { return m_has_attr_name; }
 
1689
    inline QString attributeName() { return m_attr_name; }
 
1690
    inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; }
 
1691
    inline void clearAttributeName() { m_has_attr_name = false; }
 
1692
 
 
1693
    inline bool hasAttributeStdset() { return m_has_attr_stdset; }
 
1694
    inline int attributeStdset() { return m_attr_stdset; }
 
1695
    inline void setAttributeStdset(int a) { m_attr_stdset = a; m_has_attr_stdset = true; }
 
1696
    inline void clearAttributeStdset() { m_has_attr_stdset = false; }
 
1697
 
 
1698
    // child element accessors
 
1699
    enum Kind { Unknown = 0, Bool, Color, Cstring, Cursor, Enum, Font, IconSet, Pixmap, Palette, Point, Rect, Set, SizePolicy, Size, String, StringList, Number, Float, Double, Date, Time, DateTime };
 
1700
    inline Kind kind() { return m_kind; }
 
1701
 
 
1702
    inline QString elementBool() { return m_bool; }
 
1703
    void setElementBool(const QString& a);
 
1704
 
 
1705
    inline DomColor* elementColor() { return m_color; }
 
1706
    void setElementColor(DomColor* a);
 
1707
 
 
1708
    inline QString elementCstring() { return m_cstring; }
 
1709
    void setElementCstring(const QString& a);
 
1710
 
 
1711
    inline int elementCursor() { return m_cursor; }
 
1712
    void setElementCursor(int a);
 
1713
 
 
1714
    inline QString elementEnum() { return m_enum; }
 
1715
    void setElementEnum(const QString& a);
 
1716
 
 
1717
    inline DomFont* elementFont() { return m_font; }
 
1718
    void setElementFont(DomFont* a);
 
1719
 
 
1720
    inline DomResourcePixmap* elementIconSet() { return m_iconSet; }
 
1721
    void setElementIconSet(DomResourcePixmap* a);
 
1722
 
 
1723
    inline DomResourcePixmap* elementPixmap() { return m_pixmap; }
 
1724
    void setElementPixmap(DomResourcePixmap* a);
 
1725
 
 
1726
    inline DomPalette* elementPalette() { return m_palette; }
 
1727
    void setElementPalette(DomPalette* a);
 
1728
 
 
1729
    inline DomPoint* elementPoint() { return m_point; }
 
1730
    void setElementPoint(DomPoint* a);
 
1731
 
 
1732
    inline DomRect* elementRect() { return m_rect; }
 
1733
    void setElementRect(DomRect* a);
 
1734
 
 
1735
    inline QString elementSet() { return m_set; }
 
1736
    void setElementSet(const QString& a);
 
1737
 
 
1738
    inline DomSizePolicy* elementSizePolicy() { return m_sizePolicy; }
 
1739
    void setElementSizePolicy(DomSizePolicy* a);
 
1740
 
 
1741
    inline DomSize* elementSize() { return m_size; }
 
1742
    void setElementSize(DomSize* a);
 
1743
 
 
1744
    inline DomString* elementString() { return m_string; }
 
1745
    void setElementString(DomString* a);
 
1746
 
 
1747
    inline DomStringList* elementStringList() { return m_stringList; }
 
1748
    void setElementStringList(DomStringList* a);
 
1749
 
 
1750
    inline int elementNumber() { return m_number; }
 
1751
    void setElementNumber(int a);
 
1752
 
 
1753
    inline float elementFloat() { return m_float; }
 
1754
    void setElementFloat(float a);
 
1755
 
 
1756
    inline double elementDouble() { return m_double; }
 
1757
    void setElementDouble(double a);
 
1758
 
 
1759
    inline DomDate* elementDate() { return m_date; }
 
1760
    void setElementDate(DomDate* a);
 
1761
 
 
1762
    inline DomTime* elementTime() { return m_time; }
 
1763
    void setElementTime(DomTime* a);
 
1764
 
 
1765
    inline DomDateTime* elementDateTime() { return m_dateTime; }
 
1766
    void setElementDateTime(DomDateTime* a);
 
1767
 
 
1768
private:
 
1769
    QString m_text;
 
1770
    void clear(bool clear_all = true);
 
1771
 
 
1772
    // attribute data
 
1773
    QString m_attr_name;
 
1774
    bool m_has_attr_name;
 
1775
 
 
1776
    int m_attr_stdset;
 
1777
    bool m_has_attr_stdset;
 
1778
 
 
1779
    // child element data
 
1780
    Kind m_kind;
 
1781
    QString m_bool;
 
1782
    DomColor* m_color;
 
1783
    QString m_cstring;
 
1784
    int m_cursor;
 
1785
    QString m_enum;
 
1786
    DomFont* m_font;
 
1787
    DomResourcePixmap* m_iconSet;
 
1788
    DomResourcePixmap* m_pixmap;
 
1789
    DomPalette* m_palette;
 
1790
    DomPoint* m_point;
 
1791
    DomRect* m_rect;
 
1792
    QString m_set;
 
1793
    DomSizePolicy* m_sizePolicy;
 
1794
    DomSize* m_size;
 
1795
    DomString* m_string;
 
1796
    DomStringList* m_stringList;
 
1797
    int m_number;
 
1798
    float m_float;
 
1799
    double m_double;
 
1800
    DomDate* m_date;
 
1801
    DomTime* m_time;
 
1802
    DomDateTime* m_dateTime;
 
1803
 
 
1804
    DomProperty(const DomProperty &other);
 
1805
    void operator = (const DomProperty&other);
 
1806
};
 
1807
 
 
1808
class QT_UI4_EXPORT DomConnections {
 
1809
public:
 
1810
    DomConnections();
 
1811
    ~DomConnections();
 
1812
 
 
1813
    void read(const QDomElement &node);
 
1814
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1815
    inline QString text() const { return m_text; }
 
1816
    inline void setText(const QString &s) { m_text = s; }
 
1817
 
 
1818
    // attribute accessors
 
1819
    // child element accessors
 
1820
    inline QList<DomConnection*> elementConnection() { return m_connection; }
 
1821
    void setElementConnection(const QList<DomConnection*>& a);
 
1822
 
 
1823
private:
 
1824
    QString m_text;
 
1825
    void clear(bool clear_all = true);
 
1826
 
 
1827
    // attribute data
 
1828
    // child element data
 
1829
    QList<DomConnection*> m_connection;
 
1830
 
 
1831
    DomConnections(const DomConnections &other);
 
1832
    void operator = (const DomConnections&other);
 
1833
};
 
1834
 
 
1835
class QT_UI4_EXPORT DomConnection {
 
1836
public:
 
1837
    DomConnection();
 
1838
    ~DomConnection();
 
1839
 
 
1840
    void read(const QDomElement &node);
 
1841
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1842
    inline QString text() const { return m_text; }
 
1843
    inline void setText(const QString &s) { m_text = s; }
 
1844
 
 
1845
    // attribute accessors
 
1846
    // child element accessors
 
1847
    inline QString elementSender() { return m_sender; }
 
1848
    void setElementSender(const QString& a);
 
1849
 
 
1850
    inline QString elementSignal() { return m_signal; }
 
1851
    void setElementSignal(const QString& a);
 
1852
 
 
1853
    inline QString elementReceiver() { return m_receiver; }
 
1854
    void setElementReceiver(const QString& a);
 
1855
 
 
1856
    inline QString elementSlot() { return m_slot; }
 
1857
    void setElementSlot(const QString& a);
 
1858
 
 
1859
    inline DomConnectionHints* elementHints() { return m_hints; }
 
1860
    void setElementHints(DomConnectionHints* a);
 
1861
 
 
1862
private:
 
1863
    QString m_text;
 
1864
    void clear(bool clear_all = true);
 
1865
 
 
1866
    // attribute data
 
1867
    // child element data
 
1868
    QString m_sender;
 
1869
    QString m_signal;
 
1870
    QString m_receiver;
 
1871
    QString m_slot;
 
1872
    DomConnectionHints* m_hints;
 
1873
 
 
1874
    DomConnection(const DomConnection &other);
 
1875
    void operator = (const DomConnection&other);
 
1876
};
 
1877
 
 
1878
class QT_UI4_EXPORT DomConnectionHints {
 
1879
public:
 
1880
    DomConnectionHints();
 
1881
    ~DomConnectionHints();
 
1882
 
 
1883
    void read(const QDomElement &node);
 
1884
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1885
    inline QString text() const { return m_text; }
 
1886
    inline void setText(const QString &s) { m_text = s; }
 
1887
 
 
1888
    // attribute accessors
 
1889
    // child element accessors
 
1890
    inline QList<DomConnectionHint*> elementHint() { return m_hint; }
 
1891
    void setElementHint(const QList<DomConnectionHint*>& a);
 
1892
 
 
1893
private:
 
1894
    QString m_text;
 
1895
    void clear(bool clear_all = true);
 
1896
 
 
1897
    // attribute data
 
1898
    // child element data
 
1899
    QList<DomConnectionHint*> m_hint;
 
1900
 
 
1901
    DomConnectionHints(const DomConnectionHints &other);
 
1902
    void operator = (const DomConnectionHints&other);
 
1903
};
 
1904
 
 
1905
class QT_UI4_EXPORT DomConnectionHint {
 
1906
public:
 
1907
    DomConnectionHint();
 
1908
    ~DomConnectionHint();
 
1909
 
 
1910
    void read(const QDomElement &node);
 
1911
    QDomElement write(QDomDocument &doc, const QString &tagName = QString());
 
1912
    inline QString text() const { return m_text; }
 
1913
    inline void setText(const QString &s) { m_text = s; }
 
1914
 
 
1915
    // attribute accessors
 
1916
    inline bool hasAttributeType() { return m_has_attr_type; }
 
1917
    inline QString attributeType() { return m_attr_type; }
 
1918
    inline void setAttributeType(const QString& a) { m_attr_type = a; m_has_attr_type = true; }
 
1919
    inline void clearAttributeType() { m_has_attr_type = false; }
 
1920
 
 
1921
    // child element accessors
 
1922
    inline int elementX() { return m_x; }
 
1923
    void setElementX(int a);
 
1924
 
 
1925
    inline int elementY() { return m_y; }
 
1926
    void setElementY(int a);
 
1927
 
 
1928
private:
 
1929
    QString m_text;
 
1930
    void clear(bool clear_all = true);
 
1931
 
 
1932
    // attribute data
 
1933
    QString m_attr_type;
 
1934
    bool m_has_attr_type;
 
1935
 
 
1936
    // child element data
 
1937
    int m_x;
 
1938
    int m_y;
 
1939
 
 
1940
    DomConnectionHint(const DomConnectionHint &other);
 
1941
    void operator = (const DomConnectionHint&other);
 
1942
};
 
1943
 
 
1944
#endif // UI4_H
 
1945