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

     2 **

     3 ** Copyright (C) 2009 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 "private/qlayoutengine_p.h"

    43 #include "qabstractitemdelegate.h"

    44 #include "qapplication.h"

    45 #include "qbitmap.h"

    46 #include "qcursor.h"

    47 #include "qevent.h"

    48 #include "qpainter.h"

    49 #include "qstyle.h"

    50 #include "qstyleoption.h"

    51 #include "qstylepainter.h"

    52 #include "qtabwidget.h"

    53 #include "qtooltip.h"

    54 #include "qwhatsthis.h"

    55 #include "private/qtextengine_p.h"

    56 #ifndef QT_NO_ACCESSIBILITY

    57 #include "qaccessible.h"

    58 #endif

    59 

    60 #include "qdebug.h"

    61 #include "private/qtabbar_p.h"

    62 

    63 #ifndef QT_NO_TABBAR

    64 

    65 #ifdef Q_WS_MAC

    66 #include <private/qt_mac_p.h>

    67 #include <private/qt_cocoa_helpers_mac_p.h>

    68 #endif

    69 

    70 QT_BEGIN_NAMESPACE

    71 

    72 inline static bool verticalTabs(QTabBar::Shape shape)

    73 {

    74     return shape == QTabBar::RoundedWest

    75            || shape == QTabBar::RoundedEast

    76            || shape == QTabBar::TriangularWest

    77            || shape == QTabBar::TriangularEast;

    78 }

    79 

    80 void QTabBarPrivate::updateMacBorderMetrics()

    81 {

    82 #if (defined Q_WS_MAC) && (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)

    83     if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {

    84         Q_Q(QTabBar);

    85         ::HIContentBorderMetrics metrics;

    86 

    87         // TODO: get metrics to preserve the bottom value

    88         // TODO: test tab bar position

    89 

    90         OSWindowRef window = qt_mac_window_for(q);

    91 

    92         // push base line separator down to the client are so we can paint over it (Carbon)

    93         metrics.top = (documentMode && q->isVisible()) ? 1 : 0;

    94         metrics.bottom = 0;

    95         metrics.left = 0;

    96         metrics.right = 0;

    97         qt_mac_updateContentBorderMetricts(window, metrics);

    98         

    99         // hide the base line separator if the tabs have docuemnt mode enabled (Cocoa)

   100         qt_mac_showBaseLineSeparator(window, !documentMode);

   101     }

   102 #endif

   103 }

   104 

   105 /*!

   106     Initialize \a option with the values from the tab at \a tabIndex. This method

   107     is useful for subclasses when they need a QStyleOptionTab, QStyleOptionTabV2,

   108     or QStyleOptionTabV3 but don't want to fill in all the information themselves.

   109     This function will check the version of the QStyleOptionTab and fill in the

   110     additional values for a QStyleOptionTabV2 and QStyleOptionTabV3.

   111 

   112     \sa QStyleOption::initFrom() QTabWidget::initStyleOption()

   113 */

   114 void QTabBar::initStyleOption(QStyleOptionTab *option, int tabIndex) const

   115 {

   116     Q_D(const QTabBar);

   117     int totalTabs = d->tabList.size();

   118 

   119     if (!option || (tabIndex < 0 || tabIndex >= totalTabs))

   120         return;

   121 

   122     const QTabBarPrivate::Tab &tab = d->tabList.at(tabIndex);

   123     option->initFrom(this);

   124     option->state &= ~(QStyle::State_HasFocus | QStyle::State_MouseOver);

   125     option->rect = tabRect(tabIndex);

   126     bool isCurrent = tabIndex == d->currentIndex;

   127     option->row = 0;

   128     if (tabIndex == d->pressedIndex)

   129         option->state |= QStyle::State_Sunken;

   130     if (isCurrent)

   131         option->state |= QStyle::State_Selected;

   132     if (isCurrent && hasFocus())

   133         option->state |= QStyle::State_HasFocus;

   134     if (!tab.enabled)

   135         option->state &= ~QStyle::State_Enabled;

   136     if (isActiveWindow())

   137         option->state |= QStyle::State_Active;

   138     if (!d->dragInProgress && option->rect == d->hoverRect)

   139         option->state |= QStyle::State_MouseOver;

   140     option->shape = d->shape;

   141     option->text = tab.text;

   142 

   143     if (tab.textColor.isValid())

   144         option->palette.setColor(foregroundRole(), tab.textColor);

   145 

   146     option->icon = tab.icon;

   147     if (QStyleOptionTabV2 *optionV2 = qstyleoption_cast<QStyleOptionTabV2 *>(option))

   148         optionV2->iconSize = iconSize();  // Will get the default value then.

   149 

   150     if (QStyleOptionTabV3 *optionV3 = qstyleoption_cast<QStyleOptionTabV3 *>(option)) {

   151         optionV3->leftButtonSize = tab.leftWidget ? tab.leftWidget->size() : QSize();

   152         optionV3->rightButtonSize = tab.rightWidget ? tab.rightWidget->size() : QSize();

   153         optionV3->documentMode = d->documentMode;

   154     }

   155 

   156     if (tabIndex > 0 && tabIndex - 1 == d->currentIndex)

   157         option->selectedPosition = QStyleOptionTab::PreviousIsSelected;

   158     else if (tabIndex < totalTabs - 1 && tabIndex + 1 == d->currentIndex)

   159         option->selectedPosition = QStyleOptionTab::NextIsSelected;

   160     else

   161         option->selectedPosition = QStyleOptionTab::NotAdjacent;

   162 

   163     bool paintBeginning = (tabIndex == 0) || (d->dragInProgress && tabIndex == d->pressedIndex + 1);

   164     bool paintEnd = (tabIndex == totalTabs - 1) || (d->dragInProgress && tabIndex == d->pressedIndex - 1);

   165     if (paintBeginning) {

   166         if (paintEnd)

   167             option->position = QStyleOptionTab::OnlyOneTab;

   168         else

   169             option->position = QStyleOptionTab::Beginning;

   170     } else if (paintEnd) {

   171         option->position = QStyleOptionTab::End;

   172     } else {

   173         option->position = QStyleOptionTab::Middle;

   174     }

   175 

   176 #ifndef QT_NO_TABWIDGET

   177     if (const QTabWidget *tw = qobject_cast<const QTabWidget *>(parentWidget())) {

   178         if (tw->cornerWidget(Qt::TopLeftCorner) || tw->cornerWidget(Qt::BottomLeftCorner))

   179             option->cornerWidgets |= QStyleOptionTab::LeftCornerWidget;

   180         if (tw->cornerWidget(Qt::TopRightCorner) || tw->cornerWidget(Qt::BottomRightCorner))

   181             option->cornerWidgets |= QStyleOptionTab::RightCornerWidget;

   182     }

   183 #endif

   184 

   185     QRect textRect = style()->subElementRect(QStyle::SE_TabBarTabText, option, this);

   186     option->text = fontMetrics().elidedText(option->text, d->elideMode, textRect.width(),

   187                         Qt::TextShowMnemonic);

   188 }

   189 

   190 /*!

   191     \class QTabBar

   192     \brief The QTabBar class provides a tab bar, e.g. for use in tabbed dialogs.

   193 

   194     \ingroup basicwidgets

   195 

   196 

   197     QTabBar is straightforward to use; it draws the tabs using one of

   198     the predefined \link QTabBar::Shape shapes\endlink, and emits a

   199     signal when a tab is selected. It can be subclassed to tailor the

   200     look and feel. Qt also provides a ready-made \l{QTabWidget}.

   201 

   202     Each tab has a tabText(), an optional tabIcon(), an optional

   203     tabToolTip(), optional tabWhatsThis() and optional tabData().

   204     The tabs's attributes can be changed with setTabText(), setTabIcon(),

   205     setTabToolTip(), setTabWhatsThis and setTabData(). Each tabs can be

   206     enabled or disabled individually with setTabEnabled().

   207 

   208     Each tab can display text in a distinct color. The current text color

   209     for a tab can be found with the tabTextColor() function. Set the text

   210     color for a particular tab with setTabTextColor().

   211 

   212     Tabs are added using addTab(), or inserted at particular positions

   213     using insertTab(). The total number of tabs is given by

   214     count(). Tabs can be removed from the tab bar with

   215     removeTab(). Combining removeTab() and insertTab() allows you to

   216     move tabs to different positions.

   217 

   218     The \l shape property defines the tabs' appearance. The choice of

   219     shape is a matter of taste, although tab dialogs (for preferences

   220     and similar) invariably use \l RoundedNorth.

   221     Tab controls in windows other than dialogs almost

   222     always use either \l RoundedSouth or \l TriangularSouth. Many

   223     spreadsheets and other tab controls in which all the pages are

   224     essentially similar use \l TriangularSouth, whereas \l

   225     RoundedSouth is used mostly when the pages are different (e.g. a

   226     multi-page tool palette). The default in QTabBar is \l

   227     RoundedNorth.

   228 

   229     The most important part of QTabBar's API is the currentChanged()

   230     signal.  This is emitted whenever the current tab changes (even at

   231     startup, when the current tab changes from 'none'). There is also

   232     a slot, setCurrentIndex(), which can be used to select a tab

   233     programmatically. The function currentIndex() returns the index of

   234     the current tab, \l count holds the number of tabs.

   235 

   236     QTabBar creates automatic mnemonic keys in the manner of QAbstractButton;

   237     e.g. if a tab's label is "\&Graphics", Alt+G becomes a shortcut

   238     key for switching to that tab.

   239 

   240     The following virtual functions may need to be reimplemented in

   241     order to tailor the look and feel or store extra data with each

   242     tab:

   243 

   244     \list

   245     \i tabSizeHint() calcuates the size of a tab.

   246     \i tabInserted() notifies that a new tab was added.

   247     \i tabRemoved() notifies that a tab was removed.

   248     \i tabLayoutChange() notifies that the tabs have been re-laid out.

   249     \i paintEvent() paints all tabs.

   250     \endlist

   251 

   252     For subclasses, you might also need the tabRect() functions which

   253     returns the visual geometry of a single tab.

   254 

   255     \table 100%

   256     \row \o \inlineimage plastique-tabbar.png Screenshot of a Plastique style tab bar

   257          \o A tab bar shown in the Plastique widget style.

   258     \row \o \inlineimage plastique-tabbar-truncated.png Screenshot of a truncated Plastique tab bar

   259          \o A truncated tab bar shown in the Plastique widget style.

   260     \endtable

   261 

   262     \sa QTabWidget

   263 */

   264 

   265 /*!

   266     \enum QTabBar::Shape

   267 

   268     This enum type lists the built-in shapes supported by QTabBar. Treat these

   269     as hints as some styles may not render some of the shapes. However,

   270     position should be honored.

   271 

   272     \value RoundedNorth  The normal rounded look above the pages

   273 

   274     \value RoundedSouth  The normal rounded look below the pages

   275 

   276     \value RoundedWest  The normal rounded look on the left side of the pages

   277 

   278     \value RoundedEast  The normal rounded look on the right side the pages

   279 

   280     \value TriangularNorth  Triangular tabs above the pages.

   281 

   282     \value TriangularSouth  Triangular tabs similar to those used in

   283     the Excel spreadsheet, for example

   284 

   285     \value TriangularWest  Triangular tabs on the left of the pages.

   286 

   287     \value TriangularEast  Triangular tabs on the right of the pages.

   288     \omitvalue RoundedAbove

   289     \omitvalue RoundedBelow

   290     \omitvalue TriangularAbove

   291     \omitvalue TriangularBelow

   292 */

   293 

   294 /*!

   295     \fn void QTabBar::currentChanged(int index)

   296 

   297     This signal is emitted when the tab bar's current tab changes. The

   298     new current has the given \a index, or -1 if there isn't a new one

   299     (for example, if there are no tab in the QTabBar)

   300 */

   301 

   302 /*!

   303     \fn void QTabBar::tabCloseRequested(int index)

   304     \since 4.5

   305 

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

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

   308 

   309     \sa setTabsClosable()

   310 */

   311 

   312 /*!

   313     \fn void QTabBar::tabMoved(int from, int to)

   314     \since 4.5

   315 

   316     This signal is emitted when the tab has moved the tab

   317     at index position \a from to index position \a to.

   318 

   319     note: QTabWidget will automatically move the page when

   320     this signal is emitted from its tab bar.

   321 

   322     \sa moveTab()

   323 */

   324 

   325 int QTabBarPrivate::extraWidth() const

   326 {

   327     Q_Q(const QTabBar);

   328     return 2 * qMax(q->style()->pixelMetric(QStyle::PM_TabBarScrollButtonWidth, 0, q),

   329                     QApplication::globalStrut().width());

   330 }

   331 

   332 void QTabBarPrivate::init()

   333 {

   334     Q_Q(QTabBar);

   335     leftB = new QToolButton(q);

   336     leftB->setAutoRepeat(true);

   337     QObject::connect(leftB, SIGNAL(clicked()), q, SLOT(_q_scrollTabs()));

   338     leftB->hide();

   339     rightB = new QToolButton(q);

   340     rightB->setAutoRepeat(true);

   341     QObject::connect(rightB, SIGNAL(clicked()), q, SLOT(_q_scrollTabs()));

   342     rightB->hide();

   343 #ifdef QT_KEYPAD_NAVIGATION

   344     if (QApplication::keypadNavigationEnabled()) {

   345         leftB->setFocusPolicy(Qt::NoFocus);

   346         rightB->setFocusPolicy(Qt::NoFocus);

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

   348     } else

   349 #endif

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

   351     q->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);

   352     elideMode = Qt::TextElideMode(q->style()->styleHint(QStyle::SH_TabBar_ElideMode, 0, q));

   353     useScrollButtons = !q->style()->styleHint(QStyle::SH_TabBar_PreferNoArrows, 0, q);

   354 }

   355 

   356 QTabBarPrivate::Tab *QTabBarPrivate::at(int index)

   357 {

   358     return validIndex(index)?&tabList[index]:0;

   359 }

   360 

   361 const QTabBarPrivate::Tab *QTabBarPrivate::at(int index) const

   362 {

   363     return validIndex(index)?&tabList[index]:0;

   364 }

   365 

   366 int QTabBarPrivate::indexAtPos(const QPoint &p) const

   367 {

   368     Q_Q(const QTabBar);

   369     if (q->tabRect(currentIndex).contains(p))

   370         return currentIndex;

   371     for (int i = 0; i < tabList.count(); ++i)

   372         if (tabList.at(i).enabled && q->tabRect(i).contains(p))

   373             return i;

   374     return -1;

   375 }

   376 

   377 void QTabBarPrivate::layoutTabs()

   378 {

   379     Q_Q(QTabBar);

   380     scrollOffset = 0;

   381     layoutDirty = false;

   382     QSize size = q->size();

   383     int last, available;

   384     int maxExtent;

   385     int i;

   386     bool vertTabs = verticalTabs(shape);

   387     int tabChainIndex = 0;

   388 

   389     Qt::Alignment tabAlignment = Qt::Alignment(q->style()->styleHint(QStyle::SH_TabBar_Alignment, 0, q));

   390     QVector<QLayoutStruct> tabChain(tabList.count() + 2);

   391 

   392     // We put an empty item at the front and back and set its expansive attribute

   393     // depending on tabAlignment.

   394     tabChain[tabChainIndex].init();

   395     tabChain[tabChainIndex].expansive = (tabAlignment != Qt::AlignLeft)

   396                                         && (tabAlignment != Qt::AlignJustify);

   397     tabChain[tabChainIndex].empty = true;

   398     ++tabChainIndex;

   399 

   400     // We now go through our list of tabs and set the minimum size and the size hint

   401     // This will allow us to elide text if necessary. Since we don't set

   402     // a maximum size, tabs will EXPAND to fill up the empty space.

   403     // Since tab widget is rather *ahem* strict about keeping the geometry of the

   404     // tab bar to its absolute minimum, this won't bleed through, but will show up

   405     // if you use tab bar on its own (a.k.a. not a bug, but a feature).

   406     // Update: if expanding is false, we DO set a maximum size to prevent the tabs

   407     // being wider than necessary.

   408     if (!vertTabs) {

   409         int minx = 0;

   410         int x = 0;

   411         int maxHeight = 0;

   412         for (i = 0; i < tabList.count(); ++i, ++tabChainIndex) {

   413             QSize sz = q->tabSizeHint(i);

   414             tabList[i].maxRect = QRect(x, 0, sz.width(), sz.height());

   415             x += sz.width();

   416             maxHeight = qMax(maxHeight, sz.height());

   417             sz = minimumTabSizeHint(i);

   418             tabList[i].minRect = QRect(minx, 0, sz.width(), sz.height());

   419             minx += sz.width();

   420             tabChain[tabChainIndex].init();

   421             tabChain[tabChainIndex].sizeHint = tabList.at(i).maxRect.width();

   422             tabChain[tabChainIndex].minimumSize = sz.width();

   423             tabChain[tabChainIndex].empty = false;

   424             tabChain[tabChainIndex].expansive = true;

   425 

   426             if (!expanding)

   427                 tabChain[tabChainIndex].maximumSize = tabChain[tabChainIndex].sizeHint;

   428         }

   429 

   430         last = minx;

   431         available = size.width();

   432         maxExtent = maxHeight;

   433     } else {

   434         int miny = 0;

   435         int y = 0;

   436         int maxWidth = 0;

   437         for (i = 0; i < tabList.count(); ++i, ++tabChainIndex) {

   438             QSize sz = q->tabSizeHint(i);

   439             tabList[i].maxRect = QRect(0, y, sz.width(), sz.height());

   440             y += sz.height();

   441             maxWidth = qMax(maxWidth, sz.width());

   442             sz = minimumTabSizeHint(i);

   443             tabList[i].minRect = QRect(0, miny, sz.width(), sz.height());

   444             miny += sz.height();

   445             tabChain[tabChainIndex].init();

   446             tabChain[tabChainIndex].sizeHint = tabList.at(i).maxRect.height();

   447             tabChain[tabChainIndex].minimumSize = sz.height();

   448             tabChain[tabChainIndex].empty = false;

   449             tabChain[tabChainIndex].expansive = true;

   450 

   451             if (!expanding)

   452                 tabChain[tabChainIndex].maximumSize = tabChain[tabChainIndex].sizeHint;

   453         }

   454 

   455         last = miny;

   456         available = size.height();

   457         maxExtent = maxWidth;

   458     }

   459 

   460     Q_ASSERT(tabChainIndex == tabChain.count() - 1); // add an assert just to make sure.

   461     // Mirror our front item.

   462     tabChain[tabChainIndex].init();

   463     tabChain[tabChainIndex].expansive = (tabAlignment != Qt::AlignRight)

   464                                         && (tabAlignment != Qt::AlignJustify);

   465     tabChain[tabChainIndex].empty = true;

   466 

   467     // Do the calculation

   468     qGeomCalc(tabChain, 0, tabChain.count(), 0, qMax(available, last), 0);

   469 

   470     // Use the results

   471     for (i = 0; i < tabList.count(); ++i) {

   472         const QLayoutStruct &lstruct = tabChain.at(i + 1);

   473         if (!vertTabs)

   474             tabList[i].rect.setRect(lstruct.pos, 0, lstruct.size, maxExtent);

   475         else

   476             tabList[i].rect.setRect(0, lstruct.pos, maxExtent, lstruct.size);

   477     }

   478 

   479     if (useScrollButtons && tabList.count() && last > available) {

   480         int extra = extraWidth();

   481         if (!vertTabs) {

   482             Qt::LayoutDirection ld = q->layoutDirection();

   483             QRect arrows = QStyle::visualRect(ld, q->rect(),

   484                                               QRect(available - extra, 0, extra, size.height()));

   485             int buttonOverlap = q->style()->pixelMetric(QStyle::PM_TabBar_ScrollButtonOverlap, 0, q);

   486 

   487             if (ld == Qt::LeftToRight) {

   488                 leftB->setGeometry(arrows.left(), arrows.top(), extra/2, arrows.height());

   489                 rightB->setGeometry(arrows.right() - extra/2 + buttonOverlap, arrows.top(),

   490                                     extra/2, arrows.height());

   491                 leftB->setArrowType(Qt::LeftArrow);

   492                 rightB->setArrowType(Qt::RightArrow);

   493             } else {

   494                 rightB->setGeometry(arrows.left(), arrows.top(), extra/2, arrows.height());

   495                 leftB->setGeometry(arrows.right() - extra/2 + buttonOverlap, arrows.top(),

   496                                     extra/2, arrows.height());

   497                 rightB->setArrowType(Qt::LeftArrow);

   498                 leftB->setArrowType(Qt::RightArrow);

   499             }

   500         } else {

   501             QRect arrows = QRect(0, available - extra, size.width(), extra );

   502             leftB->setGeometry(arrows.left(), arrows.top(), arrows.width(), extra/2);

   503             leftB->setArrowType(Qt::UpArrow);

   504             rightB->setGeometry(arrows.left(), arrows.bottom() - extra/2 + 1,

   505                                 arrows.width(), extra/2);

   506             rightB->setArrowType(Qt::DownArrow);

   507         }

   508         leftB->setEnabled(scrollOffset > 0);

   509         rightB->setEnabled(last - scrollOffset >= available - extra);

   510         leftB->show();

   511         rightB->show();

   512     } else {

   513         rightB->hide();

   514         leftB->hide();

   515     }

   516 

   517     layoutWidgets();

   518     q->tabLayoutChange();

   519 }

   520 

   521 void QTabBarPrivate::makeVisible(int index)

   522 {

   523     Q_Q(QTabBar);

   524     if (!validIndex(index) || leftB->isHidden())

   525         return;

   526 

   527     const QRect tabRect = tabList.at(index).rect;

   528     const int oldScrollOffset = scrollOffset;

   529     const bool horiz = !verticalTabs(shape);

   530     const int available = (horiz ? q->width() : q->height()) - extraWidth();

   531     const int start = horiz ? tabRect.left() : tabRect.top();

   532     const int end = horiz ? tabRect.right() : tabRect.bottom();

   533     if (start < scrollOffset) // too far left

   534         scrollOffset = start - (index ? 8 : 0);

   535     else if (end > scrollOffset + available) // too far right

   536         scrollOffset = end - available + 1;

   537 

   538     leftB->setEnabled(scrollOffset > 0);

   539     const int last = horiz ? tabList.last().rect.right() : tabList.last().rect.bottom();

   540     rightB->setEnabled(last - scrollOffset >= available);

   541     if (oldScrollOffset != scrollOffset) {

   542         q->update();

   543         layoutWidgets();

   544     }

   545 }

   546 

   547 void QTabBarPrivate::layoutTab(int index)

   548 {

   549     Q_Q(QTabBar);

   550     Q_ASSERT(index >= 0);

   551 

   552     Tab &tab = tabList[index];

   553     bool vertical = verticalTabs(shape);

   554     if (!(tab.leftWidget || tab.rightWidget))

   555         return;

   556 

   557     QStyleOptionTabV3 opt;

   558     q->initStyleOption(&opt, index);

   559     if (tab.leftWidget) {

   560         QRect rect = q->style()->subElementRect(QStyle::SE_TabBarTabLeftButton, &opt, q);

   561         QPoint p = rect.topLeft();

   562         if ((index == pressedIndex) || paintWithOffsets) {

   563             if (vertical)

   564                 p.setY(p.y() + tabList[index].dragOffset);

   565             else

   566                 p.setX(p.x() + tabList[index].dragOffset);

   567         }

   568         tab.leftWidget->move(p);

   569     }

   570     if (tab.rightWidget) {

   571         QRect rect = q->style()->subElementRect(QStyle::SE_TabBarTabRightButton, &opt, q);

   572         QPoint p = rect.topLeft();

   573         if ((index == pressedIndex) || paintWithOffsets) {

   574             if (vertical)

   575                 p.setY(p.y() + tab.dragOffset);

   576             else

   577                 p.setX(p.x() + tab.dragOffset);

   578         }

   579         tab.rightWidget->move(p);

   580     }

   581 }

   582 

   583 void QTabBarPrivate::layoutWidgets(int index)

   584 {

   585     Q_Q(QTabBar);

   586     int start = 0;

   587     int end = q->count();

   588     if (index != -1) {

   589         start = qMax(index, 0);

   590         end = qMin(end, start + 1);

   591     }

   592     for (int i = start; i < end; ++i) {

   593         layoutTab(i);

   594     }

   595 }

   596 

   597 void QTabBarPrivate::_q_closeTab()

   598 {

   599     Q_Q(QTabBar);

   600     QObject *object = q->sender();

   601     int tabToClose = -1;

   602     QTabBar::ButtonPosition closeSide = (QTabBar::ButtonPosition)q->style()->styleHint(QStyle::SH_TabBar_CloseButtonPosition, 0, q);

   603     for (int i = 0; i < tabList.count(); ++i) {

   604         if (closeSide == QTabBar::LeftSide) {

   605             if (tabList.at(i).leftWidget == object) {

   606                 tabToClose = i;

   607                 break;

   608             }

   609         } else {

   610             if (tabList.at(i).rightWidget == object) {

   611                 tabToClose = i;

   612                 break;

   613             }

   614         }

   615     }

   616     if (tabToClose != -1)

   617         emit q->tabCloseRequested(tabToClose);

   618 }

   619 

   620 void QTabBarPrivate::_q_scrollTabs()

   621 {

   622     Q_Q(QTabBar);

   623     const QObject *sender = q->sender();

   624     int i = -1;

   625     if (!verticalTabs(shape)) {

   626         if (sender == leftB) {

   627             for (i = tabList.count() - 1; i >= 0; --i) {

   628                 if (tabList.at(i).rect.left() - scrollOffset < 0) {

   629                     makeVisible(i);

   630                     return;

   631                 }

   632             }

   633         } else if (sender == rightB) {

   634             int availableWidth = q->width() - extraWidth();

   635             for (i = 0; i < tabList.count(); ++i) {

   636                 if (tabList.at(i).rect.right() - scrollOffset > availableWidth) {

   637                     makeVisible(i);

   638                     return;

   639                 }

   640             }

   641         }

   642     } else { // vertical

   643         if (sender == leftB) {

   644             for (i = tabList.count() - 1; i >= 0; --i) {

   645                 if (tabList.at(i).rect.top() - scrollOffset < 0) {

   646                     makeVisible(i);

   647                     return;

   648                 }

   649             }

   650         } else if (sender == rightB) {

   651             int available = q->height() - extraWidth();

   652             for (i = 0; i < tabList.count(); ++i) {

   653                 if (tabList.at(i).rect.bottom() - scrollOffset > available) {

   654                     makeVisible(i);

   655                     return;

   656                 }

   657             }

   658         }

   659     }

   660 }

   661 

   662 void QTabBarPrivate::refresh()

   663 {

   664     Q_Q(QTabBar);

   665 

   666     // be safe in case a subclass is also handling move with the tabs

   667     if (pressedIndex != -1

   668         && movable

   669         && QApplication::mouseButtons() == Qt::NoButton) {

   670         moveTabFinished(pressedIndex);

   671         if (!validIndex(pressedIndex))

   672             pressedIndex = -1;

   673     }

   674 

   675     if (!q->isVisible()) {

   676         layoutDirty = true;

   677     } else {

   678         layoutTabs();

   679         makeVisible(currentIndex);

   680         q->update();

   681         q->updateGeometry();

   682     }

   683 }

   684 

   685 /*!

   686     Creates a new tab bar with the given \a parent.

   687 */

   688 QTabBar::QTabBar(QWidget* parent)

   689     :QWidget(*new QTabBarPrivate, parent, 0)

   690 {

   691     Q_D(QTabBar);

   692     d->init();

   693 }

   694 

   695 

   696 /*!

   697     Destroys the tab bar.

   698 */

   699 QTabBar::~QTabBar()

   700 {

   701 }

   702 

   703 /*!

   704     \property QTabBar::shape

   705     \brief the shape of the tabs in the tab bar

   706 

   707     Possible values for this property are described by the Shape enum.

   708 */

   709 

   710 

   711 QTabBar::Shape QTabBar::shape() const

   712 {

   713     Q_D(const QTabBar);

   714     return d->shape;

   715 }

   716 

   717 void QTabBar::setShape(Shape shape)

   718 {

   719     Q_D(QTabBar);

   720     if (d->shape == shape)

   721         return;

   722     d->shape = shape;

   723     d->refresh();

   724 }

   725 

   726 /*!

   727     \property QTabBar::drawBase

   728     \brief defines whether or not tab bar should draw its base.

   729 

   730     If true then QTabBar draws a base in relation to the styles overlab.

   731     Otherwise only the tabs are drawn.

   732 

   733     \sa QStyle::pixelMetric() QStyle::PM_TabBarBaseOverlap QStyleOptionTabBarBaseV2

   734 */

   735 

   736 void QTabBar::setDrawBase(bool drawBase)

   737 {

   738     Q_D(QTabBar);

   739     if (d->drawBase == drawBase)

   740         return;

   741     d->drawBase = drawBase;

   742     update();

   743 }

   744 

   745 bool QTabBar::drawBase() const

   746 {

   747     Q_D(const QTabBar);

   748     return d->drawBase;

   749 }

   750 

   751 /*!

   752     Adds a new tab with text \a text. Returns the new

   753     tab's index.

   754 */

   755 int QTabBar::addTab(const QString &text)

   756 {

   757     return insertTab(-1, text);

   758 }

   759 

   760 /*!

   761     \overload

   762 

   763     Adds a new tab with icon \a icon and text \a

   764     text. Returns the new tab's index.

   765 */

   766 int QTabBar::addTab(const QIcon& icon, const QString &text)

   767 {

   768     return insertTab(-1, icon, text);

   769 }

   770 

   771 /*!

   772     Inserts a new tab with text \a text at position \a index. If \a

   773     index is out of range, the new tab is appened. Returns the new

   774     tab's index.

   775 */

   776 int QTabBar::insertTab(int index, const QString &text)

   777 {

   778     return insertTab(index, QIcon(), text);

   779 }

   780 

   781 /*!\overload

   782 

   783     Inserts a new tab with icon \a icon and text \a text at position

   784     \a index. If \a index is out of range, the new tab is

   785     appended. Returns the new tab's index.

   786 

   787     If the QTabBar was empty before this function is called, the inserted tab

   788     becomes the current tab.

   789 

   790     Inserting a new tab at an index less than or equal to the current index

   791     will increment the current index, but keep the current tab.

   792 */

   793 int QTabBar::insertTab(int index, const QIcon& icon, const QString &text)

   794 {

   795     Q_D(QTabBar);

   796     if (!d->validIndex(index)) {

   797         index = d->tabList.count();

   798         d->tabList.append(QTabBarPrivate::Tab(icon, text));

   799     } else {

   800         d->tabList.insert(index, QTabBarPrivate::Tab(icon, text));

   801     }

   802 #ifndef QT_NO_SHORTCUT

   803     d->tabList[index].shortcutId = grabShortcut(QKeySequence::mnemonic(text));

   804 #endif

   805     d->refresh();

   806     if (d->tabList.count() == 1)

   807         setCurrentIndex(index);

   808     else if (index <= d->currentIndex)

   809         ++d->currentIndex;

   810 

   811     if (d->closeButtonOnTabs) {

   812         QStyleOptionTabV3 opt;

   813         initStyleOption(&opt, index);

   814         ButtonPosition closeSide = (ButtonPosition)style()->styleHint(QStyle::SH_TabBar_CloseButtonPosition, 0, this);

   815         QAbstractButton *closeButton = new CloseButton(this);

   816         connect(closeButton, SIGNAL(clicked()), this, SLOT(_q_closeTab()));

   817         setTabButton(index, closeSide, closeButton);

   818     }

   819 

   820     for (int i = 0; i < d->tabList.count(); ++i) {

   821         if (d->tabList[i].lastTab >= index)

   822             ++d->tabList[i].lastTab;

   823     }

   824 

   825     tabInserted(index);

   826     return index;

   827 }

   828 

   829 

   830 /*!

   831     Removes the tab at position \a index.

   832 

   833     \sa SelectionBehavior

   834  */

   835 void QTabBar::removeTab(int index)

   836 {

   837     Q_D(QTabBar);

   838     if (d->validIndex(index)) {

   839 #ifndef QT_NO_SHORTCUT

   840         releaseShortcut(d->tabList.at(index).shortcutId);

   841 #endif

   842         if (d->tabList[index].leftWidget) {

   843             d->tabList[index].leftWidget->hide();

   844             d->tabList[index].leftWidget->deleteLater();

   845             d->tabList[index].leftWidget = 0;

   846         }

   847         if (d->tabList[index].rightWidget) {

   848             d->tabList[index].rightWidget->hide();

   849             d->tabList[index].rightWidget->deleteLater();

   850             d->tabList[index].rightWidget = 0;

   851         }

   852 

   853         int newIndex = d->tabList[index].lastTab;

   854         d->tabList.removeAt(index);

   855         for (int i = 0; i < d->tabList.count(); ++i) {

   856             if (d->tabList[i].lastTab == index)

   857                 d->tabList[i].lastTab = -1;

   858             if (d->tabList[i].lastTab > index)

   859                 --d->tabList[i].lastTab;

   860         }

   861         if (index == d->currentIndex) {

   862             // The current tab is going away, in order to make sure

   863             // we emit that "current has changed", we need to reset this

   864             // around.

   865             d->currentIndex = -1;

   866             if (d->tabList.size() > 0) {

   867                 switch(d->selectionBehaviorOnRemove) {

   868                 case SelectPreviousTab:

   869                     if (newIndex > index)

   870                         newIndex--;

   871                     if (d->validIndex(newIndex))

   872                         break;

   873                     // else fallthrough

   874                 case SelectRightTab:

   875                     newIndex = index;

   876                     if (newIndex >= d->tabList.size())

   877                         newIndex = d->tabList.size() - 1;

   878                     break;

   879                 case SelectLeftTab:

   880                     newIndex = index - 1;

   881                     if (newIndex < 0)

   882                         newIndex = 0;

   883                     break;

   884                 default:

   885                     break;

   886                 }

   887 

   888                 if (d->validIndex(newIndex)) {

   889                     // don't loose newIndex's old through setCurrentIndex

   890                     int bump = d->tabList[newIndex].lastTab;

   891                     setCurrentIndex(newIndex);

   892                     d->tabList[newIndex].lastTab = bump;

   893                 }

   894             } else {

   895                 emit currentChanged(-1);

   896             }

   897         } else if (index < d->currentIndex) {

   898             setCurrentIndex(d->currentIndex - 1);

   899         }

   900         d->refresh();

   901         tabRemoved(index);

   902     }

   903 }

   904 

   905 

   906 /*!

   907     Returns true if the tab at position \a index is enabled; otherwise

   908     returns false.

   909 */

   910 bool QTabBar::isTabEnabled(int index) const

   911 {

   912     Q_D(const QTabBar);

   913     if (const QTabBarPrivate::Tab *tab = d->at(index))

   914         return tab->enabled;

   915     return false;

   916 }

   917 

   918 /*!

   919     If \a enabled is true then the tab at position \a index is

   920     enabled; otherwise the item at position \a index is disabled.

   921 */

   922 void QTabBar::setTabEnabled(int index, bool enabled)

   923 {

   924     Q_D(QTabBar);

   925     if (QTabBarPrivate::Tab *tab = d->at(index)) {

   926         tab->enabled = enabled;

   927 #ifndef QT_NO_SHORTCUT

   928         setShortcutEnabled(tab->shortcutId, enabled);

   929 #endif

   930         update();

   931         if (!enabled && index == d->currentIndex)

   932             setCurrentIndex(d->validIndex(index+1)?index+1:0);

   933         else if (enabled && !d->validIndex(d->currentIndex))

   934             setCurrentIndex(index);

   935     }

   936 }

   937 

   938 

   939 /*!

   940     Returns the text of the tab at position \a index, or an empty

   941     string if \a index is out of range.

   942 */

   943 QString QTabBar::tabText(int index) const

   944 {

   945     Q_D(const QTabBar);

   946     if (const QTabBarPrivate::Tab *tab = d->at(index))

   947         return tab->text;

   948     return QString();

   949 }

   950 

   951 /*!

   952     Sets the text of the tab at position \a index to \a text.

   953 */

   954 void QTabBar::setTabText(int index, const QString &text)

   955 {

   956     Q_D(QTabBar);

   957     if (QTabBarPrivate::Tab *tab = d->at(index)) {

   958         tab->text = text;

   959 #ifndef QT_NO_SHORTCUT

   960         releaseShortcut(tab->shortcutId);

   961         tab->shortcutId = grabShortcut(QKeySequence::mnemonic(text));

   962         setShortcutEnabled(tab->shortcutId, tab->enabled);

   963 #endif

   964         d->refresh();

   965     }

   966 }

   967 

   968 /*!

   969     Returns the text color of the tab with the given \a index, or a invalid

   970     color if \a index is out of range.

   971 

   972     \sa setTabTextColor()

   973 */

   974 QColor QTabBar::tabTextColor(int index) const

   975 {

   976     Q_D(const QTabBar);

   977     if (const QTabBarPrivate::Tab *tab = d->at(index))

   978         return tab->textColor;

   979     return QColor();

   980 }

   981 

   982 /*!

   983     Sets the color of the text in the tab with the given \a index to the specified \a color.

   984 

   985     If an invalid color is specified, the tab will use the QTabBar foreground role instead.

   986 

   987     \sa tabTextColor()

   988 */

   989 void QTabBar::setTabTextColor(int index, const QColor &color)

   990 {

   991     Q_D(QTabBar);

   992     if (QTabBarPrivate::Tab *tab = d->at(index)) {

   993         tab->textColor = color;

   994         update(tabRect(index));

   995     }

   996 }

   997 

   998 /*!

   999     Returns the icon of the tab at position \a index, or a null icon

  1000     if \a index is out of range.

  1001 */

  1002 QIcon QTabBar::tabIcon(int index) const

  1003 {

  1004     Q_D(const QTabBar);

  1005     if (const QTabBarPrivate::Tab *tab = d->at(index))

  1006         return tab->icon;

  1007     return QIcon();

  1008 }

  1009 

  1010 /*!

  1011     Sets the icon of the tab at position \a index to \a icon.

  1012 */

  1013 void QTabBar::setTabIcon(int index, const QIcon & icon)

  1014 {

  1015     Q_D(QTabBar);

  1016     if (QTabBarPrivate::Tab *tab = d->at(index)) {

  1017         bool simpleIconChange = (!icon.isNull() && !tab->icon.isNull());

  1018         tab->icon = icon;

  1019         if (simpleIconChange)

  1020             update(tabRect(index));

  1021         else

  1022             d->refresh();

  1023     }

  1024 }

  1025 

  1026 #ifndef QT_NO_TOOLTIP

  1027 /*!

  1028     Sets the tool tip of the tab at position \a index to \a tip.

  1029 */

  1030 void QTabBar::setTabToolTip(int index, const QString & tip)

  1031 {

  1032     Q_D(QTabBar);

  1033     if (QTabBarPrivate::Tab *tab = d->at(index))

  1034         tab->toolTip = tip;

  1035 }

  1036 

  1037 /*!

  1038     Returns the tool tip of the tab at position \a index, or an empty

  1039     string if \a index is out of range.

  1040 */

  1041 QString QTabBar::tabToolTip(int index) const

  1042 {

  1043     Q_D(const QTabBar);

  1044     if (const QTabBarPrivate::Tab *tab = d->at(index))

  1045         return tab->toolTip;

  1046     return QString();

  1047 }

  1048 #endif // QT_NO_TOOLTIP

  1049 

  1050 #ifndef QT_NO_WHATSTHIS

  1051 /*!

  1052     \since 4.1

  1053 

  1054     Sets the What's This help text of the tab at position \a index

  1055     to \a text.

  1056 */

  1057 void QTabBar::setTabWhatsThis(int index, const QString &text)

  1058 {

  1059     Q_D(QTabBar);

  1060     if (QTabBarPrivate::Tab *tab = d->at(index))

  1061         tab->whatsThis = text;

  1062 }

  1063 

  1064 /*!

  1065     \since 4.1

  1066 

  1067     Returns the What's This help text of the tab at position \a index,

  1068     or an empty string if \a index is out of range.

  1069 */

  1070 QString QTabBar::tabWhatsThis(int index) const

  1071 {

  1072     Q_D(const QTabBar);

  1073     if (const QTabBarPrivate::Tab *tab = d->at(index))

  1074         return tab->whatsThis;

  1075     return QString();

  1076 }

  1077 

  1078 #endif // QT_NO_WHATSTHIS

  1079 

  1080 /*!

  1081     Sets the data of the tab at position \a index to \a data.

  1082 */

  1083 void QTabBar::setTabData(int index, const QVariant & data)

  1084 {

  1085     Q_D(QTabBar);

  1086     if (QTabBarPrivate::Tab *tab = d->at(index))

  1087         tab->data = data;

  1088 }

  1089 

  1090 /*!

  1091     Returns the data of the tab at position \a index, or a null

  1092     variant if \a index is out of range.

  1093 */

  1094 QVariant QTabBar::tabData(int index) const

  1095 {

  1096     Q_D(const QTabBar);

  1097     if (const QTabBarPrivate::Tab *tab = d->at(index))

  1098         return tab->data;

  1099     return QVariant();

  1100 }

  1101 

  1102 /*!

  1103     Returns the visual rectangle of the tab at position \a

  1104     index, or a null rectangle if \a index is out of range.

  1105 */

  1106 QRect QTabBar::tabRect(int index) const

  1107 {

  1108     Q_D(const QTabBar);

  1109     if (const QTabBarPrivate::Tab *tab = d->at(index)) {

  1110         if (d->layoutDirty)

  1111             const_cast<QTabBarPrivate*>(d)->layoutTabs();

  1112         QRect r = tab->rect;

  1113         if (verticalTabs(d->shape))

  1114             r.translate(0, -d->scrollOffset);

  1115         else

  1116             r.translate(-d->scrollOffset, 0);

  1117         if (!verticalTabs(d->shape))

  1118             r = QStyle::visualRect(layoutDirection(), rect(), r);

  1119         return r;

  1120     }

  1121     return QRect();

  1122 }

  1123 

  1124 /*!

  1125     \since 4.3

  1126     Returns the index of the tab that covers \a position or -1 if no

  1127     tab covers \a position;

  1128 */

  1129 

  1130 int QTabBar::tabAt(const QPoint &position) const

  1131 {

  1132     Q_D(const QTabBar);

  1133     if (d->validIndex(d->currentIndex)

  1134         && tabRect(d->currentIndex).contains(position)) {