/****************************************************************************
**
** Copyright (C) 2010 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 "qcombobox.h"
#ifndef QT_NO_COMBOBOX
#include <qstylepainter.h>
#include <qlineedit.h>
#include <qapplication.h>
#include <qdesktopwidget.h>
#include <qlistview.h>
#include <qtableview.h>
#include <qitemdelegate.h>
#include <qmap.h>
#include <qmenu.h>
#include <qevent.h>
#include <qlayout.h>
#include <qscrollbar.h>
#include <qtreeview.h>
#include <qheaderview.h>
#ifndef QT_NO_IM
#include "qinputcontext.h"
#endif
#include <private/qapplication_p.h>
#include <private/qcombobox_p.h>
#include <private/qabstractitemmodel_p.h>
#include <private/qabstractscrollarea_p.h>
#include <private/qsoftkeymanager_p.h>
#include <qdebug.h>
#ifdef Q_WS_X11
#include <private/qt_x11_p.h>
#endif
#if defined(Q_WS_MAC) && !defined(QT_NO_EFFECTS) && !defined(QT_NO_STYLE_MAC)
#include <private/qcore_mac_p.h>
#include <QMacStyle>
#include <private/qt_cocoa_helpers_mac_p.h>
#endif
#ifndef QT_NO_EFFECTS
# include <private/qeffects_p.h>
#endif
QT_BEGIN_NAMESPACE
QComboBoxPrivate::QComboBoxPrivate()
: QWidgetPrivate(),
model(0),
lineEdit(0),
container(0),
insertPolicy(QComboBox::InsertAtBottom),
sizeAdjustPolicy(QComboBox::AdjustToContentsOnFirstShow),
minimumContentsLength(0),
shownOnce(false),
autoCompletion(true),
duplicatesEnabled(false),
frame(true),
maxVisibleItems(10),
maxCount(INT_MAX),
modelColumn(0),
inserting(false),
arrowState(QStyle::State_None),
hoverControl(QStyle::SC_None),
autoCompletionCaseSensitivity(Qt::CaseInsensitive),
indexBeforeChange(-1)
#ifndef QT_NO_COMPLETER
, completer(0)
#endif
{
}
QStyleOptionMenuItem QComboMenuDelegate::getStyleOption(const QStyleOptionViewItem &option,
const QModelIndex &index) const
{
QStyleOptionMenuItem menuOption;
menuOption.palette = option.palette.resolve(QApplication::palette("QMenu"));
menuOption.state = QStyle::State_None;
if (mCombo->window()->isActiveWindow())
menuOption.state = QStyle::State_Active;
if ((option.state & QStyle::State_Enabled) && (index.model()->flags(index) & Qt::ItemIsEnabled))
menuOption.state |= QStyle::State_Enabled;
else
menuOption.palette.setCurrentColorGroup(QPalette::Disabled);
if (option.state & QStyle::State_Selected)
menuOption.state |= QStyle::State_Selected;
menuOption.checkType = QStyleOptionMenuItem::NonExclusive;
menuOption.checked = mCombo->currentIndex() == index.row();
if (QComboBoxDelegate::isSeparator(index))
menuOption.menuItemType = QStyleOptionMenuItem::Separator;
else
menuOption.menuItemType = QStyleOptionMenuItem::Normal;
QVariant variant = index.model()->data(index, Qt::DecorationRole);
switch (variant.type()) {
case QVariant::Icon:
menuOption.icon = qvariant_cast<QIcon>(variant);
break;
case QVariant::Color: {
static QPixmap pixmap(option.decorationSize);
pixmap.fill(qvariant_cast<QColor>(variant));
menuOption.icon = pixmap;
break; }
default:
menuOption.icon = qvariant_cast<QPixmap>(variant);
break;
}
menuOption.text = index.model()->data(index, Qt::DisplayRole).toString()
.replace(QLatin1Char('&'), QLatin1String("&&"));
menuOption.tabWidth = 0;
menuOption.maxIconWidth = option.decorationSize.width() + 4;
menuOption.menuRect = option.rect;
menuOption.rect = option.rect;
// Make sure fonts set on the combo box also overrides the font for the popup menu.
if (mCombo->testAttribute(Qt::WA_SetFont)
|| mCombo->testAttribute(Qt::WA_MacSmallSize)
|| mCombo->testAttribute(Qt::WA_MacMiniSize)
|| mCombo->font() != qt_app_fonts_hash()->value("QComboBox", QFont()))
menuOption.font = mCombo->font();
else
menuOption.font = qt_app_fonts_hash()->value("QComboMenuItem", mCombo->font());
menuOption.fontMetrics = QFontMetrics(menuOption.font);
return menuOption;
}
#ifdef QT_KEYPAD_NAVIGATION
void QComboBoxPrivate::_q_completerActivated()
{
Q_Q(QComboBox);
if ( QApplication::keypadNavigationEnabled()
&& q->isEditable()
&& q->completer()
&& q->completer()->completionMode() == QCompleter::UnfilteredPopupCompletion ) {
q->setEditFocus(false);
}
}
#endif
void QComboBoxPrivate::updateArrow(QStyle::StateFlag state)
{
Q_Q(QComboBox);
if (arrowState == state)
return;
arrowState = state;
QStyleOptionComboBox opt;
q->initStyleOption(&opt);
q->update(q->style()->subControlRect(QStyle::CC_ComboBox, &opt, QStyle::SC_ComboBoxArrow, q));
}
void QComboBoxPrivate::_q_modelReset()
{
Q_Q(QComboBox);
if (lineEdit) {
lineEdit->setText(QString());
updateLineEditGeometry();
}
if (currentIndex.row() != indexBeforeChange)
_q_emitCurrentIndexChanged(currentIndex);
q->update();
}
void QComboBoxPrivate::_q_modelDestroyed()
{
model = QAbstractItemModelPrivate::staticEmptyModel();
}
//Windows and KDE allows menus to cover the taskbar, while GNOME and Mac don't
QRect QComboBoxPrivate::popupGeometry(int screen) const
{
#ifdef Q_WS_WIN
return QApplication::desktop()->screenGeometry(screen);
#elif defined Q_WS_X11
if (X11->desktopEnvironment == DE_KDE)
return QApplication::desktop()->screenGeometry(screen);
else
return QApplication::desktop()->availableGeometry(screen);
#else
return QApplication::desktop()->availableGeometry(screen);
#endif
}
bool QComboBoxPrivate::updateHoverControl(const QPoint &pos)
{
Q_Q(QComboBox);
QRect lastHoverRect = hoverRect;
QStyle::SubControl lastHoverControl = hoverControl;
bool doesHover = q->testAttribute(Qt::WA_Hover);
if (lastHoverControl != newHoverControl(pos) && doesHover) {
q->update(lastHoverRect);
q->update(hoverRect);
return true;
}
return !doesHover;
}
QStyle::SubControl QComboBoxPrivate::newHoverControl(const QPoint &pos)
{
Q_Q(QComboBox);
QStyleOptionComboBox opt;
q->initStyleOption(&opt);
opt.subControls = QStyle::SC_All;
hoverControl = q->style()->hitTestComplexControl(QStyle::CC_ComboBox, &opt, pos, q);
hoverRect = (hoverControl != QStyle::SC_None)
? q->style()->subControlRect(QStyle::CC_ComboBox, &opt, hoverControl, q)
: QRect();
return hoverControl;
}
/*
Computes a size hint based on the maximum width
for the items in the combobox.
*/
int QComboBoxPrivate::computeWidthHint() const
{
Q_Q(const QComboBox);
int width = 0;
const int count = q->count();
const int iconWidth = q->iconSize().width() + 4;
const QFontMetrics &fontMetrics = q->fontMetrics();
for (int i = 0; i < count; ++i) {
const int textWidth = fontMetrics.width(q->itemText(i));
if (q->itemIcon(i).isNull())
width = (qMax(width, textWidth));
else
width = (qMax(width, textWidth + iconWidth));
}
QStyleOptionComboBox opt;
q->initStyleOption(&opt);
QSize tmp(width, 0);
tmp = q->style()->sizeFromContents(QStyle::CT_ComboBox, &opt, tmp, q);
return tmp.width();
}
QSize QComboBoxPrivate::recomputeSizeHint(QSize &sh) const
{
Q_Q(const QComboBox);
if (!sh.isValid()) {
bool hasIcon = sizeAdjustPolicy == QComboBox::AdjustToMinimumContentsLengthWithIcon ? true : false;
int count = q->count();
QSize iconSize = q->iconSize();
const QFontMetrics &fm = q->fontMetrics();
// text width
if (&sh == &sizeHint || minimumContentsLength == 0) {
switch (sizeAdjustPolicy) {
case QComboBox::AdjustToContents:
case QComboBox::AdjustToContentsOnFirstShow:
if (count == 0) {
sh.rwidth() = 7 * fm.width(QLatin1Char('x'));
} else {
for (int i = 0; i < count; ++i) {
if (!q->itemIcon(i).isNull()) {
hasIcon = true;
sh.setWidth(qMax(sh.width(), fm.boundingRect(q->itemText(i)).width() + iconSize.width() + 4));
} else {
sh.setWidth(qMax(sh.width(), fm.boundingRect(q->itemText(i)).width()));
}
}
}
break;
case QComboBox::AdjustToMinimumContentsLength:
for (int i = 0; i < count && !hasIcon; ++i)
hasIcon = !q->itemIcon(i).isNull();
default:
;
}
} else {
for (int i = 0; i < count && !hasIcon; ++i)
hasIcon = !q->itemIcon(i).isNull();
}
if (minimumContentsLength > 0)
sh.setWidth(qMax(sh.width(), minimumContentsLength * fm.width(QLatin1Char('X')) + (hasIcon ? iconSize.width() + 4 : 0)));
// height
sh.setHeight(qMax(fm.height(), 14) + 2);
if (hasIcon) {
sh.setHeight(qMax(sh.height(), iconSize.height() + 2));
}
// add style and strut values
QStyleOptionComboBox opt;
q->initStyleOption(&opt);
sh = q->style()->sizeFromContents(QStyle::CT_ComboBox, &opt, sh, q);
}
return sh.expandedTo(QApplication::globalStrut());
}
void QComboBoxPrivate::adjustComboBoxSize()
{
viewContainer()->adjustSizeTimer.start(20, container);
}
void QComboBoxPrivate::updateLayoutDirection()
{
Q_Q(const QComboBox);
QStyleOptionComboBox opt;
q->initStyleOption(&opt);
Qt::LayoutDirection dir = Qt::LayoutDirection(
q->style()->styleHint(QStyle::SH_ComboBox_LayoutDirection, &opt, q));
if (lineEdit)
lineEdit->setLayoutDirection(dir);
if (container)
container->setLayoutDirection(dir);
}
void QComboBoxPrivateContainer::timerEvent(QTimerEvent *timerEvent)
{
if (timerEvent->timerId() == adjustSizeTimer.timerId()) {
adjustSizeTimer.stop();
if (combo->sizeAdjustPolicy() == QComboBox::AdjustToContents) {
combo->adjustSize();
combo->update();
}
}
}
void QComboBoxPrivateContainer::resizeEvent(QResizeEvent *e)
{
QStyleOptionComboBox opt = comboStyleOption();
if (combo->style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, combo)) {
QStyleOption myOpt;
myOpt.initFrom(this);
QStyleHintReturnMask mask;
if (combo->style()->styleHint(QStyle::SH_Menu_Mask, &myOpt, this, &mask)) {
setMask(mask.region);
}
} else {
clearMask();
}
QFrame::resizeEvent(e);
}
void QComboBoxPrivateContainer::leaveEvent(QEvent *)
{
// On Mac using the Mac style we want to clear the selection
// when the mouse moves outside the popup.
#ifdef Q_WS_MAC
QStyleOptionComboBox opt = comboStyleOption();
if (combo->style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, combo))
view->clearSelection();
#endif
}
QComboBoxPrivateContainer::QComboBoxPrivateContainer(QAbstractItemView *itemView, QComboBox *parent)
: QFrame(parent, Qt::Popup), combo(parent), view(0), top(0), bottom(0)
{
// we need the combobox and itemview
Q_ASSERT(parent);
Q_ASSERT(itemView);
setAttribute(Qt::WA_WindowPropagation);
setAttribute(Qt::WA_X11NetWmWindowTypeCombo);
// setup container
blockMouseReleaseTimer.setSingleShot(true);
// we need a vertical layout
QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, this);
layout->setSpacing(0);
layout->setMargin(0);
// set item view
setItemView(itemView);
// add scroller arrows if style needs them
QStyleOptionComboBox opt = comboStyleOption();
const bool usePopup = combo->style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, combo);
if (usePopup) {
top = new QComboBoxPrivateScroller(QAbstractSlider::SliderSingleStepSub, this);
bottom = new QComboBoxPrivateScroller(QAbstractSlider::SliderSingleStepAdd, this);
top->hide();
bottom->hide();
} else {
setLineWidth(1);
}
setFrameStyle(combo->style()->styleHint(QStyle::SH_ComboBox_PopupFrameStyle, &opt, combo));
if (top) {
layout->insertWidget(0, top);
connect(top, SIGNAL(doScroll(int)), this, SLOT(scrollItemView(int)));
}
if (bottom) {
layout->addWidget(bottom);
connect(bottom, SIGNAL(doScroll(int)), this, SLOT(scrollItemView(int)));
}
// Some styles (Mac) have a margin at the top and bottom of the popup.
layout->insertSpacing(0, 0);
layout->addSpacing(0);
updateTopBottomMargin();
}
void QComboBoxPrivateContainer::scrollItemView(int action)
{
#ifndef QT_NO_SCROLLBAR
if (view->verticalScrollBar())
view->verticalScrollBar()->triggerAction(static_cast<QAbstractSlider::SliderAction>(action));
#endif
}
/*
Hides or shows the scrollers when we emulate a popupmenu
*/
void QComboBoxPrivateContainer::updateScrollers()
{
#ifndef QT_NO_SCROLLBAR
if (!top || !bottom)
return;
if (isVisible() == false)
return;
QStyleOptionComboBox opt = comboStyleOption();
if (combo->style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, combo) &&
view->verticalScrollBar()->minimum() < view->verticalScrollBar()->maximum()) {
bool needTop = view->verticalScrollBar()->value()
> (view->verticalScrollBar()->minimum() + spacing());
bool needBottom = view->verticalScrollBar()->value()
< (view->verticalScrollBar()->maximum() - spacing()*2);
if (needTop)
top->show();
else
top->hide();
if (needBottom)
bottom->show();
else
bottom->hide();
} else {
top->hide();
bottom->hide();
}
#endif // QT_NO_SCROLLBAR
}
/*
Cleans up when the view is destroyed.
*/
void QComboBoxPrivateContainer::viewDestroyed()
{
view = 0;
setItemView(new QComboBoxListView());
}
/*
Returns the item view used for the combobox popup.
*/
QAbstractItemView *QComboBoxPrivateContainer::itemView() const
{
return view;
}
/*!
Sets the item view to be used for the combobox popup.
*/
void QComboBoxPrivateContainer::setItemView(QAbstractItemView *itemView)
{
Q_ASSERT(itemView);
// clean up old one
if (view) {
view->removeEventFilter(this);
view->viewport()->removeEventFilter(this);
#ifndef QT_NO_SCROLLBAR
disconnect(view->verticalScrollBar(), SIGNAL(valueChanged(int)),
this, SLOT(updateScrollers()));
disconnect(view->verticalScrollBar(), SIGNAL(rangeChanged(int,int)),
this, SLOT(updateScrollers()));
#endif
disconnect(view, SIGNAL(destroyed()),
this, SLOT(viewDestroyed()));
delete view;
view = 0;
}
// setup the item view
view = itemView;
view->setParent(this);
view->setAttribute(Qt::WA_MacShowFocusRect, false);
qobject_cast<QBoxLayout*>(layout())->insertWidget(top ? 2 : 0, view);
view->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
view->installEventFilter(this);
view->viewport()->installEventFilter(this);
view->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
QStyleOptionComboBox opt = comboStyleOption();
const bool usePopup = combo->style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, combo);
#ifndef QT_NO_SCROLLBAR
if (usePopup)
view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
#endif
if (combo->style()->styleHint(QStyle::SH_ComboBox_ListMouseTracking, &opt, combo) ||
usePopup) {
view->setMouseTracking(true);
}
view->setSelectionMode(QAbstractItemView::SingleSelection);
view->setFrameStyle(QFrame::NoFrame);
view->setLineWidth(0);
view->setEditTriggers(QAbstractItemView::NoEditTriggers);
#ifndef QT_NO_SCROLLBAR
connect(view->verticalScrollBar(), SIGNAL(valueChanged(int)),
this, SLOT(updateScrollers()));
connect(view->verticalScrollBar(), SIGNAL(rangeChanged(int,int)),
this, SLOT(updateScrollers()));
#endif
connect(view, SIGNAL(destroyed()),
this, SLOT(viewDestroyed()));
#ifdef QT_SOFTKEYS_ENABLED
selectAction = QSoftKeyManager::createKeyedAction(QSoftKeyManager::SelectSoftKey, Qt::Key_Select, itemView);
cancelAction = QSoftKeyManager::createKeyedAction(QSoftKeyManager::CancelSoftKey, Qt::Key_Escape, itemView);
addAction(selectAction);
addAction(cancelAction);
#endif
}
/*!
Returns the spacing between the items in the view.
*/
int QComboBoxPrivateContainer::spacing() const
{
QListView *lview = qobject_cast<QListView*>(view);
if (lview)
return lview->spacing();
#ifndef QT_NO_TABLEVIEW
QTableView *tview = qobject_cast<QTableView*>(view);
if (tview)
return tview->showGrid() ? 1 : 0;
#endif
return 0;
}
void QComboBoxPrivateContainer::updateTopBottomMargin()
{
if (!layout() || layout()->count() < 1)
return;
QBoxLayout *boxLayout = qobject_cast<QBoxLayout *>(layout());
if (!boxLayout)
return;
const QStyleOptionComboBox opt = comboStyleOption();
const bool usePopup = combo->style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, combo);
const int margin = usePopup ? combo->style()->pixelMetric(QStyle::PM_MenuVMargin, &opt, combo) : 0;
QSpacerItem *topSpacer = boxLayout->itemAt(0)->spacerItem();
if (topSpacer)
topSpacer->changeSize(0, margin, QSizePolicy::Minimum, QSizePolicy::Fixed);
QSpacerItem *bottomSpacer = boxLayout->itemAt(boxLayout->count() - 1)->spacerItem();
if (bottomSpacer && bottomSpacer != topSpacer)
bottomSpacer->changeSize(0, margin, QSizePolicy::Minimum, QSizePolicy::Fixed);
boxLayout->invalidate();
}
void QComboBoxPrivateContainer::changeEvent(QEvent *e)
{
if (e->type() == QEvent::StyleChange) {
QStyleOptionComboBox opt = comboStyleOption();
view->setMouseTracking(combo->style()->styleHint(QStyle::SH_ComboBox_ListMouseTracking, &opt, combo) ||
combo->style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, combo));
setFrameStyle(combo->style()->styleHint(QStyle::SH_ComboBox_PopupFrameStyle, &opt, combo));
}
QWidget::changeEvent(e);
}
bool QComboBoxPrivateContainer::eventFilter(QObject *o, QEvent *e)
{
switch (e->type()) {
case QEvent::ShortcutOverride:
switch (static_cast<QKeyEvent*>(e)->key()) {
case Qt::Key_Enter:
case Qt::Key_Return:
#ifdef QT_KEYPAD_NAVIGATION
case Qt::Key_Select:
#endif
if (view->currentIndex().isValid() && (view->currentIndex().flags() & Qt::ItemIsEnabled) ) {
combo->hidePopup();
emit itemSelected(view->currentIndex());
}
return true;
case Qt::Key_Down:
if (!(static_cast<QKeyEvent*>(e)->modifiers() & Qt::AltModifier))
break;
// fall through
case Qt::Key_F4:
case Qt::Key_Escape:
combo->hidePopup();
return true;
default:
break;
}
break;
case QEvent::MouseMove:
if (isVisible()) {
QMouseEvent *m = static_cast<QMouseEvent *>(e);
QWidget *widget = static_cast<QWidget *>(o);
QPoint vector = widget->mapToGlobal(m->pos()) - initialClickPosition;
if (vector.manhattanLength() > 9 && blockMouseReleaseTimer.isActive())
blockMouseReleaseTimer.stop();
QModelIndex indexUnderMouse = view->indexAt(m->pos());
if (indexUnderMouse.isValid() && indexUnderMouse != view->currentIndex()
&& !QComboBoxDelegate::isSeparator(indexUnderMouse)) {
view->setCurrentIndex(indexUnderMouse);
}
}
break;
case QEvent::MouseButtonRelease: {
QMouseEvent *m = static_cast<QMouseEvent *>(e);
if (isVisible() && view->rect().contains(m->pos()) && view->currentIndex().isValid()
&& !blockMouseReleaseTimer.isActive()
&& (view->currentIndex().flags() & Qt::ItemIsEnabled)
&& (view->currentIndex().flags() & Qt::ItemIsSelectable)) {
combo->hidePopup();
emit itemSelected(view->currentIndex());
return true;
}
break;
}
default:
break;
}
return QFrame::eventFilter(o, e);
}
void QComboBoxPrivateContainer::showEvent(QShowEvent *)
{
combo->update();
}
void QComboBoxPrivateContainer::hideEvent(QHideEvent *)
{
emit resetButton();
combo->update();
}
void QComboBoxPrivateContainer::mousePressEvent(QMouseEvent *e)
{
QStyleOptionComboBox opt = comboStyleOption();
opt.subControls = QStyle::SC_All;
opt.activeSubControls = QStyle::SC_ComboBoxArrow;
QStyle::SubControl sc = combo->style()->hitTestComplexControl(QStyle::CC_ComboBox, &opt,
combo->mapFromGlobal(e->globalPos()),
combo);
if ((combo->isEditable() && sc == QStyle::SC_ComboBoxArrow)
|| (!combo->isEditable() && sc != QStyle::SC_None))
setAttribute(Qt::WA_NoMouseReplay);
combo->hidePopup();
}
void QComboBoxPrivateContainer::mouseReleaseEvent(QMouseEvent *e)
{
Q_UNUSED(e);
if (!blockMouseReleaseTimer.isActive()){
combo->hidePopup();
emit resetButton();
}
}
QStyleOptionComboBox QComboBoxPrivateContainer::comboStyleOption() const
{
// ### This should use QComboBox's initStyleOption(), but it's protected
// perhaps, we could cheat by having the QCombo private instead?
QStyleOptionComboBox opt;
opt.initFrom(combo);
opt.subControls = QStyle::SC_All;
opt.activeSubControls = QStyle::SC_None;
opt.editable = combo->isEditable();
return opt;
}
/*!
\enum QComboBox::InsertPolicy
This enum specifies what the QComboBox should do when a new string is
entered by the user.
\value NoInsert The string will not be inserted into the combobox.
\value InsertAtTop The string will be inserted as the first item in the combobox.
\value InsertAtCurrent The current item will be \e replaced by the string.
\value InsertAtBottom The string will be inserted after the last item in the combobox.
\value InsertAfterCurrent The string is inserted after the current item in the combobox.
\value InsertBeforeCurrent The string is inserted before the current item in the combobox.
\value InsertAlphabetically The string is inserted in the alphabetic order in the combobox.
\omitvalue NoInsertion
\omitvalue AtTop
\omitvalue AtCurrent
\omitvalue AtBottom
\omitvalue AfterCurrent
\omitvalue BeforeCurrent
*/
/*!
\enum QComboBox::SizeAdjustPolicy
This enum specifies how the size hint of the QComboBox should
adjust when new content is added or content changes.
\value AdjustToContents The combobox will always adjust to the contents
\value AdjustToContentsOnFirstShow The combobox will adjust to its contents the first time it is shown.
\value AdjustToMinimumContentsLength Use AdjustToContents or AdjustToContentsOnFirstShow instead.
\value AdjustToMinimumContentsLengthWithIcon The combobox will adjust to \l minimumContentsLength plus space for an icon. For performance reasons use this policy on large models.
*/
/*!
\fn void QComboBox::activated(int index)
This signal is sent when the user chooses an item in the combobox.
The item's \a index is passed. Note that this signal is sent even
when the choice is not changed. If you need to know when the
choice actually changes, use signal currentIndexChanged().
*/
/*!
\fn void QComboBox::activated(const QString &text)
This signal is sent when the user chooses an item in the combobox.
The item's \a text is passed. Note that this signal is sent even
when the choice is not changed. If you need to know when the
choice actually changes, use signal currentIndexChanged().
*/
/*!
\fn void QComboBox::highlighted(int index)
This signal is sent when an item in the combobox popup list is
highlighted by the user. The item's \a index is passed.
*/
/*!
\fn void QComboBox::highlighted(const QString &text)
This signal is sent when an item in the combobox popup list is
highlighted by the user. The item's \a text is passed.
*/
/*!
\fn void QComboBox::currentIndexChanged(int index)
\since 4.1
This signal is sent whenever the currentIndex in the combobox
changes either through user interaction or programmatically. The
item's \a index is passed or -1 if the combobox becomes empty or the
currentIndex was reset.
*/
/*!
\fn void QComboBox::currentIndexChanged(const QString &text)
\since 4.1
This signal is sent whenever the currentIndex in the combobox
changes either through user interaction or programmatically. The
item's \a text is passed.
*/
/*!
Constructs a combobox with the given \a parent, using the default
model QStandardItemModel.
*/
QComboBox::QComboBox(QWidget *parent)
: QWidget(*new QComboBoxPrivate(), parent, 0)
{
Q_D(QComboBox);
d->init();
}
/*!
\internal
*/
QComboBox::QComboBox(QComboBoxPrivate &dd, QWidget *parent)
: QWidget(dd, parent, 0)
{
Q_D(QComboBox);
d->init();
}
#ifdef QT3_SUPPORT
/*!
Use one of the constructors that doesn't take the \a name
argument and then use setObjectName() instead.
*/
QComboBox::QComboBox(QWidget *parent, const char *name)
: QWidget(*new QComboBoxPrivate(), parent, 0)
{
Q_D(QComboBox);
d->init();
setObjectName(QString::fromAscii(name));
}
/*!
Use one of the constructors that doesn't take the \a name
argument and then use setObjectName() instead.
*/
QComboBox::QComboBox(bool rw, QWidget *parent, const char *name)
: QWidget(*new QComboBoxPrivate(), parent, 0)
{
Q_D(QComboBox);
d->init();
setEditable(rw);
setObjectName(QString::fromAscii(name));
}
#endif //QT3_SUPPORT
/*!
\class QComboBox
\brief The QComboBox widget is a combined button and popup list.
\ingroup basicwidgets
A QComboBox provides a means of presenting a list of options to the user
in a way that takes up the minimum amount of screen space.
A combobox is a selection widget that displays the current item,
and can pop up a list of selectable items. A combobox may be editable,
allowing the user to modify each item in the list.
Comboboxes can contain pixmaps as well as strings; the
insertItem() and setItemText() functions are suitably overloaded.
For editable comboboxes, the function clearEditText() is provided,
to clear the displayed string without changing the combobox's
contents.
There are two signals emitted if the current item of a combobox
changes, currentIndexChanged() and activated().
currentIndexChanged() is always emitted regardless if the change
was done programmatically or by user interaction, while
activated() is only emitted when the change is caused by user
interaction. The highlighted() signal is emitted when the user
highlights an item in the combobox popup list. All three signals
exist in two versions, one with a QString argument and one with an
\c int argument. If the user selectes or highlights a pixmap, only
the \c int signals are emitted. Whenever the text of an editable
combobox is changed the editTextChanged() signal is emitted.
When the user enters a new string in an editable combobox, the
widget may or may not insert it, and it can insert it in several
locations. The default policy is is \l AtBottom but you can change
this using setInsertPolicy().
It is possible to constrain the input to an editable combobox
using QValidator; see setValidator(). By default, any input is
accepted.
A combobox can be populated using the insert functions,
insertItem() and insertItems() for example. Items can be
changed with setItemText(). An item can be removed with
removeItem() and all items can be removed with clear(). The text
of the current item is returned by currentText(), and the text of
a numbered item is returned with text(). The current item can be
set with setCurrentIndex(). The number of items in the combobox is
returned by count(); the maximum number of items can be set with
setMaxCount(). You can allow editing using setEditable(). For
editable comboboxes you can set auto-completion using
setCompleter() and whether or not the user can add duplicates
is set with setDuplicatesEnabled().
QComboBox uses the \l{Model/View Programming}{model/view
framework} for its popup list and to store its items. By default
a QStandardItemModel stores the items and a QListView subclass
displays the popuplist. You can access the model and view directly
(with model() and view()), but QComboBox also provides functions
to set and get item data (e.g., setItemData() and itemText()). You
can also set a new model and view (with setModel() and setView()).
For the text and icon in the combobox label, the data in the model
that has the Qt::DisplayRole and Qt::DecorationRole is used.
\image qstyle-comboboxes.png Comboboxes in the different built-in styles.
\sa QLineEdit, QSpinBox, QRadioButton, QButtonGroup,
{fowler}{GUI Design Handbook: Combo Box, Drop-Down List Box}
*/
void QComboBoxPrivate::init()
{
Q_Q(QComboBox);
q->setFocusPolicy(Qt::WheelFocus);
q->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed,
QSizePolicy::ComboBox));
setLayoutItemMargins(QStyle::SE_ComboBoxLayoutItem);
q->setModel(new QStandardItemModel(0, 1, q));
if (!q->isEditable())
q->setAttribute(Qt::WA_InputMethodEnabled, false);
else
q->setAttribute(Qt::WA_InputMethodEnabled);
}
QComboBoxPrivateContainer* QComboBoxPrivate::viewContainer()
{
if (container)
return container;
Q_Q(QComboBox);
container = new QComboBoxPrivateContainer(new QComboBoxListView(q), q);
container->itemView()->setModel(model);
container->itemView()->setTextElideMode(Qt::ElideMiddle);
updateDelegate(true);
updateLayoutDirection();
updateViewContainerPaletteAndOpacity();
QObject::connect(container, SIGNAL(itemSelected(QModelIndex)),
q, SLOT(_q_itemSelected(QModelIndex)));
QObject::connect(container->itemView()->selectionModel(),
SIGNAL(currentChanged(QModelIndex,QModelIndex)),
q, SLOT(_q_emitHighlighted(QModelIndex)));
QObject::connect(container, SIGNAL(resetButton()), q, SLOT(_q_resetButton()));
return container;
}
void QComboBoxPrivate::_q_resetButton()
{
updateArrow(QStyle::State_None);
}
void QComboBoxPrivate::_q_dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
{
Q_Q(QComboBox);
if (inserting || topLeft.parent() != root)
return;
if (sizeAdjustPolicy == QComboBox::AdjustToContents) {
sizeHint = QSize();
adjustComboBoxSize();
q->updateGeometry();
}
if (currentIndex.row() >= topLeft.row() && currentIndex.row() <= bottomRight.row()) {
if (lineEdit) {
lineEdit->setText(q->itemText(currentIndex.row()));
updateLineEditGeometry();
}
q->update();
}
}
void QComboBoxPrivate::_q_rowsInserted(const QModelIndex &parent, int start, int end)
{
Q_Q(QComboBox);
if (inserting || parent != root)
return;
if (sizeAdjustPolicy == QComboBox::AdjustToContents) {
sizeHint = QSize();
adjustComboBoxSize();
q->updateGeometry();
}
// set current index if combo was previously empty
if (start == 0 && (end - start + 1) == q->count() && !currentIndex.isValid()) {
q->setCurrentIndex(0);
// need to emit changed if model updated index "silently"
} else if (currentIndex.row() != indexBeforeChange) {
q->update();
_q_emitCurrentIndexChanged(currentIndex);
}
}
void QComboBoxPrivate::_q_updateIndexBeforeChange()
{
indexBeforeChange = currentIndex.row();
}
void QComboBoxPrivate::_q_rowsRemoved(const QModelIndex &parent, int /*start*/, int /*end*/)
{
Q_Q(QComboBox);
if (parent != root)
return;
if (sizeAdjustPolicy == QComboBox::AdjustToContents) {
sizeHint = QSize();
adjustComboBoxSize();
q->updateGeometry();
}
// model has changed the currentIndex
if (currentIndex.row() != indexBeforeChange) {
if (!currentIndex.isValid() && q->count()) {
q->setCurrentIndex(qMin(q->count() - 1, qMax(indexBeforeChange, 0)));
return;
}
if (lineEdit) {
lineEdit->setText(q->itemText(currentIndex.row()));
updateLineEditGeometry();
}
q->update();
_q_emitCurrentIndexChanged(currentIndex);
}
}
void QComboBoxPrivate::updateViewContainerPaletteAndOpacity()
{
if (!container)
return;
Q_Q(QComboBox);
QStyleOptionComboBox opt;
q->initStyleOption(&opt);
#ifndef QT_NO_MENU
if (q->style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, q)) {
QMenu menu;
menu.ensurePolished();
container->setPalette(menu.palette());
container->setWindowOpacity(menu.windowOpacity());
} else
#endif
{
container->setPalette(q->palette());
container->setWindowOpacity(1.0);
}
}
/*!
Initialize \a option with the values from this QComboBox. This method
is useful for subclasses when they need a QStyleOptionComboBox, but don't want
to fill in all the information themselves.
\sa QStyleOption::initFrom()
*/
void QComboBox::initStyleOption(QStyleOptionComboBox *option) const
{
if (!option)
return;
Q_D(const QComboBox);
option->initFrom(this);
option->editable = isEditable();
option->frame = d->frame;
if (hasFocus() && !option->editable)
option->state |= QStyle::State_Selected;
option->subControls = QStyle::SC_All;
if (d->arrowState == QStyle::State_Sunken) {
option->activeSubControls = QStyle::SC_ComboBoxArrow;
option->state |= d->arrowState;
} else {
option->activeSubControls = d->hoverControl;
}
if (d->currentIndex.isValid()) {
option->currentText = currentText();
option->currentIcon = d->itemIcon(d->currentIndex);
}
option->iconSize = iconSize();
if (d->container && d->container->isVisible())
option->state |= QStyle::State_On;
}
void QComboBoxPrivate::updateLineEditGeometry()
{
if (!lineEdit)
return;
Q_Q(QComboBox);
QStyleOptionComboBox opt;
q->initStyleOption(&opt);
QRect editRect = q->style()->subControlRect(QStyle::CC_ComboBox, &opt,
QStyle::SC_ComboBoxEditField, q);
if (!q->itemIcon(q->currentIndex()).isNull()) {
QRect comboRect(editRect);
editRect.setWidth(editRect.width() - q->iconSize().width() - 4);
editRect = QStyle::alignedRect(q->layoutDirection(), Qt::AlignRight,
editRect.size(), comboRect);
}
lineEdit->setGeometry(editRect);
}
Qt::MatchFlags QComboBoxPrivate::matchFlags() const
{
// Base how duplicates are determined on the autocompletion case sensitivity
Qt::MatchFlags flags = Qt::MatchFixedString;
#ifndef QT_NO_COMPLETER
if (!lineEdit->completer() || lineEdit->completer()->caseSensitivity() == Qt::CaseSensitive)
#endif
flags |= Qt::MatchCaseSensitive;
return flags;
}
void QComboBoxPrivate::_q_editingFinished()
{
Q_Q(QComboBox);
if (lineEdit && !lineEdit->text().isEmpty()) {
//here we just check if the current item was entered
const int index = q_func()->findText(lineEdit->text(), matchFlags());
if (index != -1 && itemText(currentIndex) != lineEdit->text()) {
q->setCurrentIndex(index);
emitActivated(currentIndex);
}
}
}
void QComboBoxPrivate::_q_returnPressed()
{
Q_Q(QComboBox);
if (lineEdit && !lineEdit->text().isEmpty()) {
if (q->count() >= maxCount && !(this->insertPolicy == QComboBox::InsertAtCurrent))
return;
lineEdit->deselect();
lineEdit->end(false);
QString text = lineEdit->text();
// check for duplicates (if not enabled) and quit
int index = -1;
if (!duplicatesEnabled) {
index = q->findText(text, matchFlags());
if (index != -1) {
q->setCurrentIndex(index);
emitActivated(currentIndex);
return;
}
}
switch (insertPolicy) {
case QComboBox::InsertAtTop:
index = 0;
break;
case QComboBox::InsertAtBottom:
index = q->count();
break;
case QComboBox::InsertAtCurrent:
case QComboBox::InsertAfterCurrent:
case QComboBox::InsertBeforeCurrent:
if (!q->count() || !currentIndex.isValid())
index = 0;
else if (insertPolicy == QComboBox::InsertAtCurrent)
q->setItemText(q->currentIndex(), text);
else if (insertPolicy == QComboBox::InsertAfterCurrent)
index = q->currentIndex() + 1;
else if (insertPolicy == QComboBox::InsertBeforeCurrent)
index = q->currentIndex();
break;
case QComboBox::InsertAlphabetically:
index = 0;
for (int i=0; i< q->count(); i++, index++ ) {
if (text.toLower() < q->itemText(i).toLower())
break;
}
break;
case QComboBox::NoInsert:
default:
break;
}
if (index >= 0) {
q->insertItem(index, text);
q->setCurrentIndex(index);
emitActivated(currentIndex);
}
}
}
void QComboBoxPrivate::_q_itemSelected(const QModelIndex &item)
{
Q_Q(QComboBox);
if (item != currentIndex) {
setCurrentIndex(item);
} else if (lineEdit) {
lineEdit->selectAll();
lineEdit->setText(q->itemText(currentIndex.row()));
}
emitActivated(currentIndex);
}
void QComboBoxPrivate::emitActivated(const QModelIndex &index)
{
Q_Q(QComboBox);
if (!index.isValid())
return;
QString text(itemText(index));
emit q->activated(index.row());
emit q->activated(text);
}
void QComboBoxPrivate::_q_emitHighlighted(const QModelIndex &index)
{
Q_Q(QComboBox);
if (!index.isValid())
return;
QString text(itemText(index));
emit q->highlighted(index.row());
emit q->highlighted(text);
}
void QComboBoxPrivate::_q_emitCurrentIndexChanged(const QModelIndex &index)
{
Q_Q(QComboBox);
emit q->currentIndexChanged(index.row());
emit q->currentIndexChanged(itemText(index));
}
QString QComboBoxPrivate::itemText(const QModelIndex &index) const
{
return index.isValid() ? model->data(index, itemRole()).toString() : QString();
}
int QComboBoxPrivate::itemRole() const
{
return q_func()->isEditable() ? Qt::EditRole : Qt::DisplayRole;
}
/*!
Destroys the combobox.
*/
QComboBox::~QComboBox()
{
// ### check delegateparent and delete delegate if us?
Q_D(QComboBox);
QT_TRY {
disconnect(d->model, SIGNAL(destroyed()),
this, SLOT(_q_modelDestroyed()));
} QT_CATCH(...) {
; // objects can't throw in destructor
}
}
/*!
\property QComboBox::maxVisibleItems
\brief the maximum allowed size on screen of the combo box, measured in items
By default, this property has a value of 10.
\note This property is ignored for non-editable comboboxes in Mac style.
*/
int QComboBox::maxVisibleItems() const
{
Q_D(const QComboBox);
return d->maxVisibleItems;
}
void QComboBox::setMaxVisibleItems(int maxItems)
{
Q_D(QComboBox);
if (maxItems < 0) {
qWarning("QComboBox::setMaxVisibleItems: "
"Invalid max visible items (%d) must be >= 0", maxItems);
return;
}
d->maxVisibleItems = maxItems;
}
/*!
\property QComboBox::count
\brief the number of items in the combobox
By default, for an empty combo box, this property has a value of 0.
*/
int QComboBox::count() const
{
Q_D(const QComboBox);
return d->model->rowCount(d->root);
}
/*!
\property QComboBox::maxCount
\brief the maximum number of items allowed in the combobox
\note If you set the maximum number to be less then the current
amount of items in the combobox, the extra items will be
truncated. This also applies if you have set an external model on
the combobox.
By default, this property's value is derived from the highest
signed integer available (typically 2147483647).
*/
void QComboBox::setMaxCount(int max)
{
Q_D(QComboBox);
if (max < 0) {
qWarning("QComboBox::setMaxCount: Invalid count (%d) must be >= 0", max);
return;
}
if (max < count())
d->model->removeRows(max, count() - max, d->root);
d->maxCount = max;
}
int QComboBox::maxCount() const
{
Q_D(const QComboBox);
return d->maxCount;
}
#ifndef QT_NO_COMPLETER
/*!
\property QComboBox::autoCompletion
\brief whether the combobox provides auto-completion for editable items
\since 4.1
\obsolete
Use setCompleter() instead.
By default, this property is true.
\sa editable
*/
/*!
\obsolete
Use setCompleter() instead.
*/
bool QComboBox::autoCompletion() const
{
Q_D(const QComboBox);
return d->autoCompletion;
}
/*!
\obsolete
Use setCompleter() instead.
*/
void QComboBox::setAutoCompletion(bool enable)
{
Q_D(QComboBox);
#ifdef QT_KEYPAD_NAVIGATION
if (QApplication::keypadNavigationEnabled() && !enable && isEditable())
qWarning("QComboBox::setAutoCompletion: auto completion is mandatory when combo box editable");
#endif
d->autoCompletion = enable;
if (!d->lineEdit)
return;
if (enable) {
if (d->lineEdit->completer())
return;
d->completer = new QCompleter(d->model, d->lineEdit);
d->completer->setCaseSensitivity(d->autoCompletionCaseSensitivity);
d->completer->setCompletionMode(QCompleter::InlineCompletion);
d->completer->setCompletionColumn(d->modelColumn);
d->lineEdit->setCompleter(d->completer);
d->completer->setWidget(this);
} else {
d->lineEdit->setCompleter(0);
}
}
/*!
\property QComboBox::autoCompletionCaseSensitivity
\brief whether string comparisons are case-sensitive or case-insensitive for auto-completion
\obsolete
By default, this property is Qt::CaseInsensitive.
Use setCompleter() instead. Case sensitivity of the auto completion can be
changed using QCompleter::setCaseSensitivity().
\sa autoCompletion
*/
/*!
\obsolete
Use setCompleter() and QCompleter::setCaseSensitivity() instead.
*/
Qt::CaseSensitivity QComboBox::autoCompletionCaseSensitivity() const
{
Q_D(const QComboBox);
return d->autoCompletionCaseSensitivity;
}
/*!
\obsolete
Use setCompleter() and QCompleter::setCaseSensitivity() instead.
*/
void QComboBox::setAutoCompletionCaseSensitivity(Qt::CaseSensitivity sensitivity)
{
Q_D(QComboBox);
d->autoCompletionCaseSensitivity = sensitivity;
if (d->lineEdit && d->lineEdit->completer())
d->lineEdit->completer()->setCaseSensitivity(sensitivity);
}
#endif // QT_NO_COMPLETER
/*!
\property QComboBox::duplicatesEnabled
\brief whether the user can enter duplicate items into the combobox
Note that it is always possible to programmatically insert duplicate items into the
combobox.
By default, this property is false (duplicates are not allowed).
*/
bool QComboBox::duplicatesEnabled() const
{
Q_D(const QComboBox);
return d->duplicatesEnabled;
}
void QComboBox::setDuplicatesEnabled(bool enable)
{
Q_D(QComboBox);
d->duplicatesEnabled = enable;
}
/*! \fn int QComboBox::findText(const QString &text, Qt::MatchFlags flags = Qt::MatchExactly|Qt::MatchCaseSensitive) const
Returns the index of the item containing the given \a text; otherwise
returns -1.
The \a flags specify how the items in the combobox are searched.
*/
/*!
Returns the index of the item containing the given \a data for the
given \a role; otherwise returns -1.
The \a flags specify how the items in the combobox are searched.
*/
int QComboBox::findData(const QVariant &data, int role, Qt::MatchFlags flags) const
{
Q_D(const QComboBox);
QModelIndexList result;
QModelIndex start = d->model->index(0, d->modelColumn, d->root);
result = d->model->match(start, role, data, 1, flags);
if (result.isEmpty())
return -1;
return result.first().row();
}
/*!
\property QComboBox::insertPolicy
\brief the policy used to determine where user-inserted items should
appear in the combobox
The default value is \l AtBottom, indicating that new items will appear
at the bottom of the list of items.
\sa InsertPolicy
*/
QComboBox::InsertPolicy QComboBox::insertPolicy() const
{
Q_D(const QComboBox);
return d->insertPolicy;
}
void QComboBox::setInsertPolicy(InsertPolicy policy)
{
Q_D(QComboBox);
d->insertPolicy = policy;
}
/*!
\property QComboBox::sizeAdjustPolicy
\brief the policy describing how the size of the combobox changes
when the content changes
The default value is \l AdjustToContentsOnFirstShow.
\sa SizeAdjustPolicy
*/
QComboBox::SizeAdjustPolicy QComboBox::sizeAdjustPolicy() const
{
Q_D(const QComboBox);
return d->sizeAdjustPolicy;
}
void QComboBox::setSizeAdjustPolicy(QComboBox::SizeAdjustPolicy policy)
{
Q_D(QComboBox);
if (policy == d->sizeAdjustPolicy)
return;
d->sizeAdjustPolicy = policy;
d->sizeHint = QSize();
d->adjustComboBoxSize();
updateGeometry();
}
/*!
\property QComboBox::minimumContentsLength
\brief the minimum number of characters that should fit into the combobox.
The default value is 0.
If this property is set to a positive value, the
minimumSizeHint() and sizeHint() take it into account.
\sa sizeAdjustPolicy
*/
int QComboBox::minimumContentsLength() const
{
Q_D(const QComboBox);
return d->minimumContentsLength;
}
void QComboBox::setMinimumContentsLength(int characters)
{
Q_D(QComboBox);
if (characters == d->minimumContentsLength || characters < 0)
return;
d->minimumContentsLength = characters;
if (d->sizeAdjustPolicy == AdjustToContents
|| d->sizeAdjustPolicy == AdjustToMinimumContentsLength
|| d->sizeAdjustPolicy == AdjustToMinimumContentsLengthWithIcon) {
d->sizeHint = QSize();
d->adjustComboBoxSize();
updateGeometry();
}
}
/*!
\property QComboBox::iconSize
\brief the size of the icons shown in the combobox.
Unless explicitly set this returns the default value of the
current style. This size is the maximum size that icons can have;
icons of smaller size are not scaled up.
*/
QSize QComboBox::iconSize() const
{
Q_D(const QComboBox);
if (d->iconSize.isValid())
return d->iconSize;
int iconWidth = style()->pixelMetric(QStyle::PM_SmallIconSize, 0, this);
return QSize(iconWidth, iconWidth);
}
void QComboBox::setIconSize(const QSize &size)
{
Q_D(QComboBox);
if (size == d->iconSize)
return;
view()->setIconSize(size);
d->iconSize = size;
d->sizeHint = QSize();
updateGeometry();
}
/*!
\property QComboBox::editable
\brief whether the combo box can be edited by the user
By default, this property is false.
*/
bool QComboBox::isEditable() const
{
Q_D(const QComboBox);
return d->lineEdit != 0;
}
/*! \internal
update the default delegate
depending on the style's SH_ComboBox_Popup hint, we use a different default delegate.
but we do not change the delegate is the combobox use a custom delegate,
unless \a force is set to true.
*/
void QComboBoxPrivate::updateDelegate(bool force)
{
Q_Q(QComboBox);
QStyleOptionComboBox opt;
q->initStyleOption(&opt);
if (q->style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, q)) {
if (force || qobject_cast<QComboBoxDelegate *>(q->itemDelegate()))
q->setItemDelegate(new QComboMenuDelegate(q->view(), q));
} else {
if (force || qobject_cast<QComboMenuDelegate *>(q->itemDelegate()))
q->setItemDelegate(new QComboBoxDelegate(q->view(), q));
}
}
QIcon QComboBoxPrivate::itemIcon(const QModelIndex &index) const
{
QVariant decoration = model->data(index, Qt::DecorationRole);
if (decoration.type() == QVariant::Pixmap)
return QIcon(qvariant_cast<QPixmap>(decoration));
else
return qvariant_cast<QIcon>(decoration);
}
void QComboBox::setEditable(bool editable)
{
Q_D(QComboBox);
if (isEditable() == editable)
return;
d->updateDelegate();
QStyleOptionComboBox opt;
initStyleOption(&opt);
if (editable) {
if (style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this)) {
d->viewContainer()->updateScrollers();
view()->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
}
QLineEdit *le = new QLineEdit(this);
setLineEdit(le);
} else {
if (style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this)) {
d->viewContainer()->updateScrollers();
view()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
}
setAttribute(Qt::WA_InputMethodEnabled, false);
d->lineEdit->hide();
d->lineEdit->deleteLater();
d->lineEdit = 0;
}
d->viewContainer()->updateTopBottomMargin();
if (!testAttribute(Qt::WA_Resized))
adjustSize();
}
/*!
Sets the line \a edit to use instead of the current line edit widget.
The combo box takes ownership of the line edit.
*/
void QComboBox::setLineEdit(QLineEdit *edit)
{
Q_D(QComboBox);
if (!edit) {
qWarning("QComboBox::setLineEdit: cannot set a 0 line edit");
return;
}
if (edit == d->lineEdit)
return;
edit->setText(currentText());
delete d->lineEdit;
d->lineEdit = edit;
if (d->lineEdit->parent() != this)
d->lineEdit->setParent(this);
connect(d->lineEdit, SIGNAL(returnPressed()), this, SLOT(_q_returnPressed()));
connect(d->lineEdit, SIGNAL(editingFinished()), this, SLOT(_q_editingFinished()));
connect(d->lineEdit, SIGNAL(textChanged(QString)), this, SIGNAL(editTextChanged(QString)));
#ifdef QT3_SUPPORT
connect(d->lineEdit, SIGNAL(textChanged(QString)), this, SIGNAL(textChanged(QString)));
#endif
d->lineEdit->setFrame(false);
d->lineEdit->setContextMenuPolicy(Qt::NoContextMenu);
d->lineEdit->setFocusProxy(this);
d->lineEdit->setAttribute(Qt::WA_MacShowFocusRect, false);
#ifndef QT_NO_COMPLETER
setAutoCompletion(d->autoCompletion);
#endif
#ifdef QT_KEYPAD_NAVIGATION
#ifndef QT_NO_COMPLETER
if (QApplication::keypadNavigationEnabled()) {
// Editable combo boxes will have a completer that is set to UnfilteredPopupCompletion.
// This means that when the user enters edit mode they are immediately presented with a
// list of possible completions.
setAutoCompletion(true);
if (d->completer) {
d->completer->setCompletionMode(QCompleter::UnfilteredPopupCompletion);
connect(d->completer, SIGNAL(activated(QModelIndex)), this, SLOT(_q_completerActivated()));
}
}
#endif
#endif
setAttribute(Qt::WA_InputMethodEnabled);
d->updateLayoutDirection();
d->updateLineEditGeometry();
if (isVisible())
d->lineEdit->show();
update();
}
/*!
Returns the line edit used to edit items in the combobox, or 0 if there
is no line edit.
Only editable combo boxes have a line edit.
*/
QLineEdit *QComboBox::lineEdit() const
{
Q_D(const QComboBox);
return d->lineEdit;
}
#ifndef QT_NO_VALIDATOR
/*!
\fn void QComboBox::setValidator(const QValidator *validator)
Sets the \a validator to use instead of the current validator.
*/
void QComboBox::setValidator(const QValidator *v)
{
Q_D(QComboBox);
if (d->lineEdit)
d->lineEdit->setValidator(v);
}
/*!
Returns the validator that is used to constrain text input for the
combobox.
\sa editable
*/
const QValidator *QComboBox::validator() const
{
Q_D(const QComboBox);
return d->lineEdit ? d->lineEdit->validator() : 0;
}
#endif // QT_NO_VALIDATOR
#ifndef QT_NO_COMPLETER
/*!
\fn void QComboBox::setCompleter(QCompleter *completer)
\since 4.2
Sets the \a completer to use instead of the current completer.
If \a completer is 0, auto completion is disabled.
By default, for an editable combo box, a QCompleter that
performs case insensitive inline completion is automatically created.
*/
void QComboBox::setCompleter(QCompleter *c)
{
Q_D(QComboBox);
if (!d->lineEdit)
return;
d->lineEdit->setCompleter(c);
if (c)
c->setWidget(this);
}
/*!
\since 4.2
Returns the completer that is used to auto complete text input for the
combobox.
\sa editable
*/
QCompleter *QComboBox::completer() const
{
Q_D(const QComboBox);
return d->lineEdit ? d->lineEdit->completer() : 0;
}
#endif // QT_NO_COMPLETER
/*!
Returns the item delegate used by the popup list view.
\sa setItemDelegate()
*/
QAbstractItemDelegate *QComboBox::itemDelegate() const
{
return view()->itemDelegate();
}
/*!
Sets the item \a delegate for the popup list view.
The combobox takes ownership of the delegate.
\warning You should not share the same instance of a delegate between comboboxes,
widget mappers or views. Doing so can cause incorrect or unintuitive editing behavior
since each view connected to a given delegate may receive the
\l{QAbstractItemDelegate::}{closeEditor()} signal, and attempt to access, modify or
close an editor that has already been closed.
\sa itemDelegate()
*/
void QComboBox::setItemDelegate(QAbstractItemDelegate *delegate)
{
if (!delegate) {
qWarning("QComboBox::setItemDelegate: cannot set a 0 delegate");
return;
}
delete view()->itemDelegate();
view()->setItemDelegate(delegate);
}
/*!
Returns the model used by the combobox.
*/
QAbstractItemModel *QComboBox::model() const
{
Q_D(const QComboBox);
if (d->model == QAbstractItemModelPrivate::staticEmptyModel()) {
QComboBox *that = const_cast<QComboBox*>(this);
that->setModel(new QStandardItemModel(0, 1, that));
}
return d->model;
}
/*!
Sets the model to be \a model. \a model must not be 0.
If you want to clear the contents of a model, call clear().
\sa clear()
*/
void QComboBox::setModel(QAbstractItemModel *model)
{
Q_D(QComboBox);
if (!model) {
qWarning("QComboBox::setModel: cannot set a 0 model");
return;
}
#ifndef QT_NO_COMPLETER
if (d->lineEdit && d->lineEdit->completer()
&& d->lineEdit->completer() == d->completer)
d->lineEdit->completer()->setModel(model);
#endif
if (d->model) {
disconnect(d->model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this, SLOT(_q_dataChanged(QModelIndex,QModelIndex)));
disconnect(d->model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(_q_updateIndexBeforeChange()));
disconnect(d->model, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SLOT(_q_rowsInserted(QModelIndex,int,int)));
disconnect(d->model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(_q_updateIndexBeforeChange()));
disconnect(d->model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SLOT(_q_rowsRemoved(QModelIndex,int,int)));
disconnect(d->model, SIGNAL(destroyed()),
this, SLOT(_q_modelDestroyed()));
disconnect(d->model, SIGNAL(modelAboutToBeReset()),
this, SLOT(_q_updateIndexBeforeChange()));
disconnect(d->model, SIGNAL(modelReset()),
this, SLOT(_q_modelReset()));
if (d->model->QObject::parent() == this)
delete d->model;
}
d->model = model;
connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this, SLOT(_q_dataChanged(QModelIndex,QModelIndex)));
connect(model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(_q_updateIndexBeforeChange()));
connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SLOT(_q_rowsInserted(QModelIndex,int,int)));
connect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(_q_updateIndexBeforeChange()));
connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SLOT(_q_rowsRemoved(QModelIndex,int,int)));
connect(model, SIGNAL(destroyed()),
this, SLOT(_q_modelDestroyed()));
connect(model, SIGNAL(modelAboutToBeReset()),
this, SLOT(_q_updateIndexBeforeChange()));
connect(model, SIGNAL(modelReset()),
this, SLOT(_q_modelReset()));
if (d->container)
d->container->itemView()->setModel(model);
bool currentReset = false;
if (count()) {
for (int pos=0; pos < count(); pos++) {
if (d->model->index(pos, d->modelColumn, d->root).flags() & Qt::ItemIsEnabled) {
setCurrentIndex(pos);
currentReset = true;
break;
}
}
}
if (!currentReset)
setCurrentIndex(-1);
d->modelChanged();
}
/*!
Returns the root model item index for the items in the combobox.
\sa setRootModelIndex()
*/
QModelIndex QComboBox::rootModelIndex() const
{
Q_D(const QComboBox);
return QModelIndex(d->root);
}
/*!
Sets the root model item \a index for the items in the combobox.
\sa rootModelIndex()
*/
void QComboBox::setRootModelIndex(const QModelIndex &index)
{
Q_D(QComboBox);
d->root = QPersistentModelIndex(index);
view()->setRootIndex(index);
update();
}
/*!
\property QComboBox::currentIndex
\brief the index of the current item in the combobox.
The current index can change when inserting or removing items.
By default, for an empty combo box or a combo box in which no current
item is set, this property has a value of -1.
*/
int QComboBox::currentIndex() const
{
Q_D(const QComboBox);
return d->currentIndex.row();
}
void QComboBox::setCurrentIndex(int index)
{
Q_D(QComboBox);
QModelIndex mi = d->model->index(index, d->modelColumn, d->root);
d->setCurrentIndex(mi);
}
void QComboBoxPrivate::setCurrentIndex(const QModelIndex &mi)
{
Q_Q(QComboBox);
bool indexChanged = (mi != currentIndex);
if (indexChanged)
currentIndex = QPersistentModelIndex(mi);
if (lineEdit) {
QString newText = q->itemText(currentIndex.row());
if (lineEdit->text() != newText)
lineEdit->setText(newText);
updateLineEditGeometry();
}
if (indexChanged) {
q->update();
_q_emitCurrentIndexChanged(currentIndex);
}
}
/*!
\property QComboBox::currentText
\brief the text of the current item
By default, for an empty combo box or a combo box in which no current
item is set, this property contains an empty string.
*/
QString QComboBox::currentText() const
{
Q_D(const QComboBox);
if (d->lineEdit)
return d->lineEdit->text();
else if (d->currentIndex.isValid())
return d->itemText(d->currentIndex);
else
return QString();
}
/*!
Returns the text for the given \a index in the combobox.
*/
QString QComboBox::itemText(int index) const
{
Q_D(const QComboBox);
QModelIndex mi = d->model->index(index, d->modelColumn, d->root);
return d->itemText(mi);
}
/*!
Returns the icon for the given \a index in the combobox.
*/
QIcon QComboBox::itemIcon(int index) const
{
Q_D(const QComboBox);
QModelIndex mi = d->model->index(index, d->modelColumn, d->root);
return d->itemIcon(mi);
}
/*!
Returns the data for the given \a role in the given \a index in the
combobox, or QVariant::Invalid if there is no data for this role.
*/
QVariant QComboBox::itemData(int index, int role) const
{
Q_D(const QComboBox);
QModelIndex mi = d->model->index(index, d->modelColumn, d->root);
return d->model->data(mi, role);
}
/*!
\fn void QComboBox::insertItem(int index, const QString &text, const QVariant &userData)
Inserts the \a text and \a userData (stored in the Qt::UserRole)
into the combobox at the given \a index.
If the index is equal to or higher than the total number of items,
the new item is appended to the list of existing items. If the
index is zero or negative, the new item is prepended to the list
of existing items.
\sa insertItems()
*/
/*!
Inserts the \a icon, \a text and \a userData (stored in the
Qt::UserRole) into the combobox at the given \a index.
If the index is equal to or higher than the total number of items,
the new item is appended to the list of existing items. If the
index is zero or negative, the new item is prepended to the list
of existing items.
\sa insertItems()
*/
void QComboBox::insertItem(int index, const QIcon &icon, const QString &text, const QVariant &userData)
{
Q_D(QComboBox);
int itemCount = count();
index = qBound(0, index, itemCount);
if (index >= d->maxCount)
return;
// For the common case where we are using the built in QStandardItemModel
// construct a QStandardItem, reducing the number of expensive signals from the model
if (QStandardItemModel *m = qobject_cast<QStandardItemModel*>(d->model)) {
QStandardItem *item = new QStandardItem(text);
if (!icon.isNull()) item->setData(icon, Qt::DecorationRole);
if (userData.isValid()) item->setData(userData, Qt::UserRole);
m->insertRow(index, item);
++itemCount;
} else {
d->inserting = true;
if (d->model->insertRows(index, 1, d->root)) {
QModelIndex item = d->model->index(index, d->modelColumn, d->root);
if (icon.isNull() && !userData.isValid()) {
d->model->setData(item, text, Qt::EditRole);
} else {
QMap<int, QVariant> values;
if (!text.isNull()) values.insert(Qt::EditRole, text);
if (!icon.isNull()) values.insert(Qt::DecorationRole, icon);
if (userData.isValid()) values.insert(Qt::UserRole, userData);
if (!values.isEmpty()) d->model->setItemData(item, values);
}
d->inserting = false;
d->_q_rowsInserted(d->root, index, index);
++itemCount;
} else {
d->inserting = false;
}
}
if (itemCount > d->maxCount)
d->model->removeRows(itemCount - 1, itemCount - d->maxCount, d->root);
}
/*!
Inserts the strings from the \a list into the combobox as separate items,
starting at the \a index specified.
If the index is equal to or higher than the total number of items, the new items
are appended to the list of existing items. If the index is zero or negative, the
new items are prepended to the list of existing items.
\sa insertItem()
*/
void QComboBox::insertItems(int index, const QStringList &list)
{
Q_D(QComboBox);
if (list.isEmpty())
return;
index = qBound(0, index, count());
int insertCount = qMin(d->maxCount - index, list.count());
if (insertCount <= 0)
return;
// For the common case where we are using the built in QStandardItemModel
// construct a QStandardItem, reducing the number of expensive signals from the model
if (QStandardItemModel *m = qobject_cast<QStandardItemModel*>(d->model)) {
QList<QStandardItem *> items;
QStandardItem *hiddenRoot = m->invisibleRootItem();
for (int i = 0; i < insertCount; ++i)
items.append(new QStandardItem(list.at(i)));
hiddenRoot->insertRows(index, items);
} else {
d->inserting = true;
if (d->model->insertRows(index, insertCount, d->root)) {
QModelIndex item;
for (int i = 0; i < insertCount; ++i) {
item = d->model->index(i+index, d->modelColumn, d->root);
d->model->setData(item, list.at(i), Qt::EditRole);
}
d->inserting = false;
d->_q_rowsInserted(d->root, index, index + insertCount - 1);
} else {
d->inserting = false;
}
}
int mc = count();
if (mc > d->maxCount)
d->model->removeRows(d->maxCount, mc - d->maxCount, d->root);
}
/*!
\since 4.4
Inserts a separator item into the combobox at the given \a index.
If the index is equal to or higher than the total number of items, the new item
is appended to the list of existing items. If the index is zero or negative, the
new item is prepended to the list of existing items.
\sa insertItem()
*/
void QComboBox::insertSeparator(int index)
{
Q_D(QComboBox);
int itemCount = count();
index = qBound(0, index, itemCount);
if (index >= d->maxCount)
return;
insertItem(index, QIcon(), QString());
QComboBoxDelegate::setSeparator(d->model, d->model->index(index, 0, d->root));
}
/*!
Removes the item at the given \a index from the combobox.
This will update the current index if the index is removed.
This function does nothing if \a index is out of range.
*/
void QComboBox::removeItem(int index)
{
Q_D(QComboBox);
if (index < 0 || index >= count())
return;
d->model->removeRows(index, 1, d->root);
}
/*!
Sets the \a text for the item on the given \a index in the combobox.
*/
void QComboBox::setItemText(int index, const QString &text)
{
Q_D(const QComboBox);
QModelIndex item = d->model->index(index, d->modelColumn, d->root);
if (item.isValid()) {
d->model->setData(item, text, Qt::EditRole);
}
}
/*!
Sets the \a icon for the item on the given \a index in the combobox.
*/
void QComboBox::setItemIcon(int index, const QIcon &icon)
{
Q_D(const QComboBox);
QModelIndex item = d->model->index(index, d->modelColumn, d->root);
if (item.isValid()) {
d->model->setData(item, icon, Qt::DecorationRole);
}
}
/*!
Sets the data \a role for the item on the given \a index in the combobox
to the specified \a value.
*/
void QComboBox::setItemData(int index, const QVariant &value, int role)
{
Q_D(const QComboBox);
QModelIndex item = d->model->index(index, d->modelColumn, d->root);
if (item.isValid()) {
d->model->setData(item, value, role);
}
}
/*!
Returns the list view used for the combobox popup.
*/
QAbstractItemView *QComboBox::view() const
{
Q_D(const QComboBox);
return const_cast<QComboBoxPrivate*>(d)->viewContainer()->itemView();
}
/*!
Sets the view to be used in the combobox popup to the given \a
itemView. The combobox takes ownership of the view.
Note: If you want to use the convenience views (like QListWidget,
QTableWidget or QTreeWidget), make sure to call setModel() on the
combobox with the convenience widgets model before calling this
function.
*/
void QComboBox::setView(QAbstractItemView *itemView)
{
Q_D(QComboBox);
if (!itemView) {
qWarning("QComboBox::setView: cannot set a 0 view");
return;
}
if (itemView->model() != d->model)
itemView->setModel(d->model);
d->viewContainer()->setItemView(itemView);
}
/*!
\reimp
*/
QSize QComboBox::minimumSizeHint() const
{
Q_D(const QComboBox);
return d->recomputeSizeHint(d->minimumSizeHint);
}
/*!
\reimp
This implementation caches the size hint to avoid resizing when
the contents change dynamically. To invalidate the cached value
change the \l sizeAdjustPolicy.
*/
QSize QComboBox::sizeHint() const
{
Q_D(const QComboBox);
return d->recomputeSizeHint(d->sizeHint);
}
/*!
Displays the list of items in the combobox. If the list is empty
then the no items will be shown.
If you reimplement this function to show a custom pop-up, make
sure you call hidePopup() to reset the internal state.
\sa hidePopup()
*/
void QComboBox::showPopup()
{
Q_D(QComboBox);
if (count() <= 0)
return;
#ifdef QT_KEYPAD_NAVIGATION
#ifndef QT_NO_COMPLETER
if (QApplication::keypadNavigationEnabled() && d->completer) {
// editable combo box is line edit plus completer
setEditFocus(true);
d->completer->complete(); // show popup
return;
}
#endif
#endif
QStyle * const style = this->style();
// set current item and select it
view()->selectionModel()->setCurrentIndex(d->currentIndex,
QItemSelectionModel::ClearAndSelect);
QComboBoxPrivateContainer* container = d->viewContainer();
QStyleOptionComboBox opt;
initStyleOption(&opt);
QRect listRect(style->subControlRect(QStyle::CC_ComboBox, &opt,
QStyle::SC_ComboBoxListBoxPopup, this));
QRect screen = d->popupGeometry(QApplication::desktop()->screenNumber(this));
QPoint below = mapToGlobal(listRect.bottomLeft());
int belowHeight = screen.bottom() - below.y();
QPoint above = mapToGlobal(listRect.topLeft());
int aboveHeight = above.y() - screen.y();
bool boundToScreen = !window()->testAttribute(Qt::WA_DontShowOnScreen);
const bool usePopup = style->styleHint(QStyle::SH_ComboBox_Popup, &opt, this);
{
int listHeight = 0;
int count = 0;
QStack<QModelIndex> toCheck;
toCheck.push(view()->rootIndex());
#ifndef QT_NO_TREEVIEW
QTreeView *treeView = qobject_cast<QTreeView*>(view());
if (treeView && treeView->header() && !treeView->header()->isHidden())
listHeight += treeView->header()->height();
#endif
while (!toCheck.isEmpty()) {
QModelIndex parent = toCheck.pop();
for (int i = 0; i < d->model->rowCount(parent); ++i) {
QModelIndex idx = d->model->index(i, d->modelColumn, parent);
if (!idx.isValid())
continue;
listHeight += view()->visualRect(idx).height() + container->spacing();
#ifndef QT_NO_TREEVIEW
if (d->model->hasChildren(idx) && treeView && treeView->isExpanded(idx))
toCheck.push(idx);
#endif
++count;
if (!usePopup && count > d->maxVisibleItems) {
toCheck.clear();
break;
}
}
}
listRect.setHeight(listHeight);
}
{
// add the spacing for the grid on the top and the bottom;
int heightMargin = 2*container->spacing();
// add the frame of the container
int marginTop, marginBottom;
container->getContentsMargins(0, &marginTop, 0, &marginBottom);
heightMargin += marginTop + marginBottom;
//add the frame of the view
view()->getContentsMargins(0, &marginTop, 0, &marginBottom);
marginTop += static_cast<QAbstractScrollAreaPrivate *>(QObjectPrivate::get(view()))->top;
marginBottom += static_cast<QAbstractScrollAreaPrivate *>(QObjectPrivate::get(view()))->bottom;
heightMargin += marginTop + marginBottom;
listRect.setHeight(listRect.height() + heightMargin);
}
// Add space for margin at top and bottom if the style wants it.
if (usePopup)
listRect.setHeight(listRect.height() + style->pixelMetric(QStyle::PM_MenuVMargin, &opt, this) * 2);
// Make sure the popup is wide enough to display its contents.
if (usePopup) {
const int diff = d->computeWidthHint() - width();
if (diff > 0)
listRect.setWidth(listRect.width() + diff);
}
//we need to activate the layout to make sure the min/maximum size are set when the widget was not yet show
container->layout()->activate();
//takes account of the minimum/maximum size of the container
listRect.setSize( listRect.size().expandedTo(container->minimumSize())
.boundedTo(container->maximumSize()));
// make sure the widget fits on screen
if (boundToScreen) {
if (listRect.width() > screen.width() )
listRect.setWidth(screen.width());
if (mapToGlobal(listRect.bottomRight()).x() > screen.right()) {
below.setX(screen.x() + screen.width() - listRect.width());
above.setX(screen.x() + screen.width() - listRect.width());
}
if (mapToGlobal(listRect.topLeft()).x() < screen.x() ) {
below.setX(screen.x());
above.setX(screen.x());
}
}
if (usePopup) {
// Position horizontally.
listRect.moveLeft(above.x());
// Position vertically so the curently selected item lines up
// with the combo box.
const QRect currentItemRect = view()->visualRect(view()->currentIndex());
const int offset = listRect.top() - currentItemRect.top();
listRect.moveTop(above.y() + offset - listRect.top());
// Clamp the listRect height and vertical position so we don't expand outside the
// available screen geometry.This may override the vertical position, but it is more
// important to show as much as possible of the popup.
const int height = !boundToScreen ? listRect.height() : qMin(listRect.height(), screen.height());
listRect.setHeight(height);
if (boundToScreen) {
if (listRect.top() < screen.top())
listRect.moveTop(screen.top());
if (listRect.bottom() > screen.bottom())
listRect.moveBottom(screen.bottom());
}
} else if (!boundToScreen || listRect.height() <= belowHeight) {
listRect.moveTopLeft(below);
} else if (listRect.height() <= aboveHeight) {
listRect.moveBottomLeft(above);
} else if (belowHeight >= aboveHeight) {
listRect.setHeight(belowHeight);
listRect.moveTopLeft(below);
} else {
listRect.setHeight(aboveHeight);
listRect.moveBottomLeft(above);
}
#ifndef QT_NO_IM
if (QInputContext *qic = inputContext())
qic->reset();
#endif
QScrollBar *sb = view()->horizontalScrollBar();
Qt::ScrollBarPolicy policy = view()->horizontalScrollBarPolicy();
bool needHorizontalScrollBar = (policy == Qt::ScrollBarAsNeeded || policy == Qt::ScrollBarAlwaysOn)
&& sb->minimum() < sb->maximum();
if (needHorizontalScrollBar) {
listRect.adjust(0, 0, 0, sb->height());
}
container->setGeometry(listRect);
#ifndef Q_WS_MAC
const bool updatesEnabled = container->updatesEnabled();
#endif
#if defined(Q_WS_WIN) && !defined(QT_NO_EFFECTS)
bool scrollDown = (listRect.topLeft() == below);
if (QApplication::isEffectEnabled(Qt::UI_AnimateCombo)
&& !style->styleHint(QStyle::SH_ComboBox_Popup, &opt, this) && !window()->testAttribute(Qt::WA_DontShowOnScreen))
qScrollEffect(container, scrollDown ? QEffects::DownScroll : QEffects::UpScroll, 150);
#endif
// Don't disable updates on Mac OS X. Windows are displayed immediately on this platform,
// which means that the window will be visible before the call to container->show() returns.
// If updates are disabled at this point we'll miss our chance at painting the popup
// menu before it's shown, causing flicker since the window then displays the standard gray
// background.
#ifndef Q_WS_MAC
container->setUpdatesEnabled(false);
#endif
container->raise();
container->show();
container->updateScrollers();
view()->setFocus();
view()->scrollTo(view()->currentIndex(),
style->styleHint(QStyle::SH_ComboBox_Popup, &opt, this)
? QAbstractItemView::PositionAtCenter
: QAbstractItemView::EnsureVisible);
#ifndef Q_WS_MAC
container->setUpdatesEnabled(updatesEnabled);
#endif
container->update();
#ifdef QT_KEYPAD_NAVIGATION
if (QApplication::keypadNavigationEnabled())
view()->setEditFocus(true);
#endif
}
/*!
Hides the list of items in the combobox if it is currently visible
and resets the internal state, so that if the custom pop-up was
shown inside the reimplemented showPopup(), then you also need to
reimplement the hidePopup() function to hide your custom pop-up
and call the base class implementation to reset the internal state
whenever your custom pop-up widget is hidden.
\sa showPopup()
*/
void QComboBox::hidePopup()
{
Q_D(QComboBox);
if (d->container && d->container->isVisible()) {
#if !defined(QT_NO_EFFECTS)
d->model->blockSignals(true);
d->container->itemView()->blockSignals(true);
d->container->blockSignals(true);
// Flash selected/triggered item (if any).
if (style()->styleHint(QStyle::SH_Menu_FlashTriggeredItem)) {
QItemSelectionModel *selectionModel = view() ? view()->selectionModel() : 0;
if (selectionModel && selectionModel->hasSelection()) {
QEventLoop eventLoop;
const QItemSelection selection = selectionModel->selection();
// Deselect item and wait 60 ms.
selectionModel->select(selection, QItemSelectionModel::Toggle);
QTimer::singleShot(60, &eventLoop, SLOT(quit()));
eventLoop.exec();
// Select item and wait 20 ms.
selectionModel->select(selection, QItemSelectionModel::Toggle);
QTimer::singleShot(20, &eventLoop, SLOT(quit()));
eventLoop.exec();
}
}
// Fade out.
bool needFade = style()->styleHint(QStyle::SH_Menu_FadeOutOnHide);
if (needFade) {
#if defined(Q_WS_MAC)
macWindowFade(qt_mac_window_for(d->container));
#endif // Q_WS_MAC
// Other platform implementations welcome :-)
}
d->model->blockSignals(false);
d->container->itemView()->blockSignals(false);
d->container->blockSignals(false);
if (!needFade)
#endif // QT_NO_EFFECTS
// Fade should implicitly hide as well ;-)
d->container->hide();
}
#ifdef QT_KEYPAD_NAVIGATION
if (QApplication::keypadNavigationEnabled() && isEditable() && hasFocus())
setEditFocus(true);
#endif
d->_q_resetButton();
}
/*!
Clears the combobox, removing all items.
Note: If you have set an external model on the combobox this model
will still be cleared when calling this function.
*/
void QComboBox::clear()
{
Q_D(QComboBox);
d->model->removeRows(0, d->model->rowCount(d->root), d->root);
}
/*!
\fn void QComboBox::clearValidator()
Use setValidator(0) instead.
*/
/*!
Clears the contents of the line edit used for editing in the combobox.
*/
void QComboBox::clearEditText()
{
Q_D(QComboBox);
if (d->lineEdit)
d->lineEdit->clear();
}
/*!
Sets the \a text in the combobox's text edit.
*/
void QComboBox::setEditText(const QString &text)
{
Q_D(QComboBox);
if (d->lineEdit)
d->lineEdit->setText(text);
}
/*!
\reimp
*/
void QComboBox::focusInEvent(QFocusEvent *e)
{
Q_D(QComboBox);
update();
if (d->lineEdit) {
d->lineEdit->event(e);
#ifndef QT_NO_COMPLETER
if (d->lineEdit->completer())
d->lineEdit->completer()->setWidget(this);
#endif
}
}
/*!
\reimp
*/
void QComboBox::focusOutEvent(QFocusEvent *e)
{
Q_D(QComboBox);
update();
if (d->lineEdit)
d->lineEdit->event(e);
}
/*! \reimp */
void QComboBox::changeEvent(QEvent *e)
{
Q_D(QComboBox);
switch (e->type()) {
case QEvent::StyleChange:
d->updateDelegate();
#ifdef Q_WS_MAC
case QEvent::MacSizeChange:
#endif
d->sizeHint = QSize(); // invalidate size hint
d->minimumSizeHint = QSize();
d->updateLayoutDirection();
if (d->lineEdit)
d->updateLineEditGeometry();
d->setLayoutItemMargins(QStyle::SE_ComboBoxLayoutItem);
// ### need to update scrollers etc. as well here
break;
case QEvent::EnabledChange:
if (!isEnabled())
hidePopup();
break;
case QEvent::PaletteChange: {
d->updateViewContainerPaletteAndOpacity();
break;
}
case QEvent::FontChange:
d->sizeHint = QSize(); // invalidate size hint
d->viewContainer()->setFont(font());
if (d->lineEdit)
d->updateLineEditGeometry();
break;
default:
break;
}
QWidget::changeEvent(e);
}
/*!
\reimp
*/
void QComboBox::resizeEvent(QResizeEvent *)
{
Q_D(QComboBox);
d->updateLineEditGeometry();
}
/*!
\reimp
*/
void QComboBox::paintEvent(QPaintEvent *)
{
QStylePainter painter(this);
painter.setPen(palette().color(QPalette::Text));
// draw the combobox frame, focusrect and selected etc.
QStyleOptionComboBox opt;
initStyleOption(&opt);
painter.drawComplexControl(QStyle::CC_ComboBox, opt);
// draw the icon and text
painter.drawControl(QStyle::CE_ComboBoxLabel, opt);
}
/*!
\reimp
*/
void QComboBox::showEvent(QShowEvent *e)
{
Q_D(QComboBox);
if (!d->shownOnce && d->sizeAdjustPolicy == QComboBox::AdjustToContentsOnFirstShow) {
d->sizeHint = QSize();
updateGeometry();
}
d->shownOnce = true;
QWidget::showEvent(e);
}
/*!
\reimp
*/
void QComboBox::hideEvent(QHideEvent *)
{
hidePopup();
}
/*!
\reimp
*/
bool QComboBox::event(QEvent *event)
{
Q_D(QComboBox);
switch(event->type()) {
case QEvent::LayoutDirectionChange:
case QEvent::ApplicationLayoutDirectionChange:
d->updateLayoutDirection();
d->updateLineEditGeometry();
break;
case QEvent::HoverEnter:
case QEvent::HoverLeave:
case QEvent::HoverMove:
if (const QHoverEvent *he = static_cast<const QHoverEvent *>(event))
d->updateHoverControl(he->pos());
break;
case QEvent::ShortcutOverride:
if (d->lineEdit)
return d->lineEdit->event(event);
break;
#ifdef QT_KEYPAD_NAVIGATION
case QEvent::EnterEditFocus:
if (!d->lineEdit)
setEditFocus(false); // We never want edit focus if we are not editable
else
d->lineEdit->event(event); //so cursor starts
break;
case QEvent::LeaveEditFocus:
if (d->lineEdit)
d->lineEdit->event(event); //so cursor stops
break;
#endif
default:
break;
}
return QWidget::event(event);
}
/*!
\reimp
*/
void QComboBox::mousePressEvent(QMouseEvent *e)
{
Q_D(QComboBox);
QStyleOptionComboBox opt;
initStyleOption(&opt);
QStyle::SubControl sc = style()->hitTestComplexControl(QStyle::CC_ComboBox, &opt, e->pos(),
this);
if (e->button() == Qt::LeftButton && (sc == QStyle::SC_ComboBoxArrow || !isEditable())
&& !d->viewContainer()->isVisible()) {
if (sc == QStyle::SC_ComboBoxArrow)
d->updateArrow(QStyle::State_Sunken);
#ifdef QT_KEYPAD_NAVIGATION
if (!d->lineEdit) {
#endif
// We've restricted the next couple of lines, because by not calling
// viewContainer(), we avoid creating the QComboBoxPrivateContainer.
d->viewContainer()->blockMouseReleaseTimer.start(QApplication::doubleClickInterval());
d->viewContainer()->initialClickPosition = mapToGlobal(e->pos());
#ifdef QT_KEYPAD_NAVIGATION
}
#endif
showPopup();
} else {
#ifdef QT_KEYPAD_NAVIGATION
if (QApplication::keypadNavigationEnabled() && sc == QStyle::SC_ComboBoxEditField && d->lineEdit) {
d->lineEdit->event(e); //so lineedit can move cursor, etc
return;
}
#endif
QWidget::mousePressEvent(e);
}
}
/*!
\reimp
*/
void QComboBox::mouseReleaseEvent(QMouseEvent *e)
{
Q_D(QComboBox);
Q_UNUSED(e);
d->updateArrow(QStyle::State_None);
}
/*!
\reimp
*/
void QComboBox::keyPressEvent(QKeyEvent *e)
{
Q_D(QComboBox);
#ifndef QT_NO_COMPLETER
if (d->lineEdit
&& d->lineEdit->completer()
&& d->lineEdit->completer()->popup()
&& d->lineEdit->completer()->popup()->isVisible()) {
// provide same autocompletion support as line edit
d->lineEdit->event(e);
return;
}
#endif
enum Move { NoMove=0 , MoveUp , MoveDown , MoveFirst , MoveLast};
Move move = NoMove;
int newIndex = currentIndex();
switch (e->key()) {
case Qt::Key_Up:
if (e->modifiers() & Qt::ControlModifier)
break; // pass to line edit for auto completion
case Qt::Key_PageUp:
#ifdef QT_KEYPAD_NAVIGATION
if (QApplication::keypadNavigationEnabled())
e->ignore();
else
#endif
move = MoveUp;
break;
case Qt::Key_Down:
if (e->modifiers() & Qt::AltModifier) {
showPopup();
return;
} else if (e->modifiers() & Qt::ControlModifier)
break; // pass to line edit for auto completion
// fall through
case Qt::Key_PageDown:
#ifdef QT_KEYPAD_NAVIGATION
if (QApplication::keypadNavigationEnabled())
e->ignore();
else
#endif
move = MoveDown;
break;
case Qt::Key_Home:
if (!d->lineEdit)
move = MoveFirst;
break;
case Qt::Key_End:
if (!d->lineEdit)
move = MoveLast;
break;
case Qt::Key_F4:
if (!e->modifiers()) {
showPopup();
return;
}
break;
case Qt::Key_Space:
if (!d->lineEdit) {
showPopup();
return;
}
case Qt::Key_Enter:
case Qt::Key_Return:
case Qt::Key_Escape:
if (!d->lineEdit)
e->ignore();
break;
#ifdef QT_KEYPAD_NAVIGATION
case Qt::Key_Select:
if (QApplication::keypadNavigationEnabled()
&& (!hasEditFocus() || !d->lineEdit)) {
showPopup();
return;
}
break;
case Qt::Key_Left:
case Qt::Key_Right:
if (QApplication::keypadNavigationEnabled() && !hasEditFocus())
e->ignore();
break;
case Qt::Key_Back:
if (QApplication::keypadNavigationEnabled()) {
if (!hasEditFocus() || !d->lineEdit)
e->ignore();
} else {
e->ignore(); // let the surounding dialog have it
}
break;
#endif
default:
if (!d->lineEdit) {
if (!e->text().isEmpty())
d->keyboardSearchString(e->text());
else
e->ignore();
}
}
if (move != NoMove) {
e->accept();
switch (move) {
case MoveFirst:
newIndex = -1;
case MoveDown:
newIndex++;
while ((newIndex < count()) && !(d->model->flags(d->model->index(newIndex,d->modelColumn,d->root)) & Qt::ItemIsEnabled))
newIndex++;
break;
case MoveLast:
newIndex = count();
case MoveUp:
newIndex--;
while ((newIndex >= 0) && !(d->model->flags(d->model->index(newIndex,d->modelColumn,d->root)) & Qt::ItemIsEnabled))
newIndex--;
break;
default:
e->ignore();
break;
}
if (newIndex >= 0 && newIndex < count() && newIndex != currentIndex()) {
setCurrentIndex(newIndex);
d->emitActivated(d->currentIndex);
}
} else if (d->lineEdit) {
d->lineEdit->event(e);
}
}
/*!
\reimp
*/
void QComboBox::keyReleaseEvent(QKeyEvent *e)
{
Q_D(QComboBox);
if (d->lineEdit)
d->lineEdit->event(e);
}
/*!
\reimp
*/
#ifndef QT_NO_WHEELEVENT
void QComboBox::wheelEvent(QWheelEvent *e)
{
Q_D(QComboBox);
if (!d->viewContainer()->isVisible()) {
int newIndex = currentIndex();
if (e->delta() > 0) {
newIndex--;
while ((newIndex >= 0) && !(d->model->flags(d->model->index(newIndex,d->modelColumn,d->root)) & Qt::ItemIsEnabled))
newIndex--;
} else {
newIndex++;
while ((newIndex < count()) && !(d->model->flags(d->model->index(newIndex,d->modelColumn,d->root)) & Qt::ItemIsEnabled))
newIndex++;
}
if (newIndex >= 0 && newIndex < count() && newIndex != currentIndex()) {
setCurrentIndex(newIndex);
d->emitActivated(d->currentIndex);
}
e->accept();
}
}
#endif
#ifndef QT_NO_CONTEXTMENU
/*!
\reimp
*/
void QComboBox::contextMenuEvent(QContextMenuEvent *e)
{
Q_D(QComboBox);
if (d->lineEdit) {
Qt::ContextMenuPolicy p = d->lineEdit->contextMenuPolicy();
d->lineEdit->setContextMenuPolicy(Qt::DefaultContextMenu);
d->lineEdit->event(e);
d->lineEdit->setContextMenuPolicy(p);
}
}
#endif // QT_NO_CONTEXTMENU
void QComboBoxPrivate::keyboardSearchString(const QString &text)
{
// use keyboardSearch from the listView so we do not duplicate code
QAbstractItemView *view = viewContainer()->itemView();
view->setCurrentIndex(currentIndex);
int currentRow = view->currentIndex().row();
view->keyboardSearch(text);
if (currentRow != view->currentIndex().row()) {
setCurrentIndex(view->currentIndex());
emitActivated(currentIndex);
}
}
void QComboBoxPrivate::modelChanged()
{
Q_Q(QComboBox);
if (sizeAdjustPolicy == QComboBox::AdjustToContents) {
sizeHint = QSize();
adjustComboBoxSize();
q->updateGeometry();
}
}
/*!
\reimp
*/
void QComboBox::inputMethodEvent(QInputMethodEvent *e)
{
Q_D(QComboBox);
if (d->lineEdit) {
d->lineEdit->event(e);
} else {
if (!e->commitString().isEmpty())
d->keyboardSearchString(e->commitString());
else
e->ignore();
}
}
/*!
\reimp
*/
QVariant QComboBox::inputMethodQuery(Qt::InputMethodQuery query) const
{
Q_D(const QComboBox);
if (d->lineEdit)
return d->lineEdit->inputMethodQuery(query);
return QWidget::inputMethodQuery(query);
}
/*!
\fn bool QComboBox::editable() const
Use isEditable() instead.
*/
/*!
\fn void QComboBox::insertItem(const QPixmap &pixmap, int index)
Use an insertItem() function that takes a QIcon instead, for
example, insertItem(index, QIcon(pixmap)).
*/
/*!
\fn void QComboBox::insertItem(const QPixmap &pixmap, const QString &text, int index)
Use an insertItem() function that takes a QIcon instead, for
example, insertItem(index, QIcon(pixmap), text).
\sa insertItems()
*/
/*!
\fn void QComboBox::changeItem(const QString &text, int index)
Use setItemText() instead.
*/
/*!
\fn void QComboBox::changeItem(const QPixmap &pixmap, int index)
Use setItemIcon() instead, for example,
setItemIcon(index, QIcon(pixmap)).
*/
/*!
\fn void QComboBox::changeItem(const QPixmap &pixmap, const QString &text, int index)
Use setItem() instead, for example, setItem(index, QIcon(pixmap),text).
*/
/*!
\fn void QComboBox::addItem(const QString &text, const QVariant &userData)
Adds an item to the combobox with the given \a text, and
containing the specified \a userData (stored in the Qt::UserRole).
The item is appended to the list of existing items.
*/
/*!
\fn void QComboBox::addItem(const QIcon &icon, const QString &text,
const QVariant &userData)
Adds an item to the combobox with the given \a icon and \a text,
and containing the specified \a userData (stored in the
Qt::UserRole). The item is appended to the list of existing items.
*/
/*!
\fn void QComboBox::addItems(const QStringList &texts)
Adds each of the strings in the given \a texts to the combobox. Each item
is appended to the list of existing items in turn.
*/
/*!
\fn void QComboBox::editTextChanged(const QString &text)
This signal is emitted when the text in the combobox's line edit
widget is changed. The new text is specified by \a text.
*/
/*!
\fn QComboBox::InsertPolicy QComboBox::insertionPolicy() const
\compat
Use QComboBox::insertPolicy instead.
*/
/*!
\fn void QComboBox::setInsertionPolicy(InsertPolicy policy)
\compat
Use QComboBox::insertPolicy instead.
*/
/*!
\fn void QComboBox::setCurrentText(const QString &text)
\compat
Use setItemText() instead.
\sa currentIndex()
*/
/*!
\fn QString QComboBox::text(int index) const
\compat
Use itemText() instead.
*/
/*!
\fn QPixmap QComboBox::pixmap(int index) const
\compat
Use itemIcon() instead.
*/
/*!
\fn void QComboBox::insertStringList(const QStringList &list, int index)
\compat
Use insertItems() instead.
*/
/*!
\fn void QComboBox::insertItem(const QString &text, int index)
\compat
*/
/*!
\fn void QComboBox::clearEdit()
\compat
Use clearEditText() instead.
*/
/*!
\property QComboBox::frame
\brief whether the combo box draws itself with a frame
If enabled (the default) the combo box draws itself inside a
frame, otherwise the combo box draws itself without any frame.
*/
bool QComboBox::hasFrame() const
{
Q_D(const QComboBox);
return d->frame;
}
void QComboBox::setFrame(bool enable)
{
Q_D(QComboBox);
d->frame = enable;
update();
updateGeometry();
}
/*!
\property QComboBox::modelColumn
\brief the column in the model that is visible.
If set prior to populating the combo box, the pop-up view will
not be affected and will show the first column (using this property's
default value).
By default, this property has a value of 0.
*/
int QComboBox::modelColumn() const
{
Q_D(const QComboBox);
return d->modelColumn;
}
void QComboBox::setModelColumn(int visibleColumn)
{
Q_D(QComboBox);
d->modelColumn = visibleColumn;
QListView *lv = qobject_cast<QListView *>(d->viewContainer()->itemView());
if (lv)
lv->setModelColumn(visibleColumn);
#ifndef QT_NO_COMPLETER
if (d->lineEdit && d->lineEdit->completer()
&& d->lineEdit->completer() == d->completer)
d->lineEdit->completer()->setCompletionColumn(visibleColumn);
#endif
setCurrentIndex(currentIndex()); //update the text to the text of the new column;
}
/*!
\fn int QComboBox::currentItem() const
Use currentIndex() instead.
*/
/*!
\fn void QComboBox::setCurrentItem(int)
Use setCurrentIndex(int) instead.
*/
/*!
\fn void QComboBox::popup()
Use showPopup() instead.
*/
/*!
\fn void QComboBox::textChanged(const QString &text)
Use the editTextChanged(const QString &text) signal instead.
*/
/*!
\typedef QComboBox::Policy
\compat
Use QComboBox::InsertPolicy instead.
*/
QT_END_NAMESPACE
#include "moc_qcombobox.cpp"
#endif // QT_NO_COMBOBOX