← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/gui/widgets/qgroupbox.cpp

  • 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/gui/widgets/qgroupbox.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 1992-2005 Trolltech AS. All rights reserved.
 
4
**
 
5
** This file is part of the widgets module 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
 
 
29
#include "qgroupbox.h"
 
30
#ifndef QT_NO_GROUPBOX
 
31
#include "qapplication.h"
 
32
#include "qbitmap.h"
 
33
#include "qcheckbox.h"
 
34
#include "qdrawutil.h"
 
35
#include "qevent.h"
 
36
#include "qlayout.h"
 
37
#include "qpainter.h"
 
38
#include "qradiobutton.h"
 
39
#include "qstyle.h"
 
40
#include "qstyleoption.h"
 
41
#ifndef QT_NO_ACCESSIBILITY
 
42
#include "qaccessible.h"
 
43
#endif
 
44
#include <private/qwidget_p.h>
 
45
 
 
46
class QGroupBoxPrivate : public QWidgetPrivate
 
47
{
 
48
    Q_DECLARE_PUBLIC(QGroupBox)
 
49
public:
 
50
 
 
51
    QGroupBoxPrivate():
 
52
        checkbox(0),
 
53
        topMargin(0){}
 
54
    void skip();
 
55
    void init();
 
56
    void calculateFrame();
 
57
    void updateCheckBoxGeometry();
 
58
    QString title;
 
59
    int align;
 
60
    int shortcutId;
 
61
 
 
62
    void fixFocus();
 
63
    void setChildrenEnabled(bool b);
 
64
    uint bFlat : 1;
 
65
 
 
66
    QCheckBox *checkbox;
 
67
    int topMargin;
 
68
};
 
69
 
 
70
/*!
 
71
    \class QGroupBox qgroupbox.h
 
72
    \brief The QGroupBox widget provides a group box frame with a title.
 
73
 
 
74
    \ingroup organizers
 
75
    \ingroup geomanagement
 
76
    \ingroup appearance
 
77
    \mainclass
 
78
 
 
79
    A group box provides a frame, a title and a keyboard shortcut, and
 
80
    displays various other widgets inside itself. The title is on top,
 
81
    the keyboard shortcut moves keyboard focus to one of the group
 
82
    box's child widgets.
 
83
 
 
84
    QGroupBox also lets you set the \l title (normally set in the
 
85
    constructor) and the title's alignment(). If setCheckable(true) is
 
86
    called then the group box is isCheckable(), and it can be
 
87
    setChecked(). Checkable group boxes child widgets are enabled or
 
88
    disabled depending on whether or not the group box is isChecked().
 
89
 
 
90
    To minimize space consumption, you can remove the right, left and
 
91
    bottom edges of the frame with setFlat().
 
92
 
 
93
    \inlineimage plastique-groupbox.png Screenshot in Plastique style
 
94
    \inlineimage windows-groupbox.png Screenshot in Windows style
 
95
 
 
96
    \sa QButtonGroup
 
97
*/
 
98
 
 
99
 
 
100
 
 
101
/*!
 
102
    Constructs a group box widget with no title and parent \a parent.
 
103
*/
 
104
 
 
105
QGroupBox::QGroupBox(QWidget *parent)
 
106
    : QWidget(*new QGroupBoxPrivate, parent, 0)
 
107
{
 
108
    Q_D(QGroupBox);
 
109
    d->init();
 
110
}
 
111
 
 
112
/*!
 
113
    Constructs a group box with the title \a title and parent \a
 
114
    parent.
 
115
*/
 
116
 
 
117
QGroupBox::QGroupBox(const QString &title, QWidget *parent)
 
118
    : QWidget(*new QGroupBoxPrivate, parent, 0)
 
119
{
 
120
    Q_D(QGroupBox);
 
121
    d->init();
 
122
    setTitle(title);
 
123
}
 
124
 
 
125
 
 
126
/*!
 
127
    Destroys the group box.
 
128
*/
 
129
QGroupBox::~QGroupBox()
 
130
{
 
131
}
 
