/**************************************************************************** | |
** | |
** Copyright (C) 2011 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$ | |
** GNU Lesser General Public License Usage | |
** 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. | |
** | |
** GNU General Public License Usage | |
** Alternatively, this file may be used under the terms of the GNU General | |
** Public License version 3.0 as published by the Free Software Foundation | |
** and appearing in the file LICENSE.GPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU General | |
** Public License version 3.0 requirements will be met: | |
** http://www.gnu.org/copyleft/gpl.html. | |
** | |
** Other Usage | |
** Alternatively, this file may be used in accordance with the terms and | |
** conditions contained in a signed written agreement between you and Nokia. | |
** | |
** | |
** | |
** | |
** | |
** $QT_END_LICENSE$ | |
** | |
****************************************************************************/ | |
#include "qtoolbox.h" | |
#ifndef QT_NO_TOOLBOX | |
#include <qapplication.h> | |
#include <qeventloop.h> | |
#include <qlayout.h> | |
#include <qlist.h> | |
#include <qpainter.h> | |
#include <qscrollarea.h> | |
#include <qstyle.h> | |
#include <qstyleoption.h> | |
#include <qtooltip.h> | |
#include <qabstractbutton.h> | |
#include "qframe_p.h" | |
QT_BEGIN_NAMESPACE | |
class QToolBoxButton : public QAbstractButton | |
{ | |
Q_OBJECT | |
public: | |
QToolBoxButton(QWidget *parent) | |
: QAbstractButton(parent), selected(false), indexInPage(-1) | |
{ | |
setBackgroundRole(QPalette::Window); | |
setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum); | |
setFocusPolicy(Qt::NoFocus); | |
} | |
inline void setSelected(bool b) { selected = b; update(); } | |
inline void setIndex(int newIndex) { indexInPage = newIndex; } | |
QSize sizeHint() const; | |
QSize minimumSizeHint() const; | |
protected: | |
void initStyleOption(QStyleOptionToolBox *opt) const; | |
void paintEvent(QPaintEvent *); | |
private: | |
bool selected; | |
int indexInPage; | |
}; | |
class QToolBoxPrivate : public QFramePrivate | |
{ | |
Q_DECLARE_PUBLIC(QToolBox) | |
public: | |
struct Page | |
{ | |
QToolBoxButton *button; | |
QScrollArea *sv; | |
QWidget *widget; | |
inline void setText(const QString &text) { button->setText(text); } | |
inline void setIcon(const QIcon &is) { button->setIcon(is); } | |
#ifndef QT_NO_TOOLTIP | |
inline void setToolTip(const QString &tip) { button->setToolTip(tip); } | |
inline QString toolTip() const { return button->toolTip(); } | |
#endif | |
inline QString text() const { return button->text(); } | |
inline QIcon icon() const { return button->icon(); } | |
inline bool operator==(const Page& other) const | |
{ | |
return widget == other.widget; | |
} | |
}; | |
typedef QList<Page> PageList; | |
inline QToolBoxPrivate() | |
: currentPage(0) | |
{ | |
} | |
void _q_buttonClicked(); | |
void _q_widgetDestroyed(QObject*); | |
Page *page(QWidget *widget) const; | |
const Page *page(int index) const; | |
Page *page(int index); | |
void updateTabs(); | |
void relayout(); | |
PageList pageList; | |
QVBoxLayout *layout; | |
Page *currentPage; | |
}; | |
QToolBoxPrivate::Page *QToolBoxPrivate::page(QWidget *widget) const | |
{ | |
if (!widget) | |
return 0; | |
for (PageList::ConstIterator i = pageList.constBegin(); i != pageList.constEnd(); ++i) | |
if ((*i).widget == widget) | |
return (Page*) &(*i); | |
return 0; | |
} | |
QToolBoxPrivate::Page *QToolBoxPrivate::page(int index) | |
{ | |
if (index >= 0 && index < pageList.size()) | |
return &pageList[index]; | |
return 0; | |
} | |
const QToolBoxPrivate::Page *QToolBoxPrivate::page(int index) const | |
{ | |
if (index >= 0 && index < pageList.size()) | |
return &pageList.at(index); | |
return 0; | |
} | |
void QToolBoxPrivate::updateTabs() | |
{ | |
QToolBoxButton *lastButton = currentPage ? currentPage->button : 0; | |
bool after = false; | |
int index = 0; | |
for (index = 0; index < pageList.count(); ++index) { | |
const Page &page = pageList.at(index); | |
QToolBoxButton *tB = page.button; | |
// update indexes, since the updates are delayed, the indexes will be correct | |
// when we actually paint. | |
tB->setIndex(index); | |
QWidget *tW = page.widget; | |
if (after) { | |
QPalette p = tB->palette(); | |
p.setColor(tB->backgroundRole(), tW->palette().color(tW->backgroundRole())); | |
tB->setPalette(p); | |
tB->update(); | |
} else if (tB->backgroundRole() != QPalette::Window) { | |
tB->setBackgroundRole(QPalette::Window); | |
tB->update(); | |
} | |
after = tB == lastButton; | |
} | |
} | |
QSize QToolBoxButton::sizeHint() const | |
{ | |
QSize iconSize(8, 8); | |
if (!icon().isNull()) { | |
int icone = style()->pixelMetric(QStyle::PM_SmallIconSize, 0, parentWidget() /* QToolBox */); | |
iconSize += QSize(icone + 2, icone); | |
} | |
QSize textSize = fontMetrics().size(Qt::TextShowMnemonic, text()) + QSize(0, 8); | |
QSize total(iconSize.width() + textSize.width(), qMax(iconSize.height(), textSize.height())); | |
return total.expandedTo(QApplication::globalStrut()); | |
} | |
QSize QToolBoxButton::minimumSizeHint() const | |
{ | |
if (icon().isNull()) | |
return QSize(); | |
int icone = style()->pixelMetric(QStyle::PM_SmallIconSize, 0, parentWidget() /* QToolBox */); | |
return QSize(icone + 8, icone + 8); | |
} | |
void QToolBoxButton::initStyleOption(QStyleOptionToolBox *option) const | |
{ | |
if (!option) | |
return; | |
option->initFrom(this); | |
if (selected) | |
option->state |= QStyle::State_Selected; | |
if (isDown()) | |
option->state |= QStyle::State_Sunken; | |
option->text = text(); | |
option->icon = icon(); | |
if (QStyleOptionToolBoxV2 *optionV2 = qstyleoption_cast<QStyleOptionToolBoxV2 *>(option)) { | |
QToolBox *toolBox = static_cast<QToolBox *>(parentWidget()); // I know I'm in a tool box. | |
int widgetCount = toolBox->count(); | |
int currIndex = toolBox->currentIndex(); | |
if (widgetCount == 1) { | |
optionV2->position = QStyleOptionToolBoxV2::OnlyOneTab; | |
} else if (indexInPage == 0) { | |
optionV2->position = QStyleOptionToolBoxV2::Beginning; | |
} else if (indexInPage == widgetCount - 1) { | |
optionV2->position = QStyleOptionToolBoxV2::End; | |
} else { | |
optionV2->position = QStyleOptionToolBoxV2::Middle; | |
} | |
if (currIndex == indexInPage - 1) { | |
optionV2->selectedPosition = QStyleOptionToolBoxV2::PreviousIsSelected; | |
} else if (currIndex == indexInPage + 1) { | |
optionV2->selectedPosition = QStyleOptionToolBoxV2::NextIsSelected; | |
} else { | |
optionV2->selectedPosition = QStyleOptionToolBoxV2::NotAdjacent; | |
} | |
} | |
} | |
void QToolBoxButton::paintEvent(QPaintEvent *) | |
{ | |
QPainter paint(this); | |
QString text = QAbstractButton::text(); | |
QPainter *p = &paint; | |
QStyleOptionToolBoxV2 opt; | |
initStyleOption(&opt); | |
style()->drawControl(QStyle::CE_ToolBoxTab, &opt, p, parentWidget()); | |
} | |
/*! | |
\class QToolBox | |
\brief The QToolBox class provides a column of tabbed widget items. | |
\ingroup basicwidgets | |
A toolbox is a widget that displays a column of tabs one above the | |
other, with the current item displayed below the current tab. | |
Every tab has an index position within the column of tabs. A tab's | |
item is a QWidget. | |
Each item has an itemText(), an optional itemIcon(), an optional | |
itemToolTip(), and a widget(). The item's attributes can be | |
changed with setItemText(), setItemIcon(), and | |
setItemToolTip(). Each item can be enabled or disabled | |
individually with setItemEnabled(). | |
Items are added using addItem(), or inserted at particular | |
positions using insertItem(). The total number of items is given | |
by count(). Items can be deleted with delete, or removed from the | |
toolbox with removeItem(). Combining removeItem() and insertItem() | |
allows you to move items to different positions. | |
The index of the current item widget is returned by currentIndex(), | |
and set with setCurrentIndex(). The index of a particular item can | |
be found using indexOf(), and the item at a given index is returned | |
by item(). | |
The currentChanged() signal is emitted when the current item is | |
changed. | |
\sa QTabWidget | |
*/ | |
/*! | |
\fn void QToolBox::currentChanged(int index) | |
This signal is emitted when the current item is changed. The new | |
current item's index is passed in \a index, or -1 if there is no | |
current item. | |
*/ | |
#ifdef QT3_SUPPORT | |
/*! | |
Constructs a toolbox called \a name with parent \a parent and flags \a f. | |
*/ | |
QToolBox::QToolBox(QWidget *parent, const char *name, Qt::WindowFlags f) | |
: QFrame(*new QToolBoxPrivate, parent, f) | |
{ | |
Q_D(QToolBox); | |
setObjectName(QString::fromAscii(name)); | |
d->layout = new QVBoxLayout(this); | |
d->layout->setMargin(0); | |
setBackgroundRole(QPalette::Button); | |
} | |
#endif | |
/*! | |
Constructs a new toolbox with the given \a parent and the flags, \a f. | |
*/ | |
QToolBox::QToolBox(QWidget *parent, Qt::WindowFlags f) | |
: QFrame(*new QToolBoxPrivate, parent, f) | |
{ | |
Q_D(QToolBox); | |
d->layout = new QVBoxLayout(this); | |
d->layout->setMargin(0); | |
setBackgroundRole(QPalette::Button); | |
} | |
/*! | |
Destroys the toolbox. | |
*/ | |
QToolBox::~QToolBox() | |
{ | |
} | |
/*! | |
\fn int QToolBox::addItem(QWidget *w, const QString &text) | |
\overload | |
Adds the widget \a w in a new tab at bottom of the toolbox. The | |
new tab's text is set to \a text. Returns the new tab's index. | |
*/ | |
/*! | |
\fn int QToolBox::addItem(QWidget *widget, const QIcon &iconSet,const QString &text) | |
Adds the \a widget in a new tab at bottom of the toolbox. The | |
new tab's text is set to \a text, and the \a iconSet is | |
displayed to the left of the \a text. Returns the new tab's index. | |
*/ | |
/*! | |
\fn int QToolBox::insertItem(int index, QWidget *widget, const QString &text) | |
\overload | |
Inserts the \a widget at position \a index, or at the bottom | |
of the toolbox if \a index is out of range. The new item's text is | |
set to \a text. Returns the new item's index. | |
*/ | |
/*! | |
Inserts the \a widget at position \a index, or at the bottom | |
of the toolbox if \a index is out of range. The new item's text | |
is set to \a text, and the \a icon is displayed to the left of | |
the \a text. Returns the new item's index. | |
*/ | |
int QToolBox::insertItem(int index, QWidget *widget, const QIcon &icon, const QString &text) | |
{ | |
if (!widget) | |
return -1; | |
Q_D(QToolBox); | |
connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(_q_widgetDestroyed(QObject*))); | |
QToolBoxPrivate::Page c; | |
c.widget = widget; | |
c.button = new QToolBoxButton(this); | |
c.button->setObjectName(QLatin1String("qt_toolbox_toolboxbutton")); | |
connect(c.button, SIGNAL(clicked()), this, SLOT(_q_buttonClicked())); | |
c.sv = new QScrollArea(this); | |
c.sv->setWidget(widget); | |
c.sv->setWidgetResizable(true); | |
c.sv->hide(); | |
c.sv->setFrameStyle(QFrame::NoFrame); | |
c.setText(text); | |
c.setIcon(icon); | |
if (index < 0 || index >= (int)d->pageList.count()) { | |
index = d->pageList.count(); | |
d->pageList.append(c); | |
d->layout->addWidget(c.button); | |
d->layout->addWidget(c.sv); | |
if (index == 0) | |
setCurrentIndex(index); | |
} else { | |
d->pageList.insert(index, c); | |
d->relayout(); | |
if (d->currentPage) { | |
QWidget *current = d->currentPage->widget; | |
int oldindex = indexOf(current); | |
if (index <= oldindex) { | |
d->currentPage = 0; // trigger change | |
setCurrentIndex(oldindex); | |
} | |
} | |
} | |
c.button->show(); | |
d->updateTabs(); | |
itemInserted(index); | |
return index; | |
} | |
void QToolBoxPrivate::_q_buttonClicked() | |
{ | |
Q_Q(QToolBox); | |
QToolBoxButton *tb = qobject_cast<QToolBoxButton*>(q->sender()); | |
QWidget* item = 0; | |
for (QToolBoxPrivate::PageList::ConstIterator i = pageList.constBegin(); i != pageList.constEnd(); ++i) | |
if ((*i).button == tb) { | |
item = (*i).widget; | |
break; | |
} | |
q->setCurrentIndex(q->indexOf(item)); | |
} | |
/*! | |
\property QToolBox::count | |
\brief The number of items contained in the toolbox. | |
By default, this property has a value of 0. | |
*/ | |
int QToolBox::count() const | |
{ | |
Q_D(const QToolBox); | |
return d->pageList.count(); | |
} | |
void QToolBox::setCurrentIndex(int index) | |
{ | |
Q_D(QToolBox); | |
QToolBoxPrivate::Page *c = d->page(index); | |
if (!c || d->currentPage == c) | |
return; | |
c->button->setSelected(true); | |
if (d->currentPage) { | |
d->currentPage->sv->hide(); | |
d->currentPage->button->setSelected(false); | |
} | |
d->currentPage = c; | |
d->currentPage->sv->show(); | |
d->updateTabs(); | |
emit currentChanged(index); | |
} | |
void QToolBoxPrivate::relayout() | |
{ | |
Q_Q(QToolBox); | |
delete layout; | |
layout = new QVBoxLayout(q); | |
layout->setMargin(0); | |
for (QToolBoxPrivate::PageList::ConstIterator i = pageList.constBegin(); i != pageList.constEnd(); ++i) { | |
layout->addWidget((*i).button); | |
layout->addWidget((*i).sv); | |
} | |
} | |
void QToolBoxPrivate::_q_widgetDestroyed(QObject *object) | |
{ | |
Q_Q(QToolBox); | |
// no verification - vtbl corrupted already | |
QWidget *p = (QWidget*)object; | |
QToolBoxPrivate::Page *c = page(p); | |
if (!p || !c) | |
return; | |
layout->removeWidget(c->sv); | |
layout->removeWidget(c->button); | |
c->sv->deleteLater(); // page might still be a child of sv | |
delete c->button; | |
bool removeCurrent = c == currentPage; | |
pageList.removeAll(*c); | |
if (!pageList.count()) { | |
currentPage = 0; | |
emit q->currentChanged(-1); | |
} else if (removeCurrent) { | |
currentPage = 0; | |
q->setCurrentIndex(0); | |
} | |
} | |
/*! | |
Removes the item at position \a index from the toolbox. Note that | |
the widget is \e not deleted. | |
*/ | |
void QToolBox::removeItem(int index) | |
{ | |
Q_D(QToolBox); | |
if (QWidget *w = widget(index)) { | |
disconnect(w, SIGNAL(destroyed(QObject*)), this, SLOT(_q_widgetDestroyed(QObject*))); | |
w->setParent(this); | |
// destroy internal data | |
d->_q_widgetDestroyed(w); | |
itemRemoved(index); | |
} | |
} | |
/*! | |
\property QToolBox::currentIndex | |
\brief the index of the current item | |
By default, for an empty toolbox, this property has a value of -1. | |
\sa indexOf(), widget() | |
*/ | |
int QToolBox::currentIndex() const | |
{ | |
Q_D(const QToolBox); | |
return d->currentPage ? indexOf(d->currentPage->widget) : -1; | |
} | |
/*! | |
Returns a pointer to the current widget, or 0 if there is no such item. | |
\sa currentIndex(), setCurrentWidget() | |
*/ | |
QWidget * QToolBox::currentWidget() const | |
{ | |
Q_D(const QToolBox); | |
return d->currentPage ? d->currentPage->widget : 0; | |
} | |
/*! | |
Makes\a widget the current widget. The \a widget must be an item in this tool box. | |
\sa addItem(), setCurrentIndex(), currentWidget() | |
*/ | |
void QToolBox::setCurrentWidget(QWidget *widget) | |
{ | |
int i = indexOf(widget); | |
if (i >= 0) | |
setCurrentIndex(i); | |
else | |
qWarning("QToolBox::setCurrentWidget: widget not contained in tool box"); | |
} | |
/*! | |
Returns the widget at position \a index, or 0 if there is no such | |
item. | |
*/ | |
QWidget *QToolBox::widget(int index) const | |
{ | |
Q_D(const QToolBox); | |
if (index < 0 || index >= (int) d->pageList.size()) | |
return 0; | |
return d->pageList.at(index).widget; | |
} | |
/*! | |
Returns the index of \a widget, or -1 if the item does not | |
exist. | |
*/ | |
int QToolBox::indexOf(QWidget *widget) const | |
{ | |
Q_D(const QToolBox); | |
QToolBoxPrivate::Page *c = (widget ? d->page(widget) : 0); | |
return c ? d->pageList.indexOf(*c) : -1; | |
} | |
/*! | |
If \a enabled is true then the item at position \a index is enabled; otherwise | |
the item at position \a index is disabled. | |
*/ | |
void QToolBox::setItemEnabled(int index, bool enabled) | |
{ | |
Q_D(QToolBox); | |
QToolBoxPrivate::Page *c = d->page(index); | |
if (!c) | |
return; | |
c->button->setEnabled(enabled); | |
if (!enabled && c == d->currentPage) { | |
int curIndexUp = index; | |
int curIndexDown = curIndexUp; | |
const int count = d->pageList.count(); | |
while (curIndexUp > 0 || curIndexDown < count-1) { | |
if (curIndexDown < count-1) { | |
if (d->page(++curIndexDown)->button->isEnabled()) { | |
index = curIndexDown; | |
break; | |
} | |
} | |
if (curIndexUp > 0) { | |
if (d->page(--curIndexUp)->button->isEnabled()) { | |
index = curIndexUp; | |
break; | |
} | |
} | |
} | |
setCurrentIndex(index); | |
} | |
} | |
/*! | |
Sets the text of the item at position \a index to \a text. | |
If the provided text contains an ampersand character ('&'), a | |
mnemonic is automatically created for it. The character that | |
follows the '&' will be used as the shortcut key. Any previous | |
mnemonic will be overwritten, or cleared if no mnemonic is defined | |
by the text. See the \l {QShortcut#mnemonic}{QShortcut} | |
documentation for details (to display an actual ampersand, use | |
'&&'). | |
*/ | |
void QToolBox::setItemText(int index, const QString &text) | |
{ | |
Q_D(QToolBox); | |
QToolBoxPrivate::Page *c = d->page(index); | |
if (c) | |
c->setText(text); | |
} | |
/*! | |
Sets the icon of the item at position \a index to \a icon. | |
*/ | |
void QToolBox::setItemIcon(int index, const QIcon &icon) | |
{ | |
Q_D(QToolBox); | |
QToolBoxPrivate::Page *c = d->page(index); | |
if (c) | |
c->setIcon(icon); | |
} | |
#ifndef QT_NO_TOOLTIP | |
/*! | |
Sets the tooltip of the item at position \a index to \a toolTip. | |
*/ | |
void QToolBox::setItemToolTip(int index, const QString &toolTip) | |
{ | |
Q_D(QToolBox); | |
QToolBoxPrivate::Page *c = d->page(index); | |
if (c) | |
c->setToolTip(toolTip); | |
} | |
#endif // QT_NO_TOOLTIP | |
/*! | |
Returns true if the item at position \a index is enabled; otherwise returns false. | |
*/ | |
bool QToolBox::isItemEnabled(int index) const | |
{ | |
Q_D(const QToolBox); | |
const QToolBoxPrivate::Page *c = d->page(index); | |
return c && c->button->isEnabled(); | |
} | |
/*! | |
Returns the text of the item at position \a index, or an empty string if | |
\a index is out of range. | |
*/ | |
QString QToolBox::itemText(int index) const | |
{ | |
Q_D(const QToolBox); | |
const QToolBoxPrivate::Page *c = d->page(index); | |
return (c ? c->text() : QString()); | |
} | |
/*! | |
Returns the icon of the item at position \a index, or a null | |
icon if \a index is out of range. | |
*/ | |
QIcon QToolBox::itemIcon(int index) const | |
{ | |
Q_D(const QToolBox); | |
const QToolBoxPrivate::Page *c = d->page(index); | |
return (c ? c->icon() : QIcon()); | |
} | |
#ifndef QT_NO_TOOLTIP | |
/*! | |
Returns the tooltip of the item at position \a index, or an | |
empty string if \a index is out of range. | |
*/ | |
QString QToolBox::itemToolTip(int index) const | |
{ | |
Q_D(const QToolBox); | |
const QToolBoxPrivate::Page *c = d->page(index); | |
return (c ? c->toolTip() : QString()); | |
} | |
#endif // QT_NO_TOOLTIP | |
/*! \reimp */ | |
void QToolBox::showEvent(QShowEvent *e) | |
{ | |
QWidget::showEvent(e); | |
} | |
/*! \reimp */ | |
void QToolBox::changeEvent(QEvent *ev) | |
{ | |
Q_D(QToolBox); | |
if(ev->type() == QEvent::StyleChange) | |
d->updateTabs(); | |
QFrame::changeEvent(ev); | |
} | |
/*! | |
This virtual handler is called after a new item was added or | |
inserted at position \a index. | |
\sa itemRemoved() | |
*/ | |
void QToolBox::itemInserted(int index) | |
{ | |
Q_UNUSED(index) | |
} | |
/*! | |
This virtual handler is called after an item was removed from | |
position \a index. | |
\sa itemInserted() | |
*/ | |
void QToolBox::itemRemoved(int index) | |
{ | |
Q_UNUSED(index) | |
} | |
/*! | |
\fn void QToolBox::setItemLabel(int index, const QString &text) | |
Use setItemText() instead. | |
*/ | |
/*! | |
\fn QString QToolBox::itemLabel(int index) const | |
Use itemText() instead. | |
*/ | |
/*! | |
\fn QWidget *QToolBox::currentItem() const | |
Use widget(currentIndex()) instead. | |
*/ | |
/*! | |
\fn void QToolBox::setCurrentItem(QWidget *widget) | |
Use setCurrentIndex(indexOf(widget)) instead. | |
*/ | |
/*! | |
\fn void QToolBox::setItemIconSet(int index, const QIcon &icon) | |
Use setItemIcon() instead. | |
*/ | |
/*! | |
\fn QIcon QToolBox::itemIconSet(int index) const | |
Use itemIcon() instead. | |
*/ | |
/*! | |
\fn int QToolBox::removeItem(QWidget *widget) | |
Use toolbox->removeItem(toolbox->indexOf(widget)) instead. | |
*/ | |
/*! | |
\fn QWidget *QToolBox::item(int index) const | |
Use widget() instead. | |
*/ | |
/*! | |
\fn void QToolBox::setMargin(int margin) | |
Sets the width of the margin around the contents of the widget to \a margin. | |
Use QWidget::setContentsMargins() instead. | |
\sa margin(), QWidget::setContentsMargins() | |
*/ | |
/*! | |
\fn int QToolBox::margin() const | |
Returns the width of the margin around the contents of the widget. | |
Use QWidget::getContentsMargins() instead. | |
\sa setMargin(), QWidget::getContentsMargins() | |
*/ | |
/*! \reimp */ | |
bool QToolBox::event(QEvent *e) | |
{ | |
return QFrame::event(e); | |
} | |
QT_END_NAMESPACE | |
#include "moc_qtoolbox.cpp" | |
#include "qtoolbox.moc" | |
#endif //QT_NO_TOOLBOX |