qtabwidget.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qtabwidget.h"
 
#include "private/qapplication_p.h"
#include "private/qwidget_p.h"
#include "private/qtabbar_p.h"
#include "qapplication.h"
#include "qbitmap.h"
#include "qevent.h"
#include "qlayout.h"
#include "qstackedwidget.h"
#include "qstyle.h"
#include "qstyleoption.h"
#include "qstylepainter.h"
#include "qtabbar.h"
#include "qtoolbutton.h"
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
class QTabWidgetPrivate : public QWidgetPrivate
{
    Q_DECLARE_PUBLIC(QTabWidget)
 
public:
    QTabWidgetPrivate();
    ~QTabWidgetPrivate();
    void updateTabBarPosition();
    void showTab(int);
    void removeTab(int);
    void tabMoved(int from, int to);
    void init();
    bool isAutoHidden() const
    {
        // see QTabBarPrivate::autoHideTabs()
        return (tabs->autoHide() && tabs->count() <= 1);
    }
 
    void initBasicStyleOption(QStyleOptionTabWidgetFrame *option) const;
 
    QTabBar *tabs;
    QStackedWidget *stack;
    QRect panelRect;
    bool dirty;
    QTabWidget::TabPosition pos;
    QTabWidget::TabShape shape;
    QWidget *leftCornerWidget;
    QWidget *rightCornerWidget;
};
 
QTabWidgetPrivate::QTabWidgetPrivate()
    : tabs(nullptr), stack(nullptr), dirty(true),
      pos(QTabWidget::North), shape(QTabWidget::Rounded),
      leftCornerWidget(nullptr), rightCornerWidget(nullptr)
{}
 
QTabWidgetPrivate::~QTabWidgetPrivate()
{}
 
void QTabWidgetPrivate::init()
{
    Q_Q(QTabWidget);
 
    stack = new QStackedWidget(q);
    stack->setObjectName("qt_tabwidget_stackedwidget"_L1);
    stack->setLineWidth(0);
    // hack so that QMacStyle::layoutSpacing() can detect tab widget pages
    stack->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred, QSizePolicy::TabWidget));
 
    QObjectPrivate::connect(stack, &QStackedWidget::widgetRemoved, this, &QTabWidgetPrivate::removeTab);
    QTabBar *tabBar = new QTabBar(q);
    tabBar->setObjectName("qt_tabwidget_tabbar"_L1);
    tabBar->setDrawBase(false);
    q->setTabBar(tabBar);
 
    q->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding,
                                 QSizePolicy::TabWidget));
#ifdef QT_KEYPAD_NAVIGATION
    if (QApplicationPrivate::keypadNavigationEnabled())
        q->setFocusPolicy(Qt::NoFocus);
    else
#endif
    q->setFocusPolicy(Qt::TabFocus);
    q->setFocusProxy(tabs);
    q->setTabPosition(static_cast<QTabWidget::TabPosition> (q->style()->styleHint(
                      QStyle::SH_TabWidget_DefaultTabPosition, nullptr, q )));
 
}
 
bool QTabWidget::hasHeightForWidth() const
{
    Q_D(const QTabWidget);
    bool has = d->size_policy.hasHeightForWidth();
    if (!has && d->stack)
        has = d->stack->hasHeightForWidth();
    return has;
}
 
void QTabWidgetPrivate::initBasicStyleOption(QStyleOptionTabWidgetFrame *option) const
{
    Q_Q(const QTabWidget);
    option->initFrom(q);
 
    if (q->documentMode())
        option->lineWidth = 0;
    else
        option->lineWidth = q->style()->pixelMetric(QStyle::PM_DefaultFrameWidth, nullptr, q);
 
    switch (pos) {
    case QTabWidget::North:
        option->shape = shape == QTabWidget::Rounded ? QTabBar::RoundedNorth
                                                     : QTabBar::TriangularNorth;
        break;
    case QTabWidget::South:
        option->shape = shape == QTabWidget::Rounded ? QTabBar::RoundedSouth
                                                     : QTabBar::TriangularSouth;
        break;
    case QTabWidget::West:
        option->shape = shape == QTabWidget::Rounded ? QTabBar::RoundedWest
                                                     : QTabBar::TriangularWest;
        break;
    case QTabWidget::East:
        option->shape = shape == QTabWidget::Rounded ? QTabBar::RoundedEast
                                                     : QTabBar::TriangularEast;
        break;
    }
 
    option->tabBarRect = q->tabBar()->geometry();
}
 