132
 
 
133
void QGroupBoxPrivate::init()
 
134
{
 
135
    align = Qt::AlignLeft;
 
136
    shortcutId = 0;
 
137
    bFlat = false;
 
138
    calculateFrame();
 
139
}
 
140
 
 
141
 
 
142
void QGroupBox::setTitle(const QString &title)
 
143
{
 
144
    Q_D(QGroupBox);
 
145
    if (d->title == title)                                // no change
 
146
        return;
 
147
    d->title = title;
 
148
    releaseShortcut(d->shortcutId);
 
149
    if (d->checkbox) {
 
150
        d->checkbox->setText(d->title);
 
151
        d->shortcutId = 0; // the checkbox does the shortcut for us
 
152
    } else {
 
153
        d->shortcutId = grabShortcut(QKeySequence::mnemonic(title));
 
154
    }
 
155
    d->calculateFrame();
 
156
    d->updateCheckBoxGeometry();
 
157
 
 
158
    update();
 
159
    updateGeometry();
 
160
#ifndef QT_NO_ACCESSIBILITY
 
161
    QAccessible::updateAccessibility(this, 0, QAccessible::NameChanged);
 
162
#endif
 
163
}
 
164
 
 
165
/*!
 
166
    \property QGroupBox::title
 
167
    \brief the group box title text.
 
168
 
 
169
    The group box title text will have a focus-change keyboard
 
170
    shortcut if the title contains \&, followed by a letter.
 
171
 
 
172
    \code
 
173
        g->setTitle("&User information");
 
174
    \endcode
 
175
    This produces "\underline{U}ser information"; \key Alt+U moves the keyboard
 
176
    focus to the group box.
 
177
 
 
178
    There is no default title text.
 
179
*/
 
180
 
 
181
QString QGroupBox::title() const
 
182
{
 
183
    Q_D(const QGroupBox);
 
184
    return d->title;
 
185
}
 
186
 
 
187
/*!
 
188
    \property QGroupBox::alignment
 
189
    \brief the alignment of the group box title.
 
190
 
 
191
    The title is always placed on the upper frame line. The horizontal
 
192
    alignment can be specified by the alignment parameter.
 
193
 
 
194
    The alignment is one of the following flags:
 
195
    \list
 
196
    \i \c Qt::AlignLeft aligns the title text to the left.
 
197
    \i \c Qt::AlignRight aligns the title text to the right.
 
198
    \i \c Qt::AlignHCenter aligns the title text centered.
 
199
    \endlist
 
200
 
 
201
    The default alignment is \c Qt::AlignLeft.
 
202
 
 
203
    \sa Qt::Alignment
 
204
*/
 
205
Qt::Alignment QGroupBox::alignment() const
 
206
{
 
207
    Q_D(const QGroupBox);
 
208
    return QFlag(d->align);
 
209
}
 
210
 
 
211
void QGroupBox::setAlignment(int alignment)
 
212
{
 
213
    Q_D(QGroupBox);
 
214
    d->align = alignment;
 
215
    d->updateCheckBoxGeometry();
 
216
    update();
 
217
}
 
218
 
 
219
/*! \reimp
 
220
*/
 
221
void QGroupBox::resizeEvent(QResizeEvent *e)
 
222
{
 
223
    Q_D(QGroupBox);
 
224
    QWidget::resizeEvent(e);
 
225
    d->updateCheckBoxGeometry();
 
226
}
 
227
 
 
228
/*! \reimp
 
229
*/
 
230
 
 
231
void QGroupBox::paintEvent(QPaintEvent *event)
 
