Long live Qt 4.5!

1 files changed, 2301 insertions, 0 deletions

diff --git a/src/gui/widgets/qtabbar.cpp b/src/gui/widgets/qtabbar.cpp
new file mode 100644
index 0000000..7d970ad
--- /dev/null
+++ b/src/gui/widgets/qtabbar.cpp
@@ -0,0 +1,2301 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, 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.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qlayoutengine_p.h"
+#include "qabstractitemdelegate.h"
+#include "qapplication.h"
+#include "qbitmap.h"
+#include "qcursor.h"
+#include "qevent.h"
+#include "qpainter.h"
+#include "qstyle.h"
+#include "qstyleoption.h"
+#include "qstylepainter.h"
+#include "qtabwidget.h"
+#include "qtooltip.h"
+#include "qwhatsthis.h"
+#include "private/qtextengine_p.h"
+#ifndef QT_NO_ACCESSIBILITY
+#include "qaccessible.h"
+#endif
+
+#include "qdebug.h"
+#include "private/qtabbar_p.h"
+
+#ifndef QT_NO_TABBAR
+
+#ifdef Q_WS_MAC
+#include <private/qt_mac_p.h>
+#include <private/qt_cocoa_helpers_mac_p.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+inline static bool verticalTabs(QTabBar::Shape shape)
+{
+    return shape == QTabBar::RoundedWest
+           || shape == QTabBar::RoundedEast
+           || shape == QTabBar::TriangularWest
+           || shape == QTabBar::TriangularEast;
+}
+
+void QTabBarPrivate::updateMacBorderMetrics()
+{
+#if (defined Q_WS_MAC) && (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
+        Q_Q(QTabBar);
+        ::HIContentBorderMetrics metrics;
+
+        // TODO: get metrics to preserve the bottom value
+        // TODO: test tab bar position
+
+        // push the black line at the bottom of the menu bar down to the client are so we can paint over it
+        metrics.top = (documentMode && q->isVisible()) ? 1 : 0;
+        metrics.bottom = 0;
+        metrics.left = 0;
+        metrics.right = 0;
+
+        qt_mac_updateContentBorderMetricts(qt_mac_window_for(q), metrics);
+    }
+#endif
+}
+
+/*!
+    Initialize \a option with the values from the tab at \a tabIndex. This method
+    is useful for subclasses when they need a QStyleOptionTab, QStyleOptionTabV2,
+    or QStyleOptionTabV3 but don't want to fill in all the information themselves.
+    This function will check the version of the QStyleOptionTab and fill in the
+    additional values for a QStyleOptionTabV2 and QStyleOptionTabV3.
+
+    \sa QStyleOption::initFrom() QTabWidget::initStyleOption()
+*/
+void QTabBar::initStyleOption(QStyleOptionTab *option, int tabIndex) const
+{
+    Q_D(const QTabBar);
+    int totalTabs = d->tabList.size();
+
+    if (!option || (tabIndex < 0 || tabIndex >= totalTabs))
+        return;
+
+    const QTabBarPrivate::Tab &tab = d->tabList.at(tabIndex);
+    option->initFrom(this);
+    option->state &= ~(QStyle::State_HasFocus | QStyle::State_MouseOver);
+    option->rect = tabRect(tabIndex);
+    bool isCurrent = tabIndex == d->currentIndex;
+    option->row = 0;
+    if (tabIndex == d->pressedIndex)
+        option->state |= QStyle::State_Sunken;
+    if (isCurrent)
+        option->state |= QStyle::State_Selected;
+    if (isCurrent && hasFocus())
+        option->state |= QStyle::State_HasFocus;
+    if (!tab.enabled)
+        option->state &= ~QStyle::State_Enabled;
+    if (isActiveWindow())
+        option->state |= QStyle::State_Active;
+    if (option->rect == d->hoverRect)
+        option->state |= QStyle::State_MouseOver;
+    option->shape = d->shape;
+    option->text = tab.text;
+
+    if (tab.textColor.isValid())
+        option->palette.setColor(foregroundRole(), tab.textColor);
+
+    option->icon = tab.icon;
+    if (QStyleOptionTabV2 *optionV2 = qstyleoption_cast<QStyleOptionTabV2 *>(option))
+        optionV2->iconSize = iconSize();  // Will get the default value then.
+
+    if (QStyleOptionTabV3 *optionV3 = qstyleoption_cast<QStyleOptionTabV3 *>(option)) {
+        optionV3->leftButtonSize = tab.leftWidget ? tab.leftWidget->size() : QSize();
+        optionV3->rightButtonSize = tab.rightWidget ? tab.rightWidget->size() : QSize();
+        optionV3->documentMode = d->documentMode;
+    }
+
+    if (tabIndex > 0 && tabIndex - 1 == d->currentIndex)
+        option->selectedPosition = QStyleOptionTab::PreviousIsSelected;
+    else if (tabIndex < totalTabs - 1 && tabIndex + 1 == d->currentIndex)
+        option->selectedPosition = QStyleOptionTab::NextIsSelected;
+    else
+        option->selectedPosition = QStyleOptionTab::NotAdjacent;
+
+    bool paintBeginning = (tabIndex == 0) || (d->dragInProgress && tabIndex == d->pressedIndex + 1);
+    bool paintEnd = (tabIndex == totalTabs - 1) || (d->dragInProgress && tabIndex == d->pressedIndex - 1);
+    if (paintBeginning) {
+        if (paintEnd)
+            option->position = QStyleOptionTab::OnlyOneTab;
+        else
+            option->position = QStyleOptionTab::Beginning;
+    } else if (paintEnd) {
+        option->position = QStyleOptionTab::End;
+    } else {
+        option->position = QStyleOptionTab::Middle;
+    }
+
+#ifndef QT_NO_TABWIDGET
+    if (const QTabWidget *tw = qobject_cast<const QTabWidget *>(parentWidget())) {
+        if (tw->cornerWidget(Qt::TopLeftCorner) || tw->cornerWidget(Qt::BottomLeftCorner))
+            option->cornerWidgets |= QStyleOptionTab::LeftCornerWidget;
+        if (tw->cornerWidget(Qt::TopRightCorner) || tw->cornerWidget(Qt::BottomRightCorner))
+            option->cornerWidgets |= QStyleOptionTab::RightCornerWidget;
+    }
+
+    QRect textRect = style()->subElementRect(QStyle::SE_TabBarTabText, option, this);
+
+    option->text = fontMetrics().elidedText(option->text, d->elideMode, textRect.width(),
+                        Qt::TextShowMnemonic);
+#endif
+}
+
+/*!
+    \class QTabBar
+    \brief The QTabBar class provides a tab bar, e.g. for use in tabbed dialogs.
+
+    \ingroup basicwidgets
+    \mainclass
+
+    QTabBar is straightforward to use; it draws the tabs using one of
+    the predefined \link QTabBar::Shape shapes\endlink, and emits a
+    signal when a tab is selected. It can be subclassed to tailor the
+    look and feel. Qt also provides a ready-made \l{QTabWidget}.
+
+    Each tab has a tabText(), an optional tabIcon(), an optional
+    tabToolTip(), optional tabWhatsThis() and optional tabData().
+    The tabs's attributes can be changed with setTabText(), setTabIcon(),
+    setTabToolTip(), setTabWhatsThis and setTabData(). Each tabs can be
+    enabled or disabled individually with setTabEnabled().
+
+    Each tab can display text in a distinct color. The current text color
+    for a tab can be found with the tabTextColor() function. Set the text
+    color for a particular tab with setTabTextColor().
+
+    Tabs are added using addTab(), or inserted at particular positions
+    using insertTab(). The total number of tabs is given by
+    count(). Tabs can be removed from the tab bar with
+    removeTab(). Combining removeTab() and insertTab() allows you to
+    move tabs to different positions.
+
+    The \l shape property defines the tabs' appearance. The choice of
+    shape is a matter of taste, although tab dialogs (for preferences
+    and similar) invariably use \l RoundedNorth.
+    Tab controls in windows other than dialogs almost
+    always use either \l RoundedSouth or \l TriangularSouth. Many
+    spreadsheets and other tab controls in which all the pages are
+    essentially similar use \l TriangularSouth, whereas \l
+    RoundedSouth is used mostly when the pages are different (e.g. a
+    multi-page tool palette). The default in QTabBar is \l
+    RoundedNorth.
+
+    The most important part of QTabBar's API is the currentChanged()
+    signal.  This is emitted whenever the current tab changes (even at
+    startup, when the current tab changes from 'none'). There is also
+    a slot, setCurrentIndex(), which can be used to select a tab
+    programmatically. The function currentIndex() returns the index of
+    the current tab, \l count holds the number of tabs.
+
+    QTabBar creates automatic mnemonic keys in the manner of QAbstractButton;
+    e.g. if a tab's label is "\&Graphics", Alt+G becomes a shortcut
+    key for switching to that tab.
+
+    The following virtual functions may need to be reimplemented in
+    order to tailor the look and feel or store extra data with each
+    tab:
+
+    \list
+    \i tabSizeHint() calcuates the size of a tab.
+    \i tabInserted() notifies that a new tab was added.
+    \i tabRemoved() notifies that a tab was removed.
+    \i tabLayoutChange() notifies that the tabs have been re-laid out.
+    \i paintEvent() paints all tabs.
+    \endlist
+
+    For subclasses, you might also need the tabRect() functions which
+    returns the visual geometry of a single tab.
+
+    \table 100%
+    \row \o \inlineimage plastique-tabbar.png Screenshot of a Plastique style tab bar
+         \o A tab bar shown in the Plastique widget style.
+    \row \o \inlineimage plastique-tabbar-truncated.png Screenshot of a truncated Plastique tab bar
+         \o A truncated tab bar shown in the Plastique widget style.
+    \endtable
+
+    \sa QTabWidget
+*/
+
+/*!
+    \enum QTabBar::Shape
+
+    This enum type lists the built-in shapes supported by QTabBar. Treat these
+    as hints as some styles may not render some of the shapes. However,
+    position should be honored.
+
+    \value RoundedNorth  The normal rounded look above the pages
+
+    \value RoundedSouth  The normal rounded look below the pages
+
+    \value RoundedWest  The normal rounded look on the left side of the pages
+
+    \value RoundedEast  The normal rounded look on the right side the pages
+
+    \value TriangularNorth  Triangular tabs above the pages.
+
+    \value TriangularSouth  Triangular tabs similar to those used in
+    the Excel spreadsheet, for example
+
+    \value TriangularWest  Triangular tabs on the left of the pages.
+
+    \value TriangularEast  Triangular tabs on the right of the pages.
+    \omitvalue RoundedAbove
+    \omitvalue RoundedBelow
+    \omitvalue TriangularAbove
+    \omitvalue TriangularBelow
+*/
+
+/*!
+    \fn void QTabBar::currentChanged(int index)
+
+    This signal is emitted when the tab bar's current tab changes. The
+    new current has the given \a index, or -1 if there isn't a new one
+    (for example, if there are no tab in the QTabBar)
+*/
+
+/*!
+    \fn void QTabBar::tabCloseRequested(int index)
+    \since 4.5
+
+    This signal is emitted when the close button on a tab is clicked.
+    The \a index is the index that should be removed.
+
+    \sa setTabsClosable()
+*/
+
+/*!
+    \fn void QTabBar::tabMoved(int from, int to)
+    \since 4.5
+
+    This signal is emitted when the tab has moved the tab
+    at index position \a from to index position \a to.
+
+    note: QTabWidget will automatically move the page when
+    this signal is emitted from its tab bar.
+
+    \sa moveTab()
+*/
+
+int QTabBarPrivate::extraWidth() const
+{
+    Q_Q(const QTabBar);
+    return 2 * qMax(q->style()->pixelMetric(QStyle::PM_TabBarScrollButtonWidth, 0, q),
+                    QApplication::globalStrut().width());
+}
+
+void QTabBarPrivate::init()
+{
+    Q_Q(QTabBar);
+    leftB = new QToolButton(q);
+    leftB->setAutoRepeat(true);
+    QObject::connect(leftB, SIGNAL(clicked()), q, SLOT(_q_scrollTabs()));
+    leftB->hide();
+    rightB = new QToolButton(q);
+    rightB->setAutoRepeat(true);
+    QObject::connect(rightB, SIGNAL(clicked()), q, SLOT(_q_scrollTabs()));
+    rightB->hide();
+#ifdef QT_KEYPAD_NAVIGATION
+    if (QApplication::keypadNavigationEnabled()) {
+        leftB->setFocusPolicy(Qt::NoFocus);
+        rightB->setFocusPolicy(Qt::NoFocus);
+        q->setFocusPolicy(Qt::NoFocus);
+    } else
+#endif
+    q->setFocusPolicy(Qt::TabFocus);
+    q->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
+    elideMode = Qt::TextElideMode(q->style()->styleHint(QStyle::SH_TabBar_ElideMode, 0, q));
+    useScrollButtons = !q->style()->styleHint(QStyle::SH_TabBar_PreferNoArrows, 0, q);
+}
+
+QTabBarPrivate::Tab *QTabBarPrivate::at(int index)
+{
+    return validIndex(index)?&tabList[index]:0;
+}
+
+const QTabBarPrivate::Tab *QTabBarPrivate::at(int index) const
+{
+    return validIndex(index)?&tabList[index]:0;
+}
+
+int QTabBarPrivate::indexAtPos(const QPoint &p) const
+{
+    Q_Q(const QTabBar);
+    if (q->tabRect(currentIndex).contains(p))
+        return currentIndex;
+    for (int i = 0; i < tabList.count(); ++i)
+        if (tabList.at(i).enabled && q->tabRect(i).contains(p))
+            return i;
+    return -1;
+}
+
+void QTabBarPrivate::layoutTabs()
+{
+    Q_Q(QTabBar);
+    scrollOffset = 0;
+    layoutDirty = false;
+    QSize size = q->size();
+    int last, available;
+    int maxExtent;
+    int i;
+    bool vertTabs = verticalTabs(shape);
+    int tabChainIndex = 0;
+
+    Qt::Alignment tabAlignment = Qt::Alignment(q->style()->styleHint(QStyle::SH_TabBar_Alignment, 0, q));
+    QVector<QLayoutStruct> tabChain(tabList.count() + 2);
+
+    // We put an empty item at the front and back and set its expansive attribute
+    // depending on tabAlignment.
+    tabChain[tabChainIndex].init();
+    tabChain[tabChainIndex].expansive = (tabAlignment != Qt::AlignLeft)
+                                        && (tabAlignment != Qt::AlignJustify);
+    tabChain[tabChainIndex].empty = true;
+    ++tabChainIndex;
+
+    // We now go through our list of tabs and set the minimum size and the size hint
+    // This will allow us to elide text if necessary. Since we don't set
+    // a maximum size, tabs will EXPAND to fill up the empty space.
+    // Since tab widget is rather *ahem* strict about keeping the geometry of the
+    // tab bar to its absolute minimum, this won't bleed through, but will show up
+    // if you use tab bar on its own (a.k.a. not a bug, but a feature).
+    // Update: if expanding is false, we DO set a maximum size to prevent the tabs
+    // being wider than necessary.
+    if (!vertTabs) {
+        int minx = 0;
+        int x = 0;
+        int maxHeight = 0;
+        for (i = 0; i < tabList.count(); ++i, ++tabChainIndex) {
+            QSize sz = q->tabSizeHint(i);
+            tabList[i].maxRect = QRect(x, 0, sz.width(), sz.height());
+            x += sz.width();
+            maxHeight = qMax(maxHeight, sz.height());
+            sz = minimumTabSizeHint(i);
+            tabList[i].minRect = QRect(minx, 0, sz.width(), sz.height());
+            minx += sz.width();
+            tabChain[tabChainIndex].init();
+            tabChain[tabChainIndex].sizeHint = tabList.at(i).maxRect.width();
+            tabChain[tabChainIndex].minimumSize = sz.width();
+            tabChain[tabChainIndex].empty = false;
+            tabChain[tabChainIndex].expansive = true;
+
+            if (!expanding)
+                tabChain[tabChainIndex].maximumSize = tabChain[tabChainIndex].sizeHint;
+        }
+
+        last = minx;
+        available = size.width();
+        maxExtent = maxHeight;
+    } else {
+        int miny = 0;
+        int y = 0;
+        int maxWidth = 0;
+        for (i = 0; i < tabList.count(); ++i, ++tabChainIndex) {
+            QSize sz = q->tabSizeHint(i);
+            tabList[i].maxRect = QRect(0, y, sz.width(), sz.height());
+            y += sz.height();
+            maxWidth = qMax(maxWidth, sz.width());
+            sz = minimumTabSizeHint(i);
+            tabList[i].minRect = QRect(0, miny, sz.width(), sz.height());
+            miny += sz.height();
+            tabChain[tabChainIndex].init();
+            tabChain[tabChainIndex].sizeHint = tabList.at(i).maxRect.height();
+            tabChain[tabChainIndex].minimumSize = sz.height();
+            tabChain[tabChainIndex].empty = false;
+            tabChain[tabChainIndex].expansive = true;
+
+            if (!expanding)
+                tabChain[tabChainIndex].maximumSize = tabChain[tabChainIndex].sizeHint;
+        }
+
+        last = miny;
+        available = size.height();
+        maxExtent = maxWidth;
+    }
+
+    if (pressedIndex != -1 && movable)
+        grabCache(0, tabList.count(), true);
+
+    Q_ASSERT(tabChainIndex == tabChain.count() - 1); // add an assert just to make sure.
+    // Mirror our front item.
+    tabChain[tabChainIndex].init();
+    tabChain[tabChainIndex].expansive = (tabAlignment != Qt::AlignRight)
+                                        && (tabAlignment != Qt::AlignJustify);
+    tabChain[tabChainIndex].empty = true;
+
+    // Do the calculation
+    qGeomCalc(tabChain, 0, tabChain.count(), 0, qMax(available, last), 0);
+
+    // Use the results
+    for (i = 0; i < tabList.count(); ++i) {
+        const QLayoutStruct &lstruct = tabChain.at(i + 1);
+        if (!vertTabs)
+            tabList[i].rect.setRect(lstruct.pos, 0, lstruct.size, maxExtent);
+        else
+            tabList[i].rect.setRect(0, lstruct.pos, maxExtent, lstruct.size);
+    }
+
+    if (useScrollButtons && tabList.count() && last > available) {
+        int extra = extraWidth();
+        if (!vertTabs) {
+            Qt::LayoutDirection ld = q->layoutDirection();
+            QRect arrows = QStyle::visualRect(ld, q->rect(),
+                                              QRect(available - extra, 0, extra, size.height()));
+            int buttonOverlap = q->style()->pixelMetric(QStyle::PM_TabBar_ScrollButtonOverlap, 0, q);
+
+            if (ld == Qt::LeftToRight) {
+                leftB->setGeometry(arrows.left(), arrows.top(), extra/2, arrows.height());
+                rightB->setGeometry(arrows.right() - extra/2 + buttonOverlap, arrows.top(),
+                                    extra/2, arrows.height());
+                leftB->setArrowType(Qt::LeftArrow);
+                rightB->setArrowType(Qt::RightArrow);
+            } else {
+                rightB->setGeometry(arrows.left(), arrows.top(), extra/2, arrows.height());
+                leftB->setGeometry(arrows.right() - extra/2 + buttonOverlap, arrows.top(),
+                                    extra/2, arrows.height());
+                rightB->setArrowType(Qt::LeftArrow);
+                leftB->setArrowType(Qt::RightArrow);
+            }
+        } else {
+            QRect arrows = QRect(0, available - extra, size.width(), extra );
+            leftB->setGeometry(arrows.left(), arrows.top(), arrows.width(), extra/2);
+            leftB->setArrowType(Qt::UpArrow);
+            rightB->setGeometry(arrows.left(), arrows.bottom() - extra/2 + 1,
+                                arrows.width(), extra/2);
+            rightB->setArrowType(Qt::DownArrow);
+        }
+        leftB->setEnabled(scrollOffset > 0);
+        rightB->setEnabled(last - scrollOffset >= available - extra);
+        leftB->show();
+        rightB->show();
+    } else {
+        rightB->hide();
+        leftB->hide();
+    }
+
+    layoutWidgets();
+    q->tabLayoutChange();
+}
+
+void QTabBarPrivate::makeVisible(int index)
+{
+    Q_Q(QTabBar);
+    if (!validIndex(index) || leftB->isHidden())
+        return;
+
+    const QRect tabRect = tabList.at(index).rect;
+    const int oldScrollOffset = scrollOffset;
+    const bool horiz = !verticalTabs(shape);
+    const int available = (horiz ? q->width() : q->height()) - extraWidth();
+    const int start = horiz ? tabRect.left() : tabRect.top();
+    const int end = horiz ? tabRect.right() : tabRect.bottom();
+    if (start < scrollOffset) // too far left
+        scrollOffset = start - (index ? 8 : 0);
+    else if (end > scrollOffset + available) // too far right
+        scrollOffset = end - available + 1;
+
+    leftB->setEnabled(scrollOffset > 0);
+    const int last = horiz ? tabList.last().rect.right() : tabList.last().rect.bottom();
+    rightB->setEnabled(last - scrollOffset >= available);
+    if (oldScrollOffset != scrollOffset) {
+        q->update();
+        layoutWidgets();
+    }
+}
+
+void QTabBarPrivate::layoutTab(int index)
+{
+    Q_Q(QTabBar);
+    Q_ASSERT(index >= 0);
+
+    Tab &tab = tabList[index];
+    bool vertical = verticalTabs(shape);
+    if (!(tab.leftWidget || tab.rightWidget))
+        return;
+
+    QStyleOptionTabV3 opt;
+    q->initStyleOption(&opt, index);
+    if (tab.leftWidget) {
+        QRect rect = q->style()->subElementRect(QStyle::SE_TabBarTabLeftButton, &opt, q);
+        QPoint p = rect.topLeft();
+        if ((index == pressedIndex) || paintWithOffsets) {
+            if (vertical)
+                p.setY(p.y() + tabList[index].dragOffset);
+            else
+                p.setX(p.x() + tabList[index].dragOffset);
+        }
+        tab.leftWidget->move(p);
+    }
+    if (tab.rightWidget) {
+        QRect rect = q->style()->subElementRect(QStyle::SE_TabBarTabRightButton, &opt, q);
+        QPoint p = rect.topLeft();
+        if ((index == pressedIndex) || paintWithOffsets) {
+            if (vertical)
+                p.setY(p.y() + tab.dragOffset);
+            else
+                p.setX(p.x() + tab.dragOffset);
+        }
+        tab.rightWidget->move(p);
+    }
+}
+
+void QTabBarPrivate::layoutWidgets(int index)
+{
+    Q_Q(QTabBar);
+    int start = 0;
+    int end = q->count();
+    if (index != -1) {
+        start = qMax(index, 0);
+        end = qMin(end, start + 1);
+    }
+    for (int i = start; i < end; ++i) {
+        layoutTab(i);
+    }
+}
+
+void QTabBarPrivate::_q_closeTab()
+{
+    Q_Q(QTabBar);
+    QObject *object = q->sender();
+    int tabToClose = -1;
+    QTabBar::ButtonPosition closeSide = (QTabBar::ButtonPosition)q->style()->styleHint(QStyle::SH_TabBar_CloseButtonPosition, 0, q);
+    for (int i = 0; i < tabList.count(); ++i) {
+        if (closeSide == QTabBar::LeftSide) {
+            if (tabList.at(i).leftWidget == object) {
+                tabToClose = i;
+                break;
+            }
+        } else {
+            if (tabList.at(i).rightWidget == object) {
+                tabToClose = i;
+                break;
+            }
+        }
+    }
+    if (tabToClose != -1)
+        emit q->tabCloseRequested(tabToClose);
+}
+
+void QTabBarPrivate::_q_scrollTabs()
+{
+    Q_Q(QTabBar);
+    const QObject *sender = q->sender();
+    int i = -1;
+    if (!verticalTabs(shape)) {
+        if (sender == leftB) {
+            for (i = tabList.count() - 1; i >= 0; --i) {
+                if (tabList.at(i).rect.left() - scrollOffset < 0) {
+                    makeVisible(i);
+                    return;
+                }
+            }
+        } else if (sender == rightB) {
+            int availableWidth = q->width() - extraWidth();
+            for (i = 0; i < tabList.count(); ++i) {
+                if (tabList.at(i).rect.right() - scrollOffset > availableWidth) {
+                    makeVisible(i);
+                    return;
+                }
+            }
+        }
+    } else { // vertical
+        if (sender == leftB) {
+            for (i = tabList.count() - 1; i >= 0; --i) {
+                if (tabList.at(i).rect.top() - scrollOffset < 0) {
+                    makeVisible(i);
+                    return;
+                }
+            }
+        } else if (sender == rightB) {
+            int available = q->height() - extraWidth();
+            for (i = 0; i < tabList.count(); ++i) {
+                if (tabList.at(i).rect.bottom() - scrollOffset > available) {
+                    makeVisible(i);
+                    return;
+                }
+            }
+        }
+    }
+}
+
+void QTabBarPrivate::refresh()
+{
+    Q_Q(QTabBar);
+
+    // be safe in case a subclass is also handling move with the tabs
+    if (pressedIndex != -1
+        && movable
+        && QApplication::mouseButtons() == Qt::NoButton) {
+        _q_moveTabFinished(pressedIndex);
+        if (!validIndex(pressedIndex))
+            pressedIndex = -1;
+    }
+
+    if (!q->isVisible()) {
+        layoutDirty = true;
+    } else {
+        layoutTabs();
+        makeVisible(currentIndex);
+        q->update();
+        q->updateGeometry();
+    }
+}
+
+/*!
+    Creates a new tab bar with the given \a parent.
+*/
+QTabBar::QTabBar(QWidget* parent)
+    :QWidget(*new QTabBarPrivate, parent, 0)
+{
+    Q_D(QTabBar);
+    d->init();
+}
+
+
+/*!
+    Destroys the tab bar.
+*/
+QTabBar::~QTabBar()
+{
+}
+
+/*!
+    \property QTabBar::shape
+    \brief the shape of the tabs in the tab bar
+
+    Possible values for this property are described by the Shape enum.
+*/
+
+
+QTabBar::Shape QTabBar::shape() const
+{
+    Q_D(const QTabBar);
+    return d->shape;
+}
+
+void QTabBar::setShape(Shape shape)
+{
+    Q_D(QTabBar);
+    if (d->shape == shape)
+        return;
+    d->shape = shape;
+    d->refresh();
+}
+
+/*!
+    \property QTabBar::drawBase
+    \brief defines whether or not tab bar should draw its base.
+
+    If true then QTabBar draws a base in relation to the styles overlab.
+    Otherwise only the tabs are drawn.
+
+    \sa QStyle::pixelMetric() QStyle::PM_TabBarBaseOverlap QStyleOptionTabBarBaseV2
+*/
+
+void QTabBar::setDrawBase(bool drawBase)
+{
+    Q_D(QTabBar);
+    if (d->drawBase == drawBase)
+        return;
+    d->drawBase = drawBase;
+    update();
+}
+
+bool QTabBar::drawBase() const
+{
+    Q_D(const QTabBar);
+    return d->drawBase;
+}
+
+/*!
+    Adds a new tab with text \a text. Returns the new
+    tab's index.
+*/
+int QTabBar::addTab(const QString &text)
+{
+    return insertTab(-1, text);
+}
+
+/*!
+    \overload
+
+    Adds a new tab with icon \a icon and text \a
+    text. Returns the new tab's index.
+*/
+int QTabBar::addTab(const QIcon& icon, const QString &text)
+{
+    return insertTab(-1, icon, text);
+}
+
+/*!
+    Inserts a new tab with text \a text at position \a index. If \a
+    index is out of range, the new tab is appened. Returns the new
+    tab's index.
+*/
+int QTabBar::insertTab(int index, const QString &text)
+{
+    return insertTab(index, QIcon(), text);
+}
+
+/*!\overload
+
+    Inserts a new tab with icon \a icon and text \a text at position
+    \a index. If \a index is out of range, the new tab is
+    appended. Returns the new tab's index.
+
+    If the QTabBar was empty before this function is called, the inserted tab
+    becomes the current tab.
+
+    Inserting a new tab at an index less than or equal to the current index
+    will increment the current index, but keep the current tab.
+*/
+int QTabBar::insertTab(int index, const QIcon& icon, const QString &text)
+{
+    Q_D(QTabBar);
+    if (!d->validIndex(index)) {
+        index = d->tabList.count();
+        d->tabList.append(QTabBarPrivate::Tab(icon, text));
+    } else {
+        d->tabList.insert(index, QTabBarPrivate::Tab(icon, text));
+    }
+#ifndef QT_NO_SHORTCUT
+    d->tabList[index].shortcutId = grabShortcut(QKeySequence::mnemonic(text));
+#endif
+    d->refresh();
+    if (d->tabList.count() == 1)
+        setCurrentIndex(index);
+    else if (index <= d->currentIndex)
+        ++d->currentIndex;
+
+    if (d->closeButtonOnTabs) {
+        QStyleOptionTabV3 opt;
+        initStyleOption(&opt, index);
+        ButtonPosition closeSide = (ButtonPosition)style()->styleHint(QStyle::SH_TabBar_CloseButtonPosition, 0, this);
+        QAbstractButton *closeButton = new CloseButton(this);
+        connect(closeButton, SIGNAL(clicked()), this, SLOT(_q_closeTab()));
+        setTabButton(index, closeSide, closeButton);
+    }
+
+    for (int i = 0; i < d->tabList.count(); ++i) {
+        if (d->tabList[i].lastTab >= index)
+            ++d->tabList[i].lastTab;
+    }
+
+    tabInserted(index);
+    return index;
+}
+
+
+/*!
+    Removes the tab at position \a index.
+
+    \sa SelectionBehavior
+ */
+void QTabBar::removeTab(int index)
+{
+    Q_D(QTabBar);
+    if (d->validIndex(index)) {
+#ifndef QT_NO_SHORTCUT
+        releaseShortcut(d->tabList.at(index).shortcutId);
+#endif
+        if (d->tabList[index].leftWidget) {
+            d->tabList[index].leftWidget->hide();
+            d->tabList[index].leftWidget->deleteLater();
+            d->tabList[index].leftWidget = 0;
+        }
+        if (d->tabList[index].rightWidget) {
+            d->tabList[index].rightWidget->hide();
+            d->tabList[index].rightWidget->deleteLater();
+            d->tabList[index].rightWidget = 0;
+        }
+
+        int newIndex = d->tabList[index].lastTab;
+        d->tabList.removeAt(index);
+        for (int i = 0; i < d->tabList.count(); ++i) {
+            if (d->tabList[i].lastTab == index)
+                d->tabList[i].lastTab = -1;
+            if (d->tabList[i].lastTab > index)
+                --d->tabList[i].lastTab;
+        }
+        if (index == d->currentIndex) {
+            // The current tab is going away, in order to make sure
+            // we emit that "current has changed", we need to reset this
+            // around.
+            d->currentIndex = -1;
+            if (d->tabList.size() > 0) {
+                switch(d->selectionBehaviorOnRemove) {
+                case SelectPreviousTab:
+                    if (newIndex > index)
+                        newIndex--;
+                    if (d->validIndex(newIndex))
+                        break;
+                    // else fallthrough
+                case SelectRightTab:
+                    newIndex = index;
+                    if (newIndex >= d->tabList.size())
+                        newIndex = d->tabList.size() - 1;
+                    break;
+                case SelectLeftTab:
+                    newIndex = index - 1;
+                    if (newIndex < 0)
+                        newIndex = 0;
+                    break;
+                default:
+                    break;
+                }
+
+                if (d->validIndex(newIndex)) {
+                    // don't loose newIndex's old through setCurrentIndex
+                    int bump = d->tabList[newIndex].lastTab;
+                    setCurrentIndex(newIndex);
+                    d->tabList[newIndex].lastTab = bump;
+                }
+            } else {
+                emit currentChanged(-1);
+            }
+        } else if (index < d->currentIndex) {
+            setCurrentIndex(d->currentIndex - 1);
+        }
+        d->refresh();
+        tabRemoved(index);
+    }
+}
+
+
+/*!
+    Returns true if the tab at position \a index is enabled; otherwise
+    returns false.
+*/
+bool QTabBar::isTabEnabled(int index) const
+{
+    Q_D(const QTabBar);
+    if (const QTabBarPrivate::Tab *tab = d->at(index))
+        return tab->enabled;
+    return false;
+}
+
+/*!
+    If \a enabled is true then the tab at position \a index is
+    enabled; otherwise the item at position \a index is disabled.
+*/
+void QTabBar::setTabEnabled(int index, bool enabled)
+{
+    Q_D(QTabBar);
+    if (QTabBarPrivate::Tab *tab = d->at(index)) {
+        tab->enabled = enabled;
+#ifndef QT_NO_SHORTCUT
+        setShortcutEnabled(tab->shortcutId, enabled);
+#endif
+        update();
+        if (!enabled && index == d->currentIndex)
+            setCurrentIndex(d->validIndex(index+1)?index+1:0);
+        else if (enabled && !d->validIndex(d->currentIndex))
+            setCurrentIndex(index);
+    }
+}
+
+
+/*!
+    Returns the text of the tab at position \a index, or an empty
+    string if \a index is out of range.
+*/
+QString QTabBar::tabText(int index) const
+{
+    Q_D(const QTabBar);
+    if (const QTabBarPrivate::Tab *tab = d->at(index))
+        return tab->text;
+    return QString();
+}
+
+/*!
+    Sets the text of the tab at position \a index to \a text.
+*/
+void QTabBar::setTabText(int index, const QString &text)
+{
+    Q_D(QTabBar);
+    if (QTabBarPrivate::Tab *tab = d->at(index)) {
+        tab->text = text;
+#ifndef QT_NO_SHORTCUT
+        releaseShortcut(tab->shortcutId);
+        tab->shortcutId = grabShortcut(QKeySequence::mnemonic(text));
+        setShortcutEnabled(tab->shortcutId, tab->enabled);
+#endif
+        d->refresh();
+    }
+}
+
+/*!
+    Returns the text color of the tab with the given \a index, or a invalid
+    color if \a index is out of range.
+
+    \sa setTabTextColor()
+*/
+QColor QTabBar::tabTextColor(int index) const
+{
+    Q_D(const QTabBar);
+    if (const QTabBarPrivate::Tab *tab = d->at(index))
+        return tab->textColor;
+    return QColor();
+}
+
+/*!
+    Sets the color of the text in the tab with the given \a index to the specified \a color.
+
+    If an invalid color is specified, the tab will use the QTabBar foreground role instead.
+
+    \sa tabTextColor()
+*/
+void QTabBar::setTabTextColor(int index, const QColor &color)
+{
+    Q_D(QTabBar);
+    if (QTabBarPrivate::Tab *tab = d->at(index)) {
+        tab->textColor = color;
+        update(tabRect(index));
+    }
+}
+
+/*!
+    Returns the icon of the tab at position \a index, or a null icon
+    if \a index is out of range.
+*/
+QIcon QTabBar::tabIcon(int index) const
+{
+    Q_D(const QTabBar);
+    if (const QTabBarPrivate::Tab *tab = d->at(index))
+        return tab->icon;
+    return QIcon();
+}
+
+/*!
+    Sets the icon of the tab at position \a index to \a icon.
+*/
+void QTabBar::setTabIcon(int index, const QIcon & icon)
+{
+    Q_D(QTabBar);
+    if (QTabBarPrivate::Tab *tab = d->at(index)) {
+        bool simpleIconChange = (!icon.isNull() && !tab->icon.isNull());
+        tab->icon = icon;
+        if (simpleIconChange)
+            update(tabRect(index));
+        else
+            d->refresh();
+    }
+}
+
+#ifndef QT_NO_TOOLTIP
+/*!
+    Sets the tool tip of the tab at position \a index to \a tip.
+*/
+void QTabBar::setTabToolTip(int index, const QString & tip)
+{
+    Q_D(QTabBar);
+    if (QTabBarPrivate::Tab *tab = d->at(index))
+        tab->toolTip = tip;
+}
+
+/*!
+    Returns the tool tip of the tab at position \a index, or an empty
+    string if \a index is out of range.
+*/
+QString QTabBar::tabToolTip(int index) const
+{
+    Q_D(const QTabBar);
+    if (const QTabBarPrivate::Tab *tab = d->at(index))
+        return tab->toolTip;
+    return QString();
+}
+#endif // QT_NO_TOOLTIP
+
+#ifndef QT_NO_WHATSTHIS
+/*!
+    \since 4.1
+
+    Sets the What's This help text of the tab at position \a index
+    to \a text.
+*/
+void QTabBar::setTabWhatsThis(int index, const QString &text)
+{
+    Q_D(QTabBar);
+    if (QTabBarPrivate::Tab *tab = d->at(index))
+        tab->whatsThis = text;
+}
+
+/*!
+    \since 4.1
+
+    Returns the What's This help text of the tab at position \a index,
+    or an empty string if \a index is out of range.
+*/
+QString QTabBar::tabWhatsThis(int index) const
+{
+    Q_D(const QTabBar);
+    if (const QTabBarPrivate::Tab *tab = d->at(index))
+        return tab->whatsThis;
+    return QString();
+}
+
+#endif // QT_NO_WHATSTHIS
+
+/*!
+    Sets the data of the tab at position \a index to \a data.
+*/
+void QTabBar::setTabData(int index, const QVariant & data)
+{
+    Q_D(QTabBar);
+    if (QTabBarPrivate::Tab *tab = d->at(index))
+        tab->data = data;
+}
+
+/*!
+    Returns the datad of the tab at position \a index, or a null
+    variant if \a index is out of range.
+*/
+QVariant QTabBar::tabData(int index) const
+{
+    Q_D(const QTabBar);
+    if (const QTabBarPrivate::Tab *tab = d->at(index))
+        return tab->data;
+    return QVariant();
+}
+
+/*!
+    Returns the visual rectangle of the of the tab at position \a
+    index, or a null rectangle if \a index is out of range.
+*/
+QRect QTabBar::tabRect(int index) const
+{
+    Q_D(const QTabBar);
+    if (const QTabBarPrivate::Tab *tab = d->at(index)) {
+        if (d->layoutDirty)
+            const_cast<QTabBarPrivate*>(d)->layoutTabs();
+        QRect r = tab->rect;
+        if (verticalTabs(d->shape))
+            r.translate(0, -d->scrollOffset);
+        else
+            r.translate(-d->scrollOffset, 0);
+        if (!verticalTabs(d->shape))
+            r = QStyle::visualRect(layoutDirection(), rect(), r);
+        return r;
+    }
+    return QRect();
+}
+
+/*!
+    \since 4.3
+    Returns the index of the tab that covers \a position or -1 if no
+    tab covers \a position;
+*/
+
+int QTabBar::tabAt(const QPoint &position) const
+{
+    Q_D(const QTabBar);
+    if (d->validIndex(d->currentIndex)
+        && tabRect(d->currentIndex).contains(position)) {
+        return d->currentIndex;
+    }
+    const int max = d->tabList.size();
+    for (int i = 0; i < max; ++i) {
+        if (tabRect(i).contains(position)) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+/*!
+    \property QTabBar::currentIndex
+    \brief the index of the tab bar's visible tab
+
+    The current index is -1 if there is no current tab.
+*/
+
+int QTabBar::currentIndex() const
+{
+    Q_D(const QTabBar);
+    if (d->validIndex(d->currentIndex))
+        return d->currentIndex;
+    return -1;
+}
+
+
+void QTabBar::setCurrentIndex(int index)
+{
+    Q_D(QTabBar);
+    if (d->dragInProgress && d->pressedIndex != -1)
+        return;
+
+    int oldIndex = d->currentIndex;
+    if (d->validIndex(index) && d->currentIndex != index) {
+        d->currentIndex = index;
+        update();
+        d->makeVisible(index);
+#ifdef QT3_SUPPORT
+        emit selected(index);
+#endif
+        emit currentChanged(index);
+        d->tabList[index].lastTab = oldIndex;
+        d->layoutWidgets(oldIndex);
+        d->layoutWidgets(index);
+    }
+}
+
+/*!
+    \property QTabBar::iconSize
+    \brief The size for icons in the tab bar
+    \since 4.1
+
+    The default value is style-dependent. \c iconSize is a maximum
+    size; icons that are smaller are not scaled up.
+
+    \sa QTabWidget::iconSize
+*/
+QSize QTabBar::iconSize() const
+{
+    Q_D(const QTabBar);
+    if (d->iconSize.isValid())
+        return d->iconSize;
+    int iconExtent = style()->pixelMetric(QStyle::PM_TabBarIconSize, 0, this);
+    return QSize(iconExtent, iconExtent);
+
+}
+
+void QTabBar::setIconSize(const QSize &size)
+{
+    Q_D(QTabBar);
+    d->iconSize = size;
+    d->layoutDirty = true;
+    update();
+    updateGeometry();
+}
+
+/*!
+    \property QTabBar::count
+    \brief the number of tabs in the tab bar
+*/
+
+int QTabBar::count() const
+{
+    Q_D(const QTabBar);
+    return d->tabList.count();
+}
+
+
+/*!\reimp
+ */
+QSize QTabBar::sizeHint() const
+{
+    Q_D(const QTabBar);
+    if (d->layoutDirty)
+        const_cast<QTabBarPrivate*>(d)->layoutTabs();
+    QRect r;
+    for (int i = 0; i < d->tabList.count(); ++i)
+        r = r.united(d->tabList.at(i).maxRect);
+    QSize sz = QApplication::globalStrut();
+    return r.size().expandedTo(sz);
+}
+
+/*!\reimp
+ */
+QSize QTabBar::minimumSizeHint() const
+{
+    Q_D(const QTabBar);
+    if (!d->useScrollButtons) {
+        QRect r;
+        for (int i = 0; i < d->tabList.count(); ++i)
+            r = r.united(d->tabList.at(i).minRect);
+        return r.size().expandedTo(QApplication::globalStrut());
+    }
+    if (verticalTabs(d->shape))
+        return QSize(sizeHint().width(), d->rightB->sizeHint().height() * 2 + 75);
+    else
+        return QSize(d->rightB->sizeHint().width() * 2 + 75, sizeHint().height());
+}
+
+static QString computeElidedText(Qt::TextElideMode mode, const QString &text)
+{
+    if (text.length() <= 7)
+        return text;
+
+    static const QLatin1String Ellipses("...");
+    QString ret;
+    switch (mode) {
+    case Qt::ElideRight:
+        ret = text.left(4) + Ellipses;
+        break;
+    case Qt::ElideMiddle:
+        ret = text.left(2) + Ellipses + text.right(2);
+        break;
+    case Qt::ElideLeft:
+        ret = Ellipses + text.right(4);
+        break;
+    case Qt::ElideNone:
+        ret = text;
+        break;
+    }
+    return ret;
+}
+
+QSize QTabBarPrivate::minimumTabSizeHint(int index)
+{
+    Q_Q(QTabBar);
+    // ### Qt 5: make this a protected virtual function in QTabBar
+    Tab &tab = tabList[index];
+    QString oldText = tab.text;
+    tab.text = computeElidedText(elideMode, oldText);
+    QSize size = q->tabSizeHint(index);
+    tab.text = oldText;
+    return size;
+}
+
+/*!
+    Returns the size hint for the tab at position \a index.
+*/
+QSize QTabBar::tabSizeHint(int index) const
+{
+    Q_D(const QTabBar);
+    if (const QTabBarPrivate::Tab *tab = d->at(index)) {
+        QStyleOptionTabV3 opt;
+        initStyleOption(&opt, index);
+        opt.text = d->tabList.at(index).text;
+        QSize iconSize = tab->icon.isNull() ? QSize(0, 0) : opt.iconSize;
+        int hframe = style()->pixelMetric(QStyle::PM_TabBarTabHSpace, &opt, this);
+        int vframe = style()->pixelMetric(QStyle::PM_TabBarTabVSpace, &opt, this);
+        const QFontMetrics fm = fontMetrics();
+
+        int maxWidgetHeight = qMax(opt.leftButtonSize.height(), opt.rightButtonSize.height());
+        int maxWidgetWidth = qMax(opt.leftButtonSize.width(), opt.rightButtonSize.width());
+
+        int widgetWidth = 0;
+        int widgetHeight = 0;
+        int padding = 0;
+        if (opt.leftButtonSize.isValid()) {
+            padding += 6 + 2;
+            widgetWidth += opt.leftButtonSize.width();
+            widgetHeight += opt.leftButtonSize.height();
+        }
+        if (opt.rightButtonSize.isValid()) {
+            padding += 6 + 2;
+            widgetWidth += opt.rightButtonSize.width();
+            widgetHeight += opt.rightButtonSize.height();
+        }
+        if (opt.iconSize.isValid())
+            padding += 2;
+
+        QSize csz;
+        if (verticalTabs(d->shape)) {
+            csz = QSize( qMax(maxWidgetWidth, qMax(fm.height(), iconSize.height())) + vframe,
+                    fm.size(Qt::TextShowMnemonic, tab->text).width() + iconSize.width() + hframe + widgetHeight + padding);
+        } else {
+            csz = QSize(fm.size(Qt::TextShowMnemonic, tab->text).width() + iconSize.width() + hframe
+                  + widgetWidth + padding,
+                  qMax(maxWidgetHeight, qMax(fm.height(), iconSize.height())) + vframe);
+        }
+
+        QSize retSize = style()->sizeFromContents(QStyle::CT_TabBarTab, &opt, csz, this);
+        return retSize;
+    }
+    return QSize();
+}
+
+/*!
+  This virtual handler is called after a new tab was added or
+  inserted at position \a index.
+
+  \sa tabRemoved()
+ */
+void QTabBar::tabInserted(int index)
+{
+    Q_UNUSED(index)
+}
+
+/*!
+  This virtual handler is called after a tab was removed from
+  position \a index.
+
+  \sa tabInserted()
+ */
+void QTabBar::tabRemoved(int index)
+{
+    Q_UNUSED(index)
+}
+
+/*!
+  This virtual handler is called whenever the tab layout changes.
+
+  \sa tabRect()
+ */
+void QTabBar::tabLayoutChange()
+{
+}
+
+
+/*!\reimp
+ */
+void QTabBar::showEvent(QShowEvent *)
+{
+    Q_D(QTabBar);
+    if (d->layoutDirty)
+        d->refresh();
+    if (!d->validIndex(d->currentIndex))
+        setCurrentIndex(0);
+    d->updateMacBorderMetrics();
+}
+
+/*!\reimp
+ */
+void QTabBar::hideEvent(QHideEvent *)
+{
+    Q_D(QTabBar);
+    d->updateMacBorderMetrics();
+}
+
+/*!\reimp
+ */
+bool QTabBar::event(QEvent *event)
+{
+    Q_D(QTabBar);
+    if (event->type() == QEvent::HoverMove
+        || event->type() == QEvent::HoverEnter) {
+        QHoverEvent *he = static_cast<QHoverEvent *>(event);
+        if (!d->hoverRect.contains(he->pos())) {
+            QRect oldHoverRect = d->hoverRect;
+            for (int i = 0; i < d->tabList.count(); ++i) {
+                QRect area = tabRect(i);
+                if (area.contains(he->pos())) {
+                    d->hoverRect = area;
+                    break;
+                }
+            }
+            if (he->oldPos() != QPoint(-1, -1))
+                update(oldHoverRect);
+            update(d->hoverRect);
+        }
+        return true;
+    } else if (event->type() == QEvent::HoverLeave ) {
+        QRect oldHoverRect = d->hoverRect;
+        d->hoverRect = QRect();
+        update(oldHoverRect);
+        return true;
+#ifndef QT_NO_TOOLTIP
+    } else if (event->type() == QEvent::ToolTip) {
+        if (const QTabBarPrivate::Tab *tab = d->at(tabAt(static_cast<QHelpEvent*>(event)->pos()))) {
+            if (!tab->toolTip.isEmpty()) {
+                QToolTip::showText(static_cast<QHelpEvent*>(event)->globalPos(), tab->toolTip, this);
+                return true;
+            }
+        }
+#endif // QT_NO_TOOLTIP
+#ifndef QT_NO_WHATSTHIS
+    } else if (event->type() == QEvent::QueryWhatsThis) {
+        const QTabBarPrivate::Tab *tab = d->at(d->indexAtPos(static_cast<QHelpEvent*>(event)->pos()));
+        if (!tab || tab->whatsThis.isEmpty())
+            event->ignore();
+        return true;
+    } else if (event->type() == QEvent::WhatsThis) {
+        if (const QTabBarPrivate::Tab *tab = d->at(d->indexAtPos(static_cast<QHelpEvent*>(event)->pos()))) {
+            if (!tab->whatsThis.isEmpty()) {
+                QWhatsThis::showText(static_cast<QHelpEvent*>(event)->globalPos(),
+                                     tab->whatsThis, this);
+                return true;
+            }
+        }
+#endif // QT_NO_WHATSTHIS
+#ifndef QT_NO_SHORTCUT
+    } else if (event->type() == QEvent::Shortcut) {
+        QShortcutEvent *se = static_cast<QShortcutEvent *>(event);
+        for (int i = 0; i < d->tabList.count(); ++i) {
+            const QTabBarPrivate::Tab *tab = &d->tabList.at(i);
+            if (tab->shortcutId == se->shortcutId()) {
+                setCurrentIndex(i);
+                return true;
+            }
+        }
+#endif
+    }
+    return QWidget::event(event);
+}
+
+/*!\reimp
+ */
+void QTabBar::resizeEvent(QResizeEvent *)
+{
+    Q_D(QTabBar);
+    if (d->layoutDirty)
+        updateGeometry();
+    d->layoutTabs();
+
+    d->makeVisible(d->currentIndex);
+}
+
+/*!\reimp
+ */
+void QTabBar::paintEvent(QPaintEvent *)
+{
+    Q_D(QTabBar);
+
+    QStyleOptionTabBarBaseV2 optTabBase;
+    QTabBarPrivate::initStyleBaseOption(&optTabBase, this, size());
+
+    QStylePainter p(this);
+    int selected = -1;
+    int cut = -1;
+    bool rtl = optTabBase.direction == Qt::RightToLeft;
+    bool vertical = verticalTabs(d->shape);
+    QStyleOptionTab cutTab;
+    selected = d->currentIndex;
+
+    for (int i = 0; i < d->tabList.count(); ++i)
+         optTabBase.tabBarRect |= tabRect(i);
+
+    optTabBase.selectedTabRect = tabRect(selected);
+
+    if (d->drawBase)
+        p.drawPrimitive(QStyle::PE_FrameTabBarBase, optTabBase);
+
+    for (int i = 0; i < d->tabList.count(); ++i) {
+        QStyleOptionTabV3 tab;
+        initStyleOption(&tab, i);
+        if (d->paintWithOffsets && d->tabList[i].dragOffset != 0) {
+            if (vertical) {
+                tab.rect.moveTop(tab.rect.y() + d->tabList[i].dragOffset);
+            } else {
+                tab.rect.moveLeft(tab.rect.x() + d->tabList[i].dragOffset);
+            }
+        }
+        if (!(tab.state & QStyle::State_Enabled)) {
+            tab.palette.setCurrentColorGroup(QPalette::Disabled);
+        }
+        // If this tab is partially obscured, make a note of it so that we can pass the information
+        // along when we draw the tear.
+        if (((!vertical && (!rtl && tab.rect.left() < 0)) || (rtl && tab.rect.right() > width()))
+            || (vertical && tab.rect.top() < 0)) {
+            cut = i;
+            cutTab = tab;
+        }
+        // Don't bother drawing a tab if the entire tab is outside of the visible tab bar.
+        if ((!vertical && (tab.rect.right() < 0 || tab.rect.left() > width()))
+            || (vertical && (tab.rect.bottom() < 0 || tab.rect.top() > height())))
+            continue;
+
+        optTabBase.tabBarRect |= tab.rect;
+        if (i == selected)
+            continue;
+
+        if (!d->tabList[i].animatingCache.isNull() && d->paintWithOffsets) {
+            p.drawPixmap(tab.rect, d->tabList[i].animatingCache);
+        } else {
+            p.drawControl(QStyle::CE_TabBarTab, tab);
+        }
+    }
+
+    // Draw the selected tab last to get it "on top"
+    if (selected >= 0) {
+        QStyleOptionTabV3 tab;
+        initStyleOption(&tab, selected);
+        if (d->paintWithOffsets && d->tabList[selected].dragOffset != 0) {
+            if (vertical)
+                tab.rect.moveTop(tab.rect.y() + d->tabList[selected].dragOffset);
+            else
+                tab.rect.moveLeft(tab.rect.x() + d->tabList[selected].dragOffset);
+        }
+        p.drawControl(QStyle::CE_TabBarTab, tab);
+    }
+
+    // Only draw the tear indicator if necessary. Most of the time we don't need too.
+    if (d->leftB->isVisible() && cut >= 0) {
+        cutTab.rect = rect();
+        cutTab.rect = style()->subElementRect(QStyle::SE_TabBarTearIndicator, &cutTab, this);
+        p.drawPrimitive(QStyle::PE_IndicatorTabTear, cutTab);
+    }
+}
+
+/*
+    Given that index at position from moved to position to where return where index goes.
+ */
+int QTabBarPrivate::calculateNewPosition(int from, int to, int index) const
+{
+    if (index == from)
+        return to;
+
+    int start = qMin(from, to);
+    int end = qMax(from, to);
+    if (index >= start && index <= end)
+        index += (from < to) ? -1 : 1;
+    return index;
+}
+
+/*!
+    Moves the item at index position \a from to index position \a to.
+    \since 4.5
+
+    \sa tabMoved(), tabLayoutChange()
+ */
+void QTabBar::moveTab(int from, int to)
+{
+    Q_D(QTabBar);
+    if (from == to
+        || !d->validIndex(from)
+        || !d->validIndex(to))
+        return;
+
+    bool vertical = verticalTabs(d->shape);
+    int oldPressedPosition = 0;
+    if (d->pressedIndex != -1) {
+        // Record the position of the pressed tab before reordering the tabs.
+        oldPressedPosition = vertical ? d->tabList[d->pressedIndex].rect.y()
+                             : d->tabList[d->pressedIndex].rect.x();
+    }
+
+    // Update the locations of the tabs first
+    int start = qMin(from, to);
+    int end = qMax(from, to);
+    int width = vertical ? d->tabList[from].rect.height() : d->tabList[from].rect.width();
+    if (from < to)
+        width *= -1;
+    bool rtl = isRightToLeft();
+    for (int i = start; i <= end; ++i) {
+        if (i == from)
+            continue;
+        if (vertical)
+            d->tabList[i].rect.moveTop(d->tabList[i].rect.y() + width);
+        else
+            d->tabList[i].rect.moveLeft(d->tabList[i].rect.x() + width);
+        int direction = -1;
+        if (rtl && !vertical)
+            direction *= -1;
+        if (d->tabList[i].dragOffset != 0)
+            d->tabList[i].dragOffset += (direction * width);
+    }
+
+    if (vertical) {
+        if (from < to)
+            d->tabList[from].rect.moveTop(d->tabList[to].rect.bottom() + 1);
+        else
+            d->tabList[from].rect.moveTop(d->tabList[to].rect.top() - width);
+    } else {
+        if (from < to)
+            d->tabList[from].rect.moveLeft(d->tabList[to].rect.right() + 1);
+        else
+            d->tabList[from].rect.moveLeft(d->tabList[to].rect.left() - width);
+    }
+
+    // Move the actual data structures
+    d->tabList.move(from, to);
+
+    // update lastTab locations
+    for (int i = 0; i < d->tabList.count(); ++i)
+        d->tabList[i].lastTab = d->calculateNewPosition(from, to, d->tabList[i].lastTab);
+
+    // update external variables
+    d->currentIndex = d->calculateNewPosition(from, to, d->currentIndex);
+
+    // If we are in the middle of a drag update the dragStartPosition
+    if (d->pressedIndex != -1) {
+        d->pressedIndex = d->calculateNewPosition(from, to, d->pressedIndex);
+        int newPressedPosition = vertical ? d->tabList[d->pressedIndex].rect.top() : d->tabList[d->pressedIndex].rect.left();
+        int diff = oldPressedPosition - newPressedPosition;
+        if (isRightToLeft() && !vertical)
+            diff *= -1;
+        if (vertical)
+            d->dragStartPosition.setY(d->dragStartPosition.y() - diff);
+        else
+            d->dragStartPosition.setX(d->dragStartPosition.x() - diff);
+    }
+
+    d->layoutWidgets(start);
+    update();
+    emit tabMoved(from, to);
+    emit tabLayoutChange();
+}
+
+void QTabBarPrivate::slide(int from, int to)
+{
+    Q_Q(QTabBar);
+    if (from == to
+            || !validIndex(from)
+            || !validIndex(to))
+        return;
+    bool vertical = verticalTabs(shape);
+    int preLocation = vertical ? q->tabRect(from).y() : q->tabRect(from).x();
+    q->setUpdatesEnabled(false);
+    q->moveTab(from, to);
+    q->setUpdatesEnabled(true);
+    int postLocation = vertical ? q->tabRect(to).y() : q->tabRect(to).x();
+    int length = postLocation - preLocation;
+    tabList[to].makeTimeLine(q);
+    tabList[to].dragOffset += -1 * length;
+    tabList[to].timeLine->setFrameRange(tabList[to].dragOffset, 0);
+    animations[tabList[to].timeLine] = to;
+    tabList[to].timeLine->setDuration(ANIMATION_DURATION);
+    if (tabList[to].timeLine->state() != QTimeLine::Running)
+        tabList[to].timeLine->start();
+}
+
+void QTabBarPrivate::_q_moveTab(int offset)
+{
+    Q_Q(QTabBar);
+    if (QTimeLine *timeLine = qobject_cast<QTimeLine *>(q->sender())) {
+        int index = animations[timeLine];
+        if (!validIndex(index))
+            return;
+        tabList[index].dragOffset = offset;
+        q->update();
+    }
+}
+
+/*!\reimp
+*/
+void QTabBar::mousePressEvent(QMouseEvent *event)
+{
+    Q_D(QTabBar);
+    if (event->button() != Qt::LeftButton) {
+        event->ignore();
+        return;
+    }
+    // Be safe!
+    if (d->pressedIndex != -1 && d->movable)
+        d->_q_moveTabFinished(d->pressedIndex);
+
+    d->pressedIndex = d->indexAtPos(event->pos());
+    if (d->validIndex(d->pressedIndex)) {
+        QStyleOptionTabBarBaseV2 optTabBase;
+        optTabBase.init(this);
+        optTabBase.documentMode = d->documentMode;
+        if (event->type() == style()->styleHint(QStyle::SH_TabBar_SelectMouseType, &optTabBase, this))
+            setCurrentIndex(d->pressedIndex);
+        else
+            repaint(tabRect(d->pressedIndex));
+        if (d->movable) {
+            d->dragStartPosition = event->pos();
+        }
+    }
+}
+
+/*!\reimp
+ */
+void QTabBar::mouseMoveEvent(QMouseEvent *event)
+{
+    Q_D(QTabBar);
+    if (d->movable) {
+        // Be safe!
+        if (d->pressedIndex != -1
+            && event->buttons() == Qt::NoButton)
+            d->_q_moveTabFinished(d->pressedIndex);
+        
+        // Start drag
+        if (!d->dragInProgress && d->pressedIndex != -1) {
+            if ((event->pos() - d->dragStartPosition).manhattanLength() > QApplication::startDragDistance()) {
+                d->dragInProgress = true;
+                if (d->animations.isEmpty())
+                    d->grabCache(0, d->tabList.count(), false);
+            }
+        }
+
+        int offset = (event->pos() - d->dragStartPosition).manhattanLength();
+        if (event->buttons() == Qt::LeftButton
+            && offset > QApplication::startDragDistance()
+            && d->validIndex(d->pressedIndex)) {
+            bool vertical = verticalTabs(d->shape);
+            int dragDistance;
+            if (vertical) {
+                dragDistance = (event->pos().y() - d->dragStartPosition.y());
+            } else {
+                dragDistance = (event->pos().x() - d->dragStartPosition.x());
+            }
+            d->tabList[d->pressedIndex].dragOffset = dragDistance;
+
+            QRect startingRect = tabRect(d->pressedIndex);
+            if (vertical)
+                startingRect.moveTop(startingRect.y() + dragDistance);
+            else
+                startingRect.moveLeft(startingRect.x() + dragDistance);
+
+            int overIndex;
+            if (dragDistance < 0)
+                overIndex = tabAt(startingRect.topLeft());
+            else
+                overIndex = tabAt(startingRect.topRight());
+
+            if (overIndex != d->pressedIndex && overIndex != -1) {
+                int offset = 1;
+                if (isRightToLeft() && !vertical)
+                    offset *= -1;
+                if (dragDistance < 0) {
+                    dragDistance *= -1;
+                    offset *= -1;
+                }
+                for (int i = d->pressedIndex;
+                     offset > 0 ? i < overIndex : i > overIndex;
+                     i += offset) {
+                    QRect overIndexRect = tabRect(overIndex);
+                    int needsToBeOver = (vertical ? overIndexRect.height() : overIndexRect.width()) / 2;
+                    if (dragDistance > needsToBeOver)
+                        d->slide(i + offset, d->pressedIndex);
+                }
+
+            }
+            // Buttons needs to follow the dragged tab
+            d->layoutTab(d->pressedIndex);
+
+            update();
+        }
+    }
+
+    if (event->buttons() != Qt::LeftButton) {
+        event->ignore();
+        return;
+    }
+    QStyleOptionTabBarBaseV2 optTabBase;
+    optTabBase.init(this);
+    optTabBase.documentMode = d->documentMode;
+}
+
+void QTabBarPrivate::_q_moveTabFinished()
+{
+    Q_Q(QTabBar);
+    if (QTimeLine *timeLine = qobject_cast<QTimeLine *>(q->sender())) {
+        int index = animations[timeLine];
+        animations.remove(timeLine);
+        _q_moveTabFinished(index);
+    }
+}
+
+void QTabBarPrivate::grabCache(int start, int end, bool unhide)
+{
+    Q_Q(QTabBar);
+    paintWithOffsets = false;
+    bool showButtonsAgain = rightB->isVisible();
+    rightB->hide();
+    leftB->hide();
+
+    QWidget *topLevel = q->window();
+    QPoint topLevelOffset(q->mapTo(topLevel, QPoint()));
+    for (int i = start; i < end; ++i) {
+        QRect tabRect = q->tabRect(i);
+        tabRect.translate(topLevelOffset);
+        if (unhide) {
+            tabList[i].unHideWidgets();
+            layoutWidgets(i);
+        }
+        tabList[i].animatingCache = QPixmap::grabWidget(topLevel, tabRect);
+        if (i != pressedIndex)
+            tabList[i].hideWidgets();
+    }
+    if (showButtonsAgain) {
+        rightB->show();
+        leftB->show();
+    }
+    paintWithOffsets = true;
+}
+
+void QTabBarPrivate::_q_moveTabFinished(int index)
+{
+    Q_Q(QTabBar);
+    bool cleanup = (pressedIndex == index) || (pressedIndex == -1) || !validIndex(index);
+    if (animations.isEmpty() && cleanup) {
+        for (int i = 0; i < tabList.count(); ++i) {
+            tabList[i].dragOffset = 0;
+            tabList[i].unHideWidgets();
+            tabList[i].animatingCache = QPixmap();
+        }
+        if (pressedIndex != -1 && movable) {
+            pressedIndex = -1;
+            dragInProgress = false;
+            dragStartPosition = QPoint();
+        }
+        layoutWidgets();
+    } else {
+        if (!validIndex(index))
+            return;
+        tabList[index].dragOffset = 0;
+    }
+    q->update();
+}
+
+/*!\reimp
+*/
+void QTabBar::mouseReleaseEvent(QMouseEvent *event)
+{
+    Q_D(QTabBar);
+    if (event->button() != Qt::LeftButton) {
+        event->ignore();
+        return;
+    }
+
+    if (d->movable && d->dragInProgress && d->validIndex(d->pressedIndex)) {
+        int length = d->tabList[d->pressedIndex].dragOffset;
+        int width = verticalTabs(d->shape)
+            ? tabRect(d->pressedIndex).height()
+            : tabRect(d->pressedIndex).width();
+        int duration = qMin(ANIMATION_DURATION,
+                ((length < 0 ? (-1 * length) : length) * ANIMATION_DURATION) / width);
+        if (duration > 0) {
+            d->tabList[d->pressedIndex].makeTimeLine(this);
+            d->tabList[d->pressedIndex].timeLine->setFrameRange(length, 0);
+            d->animations[d->tabList[d->pressedIndex].timeLine] = d->pressedIndex;
+            d->tabList[d->pressedIndex].timeLine->setDuration(duration);
+            if (d->tabList[d->pressedIndex].timeLine->state() != QTimeLine::Running)
+                d->tabList[d->pressedIndex].timeLine->start();
+        } else {
+            d->_q_moveTabFinished(d->pressedIndex);
+        }
+        d->dragInProgress = false;
+        d->dragStartPosition = QPoint();
+    }
+
+    int i = d->indexAtPos(event->pos()) == d->pressedIndex ? d->pressedIndex : -1;
+    d->pressedIndex = -1;
+    QStyleOptionTabBarBaseV2 optTabBase;
+    optTabBase.initFrom(this);
+    optTabBase.documentMode = d->documentMode;
+    if (style()->styleHint(QStyle::SH_TabBar_SelectMouseType, &optTabBase, this) == QEvent::MouseButtonRelease)
+        setCurrentIndex(i);
+}
+
+/*!\reimp
+ */
+void QTabBar::keyPressEvent(QKeyEvent *event)
+{
+    Q_D(QTabBar);
+    if (event->key() != Qt::Key_Left && event->key() != Qt::Key_Right) {
+        event->ignore();
+        return;
+    }
+    int dx = event->key() == (isRightToLeft() ? Qt::Key_Right : Qt::Key_Left) ? -1 : 1;
+    for (int index = d->currentIndex + dx; d->validIndex(index); index += dx) {
+        if (d->tabList.at(index).enabled) {
+            setCurrentIndex(index);
+            break;
+        }
+    }
+}
+
+/*!\reimp
+ */
+#ifndef QT_NO_WHEELEVENT
+void QTabBar::wheelEvent(QWheelEvent *event)
+{
+    Q_D(QTabBar);
+    int overIndex = d->indexAtPos(event->pos());
+    if (overIndex != -1) {
+        int offset = event->delta() > 0 ? -1 : 1;
+        setCurrentIndex(currentIndex() + offset);
+    }
+    QWidget::wheelEvent(event);
+}
+#endif //QT_NO_WHEELEVENT
+
+/*!\reimp
+ */
+void QTabBar::changeEvent(QEvent *event)
+{
+    Q_D(QTabBar);
+    if (event->type() == QEvent::StyleChange) {
+        d->elideMode = Qt::TextElideMode(style()->styleHint(QStyle::SH_TabBar_ElideMode, 0, this));
+        d->useScrollButtons = !style()->styleHint(QStyle::SH_TabBar_PreferNoArrows, 0, this);
+    }
+    d->refresh();
+    QWidget::changeEvent(event);
+}
+
+/*!
+    \property QTabBar::elideMode
+    \brief how to elide text in the tab bar
+    \since 4.2
+
+    This property controls how items are elided when there is not
+    enough space to show them for a given tab bar size.
+
+    By default the value is style dependent.
+
+    \sa QTabWidget::elideMode usesScrollButtons QStyle::SH_TabBar_ElideMode
+*/
+
+Qt::TextElideMode QTabBar::elideMode() const
+{
+    Q_D(const QTabBar);
+    return d->elideMode;
+}
+
+void QTabBar::setElideMode(Qt::TextElideMode mode)
+{
+    Q_D(QTabBar);
+    d->elideMode = mode;
+    d->refresh();
+}
+
+/*!
+    \property QTabBar::usesScrollButtons
+    \brief Whether or not a tab bar should use buttons to scroll tabs when it
+    has many tabs.
+    \since 4.2
+
+    When there are too many tabs in a tab bar for its size, the tab bar can either choose
+    to expand its size or to add buttons that allow you to scroll through the tabs.
+
+    By default the value is style dependant.
+
+    \sa elideMode QTabWidget::usesScrollButtons QStyle::SH_TabBar_PreferNoArrows
+*/
+bool QTabBar::usesScrollButtons() const
+{
+    return d_func()->useScrollButtons;
+}
+
+void QTabBar::setUsesScrollButtons(bool useButtons)
+{
+    Q_D(QTabBar);
+    if (d->useScrollButtons == useButtons)
+        return;
+    d->useScrollButtons = useButtons;
+    d->refresh();
+}
+
+/*!
+    \fn void QTabBar::setCurrentTab(int index)
+
+    Use setCurrentIndex() instead.
+*/
+
+/*!
+    \fn void QTabBar::selected(int index);
+
+    Use currentChanged() instead.
+*/
+
+
+/*!
+    \property QTabBar::tabsClosable
+    \brief Whether or not a tab bar should place close buttons on each tab
+    \since 4.5
+
+    When tabsClosable is set to true a close button will appear on the tab on
+    either the left or right hand side depending upon the style.  When the button
+    is clicked the tab the signal tabCloseRequested will be emitted.
+
+    By default the value is false.
+
+    \sa setTabButton(), tabRemoved()
+*/
+
+bool QTabBar::tabsClosable() const
+{
+    Q_D(const QTabBar);
+    return d->closeButtonOnTabs;
+}
+
+void QTabBar::setTabsClosable(bool closable)
+{
+    Q_D(QTabBar);
+    if (d->closeButtonOnTabs == closable)
+        return;
+    d->closeButtonOnTabs = closable;
+    ButtonPosition closeSide = (ButtonPosition)style()->styleHint(QStyle::SH_TabBar_CloseButtonPosition, 0, this);
+    if (!closable) {
+        for (int i = 0; i < d->tabList.count(); ++i) {
+            if (closeSide == LeftSide && d->tabList[i].leftWidget) {
+                d->tabList[i].leftWidget->deleteLater();
+                d->tabList[i].leftWidget = 0;
+            }
+            if (closeSide == RightSide && d->tabList[i].rightWidget) {
+                d->tabList[i].rightWidget->deleteLater();
+                d->tabList[i].rightWidget = 0;
+            }
+        }
+    } else {
+        bool newButtons = false;
+        for (int i = 0; i < d->tabList.count(); ++i) {
+            if (tabButton(i, closeSide))
+                continue;
+            newButtons = true;
+            QAbstractButton *closeButton = new CloseButton(this);
+            connect(closeButton, SIGNAL(clicked()), this, SLOT(_q_closeTab()));
+            setTabButton(i, closeSide, closeButton);
+        }
+        if (newButtons)
+            d->layoutTabs();
+    }
+    update();
+}
+
+/*!
+    \enum QTabBar::ButtonPosition
+    \since 4.5
+
+    This enum type lists the location of the widget on a tab.
+
+    \value LeftSide Left side of the tab.
+
+    \value RightSide Right side of the tab.
+
+*/
+
+/*!
+    \enum QTabBar::SelectionBehavior
+    \since 4.5
+
+    This enum type lists the behavior of QTabBar when a tab is removed
+    and the tab being removed is also the current tab.
+
+    \value SelectLeftTab  Select the tab to the left of the one being removed.
+
+    \value SelectRightTab  Select the tab to the right of the one being removed.
+
+    \value SelectPreviousTab  Select the previously selected tab.
+
+*/
+
+/*!
+    \property QTabBar::selectionBehaviorOnRemove
+    \brief What tab should be set as current when removeTab is called if
+    the removed tab is also the current tab.
+    \since 4.5
+
+    By default the value is SelectRightTab.
+
+    \sa removeTab()
+*/
+
+
+QTabBar::SelectionBehavior QTabBar::selectionBehaviorOnRemove() const
+{
+    Q_D(const QTabBar);
+    return d->selectionBehaviorOnRemove;
+}
+
+void QTabBar::setSelectionBehaviorOnRemove(QTabBar::SelectionBehavior behavior)
+{
+    Q_D(QTabBar);
+    d->selectionBehaviorOnRemove = behavior;
+}
+
+/*!
+    \property QTabBar::expanding
+    \brief When expanding is true QTabBar will expand the tabs to use the empty space.
+    \since 4.5
+
+    By default the value is true.
+
+    \sa QTabWidget::documentMode
+*/
+
+bool QTabBar::expanding() const
+{
+    Q_D(const QTabBar);
+    return d->expanding;
+}
+
+void QTabBar::setExpanding(bool enabled)
+{
+    Q_D(QTabBar);
+    if (d->expanding == enabled)
+        return;
+    d->expanding = enabled;
+    d->layoutTabs();
+}
+
+/*!
+    \property QTabBar::movable
+    \brief This property holds whether the user can move the tabs
+    within the tabbar area.
+
+    \since 4.5
+
+    By default, this property is false;
+*/
+
+bool QTabBar::isMovable() const
+{
+    Q_D(const QTabBar);
+    return d->movable;
+}
+
+void QTabBar::setMovable(bool movable)
+{
+    Q_D(QTabBar);
+    d->movable = movable;
+}
+
+
+/*!
+    \property QTabBar::documentMode
+    \brief Whether or not the tab bar is rendered in a mode suitable for the main window.
+    \since 4.5
+
+    This property is used as a hint for styles to draw the tabs in a different
+    way then they would normally look in a tab widget.  On Mac OS X this will
+    look similar to the tabs in Safari or Leopard's Terminal.app.
+
+    \sa QTabWidget::documentMode
+*/
+bool QTabBar::documentMode() const
+{
+    return d_func()->documentMode;
+}
+
+void QTabBar::setDocumentMode(bool enabled)
+{
+    Q_D(QTabBar);
+    d->documentMode = enabled;
+    d->updateMacBorderMetrics();
+}
+
+/*!
+    Sets \a widget on the tab \a index.  The widget is placed
+    on the left or right hand side depending upon the \a position.
+    \since 4.5
+
+    Any previously set widget in \a position is hidden.
+
+    The tab bar will take ownership of the widget and so all widgets set here
+    will be deleted by the tab bar when it is destroyed unless you separately
+    reparent the widget after setting some other widget (or 0).
+
+    \sa tabsClosable()
+  */
+void QTabBar::setTabButton(int index, ButtonPosition position, QWidget *widget)
+{
+    Q_D(QTabBar);
+    if (index < 0 || index >= d->tabList.count())
+        return;
+    if (widget) {
+        widget->setParent(this);
+        // make sure our left and right widgets stay on top
+        widget->lower();
+    }
+    if (position == LeftSide) {
+        if (d->tabList[index].leftWidget)
+            d->tabList[index].leftWidget->hide();
+        d->tabList[index].leftWidget = widget;
+        if(!d->tabList[index].hidLeft && widget)
+            widget->show();
+    } else {
+        if (d->tabList[index].rightWidget)
+            d->tabList[index].rightWidget->hide();
+        d->tabList[index].rightWidget = widget;
+        if(!d->tabList[index].hidRight && widget)
+            widget->show();
+    }
+    d->layoutTabs();
+    update();
+}
+
+/*!
+    Returns the widget set a tab \a index and \a position or 0 if
+    one is not set.
+  */
+QWidget *QTabBar::tabButton(int index, ButtonPosition position) const
+{
+    Q_D(const QTabBar);
+    if (index < 0 || index >= d->tabList.count())
+        return 0;
+    if (position == LeftSide)
+        return d->tabList.at(index).leftWidget;
+    else
+        return d->tabList.at(index).rightWidget;
+}
+
+CloseButton::CloseButton(QWidget *parent)
+    : QAbstractButton(parent)
+{
+    setFocusPolicy(Qt::NoFocus);
+#ifndef QT_NO_CURSOR
+    setCursor(Qt::ArrowCursor);
+#endif
+#ifndef QT_NO_TOOLTIP
+    setToolTip(tr("Close Tab"));
+#endif
+    resize(sizeHint());
+}
+
+QSize CloseButton::sizeHint() const
+{
+    ensurePolished();
+    int width = style()->pixelMetric(QStyle::PM_TabCloseIndicatorWidth, 0, this);
+    int height = style()->pixelMetric(QStyle::PM_TabCloseIndicatorHeight, 0, this);
+    return QSize(width, height);
+}
+
+void CloseButton::enterEvent(QEvent *event)
+{
+    if (isEnabled())
+        update();
+    QAbstractButton::enterEvent(event);
+}
+
+void CloseButton::leaveEvent(QEvent *event)
+{
+    if (isEnabled())
+        update();
+    QAbstractButton::leaveEvent(event);
+}
+
+void CloseButton::paintEvent(QPaintEvent *)
+{
+    QPainter p(this);
+    QStyleOption opt;
+    opt.init(this);
+    opt.state |= QStyle::State_AutoRaise;
+    if (isEnabled() && underMouse() && !isChecked() && !isDown())
+        opt.state |= QStyle::State_Raised;
+    if (isChecked())
+        opt.state |= QStyle::State_On;
+    if (isDown())
+        opt.state |= QStyle::State_Sunken;
+
+    if (const QTabBar *tb = qobject_cast<const QTabBar *>(parent())) {
+        int index = tb->currentIndex();
+        QTabBar::ButtonPosition position = (QTabBar::ButtonPosition)style()->styleHint(QStyle::SH_TabBar_CloseButtonPosition, 0, tb);
+        if (tb->tabButton(index, position) == this)
+            opt.state |= QStyle::State_Selected;
+    }
+
+    style()->drawPrimitive(QStyle::PE_IndicatorTabClose, &opt, &p, this);
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qtabbar.cpp"
+
+#endif // QT_NO_TABBAR