Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731

1 files changed, 692 insertions, 0 deletions

diff --git a/src/widgets/qtoolbox.cpp b/src/widgets/qtoolbox.cpp
new file mode 100644
index 000000000..86441878d
--- /dev/null
+++ b/src/widgets/qtoolbox.cpp
@@ -0,0 +1,692 @@
+/****************************************************************************
+**
+** Implementation of TQToolBox widget class
+**
+** Created : 961105
+**
+** 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 "qtoolbox.h"
+
+#ifndef QT_NO_TOOLBOX
+
+#include <qbutton.h>
+#include <qlayout.h>
+#include <qscrollview.h>
+#include <qpainter.h>
+#include <qstyle.h>
+#include <qobjectlist.h>
+#include <qapplication.h>
+#include <qwidgetlist.h>
+#include <qlayout.h>
+#include <qvaluelist.h>
+#include <qtooltip.h>
+#include <qeventloop.h>
+#include <qdatetime.h>
+
+class TQToolBoxButton : public TQButton
+{
+public:
+    TQToolBoxButton( TQWidget *parent, const char *name )
+	: TQButton( parent, name ), selected( FALSE )
+    {
+	setBackgroundMode(PaletteBackground);
+	setSizePolicy(TQSizePolicy::Preferred, TQSizePolicy::Minimum);
+	setFocusPolicy(NoFocus);
+    }
+
+    inline void setSelected( bool b ) { selected = b; update(); }
+    inline void setTextLabel( const TQString &text ) { label = text; update(); }
+    inline TQString textLabel() const { return label; }
+    inline void setIconSet( const TQIconSet &is ) { icon = is; update(); }
+    inline TQIconSet iconSet() const { return icon; }
+
+    TQSize sizeHint() const;
+    TQSize minimumSizeHint() const;
+
+protected:
+    void drawButton( TQPainter * );
+
+private:
+    bool selected;
+    TQString label;
+    TQIconSet icon;
+};
+
+class TQToolBoxPrivate
+{
+public:
+    struct Page
+    {
+	TQToolBoxButton *button;
+	TQScrollView *sv;
+	TQWidget *widget;
+	TQString toolTip;
+
+	inline void setTextLabel( const TQString &text ) { button->setTextLabel(text); }
+	inline void setIconSet( const TQIconSet &is ) { button->setIconSet(is); }
+	inline void setToolTip( const TQString &tip )
+	{
+	    toolTip = tip;
+	    TQToolTip::remove( button );
+	    if ( !tip.isNull() )
+		TQToolTip::add( button, tip );
+	}
+
+	inline bool operator==(const Page& other) const
+	{
+	    return widget == other.widget;
+	}
+    };
+    typedef TQValueList<Page> PageList;
+
+    inline TQToolBoxPrivate()
+	: currentPage( 0 )
+    {
+    }
+
+    Page *page( TQWidget *widget );
+    Page *page( int index );
+
+    void updateTabs();
+
+    PageList pageList;
+    TQVBoxLayout *layout;
+    Page *currentPage;
+};
+
+TQToolBoxPrivate::Page *TQToolBoxPrivate::page( TQWidget *widget )
+{
+    if ( !widget )
+	return 0;
+
+    for ( PageList::ConstIterator i = pageList.constBegin(); i != pageList.constEnd(); ++i )
+	if ( (*i).widget == widget )
+	    return (Page*) &(*i);
+    return 0;
+}
+
+TQToolBoxPrivate::Page *TQToolBoxPrivate::page( int index )
+{
+    if (index >= 0 && index < (int)pageList.size() )
+	return &*pageList.at(index);
+    return 0;
+}
+
+void TQToolBoxPrivate::updateTabs()
+{
+    TQToolBoxButton *lastButton = currentPage ? currentPage->button : 0;
+    bool after = FALSE;
+    for ( PageList::ConstIterator i = pageList.constBegin(); i != pageList.constEnd(); ++i ) {
+	if (after) {
+	    (*i).button->setEraseColor((*i).widget->eraseColor());
+	    (*i).button->update();
+	} else if ( (*i).button->backgroundMode() != TQt::PaletteBackground ) {
+	    (*i).button->setBackgroundMode( TQt::PaletteBackground );
+	    (*i).button->update();
+	}
+	after = (*i).button == lastButton;
+    }
+}
+
+TQSize TQToolBoxButton::sizeHint() const
+{
+    TQSize iconSize(8, 8);
+    if ( !icon.isNull() )
+	iconSize += icon.pixmap( TQIconSet::Small, TQIconSet::Normal ).size() + TQSize( 2, 0 );
+    TQSize textSize = fontMetrics().size( TQt::ShowPrefix, label ) + TQSize(0, 8);
+
+    TQSize total(iconSize.width() + textSize.width(), TQMAX(iconSize.height(), textSize.height()));
+    return total.expandedTo(TQApplication::globalStrut());
+}
+
+TQSize TQToolBoxButton::minimumSizeHint() const
+{
+    if ( icon.isNull() )
+	return TQSize();
+    return TQSize(8, 8) + icon.pixmap( TQIconSet::Small, TQIconSet::Normal ).size();
+}
+
+void TQToolBoxButton::drawButton( TQPainter *p )
+{
+    TQStyle::SFlags flags = TQStyle::Style_Default;
+    const TQColorGroup &cg = colorGroup();
+
+    if ( isEnabled() )
+	flags |= TQStyle::Style_Enabled;
+    if ( selected )
+	flags |= TQStyle::Style_Selected;
+    if ( hasFocus() )
+	flags |= TQStyle::Style_HasFocus;
+    if (isDown())
+	flags |= TQStyle::Style_Down;
+    style().drawControl( TQStyle::CE_ToolBoxTab, p, parentWidget(), rect(), cg, flags );
+
+    TQPixmap pm = icon.pixmap( TQIconSet::Small, isEnabled() ? TQIconSet::Normal : TQIconSet::Disabled );
+
+    TQRect cr = style().subRect( TQStyle::SR_ToolBoxTabContents, this );
+    TQRect tr, ir;
+    int ih = 0;
+    if ( pm.isNull() ) {
+	tr = cr;
+	tr.addCoords( 4, 0, -8, 0 );
+    } else {
+	int iw = pm.width() + 4;
+	ih = pm.height();
+	ir = TQRect( cr.left() + 4, cr.top(), iw + 2, ih );
+	tr = TQRect( ir.right(), cr.top(), cr.width() - ir.right() - 4, cr.height() );
+    }
+
+    if ( selected && style().styleHint( TQStyle::SH_ToolBox_SelectedPageTitleBold ) ) {
+	TQFont f( p->font() );
+	f.setBold( TRUE );
+	p->setFont( f );
+    }
+
+    TQString txt;
+    if ( p->fontMetrics().width(label) < tr.width() ) {
+	txt = label;
+    } else {
+	txt = label.left( 1 );
+	int ew = p->fontMetrics().width( "..." );
+	int i = 1;
+	while ( p->fontMetrics().width( txt ) + ew +
+		p->fontMetrics().width( label[i] )  < tr.width() )
+	    txt += label[i++];
+	txt += "...";
+    }
+
+    if ( ih )
+	p->drawPixmap( ir.left(), (height() - ih) / 2, pm );
+
+    TQToolBox *tb = (TQToolBox*)parentWidget();
+
+    const TQColor* fill = 0;
+    if ( selected &&
+	 style().styleHint( TQStyle::SH_ToolBox_SelectedPageTitleBold ) &&
+	 tb->backgroundMode() != NoBackground )
+	fill = &cg.color( TQPalette::foregroundRoleFromMode( tb->backgroundMode() ) );
+
+    int alignment = AlignLeft | AlignVCenter | ShowPrefix;
+    if (!style().styleHint(TQStyle::SH_UnderlineAccelerator, this))
+	alignment |= NoAccel;
+    style().drawItem( p, tr, alignment, cg,
+		      isEnabled(), 0, txt, -1, fill );
+
+    if ( !txt.isEmpty() && hasFocus() )
+	style().drawPrimitive( TQStyle::PE_FocusRect, p, tr, cg );
+}
+
+/*!
+    \class TQToolBox
+
+    \brief The TQToolBox class provides a column of tabbed widget
+    items.
+
+    \mainclass
+    \ingroup advanced
+
+    A toolbox is a widget that displays a column of tabs one above the
+    other, with the current item displayed below the current tab.
+    Every tab has an index position within the column of tabs. A tab's
+    item is a TQWidget.
+
+    Each item has an itemLabel(), an optional icon, itemIconSet(), an
+    optional itemToolTip(), and a \link item() widget\endlink. The
+    item's attributes can be changed with setItemLabel(),
+    setItemIconSet() and setItemToolTip().
+
+    Items are added using addItem(), or inserted at particular
+    positions using insertItem(). The total number of items is given
+    by count(). Items can be deleted with delete, or removed from the
+    toolbox with removeItem(). Combining removeItem() and insertItem()
+    allows to move items to different positions.
+
+    The current item widget is returned by currentItem() and set with
+    setCurrentItem(). If you prefer you can work in terms of indexes
+    using currentIndex(), setCurrentIndex(), indexOf() and item().
+
+    The currentChanged() signal is emitted when the current item is
+    changed.
+
+    \sa TQTabWidget
+*/
+
+/*!
+    \fn void TQToolBox::currentChanged( int index )
+
+    This signal is emitted when the current item changed. The new
+    current item's index is passed in \a index, or -1 if there is no
+    current item.
+*/
+
+/*!
+    Constructs a toolbox called \a name with parent \a parent and flags \a f.
+*/
+
+TQToolBox::TQToolBox( TQWidget *parent, const char *name, WFlags f )
+    :  TQFrame( parent, name, f )
+{
+    d = new TQToolBoxPrivate;
+    d->layout = new TQVBoxLayout( this );
+    TQWidget::setBackgroundMode( PaletteButton );
+}
+
+/*! \reimp */
+
+TQToolBox::~TQToolBox()
+{
+    delete d;
+}
+
+/*!
+    \fn int TQToolBox::addItem( TQWidget *w, const TQString &label )
+    \overload
+
+    Adds the widget \a w in a new tab at bottom of the toolbox. The
+    new tab's label is set to \a label. Returns the new tab's index.
+*/
+
+/*!
+    \fn int TQToolBox::addItem( TQWidget *item, const TQIconSet &iconSet,const TQString &label )
+    Adds the widget \a item in a new tab at bottom of the toolbox. The
+    new tab's label is set to \a label, and the \a iconSet is
+    displayed to the left of the \a label.  Returns the new tab's index.
+*/
+
+/*!
+    \fn int TQToolBox::insertItem( int index, TQWidget *item, const TQString &label )
+    \overload
+
+    Inserts the widget \a item at position \a index, or at the bottom
+    of the toolbox if \a index is out of range. The new item's label is
+    set to \a label. Returns the new item's index.
+*/
+
+/*!
+    Inserts the widget \a item at position \a index, or at the bottom
+    of the toolbox if \a index is out of range. The new item's label
+    is set to \a label, and the \a iconSet is displayed to the left of
+    the \a label. Returns the new item's index.
+*/
+
+int TQToolBox::insertItem( int index, TQWidget *item, const TQIconSet &iconSet,
+			   const TQString &label )
+{
+    if ( !item )
+	return -1;
+
+    connect(item, SIGNAL(destroyed(TQObject*)), this, SLOT(itemDestroyed(TQObject*)));
+
+    TQToolBoxPrivate::Page c;
+    c.widget = item;
+    c.button = new TQToolBoxButton( this, label.latin1() );
+    connect( c.button, SIGNAL( clicked() ), this, SLOT( buttonClicked() ) );
+
+    c.sv = new TQScrollView( this );
+    c.sv->hide();
+    c.sv->setResizePolicy( TQScrollView::AutoOneFit );
+    c.sv->addChild( item );
+    c.sv->setFrameStyle( TQFrame::NoFrame );
+
+    c.setTextLabel( label );
+    c.setIconSet( iconSet );
+
+    if ( index < 0 || index >= (int)d->pageList.count() ) {
+	index = (int)d->pageList.count();
+	d->pageList.append( c );
+	d->layout->addWidget( c.button );
+	d->layout->addWidget( c.sv );
+	if ( index == 0 )
+	    setCurrentIndex( index );
+    } else {
+	d->pageList.insert( d->pageList.at(index), c );
+	relayout();
+	if (d->currentPage) {
+	    TQWidget *current = d->currentPage->widget;
+	    int oldindex = indexOf(current);
+	    if ( index <= oldindex ) {
+		d->currentPage = 0; // trigger change
+		setCurrentIndex(oldindex);
+	    }
+	}
+    }
+
+    c.button->show();
+
+    d->updateTabs();
+    itemInserted(index);
+    return index;
+}
+
+void TQToolBox::buttonClicked()
+{
+    TQToolBoxButton *tb = ::qt_cast<TQToolBoxButton*>(sender());
+    TQWidget* item = 0;
+    for ( TQToolBoxPrivate::PageList::ConstIterator i = d->pageList.constBegin(); i != d->pageList.constEnd(); ++i )
+	if ( (*i).button == tb ) {
+	    item = (*i).widget;
+	    break;
+	}
+
+    setCurrentItem( item );
+}
+
+/*!
+    \property TQToolBox::count
+    \brief The number of items contained in the toolbox.
+*/
+
+int TQToolBox::count() const
+{
+    return (int)d->pageList.count();
+}
+
+void TQToolBox::setCurrentIndex( int index )
+{
+    setCurrentItem( item( index ) );
+}
+
+/*!
+    Sets the current item to be \a item.
+*/
+
+void TQToolBox::setCurrentItem( TQWidget *item )
+{
+    TQToolBoxPrivate::Page *c = d->page( item );
+    if ( !c || d->currentPage == c )
+	return;
+
+    c->button->setSelected( TRUE );
+    if ( d->currentPage ) {
+	d->currentPage->sv->hide();
+	d->currentPage->button->setSelected(FALSE);
+    }
+    d->currentPage = c;
+    d->currentPage->sv->show();
+    d->updateTabs();
+    emit currentChanged( indexOf(item) );
+}
+
+void TQToolBox::relayout()
+{
+    delete d->layout;
+    d->layout = new TQVBoxLayout( this );
+    for ( TQToolBoxPrivate::PageList::ConstIterator i = d->pageList.constBegin(); i != d->pageList.constEnd(); ++i ) {
+	d->layout->addWidget( (*i).button );
+	d->layout->addWidget( (*i).sv );
+    }
+}
+
+void TQToolBox::itemDestroyed(TQObject *object)
+{
+    // no verification - vtbl corrupted already
+    TQWidget *page = (TQWidget*)object;
+
+    TQToolBoxPrivate::Page *c = d->page(page);
+    if ( !page || !c )
+	return;
+
+    d->layout->remove( c->sv );
+    d->layout->remove( c->button );
+    c->sv->deleteLater(); // page might still be a child of sv
+    delete c->button;
+
+    bool removeCurrent = c == d->currentPage;
+    d->pageList.remove( *c );
+
+    if ( !d->pageList.count() ) {
+	d->currentPage = 0;
+	emit currentChanged(-1);
+    } else if ( removeCurrent ) {
+	d->currentPage = 0;
+	setCurrentIndex(0);
+    }
+}
+
+/*!
+    Removes the widget \a item from the toolbox. Note that the widget
+    is \e not deleted. Returns the removed widget's index, or -1 if
+    the widget was not in this tool box.
+*/
+
+int TQToolBox::removeItem( TQWidget *item )
+{
+    int index = indexOf(item);
+    if (index >= 0) {
+	disconnect(item, SIGNAL(destroyed(TQObject*)), this, SLOT(itemDestroyed(TQObject*)));
+	item->reparent( this, TQPoint(0,0) );
+	// destroy internal data
+	itemDestroyed(item);
+    }
+    itemRemoved(index);
+    return index;
+}
+
+
+/*!
+    Returns the toolbox's current item, or 0 if the toolbox is empty.
+*/
+
+TQWidget *TQToolBox::currentItem() const
+{
+    return d->currentPage ? d->currentPage->widget : 0;
+}
+
+/*!
+    \property TQToolBox::currentIndex
+    \brief the index of the current item, or -1 if the toolbox is empty.
+    \sa currentItem(), indexOf(), item()
+*/
+
+
+int TQToolBox::currentIndex() const
+{
+    return d->currentPage ? indexOf( d->currentPage->widget ) : -1;
+}
+
+/*!
+    Returns the item at position \a index, or 0 if there is no such
+    item.
+*/
+
+TQWidget *TQToolBox::item( int index ) const
+{
+    if ( index < 0 || index >= (int) d->pageList.size() )
+	return 0;
+    return (*d->pageList.at( index )).widget;
+}
+
+/*!
+    Returns the index of item \a item, or -1 if the item does not
+    exist.
+*/
+
+int TQToolBox::indexOf( TQWidget *item ) const
+{
+    TQToolBoxPrivate::Page *c = d->page(item);
+    return c ? d->pageList.findIndex( *c ) : -1;
+}
+
+/*!
+    If \a enabled is TRUE then the item at position \a index is enabled; otherwise item
+    \a index is disabled.
+*/
+
+void TQToolBox::setItemEnabled( int index, bool enabled )
+{
+    TQToolBoxPrivate::Page *c = d->page( index );
+    if ( !c )
+	return;
+
+    c->button->setEnabled( enabled );
+    if ( !enabled && c == d->currentPage ) {
+	int curIndexUp = index;
+	int curIndexDown = curIndexUp;
+	const int count = (int)d->pageList.count();
+	while ( curIndexUp > 0 || curIndexDown < count-1 ) {
+	    if ( curIndexDown < count-1 ) {
+		if (d->page(++curIndexDown)->button->isEnabled()) {
+		    index = curIndexDown;
+		    break;
+		}
+	    }
+	    if ( curIndexUp > 0 ) {
+		if (d->page(--curIndexUp)->button->isEnabled()) {
+		    index = curIndexUp;
+		    break;
+		}
+	    }
+	}
+	setCurrentIndex(index);
+    }
+}
+
+
+/*!
+    Sets the label of the item at position \a index to \a label.
+*/
+
+void TQToolBox::setItemLabel( int index, const TQString &label )
+{
+    TQToolBoxPrivate::Page *c = d->page( index );
+    if ( c )
+	c->setTextLabel( label );
+}
+
+/*!
+    Sets the icon of the item at position \a index to \a iconSet.
+*/
+
+void TQToolBox::setItemIconSet( int index, const TQIconSet &iconSet )
+{
+    TQToolBoxPrivate::Page *c = d->page( index );
+    if ( c )
+	c->setIconSet( iconSet );
+}
+
+/*!
+    Sets the tooltip of the item at position \a index to \a toolTip.
+*/
+
+void TQToolBox::setItemToolTip( int index, const TQString &toolTip )
+{
+    TQToolBoxPrivate::Page *c = d->page( index );
+    if ( c )
+	c->setToolTip( toolTip );
+}
+
+/*!
+    Returns TRUE if the item at position \a index is enabled; otherwise returns FALSE.
+*/
+
+bool TQToolBox::isItemEnabled( int index ) const
+{
+    TQToolBoxPrivate::Page *c = d->page( index );
+    return c && c->button->isEnabled();
+}
+
+/*!
+    Returns the label of the item at position \a index, or a null string if
+    \a index is out of range.
+*/
+
+TQString TQToolBox::itemLabel( int index ) const
+{
+    TQToolBoxPrivate::Page *c = d->page( index );
+    return ( c ? c->button->textLabel() : TQString::null );
+}
+
+/*!
+    Returns the icon of the item at position \a index, or a null
+    icon if \a index is out of range.
+*/
+
+TQIconSet TQToolBox::itemIconSet( int index ) const
+{
+    TQToolBoxPrivate::Page *c = d->page( index );
+    return ( c ? c->button->iconSet() : TQIconSet() );
+}
+
+/*!
+    Returns the tooltip of the item at position \a index, or a null
+    string if \a index is out of range.
+*/
+
+TQString TQToolBox::itemToolTip( int index ) const
+{
+    TQToolBoxPrivate::Page *c = d->page( index );
+    return ( c ? c->toolTip : TQString::null );
+}
+
+/*! \reimp */
+void TQToolBox::showEvent( TQShowEvent *e )
+{
+    TQWidget::showEvent( e );
+}
+
+/*! \reimp */
+void TQToolBox::frameChanged()
+{
+    d->layout->setMargin( frameWidth() );
+    TQFrame::frameChanged();
+}
+
+/*! \reimp */
+void TQToolBox::styleChange(TQStyle &style)
+{
+    d->updateTabs();
+    TQFrame::styleChange(style);
+}
+
+/*!
+  This virtual handler is called after a new item was added or
+  inserted at position \a index.
+ */
+void TQToolBox::itemInserted( int index )
+{
+    Q_UNUSED(index)
+}
+
+/*!
+  This virtual handler is called after an item was removed from
+  position \a index.
+ */
+void TQToolBox::itemRemoved( int index )
+{
+    Q_UNUSED(index)
+}
+
+#endif //QT_NO_TOOLBOX