void QTabWidget::initStyleOption(QStyleOptionTabWidgetFrame *option) const
{
    if (!option)
        return;
 
    Q_D(const QTabWidget);
    d->initBasicStyleOption(option);
 
    int exth = style()->pixelMetric(QStyle::PM_TabBarBaseHeight, nullptr, this);
    QSize t(0, d->stack->frameWidth());
    if (d->tabs->isVisibleTo(const_cast<QTabWidget *>(this))) {
        t = d->tabs->sizeHint();
        if (documentMode()) {
            if (tabPosition() == East || tabPosition() == West) {
                t.setHeight(height());
            } else {
                t.setWidth(width());
            }
        }
    }
 
    if (d->rightCornerWidget) {
        const QSize rightCornerSizeHint = d->rightCornerWidget->sizeHint();
        const QSize bounds(rightCornerSizeHint.width(), t.height() - exth);
        option->rightCornerWidgetSize = rightCornerSizeHint.boundedTo(bounds);
    } else {
        option->rightCornerWidgetSize = QSize(0, 0);
    }
 
    if (d->leftCornerWidget) {
        const QSize leftCornerSizeHint = d->leftCornerWidget->sizeHint();
        const QSize bounds(leftCornerSizeHint.width(), t.height() - exth);
        option->leftCornerWidgetSize = leftCornerSizeHint.boundedTo(bounds);
    } else {
        option->leftCornerWidgetSize = QSize(0, 0);
    }
 
    option->tabBarSize = t;
 
    QRect selectedTabRect = tabBar()->tabRect(tabBar()->currentIndex());
    selectedTabRect.moveTopLeft(selectedTabRect.topLeft() + option->tabBarRect.topLeft());
    option->selectedTabRect = selectedTabRect;
}
 
QTabWidget::QTabWidget(QWidget *parent)
    : QWidget(*new QTabWidgetPrivate, parent, { })
{
    Q_D(QTabWidget);
    d->init();
}
 
 
QTabWidget::~QTabWidget()
{
}
 
int QTabWidget::addTab(QWidget *child, const QString &label)
{
    return insertTab(-1, child, label);
}
 
 
int QTabWidget::addTab(QWidget *child, const QIcon& icon, const QString &label)
{
    return insertTab(-1, child, icon, label);
}
 
 
int QTabWidget::insertTab(int index, QWidget *w, const QString &label)
{
    return insertTab(index, w, QIcon(), label);
}
 
 
int QTabWidget::insertTab(int index, QWidget *w, const QIcon& icon, const QString &label)
{
    Q_D(QTabWidget);
    if (!w)
        return -1;
    index = d->stack->insertWidget(index, w);
    d->tabs->insertTab(index, icon, label);
    setUpLayout();
    tabInserted(index);
 
    return index;
}
 
 
void QTabWidget::setTabText(int index, const QString &label)
{
    Q_D(QTabWidget);
    d->tabs->setTabText(index, label);
    setUpLayout();
}
 
QString QTabWidget::tabText(int index) const
{
    Q_D(const QTabWidget);
    return d->tabs->tabText(index);
}
 
void QTabWidget::setTabIcon(int index, const QIcon &icon)
{
    Q_D(QTabWidget);
    d->tabs->setTabIcon(index, icon);
    setUpLayout();
}
 
QIcon QTabWidget::tabIcon(int index) const
{
    Q_D(const QTabWidget);
    return d->tabs->tabIcon(index);
}
 
bool QTabWidget::isTabEnabled(int index) const
{
    Q_D(const QTabWidget);
    return d->tabs->isTabEnabled(index);
}
 
void QTabWidget::setTabEnabled(int index, bool enable)
{
    Q_D(QTabWidget);
    d->tabs->setTabEnabled(index, enable);
    if (QWidget *widget = d->stack->widget(index))
        widget->setEnabled(enable);
}
 