232
{
 
233
    Q_D(QGroupBox);
 
234
    QPainter paint(this);
 
235
 
 
236
    QRect frameRect = rect();
 
237
    frameRect.setTop(d->topMargin);
 
238
    QStyleOptionFrame opt;
 
239
    opt.init(this);
 
240
    opt.rect = frameRect;
 
241
 
 
242
    opt.state |= QStyle::State_Sunken;
 
243
    opt.lineWidth = 1;
 
244
    opt.midLineWidth = 0;
 
245
 
 
246
    if (d->title.size() && !d->checkbox) {        // draw title
 
247
        QFontMetrics fm = paint.fontMetrics();
 
248
        int h = fm.height();
 
249
        int tw = fm.width(d->title + QLatin1Char(' '));
 
250
        int marg = d->bFlat ? 0 : (8 + fm.width(QLatin1Char(' ')));
 
251
        QRect rect = this->rect().adjusted(marg, 0, -marg, 0);
 
252
        QRect r = QStyle::alignedRect(opt.direction, QFlag(d->align | Qt::AlignTop), QSize(tw, h), rect);
 
253
        int va = style()->styleHint(QStyle::SH_GroupBox_TextLabelVerticalAlignment, &opt, this);
 
254
        if(va & Qt::AlignTop)
 
255
            r.translate(0, -fm.descent());
 
256
        int textColor = style()->styleHint(QStyle::SH_GroupBox_TextLabelColor, &opt, this);
 
257
        if (textColor != 0 && !testAttribute(Qt::WA_SetPalette))
 
258
            paint.setPen(QColor::fromRgba((QRgb)textColor));
 
259
        if (!style()->styleHint(QStyle::SH_UnderlineShortcut, &opt, this))
 
260
            va |= Qt::TextHideMnemonic;
 
261
        style()->drawItemText(&paint, r, Qt::TextShowMnemonic | Qt::AlignHCenter | va, palette(),
 
262
                              isEnabled(), d->title);
 
263
        paint.setClipRegion(event->region().subtract(r)); // clip everything but title
 
264
    } else if (d->checkbox) {
 
265
        QRect cbClip = d->checkbox->geometry();
 
266
        QFontMetrics fm = paint.fontMetrics();
 
267
        cbClip.setX(cbClip.x() - fm.width(QLatin1Char(' ')));
 
268
        paint.setClipRegion(event->region().subtract(cbClip));
 
269
    }
 
270
    if (d->bFlat) {
 
271
            QRect fr = frameRect;
 
272
            QPoint p1(fr.x(), fr.y() + 1);
 
273
            QPoint p2(fr.x() + fr.width(), p1.y());
 
274
            // ### This should probably be a style primitive.
 
275
            qDrawShadeLine(&paint, p1, p2, palette(), true, 1, 0);
 
276
    } else {
 
277
        style()->drawPrimitive(QStyle::PE_FrameGroupBox, &opt, &paint, this);
 
278
    }
 
279
}
 
280
 
 
281
/*! \reimp  */
 
282
bool QGroupBox::event(QEvent *e)
 
283
{
 
284
    Q_D(QGroupBox);
 
285
    if (e->type() == QEvent::Shortcut) {
 
286
        QShortcutEvent *se = static_cast<QShortcutEvent *>(e);
 
287
        if (se->shortcutId() == d->shortcutId) {
 
288
            d->fixFocus();
 
289
            return true;
 
290
        }
 
291
    }
 
292
    return QWidget::event(e);
 
293
}
 
294
 
 
295
/*!\reimp */
 
296
void QGroupBox::childEvent(QChildEvent *c)
 
297
{
 
298
    Q_D(QGroupBox);
 
299
    if (c->type() != QEvent::ChildAdded || !c->child()->isWidgetType())
 
300
        return;
 
301
    QWidget *w = (QWidget*)c->child();
 
302
    if (d->checkbox) {
 
303
        if (w == d->checkbox)
 
304
            return;
 
305
        if (d->checkbox->isChecked()) {
 
306
            if (!w->testAttribute(Qt::WA_ForceDisabled))
 
307
                w->setEnabled(true);
 
308
        } else {
 
309
            if (w->isEnabled()) {
 
310
                w->setEnabled(false);
 
311
                w->setAttribute(Qt::WA_ForceDisabled, false);
 
312
            }
 
313
        }
 
314
    }
 
315
}
 
316
 
 
317
 
 
318
/*!
 
319
    \internal
 
320
 
 
321
    This private slot finds a widget in this group box that can accept
 
322
    focus, and gives the focus to that widget.
 
323
*/
 
