--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/widgets/qcheckbox.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,438 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcheckbox.h"
+#include "qapplication.h"
+#include "qbitmap.h"
+#include "qicon.h"
+#include "qstylepainter.h"
+#include "qstyle.h"
+#include "qstyleoption.h"
+#include "qevent.h"
+
+#include "private/qabstractbutton_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QCheckBoxPrivate : public QAbstractButtonPrivate
+{
+ Q_DECLARE_PUBLIC(QCheckBox)
+public:
+ QCheckBoxPrivate()
+ : QAbstractButtonPrivate(QSizePolicy::CheckBox), tristate(false), noChange(false),
+ hovering(true), publishedState(Qt::Unchecked) {}
+
+ uint tristate : 1;
+ uint noChange : 1;
+ uint hovering : 1;
+ uint publishedState : 2;
+
+ void init();
+};
+
+/*!
+ \class QCheckBox
+ \brief The QCheckBox widget provides a checkbox with a text label.
+
+ \ingroup basicwidgets
+
+
+ A QCheckBox is an option button that can be switched on (checked) or off
+ (unchecked). Checkboxes are typically used to represent features in an
+ application that can be enabled or disabled without affecting others, but
+ different types of behavior can be implemented. For example, a
+ QButtonGroup can be used to group check buttons logically, allowing
+ exclusive checkboxes. However, QButtonGroup does not provide any visual
+ representation.
+
+ The image below further illustrates the differences between exclusive and
+ non-exclusive checkboxes.
+
+ \table
+ \row \o \inlineimage checkboxes-exclusive.png
+ \o \inlineimage checkboxes-non-exclusive.png
+ \endtable
+
+ Whenever a checkbox is checked or cleared it emits the signal
+ stateChanged(). Connect to this signal if you want to trigger an action
+ each time the checkbox changes state. You can use isChecked() to query
+ whether or not a checkbox is checked.
+
+ In addition to the usual checked and unchecked states, QCheckBox optionally
+ provides a third state to indicate "no change". This is useful whenever you
+ need to give the user the option of neither checking nor unchecking a
+ checkbox. If you need this third state, enable it with setTristate(), and
+ use checkState() to query the current toggle state.
+
+ Just like QPushButton, a checkbox displays text, and optionally a small
+ icon. The icon is set with setIcon(). The text can be set in the
+ constructor or with setText(). A shortcut key can be specified by preceding
+ the preferred character with an ampersand. For example:
+
+ \snippet doc/src/snippets/code/src_gui_widgets_qcheckbox.cpp 0
+
+ In this example the shortcut is \e{Alt+A}. See the \l{QShortcut#mnemonic}
+ {QShortcut} documentation for details (to display an actual ampersand,
+ use '&&').
+
+ Important inherited functions: text(), setText(), text(), pixmap(),
+ setPixmap(), accel(), setAccel(), isToggleButton(), setDown(), isDown(),
+ isOn(), checkState(), autoRepeat(), isExclusiveToggle(), group(),
+ setAutoRepeat(), toggle(), pressed(), released(), clicked(), toggled(),
+ checkState(), and stateChanged().
+
+ \table 100%
+ \row
+ \o \inlineimage macintosh-checkbox.png Screenshot of a Macintosh style checkbox
+ \o A checkbox shown in the \l{Macintosh Style Widget Gallery}{Macintosh widget style}.
+ \row
+ \o \inlineimage windows-checkbox.png Screenshot of a Windows XP style checkbox
+ \o A checkbox shown in the \l{Windows XP Style Widget Gallery}{Windows XP widget style}.
+ \row
+ \o \inlineimage plastique-checkbox.png Screenshot of a Plastique style checkbox
+ \o A checkbox shown in the \l{Plastique Style Widget Gallery}{Plastique widget style}.
+ \endtable
+
+ \sa QAbstractButton, QRadioButton, {fowler}{GUI Design Handbook: Check Box}
+*/
+
+/*!
+ \enum QCheckBox::ToggleState
+ \compat
+
+ \value Off Use Qt::Unchecked instead.
+ \value NoChange Use Qt::PartiallyChecked instead.
+ \value On Use Qt::Checked instead.
+*/
+
+/*!
+ \fn void QCheckBox::stateChanged(int state)
+
+ This signal is emitted whenever the check box's state changes, i.e.
+ whenever the user checks or unchecks it.
+
+ \a state contains the check box's new Qt::CheckState.
+*/
+
+/*!
+ \property QCheckBox::tristate
+ \brief whether the checkbox is a tri-state checkbox
+
+ The default is false; i.e. the checkbox has only two states.
+*/
+
+void QCheckBoxPrivate::init()
+{
+ Q_Q(QCheckBox);
+ q->setCheckable(true);
+ q->setMouseTracking(true);
+ q->setForegroundRole(QPalette::WindowText);
+ setLayoutItemMargins(QStyle::SE_CheckBoxLayoutItem);
+}
+
+/*!
+ Initializes \a option with the values from this QCheckBox. This method is
+ useful for subclasses that require a QStyleOptionButton, but do not want
+ to fill in all the information themselves.
+
+ \sa QStyleOption::initFrom()
+*/
+void QCheckBox::initStyleOption(QStyleOptionButton *option) const
+{
+ if (!option)
+ return;
+ Q_D(const QCheckBox);
+ option->initFrom(this);
+ if (d->down)
+ option->state |= QStyle::State_Sunken;
+ if (d->tristate && d->noChange)
+ option->state |= QStyle::State_NoChange;
+ else
+ option->state |= d->checked ? QStyle::State_On : QStyle::State_Off;
+ if (testAttribute(Qt::WA_Hover) && underMouse()) {
+ if (d->hovering)
+ option->state |= QStyle::State_MouseOver;
+ else
+ option->state &= ~QStyle::State_MouseOver;
+ }
+ option->text = d->text;
+ option->icon = d->icon;
+ option->iconSize = iconSize();
+}
+
+/*!
+ Constructs a checkbox with the given \a parent, but with no text.
+
+ \a parent is passed on to the QAbstractButton constructor.
+*/
+
+QCheckBox::QCheckBox(QWidget *parent)
+ : QAbstractButton (*new QCheckBoxPrivate, parent)
+{
+ Q_D(QCheckBox);
+ d->init();
+}
+
+/*!
+ Constructs a checkbox with the given \a parent and \a text.
+
+ \a parent is passed on to the QAbstractButton constructor.
+*/
+
+QCheckBox::QCheckBox(const QString &text, QWidget *parent)
+ : QAbstractButton (*new QCheckBoxPrivate, parent)
+{
+ Q_D(QCheckBox);
+ d->init();
+ setText(text);
+}
+
+void QCheckBox::setTristate(bool y)
+{
+ Q_D(QCheckBox);
+ d->tristate = y;
+}
+
+bool QCheckBox::isTristate() const
+{
+ Q_D(const QCheckBox);
+ return d->tristate;
+}
+
+
+/*!
+ Returns the check box's check state. If you do not need tristate support,
+ you can also use \l QAbstractButton::isChecked() which returns a boolean.
+
+ \sa setCheckState() Qt::CheckState
+*/
+Qt::CheckState QCheckBox::checkState() const
+{
+ Q_D(const QCheckBox);
+ if (d->tristate && d->noChange)
+ return Qt::PartiallyChecked;
+ return d->checked ? Qt::Checked : Qt::Unchecked;
+}
+
+/*!
+ Sets the check box's check state to \a state. If you do not need tristate
+ support, you can also use \l QAbstractButton::setChecked() which takes a
+ boolean.
+
+ \sa checkState() Qt::CheckState
+*/
+void QCheckBox::setCheckState(Qt::CheckState state)
+{
+ Q_D(QCheckBox);
+ if (state == Qt::PartiallyChecked) {
+ d->tristate = true;
+ d->noChange = true;
+ } else {
+ d->noChange = false;
+ }
+ d->blockRefresh = true;
+ setChecked(state != Qt::Unchecked);
+ d->blockRefresh = false;
+ d->refresh();
+ if ((uint)state != d->publishedState) {
+ d->publishedState = state;
+ emit stateChanged(state);
+ }
+}
+
+
+/*!
+ \reimp
+*/
+QSize QCheckBox::sizeHint() const
+{
+ Q_D(const QCheckBox);
+ if (d->sizeHint.isValid())
+ return d->sizeHint;
+ ensurePolished();
+ QFontMetrics fm = fontMetrics();
+ QStyleOptionButton opt;
+ initStyleOption(&opt);
+ QSize sz = style()->itemTextRect(fm, QRect(0, 0, 1, 1), Qt::TextShowMnemonic, false,
+ text()).size();
+ if (!opt.icon.isNull())
+ sz = QSize(sz.width() + opt.iconSize.width() + 4, qMax(sz.height(), opt.iconSize.height()));
+ d->sizeHint = (style()->sizeFromContents(QStyle::CT_CheckBox, &opt, sz, this)
+ .expandedTo(QApplication::globalStrut()));
+ return d->sizeHint;
+}
+
+/*!
+ \reimp
+*/
+void QCheckBox::paintEvent(QPaintEvent *)
+{
+ QStylePainter p(this);
+ QStyleOptionButton opt;
+ initStyleOption(&opt);
+ p.drawControl(QStyle::CE_CheckBox, opt);
+}
+
+/*!
+ \reimp
+*/
+void QCheckBox::mouseMoveEvent(QMouseEvent *e)
+{
+ Q_D(QCheckBox);
+ if (testAttribute(Qt::WA_Hover)) {
+ bool hit = false;
+ if (underMouse())
+ hit = hitButton(e->pos());
+
+ if (hit != d->hovering) {
+ update(rect());
+ d->hovering = hit;
+ }
+ }
+
+ QAbstractButton::mouseMoveEvent(e);
+}
+
+
+/*!
+ \reimp
+*/
+bool QCheckBox::hitButton(const QPoint &pos) const
+{
+ QStyleOptionButton opt;
+ initStyleOption(&opt);
+ return style()->subElementRect(QStyle::SE_CheckBoxClickRect, &opt, this).contains(pos);
+}
+
+/*!
+ \reimp
+*/
+void QCheckBox::checkStateSet()
+{
+ Q_D(QCheckBox);
+ d->noChange = false;
+ Qt::CheckState state = checkState();
+ if ((uint)state != d->publishedState) {
+ d->publishedState = state;
+ emit stateChanged(state);
+ }
+}
+
+/*!
+ \reimp
+*/
+void QCheckBox::nextCheckState()
+{
+ Q_D(QCheckBox);
+ if (d->tristate)
+ setCheckState((Qt::CheckState)((checkState() + 1) % 3));
+ else {
+ QAbstractButton::nextCheckState();
+ QCheckBox::checkStateSet();
+ }
+}
+
+/*!
+ \reimp
+*/
+bool QCheckBox::event(QEvent *e)
+{
+ Q_D(QCheckBox);
+ if (e->type() == QEvent::StyleChange
+#ifdef Q_WS_MAC
+ || e->type() == QEvent::MacSizeChange
+#endif
+ )
+ d->setLayoutItemMargins(QStyle::SE_CheckBoxLayoutItem);
+ return QAbstractButton::event(e);
+}
+
+#ifdef QT3_SUPPORT
+/*!
+ Use one of the constructors that doesn't take the \a name
+ argument and then use setObjectName() instead.
+*/
+QCheckBox::QCheckBox(QWidget *parent, const char* name)
+ : QAbstractButton (*new QCheckBoxPrivate, parent)
+{
+ Q_D(QCheckBox);
+ setObjectName(QString::fromAscii(name));
+ d->init();
+}
+
+/*!
+ Use one of the constructors that doesn't take the \a name
+ argument and then use setObjectName() instead.
+*/
+QCheckBox::QCheckBox(const QString &text, QWidget *parent, const char* name)
+ : QAbstractButton (*new QCheckBoxPrivate, parent)
+{
+ Q_D(QCheckBox);
+ setObjectName(QString::fromAscii(name));
+ d->init();
+ setText(text);
+}
+
+#endif
+
+
+/*!
+ \fn void QCheckBox::setNoChange()
+ \compat
+
+ Use setCheckState() instead.
+*/
+
+/*!
+ \fn void QCheckBox::setState(ToggleState state)
+ \compat
+
+ Use setCheckState() instead.
+*/
+
+/*!
+ \fn QCheckBox::ToggleState QCheckBox::state() const
+ \compat
+
+ Use checkState() instead.
+*/
+
+QT_END_NAMESPACE