bool QTabWidget::isTabVisible(int index) const
{
    Q_D(const QTabWidget);
    return d->tabs->isTabVisible(index);
}
 
void QTabWidget::setTabVisible(int index, bool visible)
{
    Q_D(QTabWidget);
    QWidget *widget = d->stack->widget(index);
    bool currentVisible = d->tabs->isTabVisible(d->tabs->currentIndex());
    d->tabs->setTabVisible(index, visible);
    if (!visible) {
        if (widget)
            widget->setVisible(false);
    } else if (!currentVisible) {
        setCurrentIndex(index);
        if (widget)
            widget->setVisible(true);
    }
    setUpLayout();
}
 
void QTabWidget::setCornerWidget(QWidget * widget, Qt::Corner corner)
{
    Q_D(QTabWidget);
    if (widget && widget->parentWidget() != this)
        widget->setParent(this);
 
    if (corner & Qt::TopRightCorner) {
        if (d->rightCornerWidget)
            d->rightCornerWidget->hide();
        d->rightCornerWidget = widget;
    } else {
        if (d->leftCornerWidget)
            d->leftCornerWidget->hide();
        d->leftCornerWidget = widget;
    }
    setUpLayout();
}
 
QWidget * QTabWidget::cornerWidget(Qt::Corner corner) const
{
    Q_D(const QTabWidget);
    if (corner & Qt::TopRightCorner)
        return d->rightCornerWidget;
    return d->leftCornerWidget;
}
 
void QTabWidget::removeTab(int index)
{
    Q_D(QTabWidget);
    if (QWidget *w = d->stack->widget(index))
        d->stack->removeWidget(w);
}
 
QWidget * QTabWidget::currentWidget() const
{
    Q_D(const QTabWidget);
    return d->stack->currentWidget();
}
 
void QTabWidget::setCurrentWidget(QWidget *widget)
{
    Q_D(const QTabWidget);
    d->tabs->setCurrentIndex(indexOf(widget));
}
 
 
int QTabWidget::currentIndex() const
{
    Q_D(const QTabWidget);
    return d->tabs->currentIndex();
}
 
void QTabWidget::setCurrentIndex(int index)
{
    Q_D(QTabWidget);
    d->tabs->setCurrentIndex(index);
}
 
 
int QTabWidget::indexOf(const QWidget *w) const
{
    Q_D(const QTabWidget);
    return d->stack->indexOf(w);
}
 
 
void QTabWidget::resizeEvent(QResizeEvent *e)
{
    QWidget::resizeEvent(e);
    setUpLayout();
}
 
void QTabWidget::setTabBar(QTabBar* tb)
{
    Q_D(QTabWidget);
    Q_ASSERT(tb);
 
    if (tb->parentWidget() != this) {
        tb->setParent(this);
        tb->show();
    }
    delete d->tabs;
    d->tabs = tb;
    setFocusProxy(d->tabs);
    QObjectPrivate::connect(d->tabs, &QTabBar::currentChanged,
                            d, &QTabWidgetPrivate::showTab);
    QObjectPrivate::connect(d->tabs, &QTabBar::tabMoved,
                            d, &QTabWidgetPrivate::tabMoved);
    connect(d->tabs, &QTabBar::tabBarClicked,
            this, &QTabWidget::tabBarClicked);
    connect(d->tabs, &QTabBar::tabBarDoubleClicked,
            this, &QTabWidget::tabBarDoubleClicked);
    if (d->tabs->tabsClosable())
        connect(d->tabs, &QTabBar::tabCloseRequested,
                this, &QTabWidget::tabCloseRequested);
    tb->setExpanding(!documentMode());
    setUpLayout();
}
 
 
QTabBar* QTabWidget::tabBar() const
{
    Q_D(const QTabWidget);
    return d->tabs;
}
 
/*
    Ensures that the selected tab's page is visible and appropriately
    sized.
*/
 
void QTabWidgetPrivate::showTab(int index)
{
    Q_Q(QTabWidget);
    if (index < stack->count() && index >= 0)
        stack->setCurrentIndex(index);
    emit q->currentChanged(index);
}
 