324
 
 
325
void QGroupBoxPrivate::fixFocus()
 
326
{
 
327
    Q_Q(QGroupBox);
 
328
    QWidget *fw = q->focusWidget();
 
329
    if (!fw) {
 
330
#ifndef QT_NO_RADIOBUTTON
 
331
        QWidget * best = 0;
 
332
#endif
 
333
        QWidget * candidate = 0;
 
334
        QWidget * w = q;
 
335
        while ((w = w->nextInFocusChain()) != q) {
 
336
            if (q->isAncestorOf(w) && (w->focusPolicy() & Qt::TabFocus) == Qt::TabFocus && w->isVisibleTo(q)) {
 
337
#ifndef QT_NO_RADIOBUTTON
 
338
                if (!best && qobject_cast<QRadioButton*>(w) && ((QRadioButton*)w)->isChecked())
 
339
                    // we prefer a checked radio button or a widget that
 
340
                    // already has focus, if there is one
 
341
                    best = w;
 
342
                else
 
343
#endif
 
344
                    if (!candidate)
 
345
                        // but we'll accept anything that takes focus
 
346
                        candidate = w;
 
347
            }
 
348
        }
 
349
#ifndef QT_NO_RADIOBUTTON
 
350
        if (best)
 
351
            fw = best;
 
352
        else
 
353
#endif
 
354
            if (candidate)
 
355
                fw = candidate;
 
356
    }
 
357
    if (fw)
 
358
        fw->setFocus();
 
359
}
 
360
 
 
361
 
 
362
/*
 
363
    Sets the right frame rect depending on the title.
 
364
*/
 
365
void QGroupBoxPrivate::calculateFrame()
 
366
{
 
367
    Q_Q(QGroupBox);
 
368
    int va = q->style()->styleHint(QStyle::SH_GroupBox_TextLabelVerticalAlignment, 0, q);
 
369
 
 
370
    topMargin = 0;
 
371
    int topHeight = 0;
 
372
    QFontMetrics fm = q->fontMetrics();
 
373
    if (checkbox) {
 
374
        topHeight = checkbox->sizeHint().height();
 
375
        if (va & Qt::AlignTop)
 
376
            topMargin = topHeight;
 
377
        else
 
378
            topMargin = topHeight / 2;
 
379
    } else if (title.size()) {
 
380
        topHeight = fm.height();
 
381
        if (va & Qt::AlignVCenter)
 
382
            topMargin = topHeight/2;
 
383
        else if (va & Qt::AlignTop)
 
384
            topMargin = topHeight;
 
385
    }
 
386
 
 
387
    int marg = bFlat ? 0 : 2; // ###NEEDS TO BE A STYLE ATTRIBUTE
 
388
    q->setContentsMargins(marg, topHeight + marg, marg, marg);
 
389
}
 
390
 
 
391
 
 
392
 
 
393
/*! \reimp
 
394
 */
 
395
void QGroupBox::focusInEvent(QFocusEvent *)
 
396
{ // note no call to super
 
397
    Q_D(QGroupBox);
 
398
    d->fixFocus();
 
399
}
 
400
 
 
401
 
 
402
/*!
 
403
  \reimp
 
404
*/
 
405
 
 
406
QSize QGroupBox::minimumSizeHint() const
 
407
{
 
408
    Q_D(const QGroupBox);
 
409
    QSize sh = QWidget::minimumSizeHint();
 
410
    if (!sh.isValid())
 
411
        sh = QSize(d->leftmargin + d->rightmargin + 2, d->topmargin + d->bottommargin + 2);
 
412
    QSize m((d->bFlat ? 0 : 2*8), 0);
 
413
    if (d->checkbox) {
 
414
        if (!d->bFlat)
 
415
            m.rwidth() += fontMetrics().width(QLatin1Char(' '));
 
416
        sh = sh.expandedTo(d->checkbox->sizeHint() + m);
 
417
    } else if (!d->title.isEmpty()) {
 
418
        sh = sh.expandedTo(fontMetrics().size(0, d->title + QLatin1Char(' ')) + m);
 
419
    }
 
420
 
 
421
    return sh;
 
422
}
 
