← Back to branch summary

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

« back to all changes in this revision

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