void QTabWidgetPrivate::removeTab(int index)
{
    Q_Q(QTabWidget);
    tabs->removeTab(index);
    q->setUpLayout();
    q->tabRemoved(index);
}
 
void QTabWidgetPrivate::tabMoved(int from, int to)
{
    const QSignalBlocker blocker(stack);
    QWidget *w = stack->widget(from);
    stack->removeWidget(w);
    stack->insertWidget(to, w);
}
 
/*
    Set up the layout.
    Get subrect from the current style, and set the geometry for the
    stack widget, tab bar and corner widgets.
*/
void QTabWidget::setUpLayout(bool onlyCheck)
{
    Q_D(QTabWidget);
    if (onlyCheck && !d->dirty)
        return; // nothing to do
 
    if (!isVisible()) {
        // this must be done immediately, because QWidgetItem relies on it (even if !isVisible())
        QStyleOptionTabWidgetFrame basicOption;
        d->initBasicStyleOption(&basicOption);
        d->setLayoutItemMargins(QStyle::SE_TabWidgetLayoutItem, &basicOption);
        d->dirty = true;
        return; // we'll do it later
    }
 
    QStyleOptionTabWidgetFrame option;
    initStyleOption(&option);
    d->setLayoutItemMargins(QStyle::SE_TabWidgetLayoutItem, &option);
 
    QRect tabRect = style()->subElementRect(QStyle::SE_TabWidgetTabBar, &option, this);
    d->panelRect = style()->subElementRect(QStyle::SE_TabWidgetTabPane, &option, this);
    QRect contentsRect = style()->subElementRect(QStyle::SE_TabWidgetTabContents, &option, this);
    QRect leftCornerRect = style()->subElementRect(QStyle::SE_TabWidgetLeftCorner, &option, this);
    QRect rightCornerRect = style()->subElementRect(QStyle::SE_TabWidgetRightCorner, &option, this);
 
    d->tabs->setGeometry(tabRect);
    d->stack->setGeometry(contentsRect);
    if (d->leftCornerWidget)
        d->leftCornerWidget->setGeometry(leftCornerRect);
    if (d->rightCornerWidget)
        d->rightCornerWidget->setGeometry(rightCornerRect);
 
    if (!onlyCheck)
        update();
    updateGeometry();
}
 
static inline QSize basicSize(
    bool horizontal, const QSize &lc, const QSize &rc, const QSize &s, const QSize &t)
{
    return horizontal
        ? QSize(qMax(s.width(), t.width() + rc.width() + lc.width()),
                s.height() + (qMax(rc.height(), qMax(lc.height(), t.height()))))
        : QSize(s.width() + (qMax(rc.width(), qMax(lc.width(), t.width()))),
                qMax(s.height(), t.height() + rc.height() + lc.height()));
}
 
QSize QTabWidget::sizeHint() const
{
    Q_D(const QTabWidget);
    QSize lc(0, 0), rc(0, 0);
    QStyleOptionTabWidgetFrame opt;
    initStyleOption(&opt);
    opt.state = QStyle::State_None;
 
    if (d->leftCornerWidget)
        lc = d->leftCornerWidget->sizeHint();
    if (d->rightCornerWidget)
        rc = d->rightCornerWidget->sizeHint();
    if (!d->dirty) {
        QTabWidget *that = const_cast<QTabWidget*>(this);
        that->setUpLayout(true);
    }
    QSize s;
    for (int i=0; i< d->stack->count(); ++i) {
        if (const QWidget* w = d->stack->widget(i)) {
            if (d->tabs->isTabVisible(i))
                s = s.expandedTo(w->sizeHint());
        }
    }
    QSize t;
    if (!d->isAutoHidden()) {
        t = d->tabs->sizeHint();
        if (usesScrollButtons())
            t = t.boundedTo(QSize(200,200));
        else
            t = t.boundedTo(QGuiApplication::primaryScreen()->virtualGeometry().size());
    }
 
    QSize sz = basicSize(d->pos == North || d->pos == South, lc, rc, s, t);
 
    return style()->sizeFromContents(QStyle::CT_TabWidget, &opt, sz, this);
}
 
 
QSize QTabWidget::minimumSizeHint() const
{
    Q_D(const QTabWidget);
    QSize lc(0, 0), rc(0, 0);
 
    if (d->leftCornerWidget)
        lc = d->leftCornerWidget->minimumSizeHint();
    if (d->rightCornerWidget)
        rc = d->rightCornerWidget->minimumSizeHint();
    if (!d->dirty) {
        QTabWidget *that = const_cast<QTabWidget*>(this);
        that->setUpLayout(true);
    }
    QSize s(d->stack->minimumSizeHint());
    QSize t;
    if (!d->isAutoHidden())
        t = d->tabs->minimumSizeHint();
 
    QSize sz = basicSize(d->pos == North || d->pos == South, lc, rc, s, t);
 
    QStyleOptionTabWidgetFrame opt;
    initStyleOption(&opt);
    opt.palette = palette();
    opt.state = QStyle::State_None;
    return style()->sizeFromContents(QStyle::CT_TabWidget, &opt, sz, this);
}
 