423
 
 
424
/*!
 
425
    \property QGroupBox::flat
 
426
    \brief whether the group box is painted flat or has a frame
 
427
 
 
428
    By default a group box has a surrounding frame, with the title
 
429
    being placed on the upper frame line. In flat mode the right, left
 
430
    and bottom frame lines are omitted, and only the thin line at the
 
431
    top is drawn.
 
432
 
 
433
    \sa title
 
434
*/
 
435
bool QGroupBox::isFlat() const
 
436
{
 
437
    Q_D(const QGroupBox);
 
438
    return d->bFlat;
 
439
}
 
440
 
 
441
void QGroupBox::setFlat(bool b)
 
442
{
 
443
    Q_D(QGroupBox);
 
444
    if ((bool)d->bFlat == b)
 
445
        return;
 
446
    d->bFlat = b;
 
447
    d->updateCheckBoxGeometry();
 
448
    update();
 
449
}
 
450
 
 
451
 
 
452
/*!
 
453
    \property QGroupBox::checkable
 
454
    \brief Whether the group box has a checkbox in its title.
 
455
 
 
456
    If this property is true, the group box has a checkbox. If the
 
457
    checkbox is checked (which is the default), the group box's
 
458
    children are enabled.
 
459
 
 
460
    setCheckable() controls whether or not the group box has a
 
461
    checkbox, and isCheckable() controls whether the checkbox is
 
462
    checked or not.
 
463
*/
 
464
void QGroupBox::setCheckable(bool b)
 
465
{
 
466
    Q_D(QGroupBox);
 
467
    if ((d->checkbox != 0) == b)
 
468
        return;
 
469
 
 
470
    if (b) {
 
471
        if (!d->checkbox) {
 
472
            d->checkbox = new QCheckBox(title(), this);
 
473
            d->checkbox->setObjectName(QLatin1String("qt_groupbox_checkbox"));
 
474
            setChecked(true);
 
475
            d->setChildrenEnabled(true);
 
476
            connect(d->checkbox, SIGNAL(toggled(bool)),
 
477
                     this, SLOT(setChildrenEnabled(bool)));
 
478
            connect(d->checkbox, SIGNAL(toggled(bool)),
 
479
                     this, SIGNAL(toggled(bool)));
 
480
            d->updateCheckBoxGeometry();
 
481
        }
 
482
        d->checkbox->show();
 
483
    } else {
 
484
        d->setChildrenEnabled(true);
 
485
        delete d->checkbox;
 
486
        d->checkbox = 0;
 
487
    }
 
488
    QString title = d->title;
 
489
    d->title.clear();
 
490
    setTitle(title); // update, including the shortcut
 
491
}
 
492
 
 
493
bool QGroupBox::isCheckable() const
 
494
{
 
495
    Q_D(const QGroupBox);
 
496
    return (d->checkbox != 0);
 
497
}
 
498
 
 
499
 
 
500
bool QGroupBox::isChecked() const
 
501
{
 
502
    Q_D(const QGroupBox);
 
503
    return d->checkbox && d->checkbox->isChecked();
 
504
}
 
505
 
 
506
 
 
507
/*!
 
508
    \fn void QGroupBox::toggled(bool on)
 
509
 
 
510
    If the group box has a check box (see \l isCheckable()) this signal
 
511
    is emitted when the check box is toggled. \a on is true if the check
 
512
    box is checked; otherwise it is false.
 
513
*/
 
514
 
 
515
/*!
 
516
    \property QGroupBox::checked
 
517
    \brief Whether the group box's checkbox is checked.
 
518
 
 
519
    If the group box has a check box (see \l isCheckable()), and the
 
520
    check box is checked, the group box's children
 
521
    are enabled. If the checkbox is unchecked the children are
 
522
    disabled.
 
523
*/
 
524
void QGroupBox::setChecked(bool b)
 
