1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qgroupbox.h"

    43 #ifndef QT_NO_GROUPBOX

    44 #include "qapplication.h"

    45 #include "qbitmap.h"

    46 #include "qdrawutil.h"

    47 #include "qevent.h"

    48 #include "qlayout.h"

    49 #include "qradiobutton.h"

    50 #include "qstyle.h"

    51 #include "qstyleoption.h"

    52 #include "qstylepainter.h"

    53 #ifndef QT_NO_ACCESSIBILITY

    54 #include "qaccessible.h"

    55 #endif

    56 #include <private/qwidget_p.h>

    57 

    58 #include "qdebug.h"

    59 

    60 QT_BEGIN_NAMESPACE

    61 

    62 class QGroupBoxPrivate : public QWidgetPrivate

    63 {

    64     Q_DECLARE_PUBLIC(QGroupBox)

    65 

    66 public:

    67     void skip();

    68     void init();

    69     void calculateFrame();

    70     QString title;

    71     int align;

    72 #ifndef QT_NO_SHORTCUT

    73     int shortcutId;

    74 #endif

    75 

    76     void _q_fixFocus(Qt::FocusReason reason);

    77     void _q_setChildrenEnabled(bool b);

    78     void click();

    79     bool flat;

    80     bool checkable;

    81     bool checked;

    82     bool hover;

    83     bool overCheckBox;

    84     QStyle::SubControl pressedControl;

    85 };

    86 

    87 /*!

    88     Initialize \a option with the values from this QGroupBox. This method

    89     is useful for subclasses when they need a QStyleOptionGroupBox, but don't want

    90     to fill in all the information themselves.

    91 

    92     \sa QStyleOption::initFrom()

    93 */

    94 void QGroupBox::initStyleOption(QStyleOptionGroupBox *option) const

    95 {

    96     if (!option)

    97         return;

    98 

    99     Q_D(const QGroupBox);

   100     option->initFrom(this);

   101     option->text = d->title;

   102     option->lineWidth = 1;

   103     option->midLineWidth = 0;

   104     option->textAlignment = Qt::Alignment(d->align);

   105     option->activeSubControls |= d->pressedControl;

   106     option->subControls = QStyle::SC_GroupBoxFrame;

   107 

   108     if (d->hover)

   109         option->state |= QStyle::State_MouseOver;

   110     else

   111         option->state &= ~QStyle::State_MouseOver;

   112 

   113     if (d->flat)

   114         option->features |= QStyleOptionFrameV2::Flat;

   115 

   116     if (d->checkable) {

   117         option->subControls |= QStyle::SC_GroupBoxCheckBox;

   118         option->state |= (d->checked ? QStyle::State_On : QStyle::State_Off);

   119         if ((d->pressedControl == QStyle::SC_GroupBoxCheckBox

   120             || d->pressedControl == QStyle::SC_GroupBoxLabel) && (d->hover || d->overCheckBox))

   121             option->state |= QStyle::State_Sunken;

   122     }

   123 

   124     if (!option->palette.isBrushSet(isEnabled() ? QPalette::Active : 

   125                                     QPalette::Disabled, QPalette::WindowText))

   126         option->textColor = QColor(style()->styleHint(QStyle::SH_GroupBox_TextLabelColor,

   127                                    option, this));

   128 

   129     if (!d->title.isEmpty())

   130         option->subControls |= QStyle::SC_GroupBoxLabel;

   131 }

   132 

   133 void QGroupBoxPrivate::click()

   134 {

   135     Q_Q(QGroupBox);

   136 

   137     QPointer<QGroupBox> guard(q);

   138     q->setChecked(!checked);

   139     if (!guard)

   140         return;

   141     emit q->clicked(checked);

   142 }

   143 

   144 /*!

   145     \class QGroupBox

   146     \brief The QGroupBox widget provides a group box frame with a title.

   147 

   148     \ingroup organizers

   149     \ingroup geomanagement

   150 

   151     A group box provides a frame, a title and a keyboard shortcut, and

   152     displays various other widgets inside itself. The title is on top,

   153     the keyboard shortcut moves keyboard focus to one of the group

   154     box's child widgets.

   155 

   156     QGroupBox also lets you set the \l title (normally set in the

   157     constructor) and the title's \l alignment. Group boxes can be

   158     \l checkable; child widgets in checkable group boxes are enabled or

   159     disabled depending on whether or not the group box is \l checked.

   160 

   161     You can minimize the space consumption of a group box by enabling

   162     the \l flat property. In most \l{QStyle}{styles}, enabling this

   163     property results in the removal of the left, right and bottom

   164     edges of the frame.

   165 

   166     QGroupBox doesn't automatically lay out the child widgets (which

   167     are often \l{QCheckBox}es or \l{QRadioButton}s but can be any

   168     widgets). The following example shows how we can set up a

   169     QGroupBox with a layout:

   170 

   171     \snippet examples/widgets/groupbox/window.cpp 2

   172 

   173     \table 100%

   174     \row \o \inlineimage windowsxp-groupbox.png Screenshot of a Windows XP style group box

   175          \o \inlineimage macintosh-groupbox.png Screenshot of a Macintosh style group box

   176          \o \inlineimage plastique-groupbox.png Screenshot of a Plastique style group box

   177     \row \o A \l{Windows XP Style Widget Gallery}{Windows XP style} group box.

   178          \o A \l{Macintosh Style Widget Gallery}{Macintosh style} group box.

   179          \o A \l{Plastique Style Widget Gallery}{Plastique style} group box.

   180     \endtable

   181 

   182     \sa QButtonGroup, {Group Box Example}

   183 */

   184 

   185 

   186 

   187 /*!

   188     Constructs a group box widget with the given \a parent but with no title.

   189 */

   190 

   191 QGroupBox::QGroupBox(QWidget *parent)

   192     : QWidget(*new QGroupBoxPrivate, parent, 0)

   193 {

   194     Q_D(QGroupBox);

   195     d->init();

   196 }

   197 

   198 /*!

   199     Constructs a group box with the given \a title and \a parent.

   200 */

   201 

   202 QGroupBox::QGroupBox(const QString &title, QWidget *parent)

   203     : QWidget(*new QGroupBoxPrivate, parent, 0)

   204 {

   205     Q_D(QGroupBox);

   206     d->init();

   207     setTitle(title);

   208 }

   209 

   210 

   211 /*!

   212     Destroys the group box.

   213 */

   214 QGroupBox::~QGroupBox()

   215 {

   216 }

   217 

   218 void QGroupBoxPrivate::init()

   219 {

   220     Q_Q(QGroupBox);

   221     align = Qt::AlignLeft;

   222 #ifndef QT_NO_SHORTCUT

   223     shortcutId = 0;

   224 #endif

   225     flat = false;

   226     checkable = false;

   227     checked = true;

   228     hover = false;

   229     overCheckBox = false;

   230     pressedControl = QStyle::SC_None;

   231     calculateFrame();

   232     q->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred, 

   233                      QSizePolicy::GroupBox));

   234 }

   235 

   236 void QGroupBox::setTitle(const QString &title)

   237 {

   238     Q_D(QGroupBox);

   239     if (d->title == title)                                // no change

   240         return;

   241     d->title = title;

   242 #ifndef QT_NO_SHORTCUT

   243     releaseShortcut(d->shortcutId);

   244     d->shortcutId = grabShortcut(QKeySequence::mnemonic(title));

   245 #endif

   246     d->calculateFrame();

   247 

   248     update();

   249     updateGeometry();

   250 #ifndef QT_NO_ACCESSIBILITY

   251     QAccessible::updateAccessibility(this, 0, QAccessible::NameChanged);

   252 #endif

   253 }

   254 

   255 /*!

   256     \property QGroupBox::title

   257     \brief the group box title text

   258 

   259     The group box title text will have a keyboard shortcut if the title

   260     contains an ampersand ('&') followed by a letter.

   261 

   262     \snippet doc/src/snippets/code/src_gui_widgets_qgroupbox.cpp 0

   263 

   264     In the example above, \key Alt+U moves the keyboard focus to the

   265     group box. See the \l {QShortcut#mnemonic}{QShortcut}

   266     documentation for details (to display an actual ampersand, use

   267     '&&').

   268 

   269     There is no default title text.

   270 

   271     \sa alignment

   272 */

   273 

   274 QString QGroupBox::title() const

   275 {

   276     Q_D(const QGroupBox);

   277     return d->title;

   278 }

   279 

   280 /*!

   281     \property QGroupBox::alignment

   282     \brief the alignment of the group box title.

   283 

   284     Most styles place the title at the top of the frame. The horizontal

   285     alignment of the title can be specified using single values from

   286     the following list:

   287 

   288     \list

   289     \i Qt::AlignLeft aligns the title text with the left-hand side of the group box.

   290     \i Qt::AlignRight aligns the title text with the right-hand side of the group box.

   291     \i Qt::AlignHCenter aligns the title text with the horizontal center of the group box.

   292     \endlist

   293 

   294     The default alignment is Qt::AlignLeft.

   295 

   296     \sa Qt::Alignment

   297 */

   298 Qt::Alignment QGroupBox::alignment() const

   299 {

   300     Q_D(const QGroupBox);

   301     return QFlag(d->align);

   302 }

   303 

   304 void QGroupBox::setAlignment(int alignment)

   305 {

   306     Q_D(QGroupBox);

   307     d->align = alignment;

   308     updateGeometry();

   309     update();

   310 }

   311 

   312 /*! \reimp

   313 */

   314 void QGroupBox::resizeEvent(QResizeEvent *e)

   315 {

   316     QWidget::resizeEvent(e);

   317 }

   318 

   319 /*! \reimp

   320 */

   321 

   322 void QGroupBox::paintEvent(QPaintEvent *)

   323 {

   324     QStylePainter paint(this);

   325     QStyleOptionGroupBox option;

   326     initStyleOption(&option);

   327     paint.drawComplexControl(QStyle::CC_GroupBox, option);

   328 }

   329 

   330 /*! \reimp  */

   331 bool QGroupBox::event(QEvent *e)

   332 {

   333     Q_D(QGroupBox);

   334 #ifndef QT_NO_SHORTCUT

   335     if (e->type() == QEvent::Shortcut) {

   336         QShortcutEvent *se = static_cast<QShortcutEvent *>(e);

   337         if (se->shortcutId() == d->shortcutId) {

   338             if (!isCheckable()) {

   339                 d->_q_fixFocus(Qt::ShortcutFocusReason);

   340             } else {

   341                 d->click();

   342                 setFocus(Qt::ShortcutFocusReason);

   343             }

   344             return true;

   345         }

   346     }

   347 #endif

   348     QStyleOptionGroupBox box;

   349     initStyleOption(&box);

   350     switch (e->type()) {

   351     case QEvent::HoverEnter:

   352     case QEvent::HoverMove: {

   353         QStyle::SubControl control = style()->hitTestComplexControl(QStyle::CC_GroupBox, &box,

   354                                                                     static_cast<QHoverEvent *>(e)->pos(),

   355                                                                     this);

   356         bool oldHover = d->hover;

   357         d->hover = d->checkable && (control == QStyle::SC_GroupBoxLabel || control == QStyle::SC_GroupBoxCheckBox);

   358         if (oldHover != d->hover) {

   359             QRect rect = style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxCheckBox, this)

   360                          | style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxLabel, this);

   361             update(rect);

   362         }

   363         return true;

   364     }

   365     case QEvent::HoverLeave:

   366         d->hover = false;

   367         if (d->checkable) {

   368             QRect rect = style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxCheckBox, this)

   369                          | style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxLabel, this);

   370             update(rect);

   371         }

   372         return true;

   373     case QEvent::KeyPress: {

   374         QKeyEvent *k = static_cast<QKeyEvent*>(e);

   375         if (!k->isAutoRepeat() && (k->key() == Qt::Key_Select || k->key() == Qt::Key_Space)) {

   376             d->pressedControl = QStyle::SC_GroupBoxCheckBox;

   377             update(style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxCheckBox, this));

   378             return true;

   379         }

   380         break;

   381     }

   382     case QEvent::KeyRelease: {

   383         QKeyEvent *k = static_cast<QKeyEvent*>(e);

   384         if (!k->isAutoRepeat() && (k->key() == Qt::Key_Select || k->key() == Qt::Key_Space)) {

   385             bool toggle = (d->pressedControl == QStyle::SC_GroupBoxLabel

   386                            || d->pressedControl == QStyle::SC_GroupBoxCheckBox);

   387             d->pressedControl = QStyle::SC_None;

   388             if (toggle)

   389                 d->click();

   390             return true;

   391         }

   392         break;

   393     }

   394     default:

   395         break;

   396     }

   397     return QWidget::event(e);

   398 }

   399 

   400 /*!\reimp */

   401 void QGroupBox::childEvent(QChildEvent *c)

   402 {

   403     Q_D(QGroupBox);

   404     if (c->type() != QEvent::ChildAdded || !c->child()->isWidgetType())

   405         return;

   406     QWidget *w = (QWidget*)c->child();

   407     if (d->checkable) {

   408         if (d->checked) {

   409             if (!w->testAttribute(Qt::WA_ForceDisabled))

   410                 w->setEnabled(true);

   411         } else {

   412             if (w->isEnabled()) {

   413                 w->setEnabled(false);

   414                 w->setAttribute(Qt::WA_ForceDisabled, false);

   415             }

   416         }

   417     }

   418 }

   419 

   420 

   421 /*!

   422     \internal

   423 

   424     This private slot finds a widget in this group box that can accept

   425     focus, and gives the focus to that widget.

   426 */

   427 

   428 void QGroupBoxPrivate::_q_fixFocus(Qt::FocusReason reason)

   429 {

   430     Q_Q(QGroupBox);

   431     QWidget *fw = q->focusWidget();

   432     if (!fw || fw == q) {

   433         QWidget * best = 0;

   434         QWidget * candidate = 0;

   435         QWidget * w = q;

   436         while ((w = w->nextInFocusChain()) != q) {

   437             if (q->isAncestorOf(w) && (w->focusPolicy() & Qt::TabFocus) == Qt::TabFocus && w->isVisibleTo(q)) {

   438                 if (!best && qobject_cast<QRadioButton*>(w) && ((QRadioButton*)w)->isChecked())

   439                     // we prefer a checked radio button or a widget that

   440                     // already has focus, if there is one

   441                     best = w;

   442                 else

   443                     if (!candidate)

   444                         // but we'll accept anything that takes focus

   445                         candidate = w;

   446             }

   447         }

   448         if (best)

   449             fw = best;

   450         else if (candidate)

   451                 fw = candidate;

   452     }

   453     if (fw)

   454         fw->setFocus(reason);

   455 }

   456 

   457 /*

   458     Sets the right frame rect depending on the title.

   459 */

   460 void QGroupBoxPrivate::calculateFrame()

   461 {

   462     Q_Q(QGroupBox);

   463     QStyleOptionGroupBox box;

   464     q->initStyleOption(&box);

   465     QRect contentsRect = q->style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxContents, q);

   466     q->setContentsMargins(contentsRect.left() - box.rect.left(), contentsRect.top() - box.rect.top(),

   467                           box.rect.right() - contentsRect.right(), box.rect.bottom() - contentsRect.bottom());

   468     setLayoutItemMargins(QStyle::SE_GroupBoxLayoutItem, &box);

   469 }

   470 

   471 /*! \reimp

   472  */

   473 void QGroupBox::focusInEvent(QFocusEvent *fe)

   474 { // note no call to super

   475     Q_D(QGroupBox);

   476     if (focusPolicy() == Qt::NoFocus) {

   477         d->_q_fixFocus(fe->reason());

   478     } else {

   479         QWidget::focusInEvent(fe);

   480     }

   481 }

   482 

   483 

   484 /*!

   485   \reimp

   486 */

   487 QSize QGroupBox::minimumSizeHint() const

   488 {

   489     Q_D(const QGroupBox);

   490     QStyleOptionGroupBox option;

   491     initStyleOption(&option);

   492 

   493     QFontMetrics metrics(fontMetrics());

   494 

   495     int baseWidth = metrics.width(d->title) + metrics.width(QLatin1Char(' '));

   496     int baseHeight = metrics.height();

   497     if (d->checkable) {

   498         baseWidth += style()->pixelMetric(QStyle::PM_IndicatorWidth);

   499         baseWidth += style()->pixelMetric(QStyle::PM_CheckBoxLabelSpacing);

   500         baseHeight = qMax(baseHeight, style()->pixelMetric(QStyle::PM_IndicatorHeight));

   501     }

   502 

   503     QSize size = style()->sizeFromContents(QStyle::CT_GroupBox, &option, QSize(baseWidth, baseHeight), this);

   504     return size.expandedTo(QWidget::minimumSizeHint());

   505 }

   506 

   507 /*!

   508     \property QGroupBox::flat

   509     \brief whether the group box is painted flat or has a frame

   510 

   511     A group box usually consists of a surrounding frame with a title

   512     at the top. If this property is enabled, only the top part of the frame is

   513     drawn in most styles; otherwise the whole frame is drawn.

   514 

   515     By default, this property is disabled; i.e. group boxes are not flat unless

   516     explicitly specified.

   517 

   518     \bold{Note:} In some styles, flat and non-flat group boxes have similar

   519     representations and may not be as distinguishable as they are in other

   520     styles.

   521 

   522     \sa title

   523 */

   524 bool QGroupBox::isFlat() const

   525 {

   526     Q_D(const QGroupBox);

   527     return d->flat;

   528 }

   529 

   530 void QGroupBox::setFlat(bool b)

   531 {

   532     Q_D(QGroupBox);

   533     if (d->flat == b)

   534         return;

   535     d->flat = b;

   536     updateGeometry();

   537     update();

   538 }

   539 

   540 

   541 /*!

   542     \property QGroupBox::checkable

   543     \brief whether the group box has a checkbox in its title

   544 

   545     If this property is true, the group box displays its title using

   546     a checkbox in place of an ordinary label. If the checkbox is checked,

   547     the group box's children are enabled; otherwise they are disabled and

   548     inaccessible.

   549 

   550     By default, group boxes are not checkable.

   551 

   552     If this property is enabled for a group box, it will also be initially

   553     checked to ensure that its contents are enabled.

   554 

   555     \sa checked

   556 */

   557 void QGroupBox::setCheckable(bool checkable)

   558 {

   559     Q_D(QGroupBox);

   560 

   561     bool wasCheckable = d->checkable;

   562     d->checkable = checkable;

   563 

   564     if (checkable) {

   565         setChecked(true);

   566         if (!wasCheckable) {

   567             setFocusPolicy(Qt::StrongFocus);

   568             d->_q_setChildrenEnabled(true);

   569             updateGeometry();

   570         }

   571     } else {

   572         if (wasCheckable) {

   573             setFocusPolicy(Qt::NoFocus);

   574             d->_q_setChildrenEnabled(true);

   575             updateGeometry();

   576         }

   577         d->_q_setChildrenEnabled(true);

   578     }

   579 

   580     if (wasCheckable != checkable) {

   581         d->calculateFrame();

   582         update();

   583     }

   584 }

   585 

   586 bool QGroupBox::isCheckable() const

   587 {

   588     Q_D(const QGroupBox);

   589     return d->checkable;

   590 }

   591 

   592 

   593 bool QGroupBox::isChecked() const

   594 {

   595     Q_D(const QGroupBox);

   596     return d->checkable && d->checked;

   597 }

   598 

   599 

   600 /*!

   601     \fn void QGroupBox::toggled(bool on)

   602 

   603     If the group box is checkable, this signal is emitted when the check box

   604     is toggled. \a on is true if the check box is checked; otherwise it is false.

   605 

   606     \sa checkable

   607 */

   608 

   609 

   610 /*!

   611     \fn void QGroupBox::clicked(bool checked)

   612     \since 4.2

   613 

   614     This signal is emitted when the check box is activated (i.e. pressed down

   615     then released while the mouse cursor is inside the button), or when the

   616     shortcut key is typed, Notably, this signal is \e not emitted if you call

   617     setChecked().

   618 

   619     If the check box is checked \a checked is true; it is false if the check

   620     box is unchecked.

   621 

   622     \sa checkable, toggled(), checked

   623 */

   624 

   625 /*!

   626     \property QGroupBox::checked

   627     \brief whether the group box is checked

   628 

   629     If the group box is checkable, it is displayed with a check box.

   630     If the check box is checked, the group box's children are enabled;

   631     otherwise the children are disabled and are inaccessible to the user.

   632 

   633     By default, checkable group boxes are also checked.

   634 

   635     \sa checkable

   636 */

   637 void QGroupBox::setChecked(bool b)

   638 {

   639     Q_D(QGroupBox);

   640     if (d->checkable && b != d->checked) {

   641         update();

   642         d->checked = b;

   643         d->_q_setChildrenEnabled(b);

   644         emit toggled(b);

   645     }

   646 }

   647 

   648 /*

   649   sets all children of the group box except the qt_groupbox_checkbox

   650   to either disabled/enabled

   651 */

   652 void QGroupBoxPrivate::_q_setChildrenEnabled(bool b)

   653 {

   654     Q_Q(QGroupBox);

   655     QObjectList childList = q->children();

   656     for (int i = 0; i < childList.size(); ++i) {

   657         QObject *o = childList.at(i);

   658         if (o->isWidgetType()) {

   659             QWidget *w = static_cast<QWidget *>(o);

   660             if (b) {

   661                 if (!w->testAttribute(Qt::WA_ForceDisabled))

   662                     w->setEnabled(true);

   663             } else {

   664                 if (w->isEnabled()) {

   665                     w->setEnabled(false);

   666                     w->setAttribute(Qt::WA_ForceDisabled, false);

   667                 }

   668             }

   669         }

   670     }

   671 }

   672 

   673 /*! \reimp */

   674 void QGroupBox::changeEvent(QEvent *ev)

   675 {

   676     Q_D(QGroupBox);

   677     if (ev->type() == QEvent::EnabledChange) {

   678         if (d->checkable && isEnabled()) {

   679             // we are being enabled - disable children

   680             if (!d->checked)

   681                 d->_q_setChildrenEnabled(false);

   682         }

   683     } else if (ev->type() == QEvent::FontChange

   684 #ifdef Q_WS_MAC

   685                || ev->type() == QEvent::MacSizeChange

   686 #endif

   687                || ev->type() == QEvent::StyleChange) {

   688         d->calculateFrame();

   689     }

   690     QWidget::changeEvent(ev);

   691 }

   692 

   693 /*! \reimp */

   694 void QGroupBox::mousePressEvent(QMouseEvent *event)

   695 {

   696     if (event->button() != Qt::LeftButton) {

   697         event->ignore();

   698         return;

   699     }

   700 

   701     Q_D(QGroupBox);

   702     QStyleOptionGroupBox box;

   703     initStyleOption(&box);

   704     d->pressedControl = style()->hitTestComplexControl(QStyle::CC_GroupBox, &box,

   705                                                        event->pos(), this);

   706     if (d->checkable && (d->pressedControl & (QStyle::SC_GroupBoxCheckBox | QStyle::SC_GroupBoxLabel))) {

   707         d->overCheckBox = true;

   708         update(style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxCheckBox, this));

   709     }

   710 }

   711 

   712 /*! \reimp */

   713 void QGroupBox::mouseMoveEvent(QMouseEvent *event)

   714 {

   715     Q_D(QGroupBox);

   716     QStyleOptionGroupBox box;

   717     initStyleOption(&box);

   718     QStyle::SubControl pressed = style()->hitTestComplexControl(QStyle::CC_GroupBox, &box,

   719                                                                 event->pos(), this);

   720     bool oldOverCheckBox = d->overCheckBox;

   721     d->overCheckBox = (pressed == QStyle::SC_GroupBoxCheckBox || pressed == QStyle::SC_GroupBoxLabel);

   722     if (d->checkable && (d->pressedControl == QStyle::SC_GroupBoxCheckBox || d->pressedControl == QStyle::SC_GroupBoxLabel)

   723         && (d->overCheckBox != oldOverCheckBox))

   724         update(style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxCheckBox, this));

   725 }

   726 

   727 /*! \reimp */

   728 void QGroupBox::mouseReleaseEvent(QMouseEvent *event)

   729 {

   730     if (event->button() != Qt::LeftButton) {

   731         event->ignore();

   732         return;

   733     }

   734 

   735     Q_D(QGroupBox);

   736     QStyleOptionGroupBox box;

   737     initStyleOption(&box);

   738     QStyle::SubControl released = style()->hitTestComplexControl(QStyle::CC_GroupBox, &box,

   739                                                                  event->pos(), this);

   740     bool toggle = d->checkable && (released == QStyle::SC_GroupBoxLabel

   741                                    || released == QStyle::SC_GroupBoxCheckBox);

   742     d->pressedControl = QStyle::SC_None;

   743     d->overCheckBox = false;

   744     if (toggle)

   745         d->click();

   746     else if (d->checkable)

   747         update(style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxCheckBox, this));

   748 }

   749 

   750 #ifdef QT3_SUPPORT

   751 /*!

   752     Use one of the constructors that doesn't take the \a name

   753     argument and then use setObjectName() instead.

   754 */

   755 QGroupBox::QGroupBox(QWidget *parent, const char *name)

   756     : QWidget(*new QGroupBoxPrivate, parent, 0)

   757 {

   758     Q_D(QGroupBox);

   759     setObjectName(QString::fromAscii(name));

   760     d->init();

   761 }

   762 

   763 /*!

   764     Use one of the constructors that doesn't take the \a name

   765     argument and then use setObjectName() instead.

   766 */

   767 QGroupBox::QGroupBox(const QString &title, QWidget *parent, const char *name)

   768     : QWidget(*new QGroupBoxPrivate, parent, 0)

   769 {

   770     Q_D(QGroupBox);

   771     setObjectName(QString::fromAscii(name));

   772     d->init();

   773     setTitle(title);

   774 }

   775 #endif // QT3_SUPPORT

   776 

   777 QT_END_NAMESPACE

   778 

   779 #include "moc_qgroupbox.cpp"

   780 

   781 #endif //QT_NO_GROUPBOX