int QTabWidget::heightForWidth(int width) const
{
    Q_D(const QTabWidget);
    QStyleOptionTabWidgetFrame opt;
    initStyleOption(&opt);
    opt.state = QStyle::State_None;
 
    QSize zero(0,0);
    const QSize padding = style()->sizeFromContents(QStyle::CT_TabWidget, &opt, zero, this);
 
    QSize lc(0, 0), rc(0, 0);
    if (d->leftCornerWidget)
        lc = d->leftCornerWidget->sizeHint();
    if (d->rightCornerWidget)
        rc = d->rightCornerWidget->sizeHint();
    if (!d->dirty) {
        QTabWidget *that = const_cast<QTabWidget*>(this);
        that->setUpLayout(true);
    }
    QSize t;
    if (!d->isAutoHidden()) {
        t = d->tabs->sizeHint();
        if (usesScrollButtons())
            t = t.boundedTo(QSize(200,200));
        else
            t = t.boundedTo(QGuiApplication::primaryScreen()->virtualSize());
    }
 
    const bool tabIsHorizontal = (d->pos == North || d->pos == South);
    const int contentsWidth = width - padding.width();
    int stackWidth = contentsWidth;
    if (!tabIsHorizontal)
        stackWidth -= qMax(t.width(), qMax(lc.width(), rc.width()));
 
    int stackHeight = d->stack->heightForWidth(stackWidth);
    QSize s(stackWidth, stackHeight);
 
    QSize contentSize = basicSize(tabIsHorizontal, lc, rc, s, t);
    return (contentSize + padding).height();
}
 
 
void QTabWidget::showEvent(QShowEvent *)
{
    setUpLayout();
}
 
void QTabWidgetPrivate::updateTabBarPosition()
{
    Q_Q(QTabWidget);
    switch (pos) {
    case QTabWidget::North:
        tabs->setShape(shape == QTabWidget::Rounded ? QTabBar::RoundedNorth
                                                    : QTabBar::TriangularNorth);
        break;
    case QTabWidget::South:
        tabs->setShape(shape == QTabWidget::Rounded ? QTabBar::RoundedSouth
                                                    : QTabBar::TriangularSouth);
        break;
    case QTabWidget::West:
        tabs->setShape(shape == QTabWidget::Rounded ? QTabBar::RoundedWest
                                                    : QTabBar::TriangularWest);
        break;
    case QTabWidget::East:
        tabs->setShape(shape == QTabWidget::Rounded ? QTabBar::RoundedEast
                                                    : QTabBar::TriangularEast);
        break;
    }
    q->setUpLayout();
}
 
QTabWidget::TabPosition QTabWidget::tabPosition() const
{
    Q_D(const QTabWidget);
    return d->pos;
}
 
void QTabWidget::setTabPosition(TabPosition pos)
{
    Q_D(QTabWidget);
    if (d->pos == pos)
        return;
    d->pos = pos;
    d->updateTabBarPosition();
}
 
bool QTabWidget::tabsClosable() const
{
    return tabBar()->tabsClosable();
}
 
