Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731

1 files changed, 1097 insertions, 0 deletions

diff --git a/src/widgets/qtabwidget.cpp b/src/widgets/qtabwidget.cpp
new file mode 100644
index 000000000..2c85a611a
--- /dev/null
+++ b/src/widgets/qtabwidget.cpp
@@ -0,0 +1,1097 @@
+/****************************************************************************
+**
+** Implementation of TQTabWidget class
+**
+** Created : 990318
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the widgets module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing retquirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qtabwidget.h"
+#ifndef QT_NO_TABWIDGET
+#include "qobjectlist.h"
+#include "qtabbar.h"
+#include "qapplication.h"
+#include "qwidgetstack.h"
+#include "qbitmap.h"
+#include "qaccel.h"
+#include "qstyle.h"
+#include "qpainter.h"
+#include "qtoolbutton.h"
+
+#ifdef Q_OS_MACX
+#include <qmacstyle_mac.h>
+#endif
+
+/*!
+    \class TQTabWidget qtabwidget.h
+    \brief The TQTabWidget class provides a stack of tabbed widgets.
+
+    \ingroup organizers
+    \ingroup advanced
+    \mainclass
+
+    A tab widget provides a tab bar of tabs and a `page area' below
+    (or above, see \l{TabPosition}) the tabs. Each tab is associated
+    with a different widget (called a `page'). Only the current tab's
+    page is shown in the page area; all the other tabs' pages are
+    hidden. The user can show a different page by clicking on its tab
+    or by pressing its Alt+\e{letter} accelerator if it has one.
+
+    The normal way to use TQTabWidget is to do the following in the
+    constructor:
+    \list 1
+    \i Create a TQTabWidget.
+    \i Create a TQWidget for each of the pages in the tab dialog,
+    insert children into it, set up geometry management for it and use
+    addTab() (or insertTab()) to set up a tab and keyboard accelerator
+    for it.
+    \i Connect to the signals and slots.
+    \endlist
+
+    The position of the tabs is set with setTabPosition(), their shape
+    with setTabShape(), and their margin with setMargin().
+
+    If you don't call addTab() and the TQTabWidget is already visible,
+    then the page you have created will not be visible. Don't
+    confuse the object name you supply to the TQWidget constructor and
+    the tab label you supply to addTab(). addTab() takes a name which
+    indicates an accelerator and is meaningful and descriptive to the
+    user, whereas the widget name is used primarily for debugging.
+
+    The signal currentChanged() is emitted when the user selects a
+    page.
+
+    The current page is available as an index position with
+    currentPageIndex() or as a wiget pointer with currentPage(). You
+    can retrieve a pointer to a page with a given index using page(),
+    and can find the index position of a page with indexOf(). Use
+    setCurrentPage() to show a particular page by index, or showPage()
+    to show a page by widget pointer.
+
+    You can change a tab's label and iconset using changeTab() or
+    setTabLabel() and setTabIconSet(). A tab page can be removed with
+    removePage().
+
+    Each tab is either enabled or disabled at any given time (see
+    setTabEnabled()). If a tab is enabled, the tab text is drawn
+    normally and the user can select that tab. If it is disabled, the
+    tab is drawn in a different way and the user cannot select that
+    tab. Note that even if a tab is disabled, the page can still be
+    visible, for example if all of the tabs happen to be disabled.
+
+    Although tab widgets can be a very good way to split up a complex
+    dialog, it's also very easy to get into a mess. See TQTabDialog for
+    some design hints. An alternative is to use a TQWidgetStack for
+    which you provide some means of navigating between pages, for
+    example, a TQToolBar or a TQListBox.
+
+    Most of the functionality in TQTabWidget is provided by a TQTabBar
+    (at the top, providing the tabs) and a TQWidgetStack (most of the
+    area, organizing the individual pages).
+
+    <img src=qtabwidget-m.png> <img src=qtabwidget-w.png>
+
+    \sa TQTabDialog, TQToolBox
+*/
+
+/*!
+  \enum TQt::Corner
+  This enum type specifies a corner in a rectangle:
+  \value TopLeft top left corner
+  \value TopRight top right corner
+  \value BottomLeft bottom left corner
+  \value BottomRight bottom right corner
+*/
+
+/*!
+    \enum TQTabWidget::TabPosition
+
+    This enum type defines where TQTabWidget draws the tab row:
+    \value Top  above the pages
+    \value Bottom  below the pages
+*/
+
+/*!
+    \enum TQTabWidget::TabShape
+
+    This enum type defines the shape of the tabs:
+    \value Rounded  rounded look (normal)
+    \value Triangular  triangular look (very unusual, included for completeness)
+*/
+
+/* undocumented now
+  \obsolete
+
+  \fn void TQTabWidget::selected( const TQString &tabLabel );
+
+  This signal is emitted whenever a tab is selected (raised),
+  including during the first show().
+
+  \sa raise()
+*/
+
+
+/*!
+    \fn void TQTabWidget::currentChanged( TQWidget* );
+
+    This signal is emitted whenever the current page changes. The
+    parameter is the new current page.
+
+    \sa currentPage(), showPage(), tabLabel()
+*/
+
+class TQTabBarBase : public TQWidget
+{
+public:
+    TQTabBarBase( TQTabWidget* parent=0, const char* name=0 )
+        : TQWidget( parent, name ) {};
+protected:
+    void paintEvent( TQPaintEvent * )
+    {
+        TQObject * obj = parent();
+        if( obj ){
+            TQTabWidget * t = (TQTabWidget *) obj;
+            TQPainter p( this );
+	    TQStyle::SFlags flags = TQStyle::Style_Default;
+
+	    if ( t->tabPosition() == TQTabWidget::Top )
+		flags |= TQStyle::Style_Top;
+	    if ( t->tabPosition() == TQTabWidget::Bottom )
+		flags |= TQStyle::Style_Bottom;
+	    if(parentWidget()->isEnabled())
+		flags |= TQStyle::Style_Enabled;
+
+	    style().drawPrimitive( TQStyle::PE_TabBarBase, &p, rect(),
+				   colorGroup(), flags );
+        }
+    }
+};
+
+class TQTabWidgetData
+{
+public:
+    TQTabWidgetData()
+        : tabs(0), tabBase(0), stack(0), dirty( TRUE ),
+          pos( TQTabWidget::Top ), shape( TQTabWidget::Rounded ),
+	  leftCornerWidget(0), rightCornerWidget(0) {};
+    ~TQTabWidgetData(){};
+    TQTabBar* tabs;
+    TQTabBarBase* tabBase;
+    TQWidgetStack* stack;
+    bool dirty;
+    TQTabWidget::TabPosition pos;
+    TQTabWidget::TabShape shape;
+    int alignment;
+    TQWidget* leftCornerWidget;
+    TQWidget* rightCornerWidget;
+};
+
+/*!
+    Constructs a tabbed widget called \a name with parent \a parent,
+    and widget flags \a f.
+*/
+TQTabWidget::TQTabWidget( TQWidget *parent, const char *name, WFlags f )
+    : TQWidget( parent, name, f )
+{
+    d = new TQTabWidgetData;
+    d->stack = new TQWidgetStack( this, "tab pages" );
+    d->stack->installEventFilter( this );
+    d->tabBase = new TQTabBarBase( this, "tab base" );
+    d->tabBase->resize( 1, 1 );
+    setTabBar( new TQTabBar( this, "tab control" ) );
+
+    d->stack->setFrameStyle( TQFrame::TabWidgetPanel | TQFrame::Raised );
+#ifdef Q_OS_TEMP
+    d->pos = Bottom;
+#endif
+
+    setSizePolicy( TQSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Expanding ) );
+    setFocusPolicy( TabFocus );
+    setFocusProxy( d->tabs );
+
+    installEventFilter( this );
+#ifdef Q_OS_MACX
+    if (::qt_cast<TQMacStyle*>(&style()))
+        setMargin(10); // According to HIGuidelines at least.
+#endif
+}
+
+/*!
+    \reimp
+*/
+TQTabWidget::~TQTabWidget()
+{
+    delete d;
+}
+
+/*!
+    Adds another tab and page to the tab view.
+
+    The new page is \a child; the tab's label is \a label. Note the
+    difference between the widget name (which you supply to widget
+    constructors and to setTabEnabled(), for example) and the tab
+    label. The name is internal to the program and invariant, whereas
+    the label is shown on-screen and may vary according to language
+    and other factors.
+
+    If the tab's \a label contains an ampersand, the letter following
+    the ampersand is used as an accelerator for the tab, e.g. if the
+    label is "Bro\&wse" then Alt+W becomes an accelerator which will
+    move the focus to this tab.
+
+    If you call addTab() after show() the screen will flicker and the
+    user may be confused.
+
+    Adding the same child twice will have undefined behavior.
+
+    \sa insertTab()
+*/
+void TQTabWidget::addTab( TQWidget *child, const TQString &label)
+{
+    insertTab( child, label );
+}
+
+
+/*!
+    \overload
+
+    Adds another tab and page to the tab view.
+
+    This function is the same as addTab(), but with an additional \a
+    iconset.
+*/
+void TQTabWidget::addTab( TQWidget *child, const TQIconSet& iconset, const TQString &label )
+{
+    insertTab( child, iconset, label );
+}
+
+/*!
+    \overload
+
+    This is a low-level function for adding tabs. It is useful if you
+    are using setTabBar() to set a TQTabBar subclass with an overridden
+    TQTabBar::paint() function for a subclass of TQTab. The \a child is
+    the new page and \a tab is the tab to put the \a child on.
+*/
+void TQTabWidget::addTab( TQWidget *child, TQTab* tab )
+{
+    insertTab( child, tab );
+}
+
+
+
+/*!
+    Inserts another tab and page to the tab view.
+
+    The new page is \a child; the tab's label is \a label. Note the
+    difference between the widget name (which you supply to widget
+    constructors and to setTabEnabled(), for example) and the tab
+    label. The name is internal to the program and invariant, whereas
+    the label is shown on-screen and may vary according to language
+    and other factors.
+
+    If the tab's \a label contains an ampersand, the letter following
+    the ampersand is used as an accelerator for the tab, e.g. if the
+    label is "Bro\&wse" then Alt+W becomes an accelerator which will
+    move the focus to this tab.
+
+    If \a index is not specified, the tab is simply appended.
+    Otherwise it is inserted at the specified position.
+
+    If you call insertTab() after show(), the screen will flicker and
+    the user may be confused.
+
+    \sa addTab()
+*/
+void TQTabWidget::insertTab( TQWidget *child, const TQString &label, int index)
+{
+    TQTab * t = new TQTab();
+    Q_CHECK_PTR( t );
+    t->label = label;
+    insertTab( child, t, index );
+}
+
+
+/*!
+    \overload
+
+    Inserts another tab and page to the tab view.
+
+    This function is the same as insertTab(), but with an additional
+    \a iconset.
+*/
+void TQTabWidget::insertTab( TQWidget *child, const TQIconSet& iconset, const TQString &label, int index )
+{
+    TQTab * t = new TQTab();
+    Q_CHECK_PTR( t );
+    t->label = label;
+    t->iconset = new TQIconSet( iconset );
+    insertTab( child, t, index );
+}
+
+/*!
+    \overload
+
+    This is a lower-level method for inserting tabs, similar to the
+    other insertTab() method. It is useful if you are using
+    setTabBar() to set a TQTabBar subclass with an overridden
+    TQTabBar::paint() function for a subclass of TQTab. The \a child is
+    the new page, \a tab is the tab to put the \a child on and \a
+    index is the position in the tab bar that this page should occupy.
+*/
+void TQTabWidget::insertTab( TQWidget *child, TQTab* tab, int index)
+{
+    tab->enabled = TRUE;
+    int id = d->tabs->insertTab( tab, index );
+    d->stack->addWidget( child, id );
+    if ( d->stack->frameStyle() != ( TQFrame::TabWidgetPanel | TQFrame::Raised ) )
+        d->stack->setFrameStyle( TQFrame::TabWidgetPanel | TQFrame::Raised );
+    setUpLayout();
+}
+
+
+/*!
+    Defines a new \a label for page \a{w}'s tab.
+*/
+void TQTabWidget::changeTab( TQWidget *w, const TQString &label)
+{
+    int id = d->stack->id( w );
+    if ( id < 0 )
+        return;
+    TQTab* t = d->tabs->tab( id );
+    if ( !t )
+        return;
+    // this will update the accelerators
+    t->setText( label );
+
+    d->tabs->layoutTabs();
+    d->tabs->update();
+    setUpLayout();
+}
+
+/*!
+    \overload
+
+    Defines a new \a iconset and a new \a label for page \a{w}'s tab.
+*/
+void TQTabWidget::changeTab( TQWidget *w, const TQIconSet& iconset, const TQString &label)
+{
+    int id = d->stack->id( w );
+    if ( id < 0 )
+        return;
+    TQTab* t = d->tabs->tab( id );
+    if ( !t )
+        return;
+    if ( t->iconset ) {
+        delete t->iconset;
+        t->iconset = 0;
+    }
+    // this will update the accelerators
+    t->iconset = new TQIconSet( iconset );
+    t->setText( label );
+
+    d->tabs->layoutTabs();
+    d->tabs->update();
+    setUpLayout();
+}
+
+/*!
+    Returns TRUE if the page \a w is enabled; otherwise returns FALSE.
+
+    \sa setTabEnabled(), TQWidget::isEnabled()
+*/
+
+bool TQTabWidget::isTabEnabled( TQWidget* w ) const
+{
+    int id = d->stack->id( w );
+    if ( id >= 0 )
+        return w->isEnabled();
+    else
+        return FALSE;
+}
+
+/*!
+    If \a enable is TRUE, page \a w is enabled; otherwise page \a w is
+    disabled. The page's tab is redrawn appropriately.
+
+    TQTabWidget uses TQWidget::setEnabled() internally, rather than
+    keeping a separate flag.
+
+    Note that even a disabled tab/page may be visible. If the page is
+    visible already, TQTabWidget will not hide it; if all the pages are
+    disabled, TQTabWidget will show one of them.
+
+    \sa isTabEnabled(), TQWidget::setEnabled()
+*/
+
+void TQTabWidget::setTabEnabled( TQWidget* w, bool enable)
+{
+    int id = d->stack->id( w );
+    if ( id >= 0 ) {
+        w->setEnabled( enable );
+        d->tabs->setTabEnabled( id, enable );
+    }
+}
+
+/*!
+  Sets widget \a w to be the shown in the specified \a corner of the
+  tab widget.
+
+  Only the horizontal element of the \a corner will be used.
+
+  \sa cornerWidget(), setTabPosition()
+*/
+void TQTabWidget::setCornerWidget( TQWidget * w, TQt::Corner corner )
+{
+    if ( !w )
+	return;
+    if ( (uint)corner & 1 )
+	d->rightCornerWidget = w;
+    else
+	d->leftCornerWidget = w;
+}
+
+/*!
+    Returns the widget shown in the \a corner of the tab widget or 0.
+*/
+TQWidget * TQTabWidget::cornerWidget( TQt::Corner corner ) const
+{
+    if ( (uint)corner & 1 )
+	return d->rightCornerWidget;
+    return d->leftCornerWidget;
+}
+
+/*!
+    Ensures that page \a w is shown. This is useful mainly for
+    accelerators.
+
+    \warning Used carelessly, this function can easily surprise or
+    confuse the user.
+
+    \sa TQTabBar::setCurrentTab()
+*/
+void TQTabWidget::showPage( TQWidget * w)
+{
+    int id = d->stack->id( w );
+    if ( id >= 0 ) {
+        d->stack->raiseWidget( w );
+        d->tabs->setCurrentTab( id );
+        // ### why overwrite the frame style?
+        if ( d->stack->frameStyle() != ( TQFrame::TabWidgetPanel |TQFrame::Raised ) )
+            d->stack->setFrameStyle( TQFrame::TabWidgetPanel | TQFrame::Raised );
+    }
+}
+
+/*!
+    Removes page \a w from this stack of widgets. Does not delete \a
+    w.
+
+    \sa addTab(), showPage(), TQWidgetStack::removeWidget()
+*/
+void TQTabWidget::removePage( TQWidget * w )
+{
+    int id = d->stack->id( w );
+    if ( id >= 0 ) {
+	int oldId = d->stack->id(currentPage());
+	bool fixCurrentTab = oldId == id;
+	//switches to the next enabled tab
+	d->tabs->setTabEnabled( id, FALSE );
+	//if no next enabled page we fix the current page
+	fixCurrentTab = fixCurrentTab && oldId == d->stack->id(currentPage());
+
+	d->stack->removeWidget( w );
+	d->tabs->removeTab( d->tabs->tab(id) );
+	if ( fixCurrentTab )
+	    showTab( d->tabs->currentTab() );
+	setUpLayout();
+
+	if ( d->tabs->count() == 0 )
+	    d->stack->setFrameStyle( TQFrame::NoFrame );
+    }
+}
+
+/*!
+    Returns the label text for the tab on page \a w.
+*/
+
+TQString TQTabWidget::tabLabel( TQWidget * w ) const
+{
+    TQTab * t = d->tabs->tab( d->stack->id( w ) );
+    return t ? t->label : TQString::null;
+}
+
+/*!
+    Sets the tab label for page \a w to \a l
+*/
+
+void TQTabWidget::setTabLabel( TQWidget * w, const TQString &l )
+{
+    TQTab * t = d->tabs->tab( d->stack->id( w ) );
+    if ( t )
+        t->label = l;
+    d->tabs->layoutTabs();
+    d->tabs->update();
+    setUpLayout();
+}
+
+/*!
+    Returns a pointer to the page currently being displayed by the tab
+    dialog. The tab dialog does its best to make sure that this value
+    is never 0 (but if you try hard enough, it can be).
+*/
+
+TQWidget * TQTabWidget::currentPage() const
+{
+    return page( currentPageIndex() );
+}
+
+/*!
+    \property TQTabWidget::autoMask
+    \brief whether the tab widget is automatically masked
+
+    \sa TQWidget::setAutoMask()
+*/
+
+/*!
+    \property TQTabWidget::currentPage
+    \brief the index position of the current tab page
+
+  \sa TQTabBar::currentTab()
+*/
+
+int TQTabWidget::currentPageIndex() const
+{
+    return d->tabs->indexOf( d->tabs->currentTab() );
+}
+
+void TQTabWidget::setCurrentPage( int index )
+{
+    d->tabs->setCurrentTab( d->tabs->tabAt( index ) );
+    showTab( d->tabs->currentTab() );
+}
+
+
+/*!
+    Returns the index position of page \a w, or -1 if the widget
+    cannot be found.
+*/
+int TQTabWidget::indexOf( TQWidget* w ) const
+{
+    return d->tabs->indexOf( d->stack->id( w ) );
+}
+
+
+/*!
+    \reimp
+*/
+void TQTabWidget::resizeEvent( TQResizeEvent *e )
+{
+    TQWidget::resizeEvent( e );
+    setUpLayout();
+}
+
+/*!
+    Replaces the dialog's TQTabBar heading with the tab bar \a tb. Note
+    that this must be called \e before any tabs have been added, or
+    the behavior is undefined.
+
+    \sa tabBar()
+*/
+void TQTabWidget::setTabBar( TQTabBar* tb)
+{
+    if ( tb->parentWidget() != this )
+        tb->reparent( this, TQPoint(0,0), TRUE );
+    delete d->tabs;
+    d->tabs = tb;
+    setFocusProxy( d->tabs );
+    connect( d->tabs, SIGNAL(selected(int)),
+             this,    SLOT(showTab(int)) );
+    setUpLayout();
+}
+
+
+/*!
+    Returns the current TQTabBar.
+
+    \sa setTabBar()
+*/
+TQTabBar* TQTabWidget::tabBar() const
+{
+    return d->tabs;
+}
+
+/*!
+    Ensures that the selected tab's page is visible and appropriately
+    sized.
+*/
+
+void TQTabWidget::showTab( int i )
+{
+    if ( d->stack->widget( i ) ) {
+	d->stack->raiseWidget( i );
+	emit selected( d->tabs->tab( i )->label );
+	emit currentChanged( d->stack->widget( i ) );
+    }
+}
+
+/*
+    Set up the layout.
+*/
+void TQTabWidget::setUpLayout( bool onlyCheck )
+{
+    if ( onlyCheck && !d->dirty )
+	return; // nothing to do
+
+    if ( !isVisible() ) {
+	d->dirty = TRUE;
+	return; // we'll do it later
+    }
+
+    TQSize t( 0, d->stack->frameWidth() );
+    if ( d->tabs->isVisibleTo(this) )
+	t = d->tabs->sizeHint();
+    int lcw = 0;
+    if ( d->leftCornerWidget && d->leftCornerWidget->isVisible()  ) {
+	TQSize sz = d->leftCornerWidget->sizeHint();
+	d->leftCornerWidget->resize(sz);
+	lcw = sz.width();
+	if ( t.height() > lcw )
+	    lcw = t.height();
+     }
+    int rcw = 0;
+    if ( d->rightCornerWidget && d->rightCornerWidget->isVisible() ) {
+	TQSize sz = d->rightCornerWidget->sizeHint();
+	d->rightCornerWidget->resize(sz);
+	rcw = sz.width();
+	if ( t.height() > rcw )
+	    rcw = t.height();
+    }
+    int tw = width() - lcw - rcw;
+    if ( t.width() > tw )
+	t.setWidth( tw );
+    int lw = d->stack->lineWidth();
+    bool reverse = TQApplication::reverseLayout();
+    int tabx, taby, stacky, exty, exth, overlap;
+
+    exth = style().pixelMetric( TQStyle::PM_TabBarBaseHeight, this );
+    overlap = style().pixelMetric( TQStyle::PM_TabBarBaseOverlap, this );
+
+    if ( d->pos == Bottom ) {
+	taby = height() - t.height() - lw;
+	stacky = 0;
+	exty = taby - (exth - overlap);
+    } else { // Top
+	taby = 0;
+	stacky = t.height()-lw + (exth - overlap);
+	exty = taby + t.height() - overlap;
+    }
+
+    int lhs = (TQMAX( 0, lw - 2 ) + lcw);
+    int alignment = style().styleHint( TQStyle::SH_TabBar_Alignment, this );
+    if ( alignment == AlignHCenter  && t.width() < width() )
+        tabx = lhs + ((width()-(lcw+rcw))/2 - t.width()/2);
+    else if(reverse || alignment == AlignRight)
+        tabx = TQMIN( width() - t.width(), width() - t.width() - lw + 2 ) - lcw;
+    else
+        tabx = lhs;
+
+    d->tabs->setGeometry( tabx, taby, t.width(), t.height() );
+    d->tabBase->setGeometry( 0, exty, width(), exth );
+    if ( exth == 0 )
+	d->tabBase->hide();
+    else
+	d->tabBase->show();
+
+    d->stack->setGeometry( 0, stacky, width(), height() - (exth-overlap) -
+			   t.height()+TQMAX(0, lw-2));
+
+    d->dirty = FALSE;
+
+    // move cornerwidgets
+    if ( d->leftCornerWidget ) {
+	int y = ( t.height() / 2 ) - ( d->leftCornerWidget->height() / 2 );
+	int x = ( reverse ? width() - lcw + y : y );
+	d->leftCornerWidget->move( x, y + taby );
+    }
+    if ( d->rightCornerWidget ) {
+	int y = ( t.height() / 2 ) - ( d->rightCornerWidget->height() / 2 );
+	int x = ( reverse ? y : width() - rcw + y );
+	d->rightCornerWidget->move( x, y + taby );
+    }
+    if ( !onlyCheck )
+	update();
+    updateGeometry();
+    if ( autoMask() )
+	updateMask();
+}
+
+/*!
+    \reimp
+*/
+TQSize TQTabWidget::sizeHint() const
+{
+    TQSize lc(0, 0), rc(0, 0);
+
+    if (d->leftCornerWidget)
+	lc = d->leftCornerWidget->sizeHint();
+    if(d->rightCornerWidget)
+	rc = d->rightCornerWidget->sizeHint();
+    if ( !d->dirty ) {
+	TQTabWidget *that = (TQTabWidget*)this;
+	that->setUpLayout( TRUE );
+    }
+    TQSize s( d->stack->sizeHint() );
+    TQSize t( d->tabs->sizeHint() );
+    if(!style().styleHint(TQStyle::SH_TabBar_PreferNoArrows, d->tabs))
+	t = t.boundedTo( TQSize(200,200) );
+    else
+        t = t.boundedTo( TQApplication::desktop()->size() );
+
+    TQSize sz( TQMAX( s.width(), t.width() + rc.width() + lc.width() ),
+	      s.height() + (TQMAX( rc.height(), TQMAX(lc.height(), t.height()))) + ( d->tabBase->isVisible() ? d->tabBase->height() : 0 ) );
+    return style().sizeFromContents(TQStyle::CT_TabWidget, this, sz).expandedTo(TQApplication::globalStrut());
+}
+
+
+/*!
+    \reimp
+
+    Returns a suitable minimum size for the tab widget.
+*/
+TQSize TQTabWidget::minimumSizeHint() const
+{
+    TQSize lc(0, 0), rc(0, 0);
+
+    if(d->leftCornerWidget)
+	lc = d->leftCornerWidget->minimumSizeHint();
+    if(d->rightCornerWidget)
+	rc = d->rightCornerWidget->minimumSizeHint();
+    if ( !d->dirty ) {
+	TQTabWidget *that = (TQTabWidget*)this;
+	that->setUpLayout( TRUE );
+    }
+    TQSize s( d->stack->minimumSizeHint() );
+    TQSize t( d->tabs->minimumSizeHint() );
+
+    TQSize sz( TQMAX( s.width(), t.width() + rc.width() + lc.width() ),
+	      s.height() + (TQMAX( rc.height(), TQMAX(lc.height(), t.height()))) + ( d->tabBase->isVisible() ? d->tabBase->height() : 0 ) );
+    return style().sizeFromContents(TQStyle::CT_TabWidget, this, sz).expandedTo(TQApplication::globalStrut());
+}
+
+/*!
+    \reimp
+ */
+void TQTabWidget::showEvent( TQShowEvent * )
+{
+    setUpLayout();
+}
+
+
+/*!
+    \property TQTabWidget::tabPosition
+    \brief the position of the tabs in this tab widget
+
+    Possible values for this property are \c TQTabWidget::Top and \c
+    TQTabWidget::Bottom.
+
+    \sa TabPosition
+*/
+TQTabWidget::TabPosition TQTabWidget::tabPosition() const
+{
+    return d->pos;
+}
+
+void TQTabWidget::setTabPosition( TabPosition pos)
+{
+    if (d->pos == pos)
+        return;
+    d->pos = pos;
+    if (d->tabs->shape() == TQTabBar::TriangularAbove || d->tabs->shape() == TQTabBar::TriangularBelow ) {
+        if ( pos == Bottom )
+            d->tabs->setShape( TQTabBar::TriangularBelow );
+        else
+            d->tabs->setShape( TQTabBar::TriangularAbove );
+    }
+    else {
+        if ( pos == Bottom )
+            d->tabs->setShape( TQTabBar::RoundedBelow );
+        else
+            d->tabs->setShape( TQTabBar::RoundedAbove );
+    }
+    d->tabs->layoutTabs();
+    setUpLayout();
+}
+
+/*!
+    \property TQTabWidget::tabShape
+    \brief the shape of the tabs in this tab widget
+
+    Possible values for this property are \c TQTabWidget::Rounded
+    (default) or \c TQTabWidget::Triangular.
+
+    \sa TabShape
+*/
+
+TQTabWidget::TabShape TQTabWidget::tabShape() const
+{
+    return d->shape;
+}
+
+void TQTabWidget::setTabShape( TabShape s )
+{
+    if ( d->shape == s )
+        return;
+    d->shape = s;
+    if ( d->pos == Top ) {
+        if ( s == Rounded )
+            d->tabs->setShape( TQTabBar::RoundedAbove );
+        else
+            d->tabs->setShape( TQTabBar::TriangularAbove );
+    } else {
+        if ( s == Rounded )
+            d->tabs->setShape( TQTabBar::RoundedBelow );
+        else
+            d->tabs->setShape( TQTabBar::TriangularBelow );
+    }
+    d->tabs->layoutTabs();
+    setUpLayout();
+}
+
+
+/*!
+    \property TQTabWidget::margin
+    \brief the margin in this tab widget
+
+    The margin is the distance between the innermost pixel of the
+    frame and the outermost pixel of the pages.
+*/
+int TQTabWidget::margin() const
+{
+    return d->stack->margin();
+}
+
+void TQTabWidget::setMargin( int w )
+{
+    d->stack->setMargin( w );
+    setUpLayout();
+}
+
+
+/*!
+    \reimp
+ */
+void TQTabWidget::styleChange( TQStyle& old )
+{
+    TQWidget::styleChange( old );
+    setUpLayout();
+}
+
+
+/*!
+    \reimp
+ */
+void TQTabWidget::updateMask()
+{
+    if ( !autoMask() )
+        return;
+
+    TQRect r;
+    TQRegion reg( r );
+    reg += TQRegion( d->tabs->geometry() );
+    reg += TQRegion( d->stack->geometry() );
+    setMask( reg );
+}
+
+
+/*!
+    \reimp
+ */
+bool TQTabWidget::eventFilter( TQObject *o, TQEvent * e)
+{
+    if ( o == this ) {
+	if ( e->type() == TQEvent::LanguageChange || e->type() == TQEvent::LayoutHint ) {
+	    d->dirty = TRUE;
+	    setUpLayout();
+	    updateGeometry();
+	} else if ( e->type() == TQEvent::KeyPress ) {
+	    TQKeyEvent *ke = (TQKeyEvent*) e;
+	    if ( ( ke->key() == TQt::Key_Tab || ke->key() == TQt::Key_Backtab ) &&
+		 count() > 1 &&
+		 ke->state() & TQt::ControlButton ) {
+		int page = currentPageIndex();
+		if ( ke->key() == TQt::Key_Backtab || ke->state() & TQt::ShiftButton ) {
+		    page--;
+		    if ( page < 0 )
+			page = count() - 1;
+		} else {
+		    page++;
+		    if ( page >= count() )
+			page = 0;
+		}
+		setCurrentPage( page );
+		if ( !qApp->focusWidget() )
+		    d->tabs->setFocus();
+		return TRUE;
+	    }
+	}
+
+    } else if ( o == d->stack ) {
+	if ( e->type() == TQEvent::ChildRemoved
+	     && ( (TQChildEvent*)e )->child()->isWidgetType() ) {
+	    removePage( (TQWidget*)  ( (TQChildEvent*)e )->child() );
+	    return TRUE;
+	} else if ( e->type() == TQEvent::LayoutHint ) {
+	    updateGeometry();
+	}
+    }
+    return FALSE;
+}
+
+/*!
+    Returns the tab page at index position \a index or 0 if the \a
+    index is out of range.
+*/
+TQWidget *TQTabWidget::page( int index ) const
+{
+    TQTab *t = d->tabs->tabAt(index);
+    if ( t )
+	return d->stack->widget( t->id );
+    // else
+    return 0;
+}
+
+/*!
+    Returns the label of the tab at index position \a index or
+    TQString::null if the \a index is out of range.
+*/
+TQString TQTabWidget::label( int index ) const
+{
+    TQTab *t = d->tabs->tabAt( index );
+    if ( t )
+ 	return t->label;
+    // else
+    return TQString::null;
+}
+
+/*!
+    \property TQTabWidget::count
+    \brief the number of tabs in the tab bar
+*/
+int TQTabWidget::count() const
+{
+    return d->tabs->count();
+}
+
+/*!
+    Returns the iconset of page \a w or a \link TQIconSet::TQIconSet()
+    null iconset\endlink if \a w is not a tab page or does not have an
+    iconset.
+*/
+TQIconSet TQTabWidget::tabIconSet( TQWidget * w ) const
+{
+    int id = d->stack->id( w );
+    if ( id < 0 )
+        return TQIconSet();
+    TQTab* t = d->tabs->tab( id );
+    if ( !t )
+        return TQIconSet();
+    if ( t->iconset )
+	return TQIconSet( *t->iconset );
+    else
+	return TQIconSet();
+}
+
+/*!
+    Sets the iconset for page \a w to \a iconset.
+*/
+void TQTabWidget::setTabIconSet( TQWidget * w, const TQIconSet & iconset )
+{
+    int id = d->stack->id( w );
+    if ( id < 0 )
+        return;
+    TQTab* t = d->tabs->tab( id );
+    if ( !t )
+        return;
+    if ( t->iconset )
+        delete t->iconset;
+    t->iconset = new TQIconSet( iconset );
+
+    d->tabs->layoutTabs();
+    d->tabs->update();
+    setUpLayout();
+}
+
+/*!
+    Sets the tab tool tip for page \a w to \a tip.
+
+    \sa removeTabToolTip(), tabToolTip()
+*/
+void TQTabWidget::setTabToolTip( TQWidget * w, const TQString & tip )
+{
+    int index = d->tabs->indexOf( d->stack->id( w ) );
+    if ( index < 0 )
+        return;
+    d->tabs->setToolTip( index, tip );
+}
+
+/*!
+    Returns the tab tool tip for page \a w or TQString::null if no tool
+    tip has been set.
+
+    \sa setTabToolTip(), removeTabToolTip()
+*/
+TQString TQTabWidget::tabToolTip( TQWidget * w ) const
+{
+    int index = d->tabs->indexOf( d->stack->id( w ) );
+    if ( index < 0 )
+        return TQString();
+    return d->tabs->toolTip( index );
+}
+
+/*!
+    Removes the tab tool tip for page \a w. If the page does not have
+    a tip, nothing happens.
+
+    \sa setTabToolTip(), tabToolTip()
+*/
+void TQTabWidget::removeTabToolTip( TQWidget * w )
+{
+    int index = d->tabs->indexOf( d->stack->id( w ) );
+    if ( index < 0 )
+        return;
+    d->tabs->removeToolTip( index );
+}
+
+#endif