| /**************************************************************************** |
| ** |
| ** 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 "qstatusbar.h" |
| #ifndef QT_NO_STATUSBAR |
| |
| #include "qlist.h" |
| #include "qdebug.h" |
| #include "qevent.h" |
| #include "qlayout.h" |
| #include "qpainter.h" |
| #include "qtimer.h" |
| #include "qstyle.h" |
| #include "qstyleoption.h" |
| #include "qsizegrip.h" |
| #include "qmainwindow.h" |
| |
| #include <private/qlayoutengine_p.h> |
| #include <private/qwidget_p.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| class QStatusBarPrivate : public QWidgetPrivate |
| { |
| Q_DECLARE_PUBLIC(QStatusBar) |
| public: |
| QStatusBarPrivate() {} |
| |
| struct SBItem { |
| SBItem(QWidget* widget, int stretch, bool permanent) |
| : s(stretch), w(widget), p(permanent) {} |
| int s; |
| QWidget * w; |
| bool p; |
| }; |
| |
| QList<SBItem *> items; |
| QString tempItem; |
| |
| QBoxLayout * box; |
| QTimer * timer; |
| |
| #ifndef QT_NO_SIZEGRIP |
| QSizeGrip * resizer; |
| bool showSizeGrip; |
| #endif |
| |
| int savedStrut; |
| |
| #ifdef Q_WS_MAC |
| QPoint dragStart; |
| #endif |
| |
| int indexToLastNonPermanentWidget() const |
| { |
| int i = items.size() - 1; |
| for (; i >= 0; --i) { |
| SBItem *item = items.at(i); |
| if (!(item && item->p)) |
| break; |
| } |
| return i; |
| } |
| |
| #ifndef QT_NO_SIZEGRIP |
| void tryToShowSizeGrip() |
| { |
| if (!showSizeGrip) |
| return; |
| showSizeGrip = false; |
| if (!resizer || resizer->isVisible()) |
| return; |
| resizer->setAttribute(Qt::WA_WState_ExplicitShowHide, false); |
| QMetaObject::invokeMethod(resizer, "_q_showIfNotHidden", Qt::DirectConnection); |
| resizer->setAttribute(Qt::WA_WState_ExplicitShowHide, false); |
| } |
| #endif |
| |
| QRect messageRect() const; |
| }; |
| |
| |
| QRect QStatusBarPrivate::messageRect() const |
| { |
| Q_Q(const QStatusBar); |
| bool rtl = q->layoutDirection() == Qt::RightToLeft; |
| |
| int left = 6; |
| int right = q->width() - 12; |
| |
| #ifndef QT_NO_SIZEGRIP |
| if (resizer && resizer->isVisible()) { |
| if (rtl) |
| left = resizer->x() + resizer->width(); |
| else |
| right = resizer->x(); |
| } |
| #endif |
| |
| for (int i=0; i<items.size(); ++i) { |
| QStatusBarPrivate::SBItem* item = items.at(i); |
| if (!item) |
| break; |
| if (item->p && item->w->isVisible()) { |
| if (item->p) { |
| if (rtl) |
| left = qMax(left, item->w->x() + item->w->width() + 2); |
| else |
| right = qMin(right, item->w->x() - 2); |
| } |
| break; |
| } |
| } |
| return QRect(left, 0, right-left, q->height()); |
| } |
| |
| |
| /*! |
| \class QStatusBar |
| \brief The QStatusBar class provides a horizontal bar suitable for |
| presenting status information. |
| |
| \ingroup mainwindow-classes |
| \ingroup helpsystem |
| |
| |
| Each status indicator falls into one of three categories: |
| |
| \list |
| \o \e Temporary - briefly occupies most of the status bar. Used |
| to explain tool tip texts or menu entries, for example. |
| \o \e Normal - occupies part of the status bar and may be hidden |
| by temporary messages. Used to display the page and line |
| number in a word processor, for example. |
| \o \e Permanent - is never hidden. Used for important mode |
| indications, for example, some applications put a Caps Lock |
| indicator in the status bar. |
| \endlist |
| |
| QStatusBar lets you display all three types of indicators. |
| |
| Typically, a request for the status bar functionality occurs in |
| relation to a QMainWindow object. QMainWindow provides a main |
| application window, with a menu bar, tool bars, dock widgets \e |
| and a status bar around a large central widget. The status bar can |
| be retrieved using the QMainWindow::statusBar() function, and |
| replaced using the QMainWindow::setStatusBar() function. |
| |
| Use the showMessage() slot to display a \e temporary message: |
| |
| \snippet examples/mainwindows/dockwidgets/mainwindow.cpp 8 |
| |
| To remove a temporary message, use the clearMessage() slot, or set |
| a time limit when calling showMessage(). For example: |
| |
| \snippet examples/mainwindows/dockwidgets/mainwindow.cpp 3 |
| |
| Use the currentMessage() function to retrieve the temporary |
| message currently shown. The QStatusBar class also provide the |
| messageChanged() signal which is emitted whenever the temporary |
| status message changes. |
| |
| \target permanent message |
| \e Normal and \e Permanent messages are displayed by creating a |
| small widget (QLabel, QProgressBar or even QToolButton) and then |
| adding it to the status bar using the addWidget() or the |
| addPermanentWidget() function. Use the removeWidget() function to |
| remove such messages from the status bar. |
| |
| \snippet doc/src/snippets/code/src_gui_widgets_qstatusbar.cpp 0 |
| |
| By default QStatusBar provides a QSizeGrip in the lower-right |
| corner. You can disable it using the setSizeGripEnabled() |
| function. Use the isSizeGripEnabled() function to determine the |
| current status of the size grip. |
| |
| \image plastique-statusbar.png A status bar shown in the Plastique widget style |
| |
| \sa QMainWindow, QStatusTipEvent, {fowler}{GUI Design Handbook: |
| Status Bar}, {Application Example} |
| */ |
| |
| #ifdef QT3_SUPPORT |
| /*! |
| Constructs a status bar with a size grip and the given \a parent |
| and object \a name. |
| |
| Use the QStatusBar() constructor and the QObject::setObjectName() |
| function instead. |
| |
| \oldcode |
| QStatusBar *myStatusBar = new QStatusBar(parent, name); |
| \newcode |
| QStatusBar *myStatusBar = new QStatusBar(parent); |
| myStatusBar->setObjectName(name); |
| \endcode |
| */ |
| QStatusBar::QStatusBar(QWidget * parent, const char *name) |
| : QWidget(*new QStatusBarPrivate, parent, 0) |
| { |
| Q_D(QStatusBar); |
| setObjectName(QString::fromAscii(name)); |
| d->box = 0; |
| d->timer = 0; |
| |
| #ifndef QT_NO_SIZEGRIP |
| d->resizer = 0; |
| d->showSizeGrip = false; |
| setSizeGripEnabled(true); // causes reformat() |
| #else |
| reformat(); |
| #endif |
| } |
| |
| |
| /*! |
| \fn void QStatusBar::addWidget(QWidget * widget, int stretch, bool permanent) |
| |
| Use addWidget() or addPermanentWidget() instead, depending on the |
| value of the \a permanent parameter. |
| |
| \oldcode |
| QStatusBar *myStatusBar; |
| myStatusBar->addWidget(widget, stretch, permanent); // permanent == true |
| \newcode |
| QStatusBar *myStatusBar; |
| myStatusBar->addPermanentWidget(widget, stretch); |
| \endcode |
| */ |
| |
| #endif |
| |
| /*! |
| Constructs a status bar with a size grip and the given \a parent. |
| |
| \sa setSizeGripEnabled() |
| */ |
| QStatusBar::QStatusBar(QWidget * parent) |
| : QWidget(*new QStatusBarPrivate, parent, 0) |
| { |
| Q_D(QStatusBar); |
| d->box = 0; |
| d->timer = 0; |
| |
| #ifndef QT_NO_SIZEGRIP |
| d->resizer = 0; |
| setSizeGripEnabled(true); // causes reformat() |
| #else |
| reformat(); |
| #endif |
| } |
| |
| /*! |
| Destroys this status bar and frees any allocated resources and |
| child widgets. |
| */ |
| QStatusBar::~QStatusBar() |
| { |
| Q_D(QStatusBar); |
| while (!d->items.isEmpty()) |
| delete d->items.takeFirst(); |
| } |
| |
| |
| /*! |
| Adds the given \a widget to this status bar, reparenting the |
| widget if it isn't already a child of this QStatusBar object. The |
| \a stretch parameter is used to compute a suitable size for the |
| given \a widget as the status bar grows and shrinks. The default |
| stretch factor is 0, i.e giving the widget a minimum of space. |
| |
| The widget is located to the far left of the first permanent |
| widget (see addPermanentWidget()) and may be obscured by temporary |
| messages. |
| |
| \sa insertWidget(), removeWidget(), addPermanentWidget() |
| */ |
| |
| void QStatusBar::addWidget(QWidget * widget, int stretch) |
| { |
| if (!widget) |
| return; |
| insertWidget(d_func()->indexToLastNonPermanentWidget() + 1, widget, stretch); |
| } |
| |
| /*! |
| \since 4.2 |
| |
| Inserts the given \a widget at the given \a index to this status bar, |
| reparenting the widget if it isn't already a child of this |
| QStatusBar object. If \a index is out of range, the widget is appended |
| (in which case it is the actual index of the widget that is returned). |
| |
| The \a stretch parameter is used to compute a suitable size for |
| the given \a widget as the status bar grows and shrinks. The |
| default stretch factor is 0, i.e giving the widget a minimum of |
| space. |
| |
| The widget is located to the far left of the first permanent |
| widget (see addPermanentWidget()) and may be obscured by temporary |
| messages. |
| |
| \sa addWidget(), removeWidget(), addPermanentWidget() |
| */ |
| int QStatusBar::insertWidget(int index, QWidget *widget, int stretch) |
| { |
| if (!widget) |
| return -1; |
| |
| Q_D(QStatusBar); |
| QStatusBarPrivate::SBItem* item = new QStatusBarPrivate::SBItem(widget, stretch, false); |
| |
| int idx = d->indexToLastNonPermanentWidget(); |
| if (index < 0 || index > d->items.size() || (idx >= 0 && index > idx + 1)) { |
| qWarning("QStatusBar::insertWidget: Index out of range (%d), appending widget", index); |
| index = idx + 1; |
| } |
| d->items.insert(index, item); |
| |
| if (!d->tempItem.isEmpty()) |
| widget->hide(); |
| |
| reformat(); |
| if (!widget->isHidden() || !widget->testAttribute(Qt::WA_WState_ExplicitShowHide)) |
| widget->show(); |
| |
| return index; |
| } |
| |
| /*! |
| Adds the given \a widget permanently to this status bar, |
| reparenting the widget if it isn't already a child of this |
| QStatusBar object. The \a stretch parameter is used to compute a |
| suitable size for the given \a widget as the status bar grows and |
| shrinks. The default stretch factor is 0, i.e giving the widget a |
| minimum of space. |
| |
| Permanently means that the widget may not be obscured by temporary |
| messages. It is is located at the far right of the status bar. |
| |
| \sa insertPermanentWidget(), removeWidget(), addWidget() |
| */ |
| |
| void QStatusBar::addPermanentWidget(QWidget * widget, int stretch) |
| { |
| if (!widget) |
| return; |
| insertPermanentWidget(d_func()->items.size(), widget, stretch); |
| } |
| |
| |
| /*! |
| \since 4.2 |
| |
| Inserts the given \a widget at the given \a index permanently to this status bar, |
| reparenting the widget if it isn't already a child of this |
| QStatusBar object. If \a index is out of range, the widget is appended |
| (in which case it is the actual index of the widget that is returned). |
| |
| The \a stretch parameter is used to compute a |
| suitable size for the given \a widget as the status bar grows and |
| shrinks. The default stretch factor is 0, i.e giving the widget a |
| minimum of space. |
| |
| Permanently means that the widget may not be obscured by temporary |
| messages. It is is located at the far right of the status bar. |
| |
| \sa addPermanentWidget(), removeWidget(), addWidget() |
| */ |
| int QStatusBar::insertPermanentWidget(int index, QWidget *widget, int stretch) |
| { |
| if (!widget) |
| return -1; |
| |
| Q_D(QStatusBar); |
| QStatusBarPrivate::SBItem* item = new QStatusBarPrivate::SBItem(widget, stretch, true); |
| |
| int idx = d->indexToLastNonPermanentWidget(); |
| if (index < 0 || index > d->items.size() || (idx >= 0 && index <= idx)) { |
| qWarning("QStatusBar::insertPermanentWidget: Index out of range (%d), appending widget", index); |
| index = d->items.size(); |
| } |
| d->items.insert(index, item); |
| |
| reformat(); |
| if (!widget->isHidden() || !widget->testAttribute(Qt::WA_WState_ExplicitShowHide)) |
| widget->show(); |
| |
| return index; |
| } |
| |
| /*! |
| Removes the specified \a widget from the status bar. |
| |
| \note This function does not delete the widget but \e hides it. |
| To add the widget again, you must call both the addWidget() and |
| show() functions. |
| |
| \sa addWidget(), addPermanentWidget(), clearMessage() |
| */ |
| |
| void QStatusBar::removeWidget(QWidget *widget) |
| { |
| if (!widget) |
| return; |
| |
| Q_D(QStatusBar); |
| bool found = false; |
| QStatusBarPrivate::SBItem* item; |
| for (int i=0; i<d->items.size(); ++i) { |
| item = d->items.at(i); |
| if (!item) |
| break; |
| if (item->w == widget) { |
| d->items.removeAt(i); |
| item->w->hide(); |
| delete item; |
| found = true; |
| break; |
| } |
| } |
| |
| if (found) |
| reformat(); |
| #if defined(QT_DEBUG) |
| else |
| qDebug("QStatusBar::removeWidget(): Widget not found."); |
| #endif |
| } |
| |
| /*! |
| \property QStatusBar::sizeGripEnabled |
| |
| \brief whether the QSizeGrip in the bottom-right corner of the |
| status bar is enabled |
| |
| The size grip is enabled by default. |
| */ |
| |
| bool QStatusBar::isSizeGripEnabled() const |
| { |
| #ifdef QT_NO_SIZEGRIP |
| return false; |
| #else |
| Q_D(const QStatusBar); |
| return !!d->resizer; |
| #endif |
| } |
| |
| void QStatusBar::setSizeGripEnabled(bool enabled) |
| { |
| #ifdef QT_NO_SIZEGRIP |
| Q_UNUSED(enabled); |
| #else |
| Q_D(QStatusBar); |
| if (!enabled != !d->resizer) { |
| if (enabled) { |
| d->resizer = new QSizeGrip(this); |
| d->resizer->hide(); |
| d->resizer->installEventFilter(this); |
| d->showSizeGrip = true; |
| } else { |
| delete d->resizer; |
| d->resizer = 0; |
| d->showSizeGrip = false; |
| } |
| reformat(); |
| if (d->resizer && isVisible()) |
| d->tryToShowSizeGrip(); |
| } |
| #endif |
| } |
| |
| |
| /*! |
| Changes the status bar's appearance to account for item changes. |
| |
| Special subclasses may need this function, but geometry management |
| will usually take care of any necessary rearrangements. |
| */ |
| void QStatusBar::reformat() |
| { |
| Q_D(QStatusBar); |
| if (d->box) |
| delete d->box; |
| |
| QBoxLayout *vbox; |
| #ifndef QT_NO_SIZEGRIP |
| if (d->resizer) { |
| d->box = new QHBoxLayout(this); |
| d->box->setMargin(0); |
| vbox = new QVBoxLayout; |
| d->box->addLayout(vbox); |
| } else |
| #endif |
| { |
| vbox = d->box = new QVBoxLayout(this); |
| d->box->setMargin(0); |
| } |
| vbox->addSpacing(3); |
| QBoxLayout* l = new QHBoxLayout; |
| vbox->addLayout(l); |
| l->addSpacing(2); |
| l->setSpacing(6); |
| |
| int maxH = fontMetrics().height(); |
| |
| int i; |
| QStatusBarPrivate::SBItem* item; |
| for (i=0,item=0; i<d->items.size(); ++i) { |
| item = d->items.at(i); |
| if (!item || item->p) |
| break; |
| l->addWidget(item->w, item->s); |
| int itemH = qMin(qSmartMinSize(item->w).height(), item->w->maximumHeight()); |
| maxH = qMax(maxH, itemH); |
| } |
| |
| l->addStretch(0); |
| |
| for (item=0; i<d->items.size(); ++i) { |
| item = d->items.at(i); |
| if (!item) |
| break; |
| l->addWidget(item->w, item->s); |
| int itemH = qMin(qSmartMinSize(item->w).height(), item->w->maximumHeight()); |
| maxH = qMax(maxH, itemH); |
| } |
| #ifndef QT_NO_SIZEGRIP |
| if (d->resizer) { |
| maxH = qMax(maxH, d->resizer->sizeHint().height()); |
| d->box->addSpacing(1); |
| d->box->addWidget(d->resizer, 0, Qt::AlignBottom); |
| } |
| #endif |
| l->addStrut(maxH); |
| d->savedStrut = maxH; |
| vbox->addSpacing(2); |
| d->box->activate(); |
| update(); |
| } |
| |
| /*! |
| |
| Hides the normal status indications and displays the given \a |
| message for the specified number of milli-seconds (\a{timeout}). If |
| \a{timeout} is 0 (default), the \a {message} remains displayed until |
| the clearMessage() slot is called or until the showMessage() slot is |
| called again to change the message. |
| |
| Note that showMessage() is called to show temporary explanations of |
| tool tip texts, so passing a \a{timeout} of 0 is not sufficient to |
| display a \l{permanent message}{permanent message}. |
| |
| \sa messageChanged(), currentMessage(), clearMessage() |
| */ |
| void QStatusBar::showMessage(const QString &message, int timeout) |
| { |
| Q_D(QStatusBar); |
| if (d->tempItem == message) |
| return; |
| |
| d->tempItem = message; |
| |
| if (timeout > 0) { |
| if (!d->timer) { |
| d->timer = new QTimer(this); |
| connect(d->timer, SIGNAL(timeout()), this, SLOT(clearMessage())); |
| } |
| d->timer->start(timeout); |
| } else if (d->timer) { |
| delete d->timer; |
| d->timer = 0; |
| } |
| |
| hideOrShow(); |
| } |
| |
| /*! |
| Removes any temporary message being shown. |
| |
| \sa currentMessage(), showMessage(), removeWidget() |
| */ |
| |
| void QStatusBar::clearMessage() |
| { |
| Q_D(QStatusBar); |
| if (d->tempItem.isEmpty()) |
| return; |
| if (d->timer) { |
| qDeleteInEventHandler(d->timer); |
| d->timer = 0; |
| } |
| d->tempItem.clear(); |
| hideOrShow(); |
| } |
| |
| /*! |
| Returns the temporary message currently shown, |
| or an empty string if there is no such message. |
| |
| \sa showMessage() |
| */ |
| QString QStatusBar::currentMessage() const |
| { |
| Q_D(const QStatusBar); |
| return d->tempItem; |
| } |
| |
| /*! |
| \fn void QStatusBar::message(const QString &message, int timeout) |
| |
| Use the showMessage() function instead. |
| */ |
| |
| /*! |
| \fn void QStatusBar::clear() |
| |
| Use the clearMessage() function instead. |
| */ |
| |
| /*! |
| \fn QStatusBar::messageChanged(const QString &message) |
| |
| This signal is emitted whenever the temporary status message |
| changes. The new temporary message is passed in the \a message |
| parameter which is a null-string when the message has been |
| removed. |
| |
| \sa showMessage(), clearMessage() |
| */ |
| |
| /*! |
| Ensures that the right widgets are visible. |
| |
| Used by the showMessage() and clearMessage() functions. |
| */ |
| void QStatusBar::hideOrShow() |
| { |
| Q_D(QStatusBar); |
| bool haveMessage = !d->tempItem.isEmpty(); |
| |
| QStatusBarPrivate::SBItem* item = 0; |
| for (int i=0; i<d->items.size(); ++i) { |
| item = d->items.at(i); |
| if (!item || item->p) |
| break; |
| if (haveMessage && item->w->isVisible()) { |
| item->w->hide(); |
| item->w->setAttribute(Qt::WA_WState_ExplicitShowHide, false); |
| } else if (!haveMessage && !item->w->testAttribute(Qt::WA_WState_ExplicitShowHide)) { |
| item->w->show(); |
| } |
| } |
| |
| emit messageChanged(d->tempItem); |
| repaint(d->messageRect()); |
| } |
| |
| /*! |
| \reimp |
| */ |
| void QStatusBar::showEvent(QShowEvent *) |
| { |
| #ifndef QT_NO_SIZEGRIP |
| Q_D(QStatusBar); |
| if (d->resizer && d->showSizeGrip) |
| d->tryToShowSizeGrip(); |
| #endif |
| } |
| |
| /*! |
| \reimp |
| \fn void QStatusBar::paintEvent(QPaintEvent *event) |
| |
| Shows the temporary message, if appropriate, in response to the |
| paint \a event. |
| */ |
| void QStatusBar::paintEvent(QPaintEvent *event) |
| { |
| Q_D(QStatusBar); |
| bool haveMessage = !d->tempItem.isEmpty(); |
| |
| QPainter p(this); |
| QStyleOption opt; |
| opt.initFrom(this); |
| style()->drawPrimitive(QStyle::PE_PanelStatusBar, &opt, &p, this); |
| |
| for (int i=0; i<d->items.size(); ++i) { |
| QStatusBarPrivate::SBItem* item = d->items.at(i); |
| if (item && item->w->isVisible() && (!haveMessage || item->p)) { |
| QRect ir = item->w->geometry().adjusted(-2, -1, 2, 1); |
| if (event->rect().intersects(ir)) { |
| QStyleOption opt(0); |
| opt.rect = ir; |
| opt.palette = palette(); |
| opt.state = QStyle::State_None; |
| style()->drawPrimitive(QStyle::PE_FrameStatusBarItem, &opt, &p, item->w); |
| } |
| } |
| } |
| if (haveMessage) { |
| p.setPen(palette().foreground().color()); |
| p.drawText(d->messageRect(), Qt::AlignLeading | Qt::AlignVCenter | Qt::TextSingleLine, d->tempItem); |
| } |
| } |
| |
| /*! |
| \reimp |
| */ |
| void QStatusBar::resizeEvent(QResizeEvent * e) |
| { |
| QWidget::resizeEvent(e); |
| } |
| |
| /*! |
| \reimp |
| */ |
| |
| bool QStatusBar::event(QEvent *e) |
| { |
| Q_D(QStatusBar); |
| |
| if (e->type() == QEvent::LayoutRequest |
| #ifdef QT3_SUPPORT |
| || e->type() == QEvent::LayoutHint |
| #endif |
| ) { |
| // Calculate new strut height and call reformat() if it has changed |
| int maxH = fontMetrics().height(); |
| |
| QStatusBarPrivate::SBItem* item = 0; |
| for (int i=0; i<d->items.size(); ++i) { |
| item = d->items.at(i); |
| if (!item) |
| break; |
| int itemH = qMin(qSmartMinSize(item->w).height(), item->w->maximumHeight()); |
| maxH = qMax(maxH, itemH); |
| } |
| |
| #ifndef QT_NO_SIZEGRIP |
| if (d->resizer) |
| maxH = qMax(maxH, d->resizer->sizeHint().height()); |
| #endif |
| |
| if (maxH != d->savedStrut) |
| reformat(); |
| else |
| update(); |
| } |
| if (e->type() == QEvent::ChildRemoved) { |
| QStatusBarPrivate::SBItem* item = 0; |
| for (int i=0; i<d->items.size(); ++i) { |
| item = d->items.at(i); |
| if (!item) |
| break; |
| if (item->w == ((QChildEvent*)e)->child()) { |
| d->items.removeAt(i); |
| delete item; |
| } |
| } |
| } |
| |
| // On Mac OS X Leopard it is possible to drag the window by clicking |
| // on the tool bar on most applications. |
| #ifndef Q_WS_MAC |
| return QWidget::event(e); |
| #else |
| if (QSysInfo::MacintoshVersion <= QSysInfo::MV_10_4) |
| return QWidget::event(e); |
| |
| // Enable drag-click only if the status bar is the status bar for a |
| // QMainWindow with a unifed toolbar. |
| if (parent() == 0 || qobject_cast<QMainWindow *>(parent()) == 0 || |
| qobject_cast<QMainWindow *>(parent())->unifiedTitleAndToolBarOnMac() == false ) |
| return QWidget::event(e); |
| |
| // Check for mouse events. |
| QMouseEvent *mouseEvent; |
| if (e->type() == QEvent::MouseButtonPress || |
| e->type() == QEvent::MouseMove || |
| e->type() == QEvent::MouseButtonRelease) { |
| mouseEvent = static_cast <QMouseEvent*>(e); |
| } else { |
| return QWidget::event(e); |
| } |
| |
| // The following is a standard mouse drag handler. |
| if (e->type() == QEvent::MouseButtonPress && (mouseEvent->button() == Qt::LeftButton)) { |
| d->dragStart = mouseEvent->pos(); |
| } else if (e->type() == QEvent::MouseMove){ |
| if (d->dragStart == QPoint()) |
| return QWidget::event(e); |
| QPoint pos = mouseEvent->pos(); |
| QPoint delta = (pos - d->dragStart); |
| window()->move(window()->pos() + delta); |
| } else if (e->type() == QEvent::MouseButtonRelease && (mouseEvent->button() == Qt::LeftButton)){ |
| d->dragStart = QPoint(); |
| } else { |
| return QWidget::event(e); |
| } |
| |
| return true; |
| #endif |
| } |
| |
| QT_END_NAMESPACE |
| |
| #endif |