void QTabWidget::setTabsClosable(bool closeable)
{
    if (tabsClosable() == closeable)
        return;
 
    tabBar()->setTabsClosable(closeable);
    if (closeable)
        connect(tabBar(), SIGNAL(tabCloseRequested(int)),
                this, SIGNAL(tabCloseRequested(int)));
    else
        disconnect(tabBar(), SIGNAL(tabCloseRequested(int)),
                  this, SIGNAL(tabCloseRequested(int)));
    setUpLayout();
}
 
bool QTabWidget::isMovable() const
{
    return tabBar()->isMovable();
}
 
void QTabWidget::setMovable(bool movable)
{
    tabBar()->setMovable(movable);
}
 
QTabWidget::TabShape QTabWidget::tabShape() const
{
    Q_D(const QTabWidget);
    return d->shape;
}
 
void QTabWidget::setTabShape(TabShape s)
{
    Q_D(QTabWidget);
    if (d->shape == s)
        return;
    d->shape = s;
    d->updateTabBarPosition();
}
 
bool QTabWidget::event(QEvent *ev)
{
    if (ev->type() == QEvent::LayoutRequest)
        setUpLayout();
    return QWidget::event(ev);
}
 
void QTabWidget::changeEvent(QEvent *ev)
{
    if (ev->type() == QEvent::StyleChange
#ifdef Q_OS_MAC
            || ev->type() == QEvent::MacSizeChange
#endif
            )
        setUpLayout();
    QWidget::changeEvent(ev);
}
 
 
void QTabWidget::keyPressEvent(QKeyEvent *e)
{
    Q_D(QTabWidget);
    if (((e->key() == Qt::Key_Tab || e->key() == Qt::Key_Backtab) &&
          count() > 1 && e->modifiers() & Qt::ControlModifier)
#ifdef QT_KEYPAD_NAVIGATION
          || QApplicationPrivate::keypadNavigationEnabled() && (e->key() == Qt::Key_Left || e->key() == Qt::Key_Right) && count() > 1
#endif
       ) {
        int pageCount = d->tabs->count();
        int page = currentIndex();
        int dx = (e->key() == Qt::Key_Backtab || e->modifiers() & Qt::ShiftModifier) ? -1 : 1;
#ifdef QT_KEYPAD_NAVIGATION
        if (QApplicationPrivate::keypadNavigationEnabled() && (e->key() == Qt::Key_Left || e->key() == Qt::Key_Right))
            dx = e->key() == (isRightToLeft() ? Qt::Key_Right : Qt::Key_Left) ? -1 : 1;
#endif
        for (int pass = 0; pass < pageCount; ++pass) {
            page+=dx;
            if (page < 0
#ifdef QT_KEYPAD_NAVIGATION
                && !e->isAutoRepeat()
#endif
               ) {
                page = count() - 1;
            } else if (page >= pageCount
#ifdef QT_KEYPAD_NAVIGATION
                       && !e->isAutoRepeat()
#endif
                      ) {
                page = 0;
            }
            if (d->tabs->isTabEnabled(page) && d->tabs->isTabVisible(page)) {
                setCurrentIndex(page);
                break;
            }
        }
        if (!QApplication::focusWidget())
            d->tabs->setFocus();
    } else {
        e->ignore();
    }
}
 
QWidget *QTabWidget::widget(int index) const
{
    Q_D(const QTabWidget);
    return d->stack->widget(index);
}
 
int QTabWidget::count() const
{
    Q_D(const QTabWidget);
    return d->tabs->count();
}
 
#if QT_CONFIG(tooltip)
void QTabWidget::setTabToolTip(int index, const QString & tip)
{
    Q_D(QTabWidget);
    d->tabs->setTabToolTip(index, tip);
}
 
QString QTabWidget::tabToolTip(int index) const
{
    Q_D(const QTabWidget);
    return d->tabs->tabToolTip(index);
}
#endif // QT_CONFIG(tooltip)
 
#if QT_CONFIG(whatsthis)
void QTabWidget::setTabWhatsThis(int index, const QString &text)
{
    Q_D(QTabWidget);
    d->tabs->setTabWhatsThis(index, text);
}
 