525
{
 
526
    Q_D(QGroupBox);
 
527
    if (d->checkbox)
 
528
        d->checkbox->setChecked(b);
 
529
}
 
530
 
 
531
/*
 
532
  sets all children of the group box except the qt_groupbox_checkbox
 
533
  to either disabled/enabled
 
534
*/
 
535
void QGroupBoxPrivate::setChildrenEnabled(bool b)
 
536
{
 
537
    Q_Q(QGroupBox);
 
538
    QObjectList childs = q->children();
 
539
    if (childs.isEmpty())
 
540
        return;
 
541
    for (int i = 0; i < childs.size(); ++i) {
 
542
        QObject *o = childs.at(i);
 
543
        if (o->isWidgetType()
 
544
             && o != checkbox
 
545
           ) {
 
546
            QWidget *w = static_cast<QWidget *>(o);
 
547
            if (b) {
 
548
                if (!w->testAttribute(Qt::WA_ForceDisabled))
 
549
                    w->setEnabled(true);
 
550
            } else {
 
551
                if (w->isEnabled()) {
 
552
                    w->setEnabled(false);
 
553
                    w->setAttribute(Qt::WA_ForceDisabled, false);
 
554
                }
 
555
            }
 
556
        }
 
557
    }
 
558
}
 
559
 
 
560
/*! \reimp */
 
561
void QGroupBox::changeEvent(QEvent *ev)
 
562
{
 
563
    Q_D(QGroupBox);
 
564
    if(ev->type() == QEvent::EnabledChange) {
 
565
        if (d->checkbox && isEnabled()) {
 
566
            // we are being enabled - disable children
 
567
            if (!d->checkbox->isChecked())
 
568
                d->setChildrenEnabled(false);
 
569
        }
 
570
    } else if(ev->type() == QEvent::FontChange || ev->type() == QEvent::StyleChange) {
 
571
        d->updateCheckBoxGeometry();
 
572
        d->calculateFrame();
 
573
    }
 
574
    QWidget::changeEvent(ev);
 
575
}
 
576
 
 
577
/*
 
578
  recalculates and sets the checkbox setGeometry
 
579
*/
 
580
void QGroupBoxPrivate::updateCheckBoxGeometry()
 
581
{
 
582
    Q_Q(QGroupBox);
 
583
    if (checkbox) {
 
584
        QSize cbSize = checkbox->sizeHint();
 
585
        int marg = bFlat ? 0 : (8 + q->fontMetrics().width(QLatin1Char(' ')));
 
586
        QRect rect = q->rect().adjusted(marg, 0, -marg, 0);
 
587
        QRect cbRect = QStyle::alignedRect(q->layoutDirection(), QFlag(this->align | Qt::AlignTop), cbSize, rect);
 
588
        checkbox->setGeometry(cbRect);
 
589
    }
 
590
}
 
591
 
 
592
#ifdef QT3_SUPPORT
 
593
/*!
 
594
    Use one of the constructors that doesn't take the \a name
 
595
    argument and then use setObjectName() instead.
 
596
*/
 
597
QGroupBox::QGroupBox(QWidget *parent, const char *name)
 
598
    : QWidget(*new QGroupBoxPrivate, parent, 0)
 
599
{
 
600
    Q_D(QGroupBox);
 
601
    setObjectName(name);
 
602
    d->init();
 
603
}
 
604
 
 
605
/*!
 
606
    Use one of the constructors that doesn't take the \a name
 
607
    argument and then use setObjectName() instead.
 
608
*/
 
609
QGroupBox::QGroupBox(const QString &title, QWidget *parent, const char *name)
 
610
    : QWidget(*new QGroupBoxPrivate, parent, 0)
 
611
{
 
612
    Q_D(QGroupBox);
 
613
    setObjectName(name);
 
614
    d->init();
 
615
    setTitle(title);
 
616
}
 
617
#endif // QT3_SUPPORT
 
618
 
 
619
#include "moc_qgroupbox.cpp"
 
620
 
 
621
#endif //QT_NO_GROUPBOX