1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qtabwidget.h"

    43 

    44 #ifndef QT_NO_TABWIDGET

    45 #include "private/qwidget_p.h"

    46 #include "private/qtabbar_p.h"

    47 #include "qapplication.h"

    48 #include "qbitmap.h"

    49 #include "qdesktopwidget.h"

    50 #include "qevent.h"

    51 #include "qlayout.h"

    52 #include "qstackedwidget.h"

    53 #include "qstyle.h"

    54 #include "qstyleoption.h"

    55 #include "qstylepainter.h"

    56 #include "qtabbar.h"

    57 #include "qtoolbutton.h"

    58 

    59 QT_BEGIN_NAMESPACE

    60 

    61 /*!

    62     \class QTabWidget

    63     \brief The QTabWidget class provides a stack of tabbed widgets.

    64 

    65     \ingroup organizers

    66     \ingroup basicwidgets

    67 

    68 

    69     A tab widget provides a tab bar (see QTabBar) and a "page area"

    70     that is used to display pages related to each tab. By default, the

    71     tab bar is shown above the page area, but different configurations

    72     are available (see \l{TabPosition}). Each tab is associated with a

    73     different widget (called a page). Only the current page is shown in

    74     the page area; all the other pages are hidden. The user can show a

    75     different page by clicking on its tab or by pressing its

    76     Alt+\e{letter} shortcut if it has one.

    77 

    78     The normal way to use QTabWidget is to do the following:

    79     \list 1

    80     \i Create a QTabWidget.

    81     \i Create a QWidget for each of the pages in the tab dialog, but

    82        do not specify parent widgets for them.

    83     \i Insert child widgets into the page widget, using layouts to

    84        position them as normal.

    85     \i Call addTab() or insertTab() to put the page widgets into the

    86        tab widget, giving each tab a suitable label with an optional

    87        keyboard shortcut.

    88     \endlist

    89 

    90     The position of the tabs is defined by \l tabPosition, their shape

    91     by \l tabShape.

    92 

    93     The signal currentChanged() is emitted when the user selects a

    94     page.

    95 

    96     The current page index is available as currentIndex(), the current

    97     page widget with currentWidget().  You can retrieve a pointer to a

    98     page widget with a given index using widget(), and can find the

    99     index position of a widget with indexOf(). Use setCurrentWidget()

   100     or setCurrentIndex() to show a particular page.

   101 

   102     You can change a tab's text and icon using setTabText() or

   103     setTabIcon(). A tab and its associated page can be removed with

   104     removeTab().

   105 

   106     Each tab is either enabled or disabled at any given time (see

   107     setTabEnabled()). If a tab is enabled, the tab text is drawn

   108     normally and the user can select that tab. If it is disabled, the

   109     tab is drawn in a different way and the user cannot select that

   110     tab. Note that even if a tab is disabled, the page can still be

   111     visible, for example if all of the tabs happen to be disabled.

   112 

   113     Tab widgets can be a very good way to split up a complex dialog.

   114     An alternative is to use a QStackedWidget for which you provide some

   115     means of navigating between pages, for example, a QToolBar or a

   116     QListWidget.

   117 

   118     Most of the functionality in QTabWidget is provided by a QTabBar

   119     (at the top, providing the tabs) and a QStackedWidget (most of the

   120     area, organizing the individual pages).

   121 

   122     \table 100%

   123     \row \o \inlineimage windowsxp-tabwidget.png Screenshot of a Windows XP style tab widget

   124          \o \inlineimage macintosh-tabwidget.png Screenshot of a Macintosh style tab widget

   125          \o \inlineimage plastique-tabwidget.png Screenshot of a Plastique style tab widget

   126     \row \o A Windows XP style tab widget.

   127          \o A Macintosh style tab widget.

   128          \o A Plastique style tab widget.

   129     \endtable

   130 

   131     \sa QTabBar, QStackedWidget, QToolBox, {Tab Dialog Example}

   132 */

   133 

   134 /*!

   135     \enum QTabWidget::TabPosition

   136 

   137     This enum type defines where QTabWidget draws the tab row:

   138 

   139     \value North  The tabs are drawn above the pages.

   140     \value South  The tabs are drawn below the pages.

   141     \value West  The tabs are drawn to the left of the pages.

   142     \value East  The tabs are drawn to the right of the pages.

   143     \omitvalue Bottom

   144     \omitvalue Top

   145 */

   146 

   147 /*!

   148     \enum QTabWidget::TabShape

   149 

   150     This enum type defines the shape of the tabs:

   151     \value Rounded  The tabs are drawn with a rounded look. This is the default

   152                     shape.

   153     \value Triangular  The tabs are drawn with a triangular look.

   154 */

   155 

   156 /*!

   157     \fn void QTabWidget::selected(const QString &tabLabel)

   158 

   159     This signal is emitted whenever a tab is selected (raised),

   160     including during the first show().

   161 

   162     You can normally use currentChanged() instead.

   163 */

   164 

   165 /*!

   166     \fn void QTabWidget::currentChanged(int index)

   167 

   168     This signal is emitted whenever the current page index changes.

   169     The parameter is the new current page \a index position, or -1

   170     if there isn't a new one (for example, if there are no widgets

   171     in the QTabWidget)

   172 

   173     \sa currentWidget() currentIndex

   174 */

   175 

   176 /*!

   177     \fn void QTabWidget::tabCloseRequested(int index)

   178     \since 4.5

   179 

   180     This signal is emitted when the close button on a tab is clicked.

   181     The \a index is the index that should be removed.

   182 

   183     \sa setTabsClosable()

   184 */

   185 

   186 class QTabWidgetPrivate : public QWidgetPrivate

   187 {

   188     Q_DECLARE_PUBLIC(QTabWidget)

   189 

   190 public:

   191     QTabWidgetPrivate();

   192     ~QTabWidgetPrivate();

   193     void updateTabBarPosition();

   194     void _q_showTab(int);

   195     void _q_removeTab(int);

   196     void _q_tabMoved(int from, int to);

   197     void init();

   198 

   199     QTabBar *tabs;

   200     QStackedWidget *stack;

   201     QRect panelRect;

   202     bool dirty;

   203     QTabWidget::TabPosition pos;

   204     QTabWidget::TabShape shape;

   205     int alignment;

   206     QWidget *leftCornerWidget;

   207     QWidget *rightCornerWidget;

   208 };

   209 

   210 QTabWidgetPrivate::QTabWidgetPrivate()

   211     : tabs(0), stack(0), dirty(true),

   212       pos(QTabWidget::North), shape(QTabWidget::Rounded),

   213       leftCornerWidget(0), rightCornerWidget(0)

   214 {}

   215 

   216 QTabWidgetPrivate::~QTabWidgetPrivate()

   217 {}

   218 

   219 void QTabWidgetPrivate::init()

   220 {

   221     Q_Q(QTabWidget);

   222 

   223     stack = new QStackedWidget(q);

   224     stack->setObjectName(QLatin1String("qt_tabwidget_stackedwidget"));

   225     stack->setLineWidth(0);

   226     // hack so that QMacStyle::layoutSpacing() can detect tab widget pages

   227     stack->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred, QSizePolicy::TabWidget));

   228 

   229     QObject::connect(stack, SIGNAL(widgetRemoved(int)), q, SLOT(_q_removeTab(int)));

   230     QTabBar *tabBar = new QTabBar(q);

   231     tabBar->setObjectName(QLatin1String("qt_tabwidget_tabbar"));

   232     tabBar->setDrawBase(false);

   233     q->setTabBar(tabBar);

   234 

   235     q->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding,

   236                                  QSizePolicy::TabWidget));

   237 #ifdef QT_KEYPAD_NAVIGATION

   238     if (QApplication::keypadNavigationEnabled())

   239         q->setFocusPolicy(Qt::NoFocus);

   240     else

   241 #endif

   242     q->setFocusPolicy(Qt::TabFocus);

   243     q->setFocusProxy(tabs);

   244     q->setTabPosition(static_cast<QTabWidget::TabPosition> (q->style()->styleHint(

   245                       QStyle::SH_TabWidget_DefaultTabPosition, 0, q )));

   246 

   247 }

   248 

   249 /*!

   250     Initialize \a option with the values from this QTabWidget. This method is useful

   251     for subclasses when they need a QStyleOptionTabWidgetFrame, but don't want to fill

   252     in all the information themselves.

   253 

   254     \sa QStyleOption::initFrom() QTabBar::initStyleOption()

   255 */

   256 void QTabWidget::initStyleOption(QStyleOptionTabWidgetFrame *option) const

   257 {

   258     if (!option)

   259         return;

   260 

   261     Q_D(const QTabWidget);

   262     option->initFrom(this);

   263 

   264     if (documentMode())

   265         option->lineWidth = 0;

   266     else

   267         option->lineWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth, 0, this);

   268 

   269     int exth = style()->pixelMetric(QStyle::PM_TabBarBaseHeight, 0, this);

   270     QSize t(0, d->stack->frameWidth());

   271     if (d->tabs->isVisibleTo(const_cast<QTabWidget *>(this))) {

   272         t = d->tabs->sizeHint();

   273         if (documentMode()) {

   274             if (tabPosition() == East || tabPosition() == West) {

   275                 t.setHeight(height());

   276             } else {

   277                 t.setWidth(width());

   278             }

   279         }

   280     }

   281 

   282     if (d->rightCornerWidget) {

   283         const QSize rightCornerSizeHint = d->rightCornerWidget->sizeHint();

   284         const QSize bounds(rightCornerSizeHint.width(), t.height() - exth);

   285         option->rightCornerWidgetSize = rightCornerSizeHint.boundedTo(bounds);

   286     } else {

   287         option->rightCornerWidgetSize = QSize(0, 0);

   288     }

   289 

   290     if (d->leftCornerWidget) {

   291         const QSize leftCornerSizeHint = d->leftCornerWidget->sizeHint();

   292         const QSize bounds(leftCornerSizeHint.width(), t.height() - exth);

   293         option->leftCornerWidgetSize = leftCornerSizeHint.boundedTo(bounds);

   294     } else {

   295         option->leftCornerWidgetSize = QSize(0, 0);

   296     }

   297 

   298     switch (d->pos) {

   299     case QTabWidget::North:

   300         option->shape = d->shape == QTabWidget::Rounded ? QTabBar::RoundedNorth

   301                                                         : QTabBar::TriangularNorth;

   302         break;

   303     case QTabWidget::South:

   304         option->shape = d->shape == QTabWidget::Rounded ? QTabBar::RoundedSouth

   305                                                         : QTabBar::TriangularSouth;

   306         break;

   307     case QTabWidget::West:

   308         option->shape = d->shape == QTabWidget::Rounded ? QTabBar::RoundedWest

   309                                                         : QTabBar::TriangularWest;

   310         break;

   311     case QTabWidget::East:

   312         option->shape = d->shape == QTabWidget::Rounded ? QTabBar::RoundedEast

   313                                                         : QTabBar::TriangularEast;

   314         break;

   315     }

   316 

   317     option->tabBarSize = t;

   318 

   319     if (QStyleOptionTabWidgetFrameV2 *tabframe = qstyleoption_cast<QStyleOptionTabWidgetFrameV2*>(option)) {

   320         QRect tbRect = tabBar()->geometry();

   321         QRect selectedTabRect = tabBar()->tabRect(tabBar()->currentIndex());

   322         tabframe->tabBarRect = tbRect;

   323         selectedTabRect.moveTopLeft(selectedTabRect.topLeft() + tbRect.topLeft());

   324         tabframe->selectedTabRect = selectedTabRect;

   325     }

   326 }

   327 

   328 /*!

   329     Constructs a tabbed widget with parent \a parent.

   330 */

   331 QTabWidget::QTabWidget(QWidget *parent)

   332     : QWidget(*new QTabWidgetPrivate, parent, 0)

   333 {

   334     Q_D(QTabWidget);

   335     d->init();

   336 }

   337 

   338 #ifdef QT3_SUPPORT

   339 /*!

   340     Use one of the constructors that doesn't take the \a name

   341     argument and then use setObjectName() instead.

   342 */

   343 QTabWidget::QTabWidget(QWidget *parent, const char *name, Qt::WindowFlags f)

   344     : QWidget(*new QTabWidgetPrivate, parent, f)

   345 {

   346     Q_D(QTabWidget);

   347     setObjectName(QString::fromAscii(name));

   348     d->init();

   349 }

   350 #endif

   351 

   352 /*!

   353     Destroys the tabbed widget.

   354 */

   355 QTabWidget::~QTabWidget()

   356 {

   357 }

   358 

   359 /*!

   360     \fn int QTabWidget::addTab(QWidget *page, const QString &label)

   361 

   362     Adds a tab with the given \a page and \a label to the tab widget,

   363     and returns the index of the tab in the tab bar.

   364 

   365     If the tab's \a label contains an ampersand, the letter following

   366     the ampersand is used as a shortcut for the tab, e.g. if the

   367     label is "Bro\&wse" then Alt+W becomes a shortcut which will

   368     move the focus to this tab.

   369 

   370     \note If you call addTab() after show(), the layout system will try

   371     to adjust to the changes in its widgets hierarchy and may cause

   372     flicker. To prevent this, you can set the QWidget::updatesEnabled

   373     property to false prior to changes; remember to set the property

   374     to true when the changes are done, making the widget receive paint

   375     events again.

   376 

   377     \sa insertTab()

   378 */

   379 int QTabWidget::addTab(QWidget *child, const QString &label)

   380 {

   381     return insertTab(-1, child, label);

   382 }

   383 

   384 

   385 /*!

   386     \fn int QTabWidget::addTab(QWidget *page, const QIcon &icon, const QString &label)

   387     \overload

   388 

   389     Adds a tab with the given \a page, \a icon, and \a label to the tab

   390     widget, and returns the index of the tab in the tab bar.

   391 

   392     This function is the same as addTab(), but with an additional \a

   393     icon.

   394 */

   395 int QTabWidget::addTab(QWidget *child, const QIcon& icon, const QString &label)

   396 {

   397     return insertTab(-1, child, icon, label);

   398 }

   399 

   400 

   401 /*!

   402     \fn int QTabWidget::insertTab(int index, QWidget *page, const QString &label)

   403 

   404     Inserts a tab with the given \a label and \a page into the tab

   405     widget at the specified \a index, and returns the index of the

   406     inserted tab in the tab bar.

   407 

   408     The label is displayed in the tab and may vary in appearance depending

   409     on the configuration of the tab widget.

   410 

   411     If the tab's \a label contains an ampersand, the letter following

   412     the ampersand is used as a shortcut for the tab, e.g. if the

   413     label is "Bro\&wse" then Alt+W becomes a shortcut which will

   414     move the focus to this tab.

   415 

   416     If \a index is out of range, the tab is simply appended.

   417     Otherwise it is inserted at the specified position.

   418 

   419     If the QTabWidget was empty before this function is called, the

   420     new page becomes the current page. Inserting a new tab at an index

   421     less than or equal to the current index will increment the current

   422     index, but keep the current page.

   423 

   424     \note If you call insertTab() after show(), the layout system will try

   425     to adjust to the changes in its widgets hierarchy and may cause

   426     flicker. To prevent this, you can set the QWidget::updatesEnabled

   427     property to false prior to changes; remember to set the property

   428     to true when the changes are done, making the widget receive paint

   429     events again.

   430 

   431     \sa addTab()

   432 */

   433 int QTabWidget::insertTab(int index, QWidget *w, const QString &label)

   434 {

   435     return insertTab(index, w, QIcon(), label);

   436 }

   437 

   438 

   439 /*!

   440     \fn int QTabWidget::insertTab(int index, QWidget *page, const QIcon& icon, const QString &label)

   441     \overload

   442 

   443     Inserts a tab with the given \a label, \a page, and \a icon into

   444     the tab widget at the specified \a index, and returns the index of the

   445     inserted tab in the tab bar.

   446 

   447     This function is the same as insertTab(), but with an additional

   448     \a icon.

   449 */

   450 int QTabWidget::insertTab(int index, QWidget *w, const QIcon& icon, const QString &label)

   451 {

   452     Q_D(QTabWidget);

   453     if(!w)

   454         return -1;

   455     index = d->stack->insertWidget(index, w);

   456     d->tabs->insertTab(index, icon, label);

   457     setUpLayout();

   458     tabInserted(index);

   459 

   460     return index;

   461 }

   462 

   463 

   464 /*!

   465     Defines a new \a label for the page at position \a index's tab.

   466 

   467     If the provided text contains an ampersand character ('&'), a

   468     shortcut is automatically created for it. The character that

   469     follows the '&' will be used as the shortcut key. Any previous

   470     shortcut will be overwritten, or cleared if no shortcut is defined

   471     by the text. See the \l {QShortcut#mnemonic}{QShortcut}

   472     documentation for details (to display an actual ampersand, use

   473     '&&').

   474 

   475 */

   476 void QTabWidget::setTabText(int index, const QString &label)

   477 {

   478     Q_D(QTabWidget);

   479     d->tabs->setTabText(index, label);

   480     setUpLayout();

   481 }

   482 

   483 /*!

   484     Returns the label text for the tab on the page at position \a index.

   485 */

   486 

   487 QString QTabWidget::tabText(int index) const

   488 {

   489     Q_D(const QTabWidget);

   490     return d->tabs->tabText(index);

   491 }

   492 

   493 /*!

   494     \overload

   495 

   496     Sets the \a icon for the tab at position \a index.

   497 */

   498 void QTabWidget::setTabIcon(int index, const QIcon &icon)

   499 {

   500     Q_D(QTabWidget);

   501     d->tabs->setTabIcon(index, icon);

   502     setUpLayout();

   503 }

   504 

   505 /*!

   506     Returns the icon for the tab on the page at position \a index.

   507 */

   508 

   509 QIcon QTabWidget::tabIcon(int index) const

   510 {

   511     Q_D(const QTabWidget);

   512     return d->tabs->tabIcon(index);

   513 }

   514 

   515 /*!

   516     Returns true if the page at position \a index is enabled; otherwise returns false.

   517 

   518     \sa setTabEnabled(), QWidget::isEnabled()

   519 */

   520 

   521 bool QTabWidget::isTabEnabled(int index) const

   522 {

   523     Q_D(const QTabWidget);

   524     return d->tabs->isTabEnabled(index);

   525 }

   526 

   527 /*!

   528     If \a enable is true, the page at position \a index is enabled; otherwise the page at position \a index is

   529     disabled. The page's tab is redrawn appropriately.

   530 

   531     QTabWidget uses QWidget::setEnabled() internally, rather than

   532     keeping a separate flag.

   533 

   534     Note that even a disabled tab/page may be visible. If the page is

   535     visible already, QTabWidget will not hide it; if all the pages are

   536     disabled, QTabWidget will show one of them.

   537 

   538     \sa isTabEnabled(), QWidget::setEnabled()

   539 */

   540 

   541 void QTabWidget::setTabEnabled(int index, bool enable)

   542 {

   543     Q_D(QTabWidget);

   544     d->tabs->setTabEnabled(index, enable);

   545 }

   546 

   547 /*!

   548   \fn void QTabWidget::setCornerWidget(QWidget *widget, Qt::Corner corner)

   549 

   550   Sets the given \a widget to be shown in the specified \a corner of the

   551   tab widget. The geometry of the widget is determined based on the widget's

   552   sizeHint() and the style().

   553 

   554   Only the horizontal element of the \a corner will be used.

   555 

   556   Passing 0 shows no widget in the corner.

   557 

   558   Any previously set corner widget is hidden.

   559 

   560   All widgets set here will be deleted by the tab widget when it is

   561   destroyed unless you separately reparent the widget after setting

   562   some other corner widget (or 0).

   563 

   564   Note: Corner widgets are designed for \l North and \l South tab positions;

   565   other orientations are known to not work properly.

   566 

   567   \sa cornerWidget(), setTabPosition()

   568 */

   569 void QTabWidget::setCornerWidget(QWidget * widget, Qt::Corner corner)

   570 {

   571     Q_D(QTabWidget);

   572     if (widget && widget->parentWidget() != this)

   573         widget->setParent(this);

   574 

   575     if (corner & Qt::TopRightCorner) {

   576         if (d->rightCornerWidget)

   577             d->rightCornerWidget->hide();

   578         d->rightCornerWidget = widget;

   579     } else {

   580         if (d->leftCornerWidget)

   581             d->leftCornerWidget->hide();

   582         d->leftCornerWidget = widget;

   583     }

   584     setUpLayout();

   585 }

   586 

   587 /*!

   588     Returns the widget shown in the \a corner of the tab widget or 0.

   589 */

   590 QWidget * QTabWidget::cornerWidget(Qt::Corner corner) const

   591 {

   592     Q_D(const QTabWidget);

   593     if (corner & Qt::TopRightCorner)

   594         return d->rightCornerWidget;

   595     return d->leftCornerWidget;

   596 }

   597 

   598 /*!

   599    Removes the tab at position \a index from this stack of widgets.

   600    The page widget itself is not deleted.

   601 

   602    \sa addTab(), insertTab()

   603 */

   604 void QTabWidget::removeTab(int index)

   605 {

   606     Q_D(QTabWidget);

   607     if (QWidget *w = d->stack->widget(index))

   608         d->stack->removeWidget(w);

   609 }

   610 

   611 /*!

   612     Returns a pointer to the page currently being displayed by the tab

   613     dialog. The tab dialog does its best to make sure that this value

   614     is never 0 (but if you try hard enough, it can be).

   615 

   616     \sa currentIndex(), setCurrentWidget()

   617 */

   618 

   619 QWidget * QTabWidget::currentWidget() const

   620 {

   621     Q_D(const QTabWidget);

   622     return d->stack->currentWidget();

   623 }

   624 

   625 /*!

   626     Makes \a widget the current widget. The \a widget used must be a page in

   627     this tab widget.

   628 

   629     \sa addTab(), setCurrentIndex(), currentWidget()

   630  */

   631 void QTabWidget::setCurrentWidget(QWidget *widget)

   632 {

   633     Q_D(const QTabWidget);

   634     d->tabs->setCurrentIndex(indexOf(widget));

   635 }

   636 

   637 

   638 /*!

   639     \property QTabWidget::currentIndex

   640     \brief the index position of the current tab page

   641 

   642     The current index is -1 if there is no current widget.

   643 

   644     By default, this property contains a value of -1 because there are initially

   645     no tabs in the widget.

   646 */

   647 

   648 int QTabWidget::currentIndex() const

   649 {

   650     Q_D(const QTabWidget);

   651     return d->tabs->currentIndex();

   652 }

   653 

   654 void QTabWidget::setCurrentIndex(int index)

   655 {

   656     Q_D(QTabWidget);

   657     d->tabs->setCurrentIndex(index);

   658 }

   659 

   660 

   661 /*!

   662     Returns the index position of the page occupied by the widget \a

   663     w, or -1 if the widget cannot be found.

   664 */

   665 int QTabWidget::indexOf(QWidget* w) const

   666 {

   667     Q_D(const QTabWidget);

   668     return d->stack->indexOf(w);

   669 }

   670 

   671 

   672 /*!

   673     \reimp

   674 */

   675 void QTabWidget::resizeEvent(QResizeEvent *e)

   676 {

   677     QWidget::resizeEvent(e);

   678     setUpLayout();

   679 }

   680 

   681 /*!

   682     Replaces the dialog's QTabBar heading with the tab bar \a tb. Note

   683     that this must be called \e before any tabs have been added, or

   684     the behavior is undefined.

   685 

   686     \sa tabBar()

   687 */

   688 void QTabWidget::setTabBar(QTabBar* tb)

   689 {

   690     Q_D(QTabWidget);

   691     Q_ASSERT(tb);

   692 

   693     if (tb->parentWidget() != this) {

   694         tb->setParent(this);

   695         tb->show();

   696     }

   697     delete d->tabs;

   698     d->tabs = tb;

   699     setFocusProxy(d->tabs);

   700     connect(d->tabs, SIGNAL(currentChanged(int)),

   701             this, SLOT(_q_showTab(int)));

   702     connect(d->tabs, SIGNAL(tabMoved(int,int)),

   703             this, SLOT(_q_tabMoved(int,int)));

   704     if (d->tabs->tabsClosable())

   705         connect(d->tabs, SIGNAL(tabCloseRequested(int)),

   706                 this, SIGNAL(tabCloseRequested(int)));

   707     tb->setExpanding(!documentMode());

   708     setUpLayout();

   709 }

   710 

   711 

   712 /*!

   713     Returns the current QTabBar.

   714 

   715     \sa setTabBar()

   716 */

   717 QTabBar* QTabWidget::tabBar() const

   718 {

   719     Q_D(const QTabWidget);

   720     return d->tabs;

   721 }

   722 

   723 /*!

   724     Ensures that the selected tab's page is visible and appropriately

   725     sized.

   726 */

   727 

   728 void QTabWidgetPrivate::_q_showTab(int index)

   729 {

   730     Q_Q(QTabWidget);

   731     if (index < stack->count() && index >= 0)

   732         stack->setCurrentIndex(index);

   733     emit q->currentChanged(index);

   734 #ifdef QT3_SUPPORT

   735     emit q->selected(q->tabText(index));

   736     emit q->currentChanged(stack->widget(index));

   737 #endif

   738 }

   739 

   740 void QTabWidgetPrivate::_q_removeTab(int index)

   741 {

   742     Q_Q(QTabWidget);

   743     tabs->removeTab(index);

   744     q->setUpLayout();

   745     q->tabRemoved(index);

   746 }

   747 

   748 void QTabWidgetPrivate::_q_tabMoved(int from, int to)

   749 {

   750     stack->blockSignals(true);

   751     QWidget *w = stack->widget(from);

   752     stack->removeWidget(w);

   753     stack->insertWidget(to, w);

   754     stack->blockSignals(false);

   755 }

   756 

   757 /*

   758     Set up the layout.

   759     Get subrect from the current style, and set the geometry for the

   760     stack widget, tab bar and corner widgets.

   761 */

   762 void QTabWidget::setUpLayout(bool onlyCheck)

   763 {

   764     Q_D(QTabWidget);

   765     if (onlyCheck && !d->dirty)

   766         return; // nothing to do

   767 

   768     QStyleOptionTabWidgetFrameV2 option;

   769     initStyleOption(&option);

   770 

   771     // this must be done immediately, because QWidgetItem relies on it (even if !isVisible())

   772     d->setLayoutItemMargins(QStyle::SE_TabWidgetLayoutItem, &option);

   773 

   774     if (!isVisible()) {

   775         d->dirty = true;

   776         return; // we'll do it later

   777     }

   778 

   779     QRect tabRect = style()->subElementRect(QStyle::SE_TabWidgetTabBar, &option, this);

   780     d->panelRect = style()->subElementRect(QStyle::SE_TabWidgetTabPane, &option, this);

   781     QRect contentsRect = style()->subElementRect(QStyle::SE_TabWidgetTabContents, &option, this);

   782     QRect leftCornerRect = style()->subElementRect(QStyle::SE_TabWidgetLeftCorner, &option, this);

   783     QRect rightCornerRect = style()->subElementRect(QStyle::SE_TabWidgetRightCorner, &option, this);

   784 

   785     d->tabs->setGeometry(tabRect);

   786     d->stack->setGeometry(contentsRect);

   787     if (d->leftCornerWidget)

   788         d->leftCornerWidget->setGeometry(leftCornerRect);

   789     if (d->rightCornerWidget)

   790         d->rightCornerWidget->setGeometry(rightCornerRect);

   791 

   792     if (!onlyCheck)

   793         update();

   794     updateGeometry();

   795 }

   796 

   797 /*!

   798     \internal

   799 */

   800 static inline QSize basicSize(

   801     bool horizontal, const QSize &lc, const QSize &rc, const QSize &s, const QSize &t)

   802 {

   803     return horizontal

   804         ? QSize(qMax(s.width(), t.width() + rc.width() + lc.width()),

   805                 s.height() + (qMax(rc.height(), qMax(lc.height(), t.height()))))

   806         : QSize(s.width() + (qMax(rc.width(), qMax(lc.width(), t.width()))),

   807                 qMax(s.height(), t.height() + rc.height() + lc.height()));

   808 }

   809 

   810 /*!

   811     \reimp

   812 */

   813 QSize QTabWidget::sizeHint() const

   814 {

   815     Q_D(const QTabWidget);

   816     QSize lc(0, 0), rc(0, 0);

   817     QStyleOption opt(0);

   818     opt.init(this);

   819     opt.state = QStyle::State_None;

   820 

   821     if (d->leftCornerWidget)

   822         lc = d->leftCornerWidget->sizeHint();

   823     if(d->rightCornerWidget)

   824         rc = d->rightCornerWidget->sizeHint();

   825     if (!d->dirty) {

   826         QTabWidget *that = (QTabWidget*)this;

   827         that->setUpLayout(true);

   828     }

   829     QSize s(d->stack->sizeHint());

   830     QSize t(d->tabs->sizeHint());

   831     if(usesScrollButtons())

   832         t = t.boundedTo(QSize(200,200));

   833     else

   834         t = t.boundedTo(QApplication::desktop()->size());

   835 

   836     QSize sz = basicSize(d->pos == North || d->pos == South, lc, rc, s, t);

   837 

   838     return style()->sizeFromContents(QStyle::CT_TabWidget, &opt, sz, this)

   839                     .expandedTo(QApplication::globalStrut());

   840 }

   841 

   842 

   843 /*!

   844     \reimp

   845 

   846     Returns a suitable minimum size for the tab widget.

   847 */

   848 QSize QTabWidget::minimumSizeHint() const

   849 {

   850     Q_D(const QTabWidget);

   851     QSize lc(0, 0), rc(0, 0);

   852 

   853     if(d->leftCornerWidget)

   854         lc = d->leftCornerWidget->minimumSizeHint();

   855     if(d->rightCornerWidget)

   856         rc = d->rightCornerWidget->minimumSizeHint();

   857     if (!d->dirty) {

   858         QTabWidget *that = (QTabWidget*)this;

   859         that->setUpLayout(true);

   860     }

   861     QSize s(d->stack->minimumSizeHint());

   862     QSize t(d->tabs->minimumSizeHint());

   863 

   864     QSize sz = basicSize(d->pos == North || d->pos == South, lc, rc, s, t);

   865 

   866     QStyleOption opt(0);

   867     opt.rect = rect();

   868     opt.palette = palette();

   869     opt.state = QStyle::State_None;

   870     return style()->sizeFromContents(QStyle::CT_TabWidget, &opt, sz, this)

   871                     .expandedTo(QApplication::globalStrut());

   872 }

   873 

   874 /*!

   875     \reimp

   876  */

   877 void QTabWidget::showEvent(QShowEvent *)

   878 {

   879     setUpLayout();

   880 }

   881 

   882 void QTabWidgetPrivate::updateTabBarPosition()

   883 {

   884     Q_Q(QTabWidget);

   885     switch (pos) {

   886     case QTabWidget::North:

   887         tabs->setShape(shape == QTabWidget::Rounded ? QTabBar::RoundedNorth

   888                                                     : QTabBar::TriangularNorth);

   889         break;

   890     case QTabWidget::South:

   891         tabs->setShape(shape == QTabWidget::Rounded ? QTabBar::RoundedSouth

   892                                                     : QTabBar::TriangularSouth);

   893         break;

   894     case QTabWidget::West:

   895         tabs->setShape(shape == QTabWidget::Rounded ? QTabBar::RoundedWest

   896                                                     : QTabBar::TriangularWest);

   897         break;

   898     case QTabWidget::East:

   899         tabs->setShape(shape == QTabWidget::Rounded ? QTabBar::RoundedEast

   900                                                     : QTabBar::TriangularEast);

   901         break;

   902     }

   903     q->setUpLayout();

   904 }

   905 

   906 /*!

   907     \property QTabWidget::tabPosition

   908     \brief the position of the tabs in this tab widget

   909 

   910     Possible values for this property are described by the TabPosition

   911     enum.

   912 

   913     By default, this property is set to \l North.

   914 

   915     \sa TabPosition

   916 */

   917 QTabWidget::TabPosition QTabWidget::tabPosition() const

   918 {

   919     Q_D(const QTabWidget);

   920     return d->pos;

   921 }

   922 

   923 void QTabWidget::setTabPosition(TabPosition pos)

   924 {

   925     Q_D(QTabWidget);

   926     if (d->pos == pos)

   927         return;

   928     d->pos = pos;

   929     d->updateTabBarPosition();

   930 }

   931 

   932 /*!

   933     \property QTabWidget::tabsClosable

   934     \brief whether close buttons are automatically added to each tab.

   935 

   936     \since 4.5

   937 

   938     \sa QTabBar::tabsClosable()

   939 */

   940 bool QTabWidget::tabsClosable() const

   941 {

   942     return tabBar()->tabsClosable();

   943 }

   944 

   945 void QTabWidget::setTabsClosable(bool closeable)

   946 {

   947     if (tabsClosable() == closeable)

   948         return;

   949 

   950     tabBar()->setTabsClosable(closeable);

   951     if (closeable)

   952         connect(tabBar(), SIGNAL(tabCloseRequested(int)),

   953                 this, SIGNAL(tabCloseRequested(int)));

   954     else

   955         disconnect(tabBar(), SIGNAL(tabCloseRequested(int)),

   956                   this, SIGNAL(tabCloseRequested(int)));

   957     setUpLayout();

   958 }

   959 

   960 /*!

   961     \property QTabWidget::movable

   962     \brief This property holds whether the user can move the tabs

   963     within the tabbar area.

   964 

   965     \since 4.5

   966 

   967     By default, this property is false;

   968 */

   969 

   970 bool QTabWidget::isMovable() const

   971 {

   972     return tabBar()->isMovable();

   973 }

   974 

   975 void QTabWidget::setMovable(bool movable)

   976 {

   977     tabBar()->setMovable(movable);

   978 }

   979 

   980 /*!

   981     \property QTabWidget::tabShape

   982     \brief the shape of the tabs in this tab widget

   983 

   984     Possible values for this property are QTabWidget::Rounded

   985     (default) or QTabWidget::Triangular.

   986 

   987     \sa TabShape

   988 */

   989 

   990 QTabWidget::TabShape QTabWidget::tabShape() const

   991 {

   992     Q_D(const QTabWidget);

   993     return d->shape;

   994 }

   995 

   996 void QTabWidget::setTabShape(TabShape s)

   997 {

   998     Q_D(QTabWidget);

   999     if (d->shape == s)

  1000         return;

  1001     d->shape = s;

  1002     d->updateTabBarPosition();

  1003 }

  1004 

  1005 /*!

  1006     \reimp

  1007  */

  1008 bool QTabWidget::event(QEvent *ev)

  1009 {

  1010     if (ev->type() == QEvent::LayoutRequest)

  1011         setUpLayout();

  1012     return QWidget::event(ev);

  1013 }

  1014 

  1015 /*!

  1016     \reimp

  1017  */

  1018 void QTabWidget::changeEvent(QEvent *ev)

  1019 {

  1020     if (ev->type() == QEvent::StyleChange

  1021 #ifdef Q_WS_MAC

  1022             || ev->type() == QEvent::MacSizeChange

  1023 #endif

  1024             )

  1025         setUpLayout();

  1026     QWidget::changeEvent(ev);

  1027 }

  1028 

  1029 

  1030 /*!

  1031     \reimp

  1032  */

  1033 void QTabWidget::keyPressEvent(QKeyEvent *e)

  1034 {

  1035     Q_D(QTabWidget);

  1036     if (((e->key() == Qt::Key_Tab || e->key() == Qt::Key_Backtab) &&

  1037           count() > 1 && e->modifiers() & Qt::ControlModifier)

  1038 #ifdef QT_KEYPAD_NAVIGATION

  1039           || QApplication::keypadNavigationEnabled() && (e->key() == Qt::Key_Left || e->key() == Qt::Key_Right) && count() > 1

  1040 #endif

  1041        ) {

  1042         int pageCount = d->tabs->count();

  1043         int page = currentIndex();

  1044         int dx = (e->key() == Qt::Key_Backtab || e->modifiers() & Qt::ShiftModifier) ? -1 : 1;

  1045 #ifdef QT_KEYPAD_NAVIGATION

  1046         if (QApplication::keypadNavigationEnabled() && (e->key() == Qt::Key_Left || e->key() == Qt::Key_Right))

  1047             dx = e->key() == (isRightToLeft() ? Qt::Key_Right : Qt::Key_Left) ? -1 : 1;

  1048 #endif

  1049         for (int pass = 0; pass < pageCount; ++pass) {

  1050             page+=dx;

  1051             if (page < 0

  1052 #ifdef QT_KEYPAD_NAVIGATION

  1053                 && !e->isAutoRepeat()

  1054 #endif

  1055                ) {

  1056                 page = count() - 1;

  1057             } else if (page >= pageCount

  1058 #ifdef QT_KEYPAD_NAVIGATION

  1059                        && !e->isAutoRepeat()

  1060 #endif

  1061                       ) {

  1062                 page = 0;

  1063             }

  1064             if (d->tabs->isTabEnabled(page)) {

  1065                 setCurrentIndex(page);

  1066                 break;

  1067             }

  1068         }

  1069         if (!QApplication::focusWidget())

  1070             d->tabs->setFocus();

  1071     } else {

  1072         e->ignore();

  1073     }

  1074 }

  1075 

  1076 /*!

  1077     Returns the tab page at index position \a index or 0 if the \a

  1078     index is out of range.

  1079 */

  1080 QWidget *QTabWidget::widget(int index) const

  1081 {

  1082     Q_D(const QTabWidget);

  1083     return d->stack->widget(index);

  1084 }

  1085 

  1086 /*!

  1087     \property QTabWidget::count

  1088     \brief the number of tabs in the tab bar

  1089 

  1090     By default, this property contains a value of 0.

  1091 */

  1092 int QTabWidget::count() const

  1093 {

  1094     Q_D(const QTabWidget);

  1095     return d->tabs->count();

  1096 }

  1097 

  1098 #ifndef QT_NO_TOOLTIP

  1099 /*!

  1100     Sets the tab tool tip for the page at position \a index to \a tip.

  1101 

  1102     \sa  tabToolTip()

  1103 */

  1104 void QTabWidget::setTabToolTip(int index, const QString & tip)

  1105 {

  1106     Q_D(QTabWidget);

  1107     d->tabs->setTabToolTip(index, tip);

  1108 }

  1109 

  1110 /*!

  1111     Returns the tab tool tip for the page at position \a index or

  1112     an empty string if no tool tip has been set.

  1113 

  1114     \sa setTabToolTip()

  1115 */

  1116 QString QTabWidget::tabToolTip(int index) const

  1117 {

  1118     Q_D(const QTabWidget);

  1119     return d->tabs->tabToolTip(index);

  1120 }

  1121 #endif // QT_NO_TOOLTIP

  1122 

  1123 #ifndef QT_NO_WHATSTHIS

  1124 /*!

  1125     \since 4.1

  1126 

  1127     Sets the What's This help text for the page at position \a index

  1128     to \a text.

  1129 */

  1130 void QTabWidget::setTabWhatsThis(int index, const QString &text)

  1131 {

  1132     Q_D(QTabWidget);

  1133     d->tabs->setTabWhatsThis(index, text);

  1134 }

  1135