QString QTabWidget::tabWhatsThis(int index) const
{
    Q_D(const QTabWidget);
    return d->tabs->tabWhatsThis(index);
}
#endif // QT_CONFIG(whatsthis)
 
void QTabWidget::tabInserted(int index)
{
    Q_UNUSED(index);
}
 
void QTabWidget::tabRemoved(int index)
{
    Q_UNUSED(index);
}
 
void QTabWidget::paintEvent(QPaintEvent *)
{
    Q_D(QTabWidget);
    if (documentMode()) {
        QStylePainter p(this, tabBar());
        if (QWidget *w = cornerWidget(Qt::TopLeftCorner)) {
            QStyleOptionTabBarBase opt;
            QTabBarPrivate::initStyleBaseOption(&opt, tabBar(), w->size());
            opt.rect.moveLeft(w->x() + opt.rect.x());
            opt.rect.moveTop(w->y() + opt.rect.y());
            p.drawPrimitive(QStyle::PE_FrameTabBarBase, opt);
        }
        if (QWidget *w = cornerWidget(Qt::TopRightCorner)) {
            QStyleOptionTabBarBase opt;
            QTabBarPrivate::initStyleBaseOption(&opt, tabBar(), w->size());
            opt.rect.moveLeft(w->x() + opt.rect.x());
            opt.rect.moveTop(w->y() + opt.rect.y());
            p.drawPrimitive(QStyle::PE_FrameTabBarBase, opt);
        }
        return;
    }
    QStylePainter p(this);
 
    QStyleOptionTabWidgetFrame opt;
    initStyleOption(&opt);
    opt.rect = d->panelRect;
    p.drawPrimitive(QStyle::PE_FrameTabWidget, opt);
}
 
QSize QTabWidget::iconSize() const
{
    return d_func()->tabs->iconSize();
}
 
void QTabWidget::setIconSize(const QSize &size)
{
    d_func()->tabs->setIconSize(size);
}
 
Qt::TextElideMode QTabWidget::elideMode() const
{
    return d_func()->tabs->elideMode();
}
 
void QTabWidget::setElideMode(Qt::TextElideMode mode)
{
    d_func()->tabs->setElideMode(mode);
}
 
bool QTabWidget::usesScrollButtons() const
{
    return d_func()->tabs->usesScrollButtons();
}
 
void QTabWidget::setUsesScrollButtons(bool useButtons)
{
    d_func()->tabs->setUsesScrollButtons(useButtons);
}
 
bool QTabWidget::documentMode() const
{
    Q_D(const QTabWidget);
    return d->tabs->documentMode();
}
 
void QTabWidget::setDocumentMode(bool enabled)
{
    Q_D(QTabWidget);
    d->tabs->setDocumentMode(enabled);
    d->tabs->setExpanding(!enabled);
    d->tabs->setDrawBase(enabled);
    setUpLayout();
}
 
bool QTabWidget::tabBarAutoHide() const
{
    Q_D(const QTabWidget);
    return d->tabs->autoHide();
}
 
void QTabWidget::setTabBarAutoHide(bool enabled)
{
    Q_D(QTabWidget);
    return d->tabs->setAutoHide(enabled);
}
 
void QTabWidget::clear()
{
    // ### optimize by introduce QStackedLayout::clear()
    while (count())
        removeTab(0);
}
 
QTabBar::Shape _q_tb_tabBarShapeFrom(QTabWidget::TabShape shape, QTabWidget::TabPosition position)
{
    const bool rounded = (shape == QTabWidget::Rounded);
    if (position == QTabWidget::North)
        return rounded ? QTabBar::RoundedNorth : QTabBar::TriangularNorth;
    if (position == QTabWidget::South)
        return rounded ? QTabBar::RoundedSouth : QTabBar::TriangularSouth;
    if (position == QTabWidget::East)
        return rounded ? QTabBar::RoundedEast : QTabBar::TriangularEast;
    if (position == QTabWidget::West)
        return rounded ? QTabBar::RoundedWest : QTabBar::TriangularWest;
    return QTabBar::RoundedNorth;
}
 
QT_END_NAMESPACE
 
#include "moc_qtabwidget.cpp"