Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731

1 files changed, 1041 insertions, 0 deletions

diff --git a/src/widgets/qtoolbutton.cpp b/src/widgets/qtoolbutton.cpp
new file mode 100644
index 000000000..ac14adc1d
--- /dev/null
+++ b/src/widgets/qtoolbutton.cpp
@@ -0,0 +1,1041 @@
+/****************************************************************************
+**
+** Implementation of TQToolButton class
+**
+** Created : 980320
+**
+** 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 [email protected].
+**
+** 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.
+**
+**********************************************************************/
+
+#undef QT_NO_COMPAT
+#include "qtoolbutton.h"
+#ifndef QT_NO_TOOLBUTTON
+
+#include "qdrawutil.h"
+#include "qpainter.h"
+#include "qpixmap.h"
+#include "qwmatrix.h"
+#include "qapplication.h"
+#include "qstyle.h"
+#include "qmainwindow.h"
+#include "qtooltip.h"
+#include "qtoolbar.h"
+#include "qimage.h"
+#include "qiconset.h"
+#include "qtimer.h"
+#include "qpopupmenu.h"
+#include "qguardedptr.h"
+
+class TQToolButtonPrivate
+{
+    // ### add tool tip magic here
+public:
+#ifndef QT_NO_POPUPMENU
+    TQGuardedPtr<TQPopupMenu> popup;
+    TQTimer* popupTimer;
+    int delay;
+#endif
+    TQt::ArrowType arrow;
+    uint instantPopup	    : 1;
+    uint autoraise	    : 1;
+    uint repeat		    : 1;
+    uint discardNextMouseEvent : 1;
+    TQToolButton::TextPosition textPos;
+};
+
+
+/*!
+    \class TQToolButton qtoolbutton.h
+    \brief The TQToolButton class provides a tquick-access button to
+    commands or options, usually used inside a TQToolBar.
+
+    \ingroup basic
+    \mainclass
+
+    A tool button is a special button that provides tquick-access to
+    specific commands or options. As opposed to a normal command
+    button, a tool button usually doesn't show a text label, but shows
+    an icon instead. Its classic usage is to select tools, for example
+    the "pen" tool in a drawing program. This would be implemented
+    with a TQToolButton as toggle button (see setToggleButton() ).
+
+    TQToolButton supports auto-raising. In auto-raise mode, the button
+    draws a 3D frame only when the mouse points at it. The feature is
+    automatically turned on when a button is used inside a TQToolBar.
+    Change it with setAutoRaise().
+
+    A tool button's icon is set as TQIconSet. This makes it possible to
+    specify different pixmaps for the disabled and active state. The
+    disabled pixmap is used when the button's functionality is not
+    available. The active pixmap is displayed when the button is
+    auto-raised because the mouse pointer is hovering over it.
+
+    The button's look and dimension is adjustable with
+    setUsesBigPixmap() and setUsesTextLabel(). When used inside a
+    TQToolBar in a TQMainWindow, the button automatically adjusts to
+    TQMainWindow's settings (see TQMainWindow::setUsesTextLabel() and
+    TQMainWindow::setUsesBigPixmaps()). The pixmap set on a TQToolButton
+    will be set to 22x22 if it is bigger than this size. If
+    usesBigPixmap() is TRUE, then the pixmap will be set to 32x32.
+
+    A tool button can offer additional choices in a popup menu. The
+    feature is sometimes used with the "Back" button in a web browser.
+    After pressing and holding the button down for a while, a menu
+    pops up showing a list of possible pages to jump to. With
+    TQToolButton you can set a popup menu using setPopup(). The default
+    delay is 600ms; you can adjust it with setPopupDelay().
+
+    \img qdockwindow.png Toolbar with Toolbuttons \caption A floating
+    TQToolbar with TQToolbuttons
+
+    \sa TQPushButton TQToolBar TQMainWindow \link guibooks.html#fowler
+    GUI Design Handbook: Push Button\endlink
+*/
+
+/*!
+    \enum TQToolButton::TextPosition
+
+    The position of the tool button's textLabel in relation to the
+    tool button's icon.
+
+    \value BesideIcon The text appears beside the icon.
+    \value BelowIcon The text appears below the icon.
+*/
+
+
+/*!
+    Constructs an empty tool button called \a name, with parent \a
+    parent.
+*/
+
+TQToolButton::TQToolButton( TQWidget * parent, const char *name )
+    : TQButton( parent, name )
+{
+    init();
+#ifndef QT_NO_TOOLBAR
+    TQToolBar* tb = ::qt_cast<TQToolBar*>(parent);
+    if ( tb ) {
+	setAutoRaise( TRUE );
+	if ( tb->mainWindow() ) {
+	    connect( tb->mainWindow(), SIGNAL(pixmapSizeChanged(bool)),
+	             this, SLOT(setUsesBigPixmap(bool)) );
+	    setUsesBigPixmap( tb->mainWindow()->usesBigPixmaps() );
+	    connect( tb->mainWindow(), SIGNAL(usesTextLabelChanged(bool)),
+	             this, SLOT(setUsesTextLabel(bool)) );
+	    setUsesTextLabel( tb->mainWindow()->usesTextLabel() );
+	} else {
+	    setUsesBigPixmap( FALSE );
+	}
+    } else
+#endif
+    {
+	setUsesBigPixmap( FALSE );
+    }
+}
+
+
+/*!
+    Constructs a tool button as an arrow button. The \c ArrowType \a
+    type defines the arrow direction. Possible values are \c
+    LeftArrow, \c RightArrow, \c UpArrow and \c DownArrow.
+
+    An arrow button has auto-repeat turned on by default.
+
+    The \a parent and \a name arguments are sent to the TQWidget
+    constructor.
+*/
+TQToolButton::TQToolButton( ArrowType type, TQWidget *parent, const char *name )
+    : TQButton( parent, name )
+{
+    init();
+    setUsesBigPixmap( FALSE );
+    setAutoRepeat( TRUE );
+    d->arrow = type;
+    hasArrow = TRUE;
+}
+
+
+/*  Set-up code common to all the constructors */
+
+void TQToolButton::init()
+{
+    d = new TQToolButtonPrivate;
+    d->textPos = Under;
+#ifndef QT_NO_POPUPMENU
+    d->delay = 600;
+    d->popup = 0;
+    d->popupTimer = 0;
+#endif
+    d->autoraise = FALSE;
+    d->arrow = LeftArrow;
+    d->instantPopup = FALSE;
+    d->discardNextMouseEvent = FALSE;
+    bpID = bp.serialNumber();
+    spID = sp.serialNumber();
+
+    utl = FALSE;
+    ubp = TRUE;
+    hasArrow = FALSE;
+
+    s = 0;
+
+    setFocusPolicy( NoFocus );
+    setBackgroundMode( PaletteButton);
+    setSizePolicy( TQSizePolicy( TQSizePolicy::Minimum, TQSizePolicy::Minimum ) );
+}
+
+#ifndef QT_NO_TOOLBAR
+
+/*!
+    Constructs a tool button called \a name, that is a child of \a
+    parent (which must be a TQToolBar).
+
+    The tool button will display \a iconSet, with its text label and
+    tool tip set to \a textLabel and its status bar message set to \a
+    grouptext. It will be connected to the \a slot in object \a
+    receiver.
+*/
+
+TQToolButton::TQToolButton( const TQIconSet& iconSet, const TQString &textLabel,
+			  const TQString& grouptext,
+			  TQObject * receiver, const char *slot,
+			  TQToolBar * parent, const char *name )
+    : TQButton( parent, name )
+{
+    init();
+    setAutoRaise( TRUE );
+    setIconSet( iconSet );
+    setTextLabel( textLabel );
+    if ( receiver && slot )
+	connect( this, SIGNAL(clicked()), receiver, slot );
+    if ( parent->mainWindow() ) {
+	connect( parent->mainWindow(), SIGNAL(pixmapSizeChanged(bool)),
+		 this, SLOT(setUsesBigPixmap(bool)) );
+	setUsesBigPixmap( parent->mainWindow()->usesBigPixmaps() );
+	connect( parent->mainWindow(), SIGNAL(usesTextLabelChanged(bool)),
+		 this, SLOT(setUsesTextLabel(bool)) );
+	setUsesTextLabel( parent->mainWindow()->usesTextLabel() );
+    } else {
+	setUsesBigPixmap( FALSE );
+    }
+#ifndef QT_NO_TOOLTIP
+    if ( !textLabel.isEmpty() ) {
+	if ( !grouptext.isEmpty() && parent->mainWindow() )
+	    TQToolTip::add( this, textLabel,
+			   parent->mainWindow()->toolTipGroup(), grouptext );
+	else
+	    TQToolTip::add( this, textLabel );
+    } else if ( !grouptext.isEmpty() && parent->mainWindow() )
+	TQToolTip::add( this, TQString::null,
+		parent->mainWindow()->toolTipGroup(), grouptext );
+#endif
+}
+
+#endif
+
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+TQToolButton::~TQToolButton()
+{
+#ifndef QT_NO_POPUPMENU
+    d->popupTimer = 0;
+    d->popup = 0;
+#endif
+    delete d;
+    delete s;
+}
+
+
+/*!
+    \property TQToolButton::backgroundMode
+    \brief the toolbutton's background mode
+
+    Get this property with backgroundMode().
+
+    \sa TQWidget::setBackgroundMode()
+*/
+
+/*!
+    \property TQToolButton::toggleButton
+    \brief whether this tool button is a toggle button.
+
+    Toggle buttons have an on/off state similar to \link TQCheckBox
+    check boxes. \endlink A tool button is not a toggle button by
+    default.
+
+    \sa setOn(), toggle()
+*/
+
+void TQToolButton::setToggleButton( bool enable )
+{
+    TQButton::setToggleButton( enable );
+}
+
+
+/*!
+    \reimp
+*/
+TQSize TQToolButton::sizeHint() const
+{
+    constPolish();
+
+    int w = 0, h = 0;
+
+    if ( iconSet().isNull() && !text().isNull() && !usesTextLabel() ) {
+     	w = fontMetrics().width( text() );
+     	h = fontMetrics().height(); // boundingRect()?
+    } else if ( usesBigPixmap() ) {
+     	TQPixmap pm = iconSet().pixmap( TQIconSet::Large, TQIconSet::Normal );
+     	w = pm.width();
+     	h = pm.height();
+	TQSize iconSize = TQIconSet::iconSize( TQIconSet::Large );
+	if ( w < iconSize.width() )
+     	    w = iconSize.width();
+     	if ( h < iconSize.height() )
+     	    h = iconSize.height();
+    } else if ( !iconSet().isNull() ) {
+	// ### in 3.1, use TQIconSet::iconSize( TQIconSet::Small );
+     	TQPixmap pm = iconSet().pixmap( TQIconSet::Small, TQIconSet::Normal );
+     	w = pm.width();
+     	h = pm.height();
+	if ( w < 16 )
+	    w = 16;
+	if ( h < 16 )
+	    h = 16;
+    }
+
+    if ( usesTextLabel() ) {
+	TQSize textSize = fontMetrics().size( TQt::ShowPrefix, textLabel() );
+	textSize.setWidth( textSize.width() + fontMetrics().width(' ')*2 );
+	if ( d->textPos == Under ) {
+	    h += 4 + textSize.height();
+	    if ( textSize.width() > w )
+		w = textSize.width();
+	} else { // Right
+	    w += 4 + textSize.width();
+	    if ( textSize.height() > h )
+		h = textSize.height();
+	}
+    }
+
+#ifndef QT_NO_POPUPMENU
+    if ( popup() && ! popupDelay() )
+     	w += style().pixelMetric(TQStyle::PM_MenuButtonIndicator, this);
+#endif
+    return (style().sizeFromContents(TQStyle::CT_ToolButton, this, TQSize(w, h)).
+	    expandedTo(TQApplication::globalStrut()));
+}
+
+/*!
+    \reimp
+ */
+TQSize TQToolButton::minimumSizeHint() const
+{
+    return sizeHint();
+}
+
+/*!
+    \property TQToolButton::usesBigPixmap
+    \brief whether this toolbutton uses big pixmaps.
+
+    TQToolButton automatically connects this property to the relevant
+    signal in the TQMainWindow in which it resides. We strongly
+    recommend that you use TQMainWindow::setUsesBigPixmaps() instead.
+
+    This property's default is TRUE.
+
+    \warning If you set some buttons (in a TQMainWindow) to have big
+    pixmaps and others to have small pixmaps, TQMainWindow may not get
+    the geometry right.
+*/
+
+void TQToolButton::setUsesBigPixmap( bool enable )
+{
+    if ( (bool)ubp == enable )
+	return;
+
+    ubp = enable;
+    if ( isVisible() ) {
+	update();
+	updateGeometry();
+    }
+}
+
+
+/*!
+    \property TQToolButton::usesTextLabel
+    \brief whether the toolbutton displays a text label below the button pixmap.
+
+    The default is FALSE.
+
+    TQToolButton automatically connects this slot to the relevant
+    signal in the TQMainWindow in which is resides.
+*/
+
+void TQToolButton::setUsesTextLabel( bool enable )
+{
+    if ( (bool)utl == enable )
+	return;
+
+    utl = enable;
+    if ( isVisible() ) {
+	update();
+	updateGeometry();
+    }
+}
+
+
+/*!
+    \property TQToolButton::on
+    \brief whether this tool button is on.
+
+    This property has no effect on \link isToggleButton() non-toggling
+    buttons. \endlink The default is FALSE (i.e. off).
+
+    \sa isToggleButton() toggle()
+*/
+
+void TQToolButton::setOn( bool enable )
+{
+    if ( !isToggleButton() )
+	return;
+    TQButton::setOn( enable );
+}
+
+
+/*!
+    Toggles the state of this tool button.
+
+    This function has no effect on \link isToggleButton() non-toggling
+    buttons. \endlink
+
+    \sa isToggleButton() toggled()
+*/
+
+void TQToolButton::toggle()
+{
+    if ( !isToggleButton() )
+	return;
+    TQButton::setOn( !isOn() );
+}
+
+
+/*!
+    \reimp
+*/
+void TQToolButton::drawButton( TQPainter * p )
+{
+    TQStyle::SCFlags controls = TQStyle::SC_ToolButton;
+    TQStyle::SCFlags active = TQStyle::SC_None;
+
+    TQt::ArrowType arrowtype = d->arrow;
+
+    if (isDown())
+	active |= TQStyle::SC_ToolButton;
+
+#ifndef QT_NO_POPUPMENU
+    if (d->popup && !d->delay) {
+	controls |= TQStyle::SC_ToolButtonMenu;
+	if (d->instantPopup || isDown())
+	    active |= TQStyle::SC_ToolButtonMenu;
+    }
+#endif
+
+    TQStyle::SFlags flags = TQStyle::Style_Default;
+    if (isEnabled())
+	flags |= TQStyle::Style_Enabled;
+    if (hasFocus())
+	flags |= TQStyle::Style_HasFocus;
+    if (isDown())
+	flags |= TQStyle::Style_Down;
+    if (isOn())
+	flags |= TQStyle::Style_On;
+    if (autoRaise()) {
+	flags |= TQStyle::Style_AutoRaise;
+	if (uses3D()) {
+	    flags |= TQStyle::Style_MouseOver;
+	    if (! isOn() && ! isDown())
+		flags |= TQStyle::Style_Raised;
+	}
+    } else if (! isOn() && ! isDown())
+	flags |= TQStyle::Style_Raised;
+
+    style().drawComplexControl(TQStyle::CC_ToolButton, p, this, rect(), colorGroup(),
+			       flags, controls, active,
+				hasArrow ? TQStyleOption(arrowtype) :
+				    TQStyleOption());
+    drawButtonLabel(p);
+}
+
+
+/*!
+    \reimp
+*/
+void TQToolButton::drawButtonLabel(TQPainter *p)
+{
+    TQRect r =
+	TQStyle::visualRect(style().subRect(TQStyle::SR_ToolButtonContents, this), this);
+
+    TQt::ArrowType arrowtype = d->arrow;
+
+    TQStyle::SFlags flags = TQStyle::Style_Default;
+    if (isEnabled())
+	flags |= TQStyle::Style_Enabled;
+    if (hasFocus())
+	flags |= TQStyle::Style_HasFocus;
+    if (isDown())
+	flags |= TQStyle::Style_Down;
+    if (isOn())
+	flags |= TQStyle::Style_On;
+    if (autoRaise()) {
+	flags |= TQStyle::Style_AutoRaise;
+	if (uses3D()) {
+	    flags |= TQStyle::Style_MouseOver;
+	    if (! isOn() && ! isDown())
+		flags |= TQStyle::Style_Raised;
+	}
+    } else if (! isOn() && ! isDown())
+	flags |= TQStyle::Style_Raised;
+
+    style().drawControl(TQStyle::CE_ToolButtonLabel, p, this, r,
+			colorGroup(), flags,
+			hasArrow ? TQStyleOption(arrowtype) :
+			    TQStyleOption());
+}
+
+
+/*!
+    \reimp
+ */
+void TQToolButton::enterEvent( TQEvent * e )
+{
+    if ( autoRaise() && isEnabled() )
+	repaint(FALSE);
+
+    TQButton::enterEvent( e );
+}
+
+
+/*!
+    \reimp
+ */
+void TQToolButton::leaveEvent( TQEvent * e )
+{
+    if ( autoRaise() && isEnabled() )
+	repaint(FALSE);
+
+    TQButton::leaveEvent( e );
+}
+
+/*!
+    \reimp
+ */
+void TQToolButton::moveEvent( TQMoveEvent * )
+{
+    //   Reimplemented to handle pseudo transparency in case the toolbars
+    //   has a fancy pixmap background.
+    if ( parentWidget() && parentWidget()->backgroundPixmap() &&
+	 autoRaise() && !uses3D() )
+	repaint( FALSE );
+}
+
+/*!
+    \reimp
+*/
+void TQToolButton::mousePressEvent( TQMouseEvent *e )
+{
+    TQRect popupr =
+	TQStyle::visualRect( style().querySubControlMetrics(TQStyle::CC_ToolButton, this,
+				       TQStyle::SC_ToolButtonMenu), this );
+    d->instantPopup = (popupr.isValid() && popupr.contains(e->pos()));
+
+#ifndef QT_NO_POPUPMENU
+    if ( d->discardNextMouseEvent ) {
+	d->discardNextMouseEvent = FALSE;
+	d->instantPopup = FALSE;
+	d->popup->removeEventFilter( this );
+	return;
+    }
+    if ( e->button() == LeftButton && d->delay <= 0 && d->popup && d->instantPopup && !d->popup->isVisible() ) {
+	openPopup();
+	return;
+    }
+#endif
+
+    d->instantPopup = FALSE;
+    TQButton::mousePressEvent( e );
+}
+
+/*!
+    \reimp
+*/
+bool TQToolButton::eventFilter( TQObject *o, TQEvent *e )
+{
+#ifndef QT_NO_POPUPMENU
+    if ( o != d->popup )
+	return TQButton::eventFilter( o, e );
+    switch ( e->type() ) {
+    case TQEvent::MouseButtonPress:
+    case TQEvent::MouseButtonDblClick:
+	{
+	    TQMouseEvent *me = (TQMouseEvent*)e;
+	    TQPoint p = me->globalPos();
+	    if ( TQApplication::widgetAt( p, TRUE ) == this )
+		d->discardNextMouseEvent = TRUE;
+	}
+	break;
+    default:
+	break;
+    }
+#endif
+    return TQButton::eventFilter( o, e );
+}
+
+/*!
+    Returns TRUE if this button should be drawn using raised edges;
+    otherwise returns FALSE.
+
+    \sa drawButton()
+*/
+
+bool TQToolButton::uses3D() const
+{
+    return style().styleHint(TQStyle::SH_ToolButton_Uses3D)
+	&& (!autoRaise() || ( hasMouse() && isEnabled() )
+#ifndef QT_NO_POPUPMENU
+	    || ( d->popup && d->popup->isVisible() && d->delay <= 0 ) || d->instantPopup
+#endif
+	    );
+}
+
+
+/*!
+    \property TQToolButton::textLabel
+    \brief the label of this button.
+
+    Setting this property automatically sets the text as a tool tip
+    too. There is no default text.
+*/
+
+void TQToolButton::setTextLabel( const TQString &newLabel )
+{
+    setTextLabel( newLabel, TRUE );
+}
+
+/*!
+    \overload
+
+    Sets the label of this button to \a newLabel and automatically
+    sets it as a tool tip if \a tipToo is TRUE.
+*/
+
+void TQToolButton::setTextLabel( const TQString &newLabel , bool tipToo )
+{
+    if ( tl == newLabel )
+	return;
+
+#ifndef QT_NO_TOOLTIP
+    if ( tipToo ) {
+        TQToolTip::remove( this );
+        TQToolTip::add( this, newLabel );
+    }
+#endif
+
+    tl = newLabel;
+    if ( usesTextLabel() && isVisible() ) {
+	update();
+	updateGeometry();
+    }
+
+}
+
+#ifndef QT_NO_COMPAT
+
+TQIconSet TQToolButton::onIconSet() const
+{
+    return iconSet();
+}
+
+TQIconSet TQToolButton::offIconSet( ) const
+{
+    return iconSet();
+}
+
+
+/*!
+  \property TQToolButton::onIconSet
+  \brief the icon set that is used when the button is in an "on" state
+
+  \obsolete
+
+  Since TQt 3.0, TQIconSet contains both the On and Off icons. There is
+  now an \l TQToolButton::iconSet property that replaces both \l
+  TQToolButton::onIconSet and \l TQToolButton::offIconSet.
+
+  For ease of porting, this property is a synonym for \l
+  TQToolButton::iconSet. You probably want to go over your application
+  code and use the TQIconSet On/Off mechanism.
+
+  \sa iconSet TQIconSet::State
+*/
+void TQToolButton::setOnIconSet( const TQIconSet& set )
+{
+    setIconSet( set );
+    /*
+      ### Get rid of all qWarning in this file in 4.0.
+      Also consider inlining the obsolete functions then.
+    */
+    qWarning( "TQToolButton::setOnIconSet(): This function is not supported"
+	      " anymore" );
+}
+
+/*!
+  \property TQToolButton::offIconSet
+  \brief the icon set that is used when the button is in an "off" state
+
+  \obsolete
+
+  Since TQt 3.0, TQIconSet contains both the On and Off icons. There is
+  now an \l TQToolButton::iconSet property that replaces both \l
+  TQToolButton::onIconSet and \l TQToolButton::offIconSet.
+
+  For ease of porting, this property is a synonym for \l
+  TQToolButton::iconSet. You probably want to go over your application
+  code and use the TQIconSet On/Off mechanism.
+
+  \sa iconSet TQIconSet::State
+*/
+void TQToolButton::setOffIconSet( const TQIconSet& set )
+{
+    setIconSet( set );
+}
+
+#endif
+
+/*! \property TQToolButton::pixmap
+    \brief the pixmap of the button
+
+    The pixmap property has no meaning for tool buttons. Use the
+    iconSet property instead.
+*/
+
+/*!
+    \property TQToolButton::iconSet
+    \brief the icon set providing the icon shown on the button
+
+    Setting this property sets \l TQToolButton::pixmap to a null
+    pixmap. There is no default iconset.
+
+    \sa pixmap(), setToggleButton(), isOn()
+*/
+void TQToolButton::setIconSet( const TQIconSet & set )
+{
+    if ( s )
+	delete s;
+    setPixmap( TQPixmap() );
+    s = new TQIconSet( set );
+    if ( isVisible() )
+	update();
+}
+
+/*! \overload
+    \obsolete
+
+  Since TQt 3.0, TQIconSet contains both the On and Off icons.
+
+  For ease of porting, this function ignores the \a on parameter and
+  sets the \l iconSet property. If you relied on the \a on parameter,
+  you probably want to update your code to use the TQIconSet On/Off
+  mechanism.
+
+  \sa iconSet TQIconSet::State
+*/
+
+#ifndef QT_NO_COMPAT
+
+void TQToolButton::setIconSet( const TQIconSet & set, bool /* on */ )
+{
+    setIconSet( set );
+    qWarning( "TQToolButton::setIconSet(): 'on' parameter ignored" );
+}
+
+#endif
+
+TQIconSet TQToolButton::iconSet() const
+{
+    TQToolButton *that = (TQToolButton *) this;
+
+    if ( pixmap() && !pixmap()->isNull() &&
+	 (!that->s || (that->s->pixmap().serialNumber() !=
+	 pixmap()->serialNumber())) ) {
+	if ( that->s )
+	    delete that->s;
+	that->s = new TQIconSet( *pixmap() );
+    }
+    if ( that->s )
+	return *that->s;
+    /*
+      In 2.x, we used to return a temporary nonnull TQIconSet. If you
+      revert to the old behavior, you will break calls to
+      TQIconSet::isNull() in this file.
+    */
+    return TQIconSet();
+}
+
+#ifndef QT_NO_COMPAT
+/*! \overload
+    \obsolete
+
+  Since TQt 3.0, TQIconSet contains both the On and Off icons.
+
+  For ease of porting, this function ignores the \a on parameter and
+  returns the \l iconSet property. If you relied on the \a on
+  parameter, you probably want to update your code to use the TQIconSet
+  On/Off mechanism.
+*/
+TQIconSet TQToolButton::iconSet( bool /* on */ ) const
+{
+    return iconSet();
+}
+
+#endif
+
+#ifndef QT_NO_POPUPMENU
+/*!
+    Associates the popup menu \a popup with this tool button.
+
+    The popup will be shown each time the tool button has been pressed
+    down for a certain amount of time. A typical application example
+    is the "back" button in some web browsers's tool bars. If the user
+    clicks it, the browser simply browses back to the previous page.
+    If the user presses and holds the button down for a while, the
+    tool button shows a menu containing the current history list.
+
+    Ownership of the popup menu is not transferred to the tool button.
+
+    \sa popup()
+*/
+void TQToolButton::setPopup( TQPopupMenu* popup )
+{
+    if ( popup && !d->popupTimer ) {
+	connect( this, SIGNAL( pressed() ), this, SLOT( popupPressed() ) );
+	d->popupTimer = new TQTimer( this );
+	connect( d->popupTimer, SIGNAL( timeout() ), this, SLOT( popupTimerDone() ) );
+    }
+    d->popup = popup;
+
+    update();
+}
+
+/*!
+    Returns the associated popup menu, or 0 if no popup menu has been
+    defined.
+
+    \sa setPopup()
+*/
+TQPopupMenu* TQToolButton::popup() const
+{
+    return d->popup;
+}
+
+/*!
+    Opens (pops up) the associated popup menu. If there is no such
+    menu, this function does nothing. This function does not return
+    until the popup menu has been closed by the user.
+*/
+void TQToolButton::openPopup()
+{
+    if ( !d->popup )
+	return;
+
+    d->instantPopup = TRUE;
+    repaint( FALSE );
+    if ( d->popupTimer )
+	d->popupTimer->stop();
+    TQGuardedPtr<TQToolButton> that = this;
+    popupTimerDone();
+    if ( !that )
+	return;
+    d->instantPopup = FALSE;
+    repaint( FALSE );
+}
+
+void TQToolButton::popupPressed()
+{
+    if ( d->popupTimer && d->delay > 0 )
+	d->popupTimer->start( d->delay, TRUE );
+}
+
+void TQToolButton::popupTimerDone()
+{
+    if ( (!isDown() && d->delay > 0 ) || !d->popup )
+	return;
+
+    d->popup->installEventFilter( this );
+    d->repeat = autoRepeat();
+    setAutoRepeat( FALSE );
+    bool horizontal = TRUE;
+#ifndef QT_NO_TOOLBAR
+    TQToolBar *tb = ::qt_cast<TQToolBar*>(parentWidget());
+    if ( tb && tb->orientation() == Vertical )
+	horizontal = FALSE;
+#endif
+    TQPoint p;
+    TQRect screen = qApp->desktop()->availableGeometry( this );
+    if ( horizontal ) {
+	if ( TQApplication::reverseLayout() ) {
+	    if ( mapToGlobal( TQPoint( 0, rect().bottom() ) ).y() + d->popup->sizeHint().height() <= screen.height() ) {
+		p = mapToGlobal( rect().bottomRight() );
+	    } else {
+		p = mapToGlobal( rect().topRight() - TQPoint( 0, d->popup->sizeHint().height() ) );
+	    }
+	    p.rx() -= d->popup->sizeHint().width();
+	} else {
+	    if ( mapToGlobal( TQPoint( 0, rect().bottom() ) ).y() + d->popup->sizeHint().height() <= screen.height() ) {
+		p = mapToGlobal( rect().bottomLeft() );
+	    } else {
+		p = mapToGlobal( rect().topLeft() - TQPoint( 0, d->popup->sizeHint().height() ) );
+	    }
+	}
+    } else {
+	if ( TQApplication::reverseLayout() ) {
+	    if ( mapToGlobal( TQPoint( rect().left(), 0 ) ).x() - d->popup->sizeHint().width() <= screen.x() ) {
+		p = mapToGlobal( rect().topRight() );
+	    } else {
+		p = mapToGlobal( rect().topLeft() );
+		p.rx() -= d->popup->sizeHint().width();
+	    }
+	} else {
+	    if ( mapToGlobal( TQPoint( rect().right(), 0 ) ).x() + d->popup->sizeHint().width() <= screen.width() ) {
+		p = mapToGlobal( rect().topRight() );
+	    } else {
+		p = mapToGlobal( rect().topLeft() - TQPoint( d->popup->sizeHint().width(), 0 ) );
+	    }
+	}
+    }
+    TQGuardedPtr<TQToolButton> that = this;
+    d->popup->exec( p, -1 );
+    if ( !that )
+	return;
+
+    setDown( FALSE );
+    if ( d->repeat )
+	setAutoRepeat( TRUE );
+}
+
+/*!
+    \property TQToolButton::popupDelay
+    \brief the time delay between pressing the button and the appearance of the associated popup menu in milliseconds.
+
+    Usually this is around half a second. A value of 0 draws the down
+    arrow button to the side of the button which can be used to open
+    up the popup menu.
+
+    \sa setPopup()
+*/
+void TQToolButton::setPopupDelay( int delay )
+{
+    d->delay = delay;
+
+    update();
+}
+
+int TQToolButton::popupDelay() const
+{
+    return d->delay;
+}
+#endif
+
+
+/*!
+    \property TQToolButton::autoRaise
+    \brief whether auto-raising is enabled or not.
+
+    The default is disabled (i.e. FALSE).
+*/
+void TQToolButton::setAutoRaise( bool enable )
+{
+    d->autoraise = enable;
+
+    update();
+}
+
+bool TQToolButton::autoRaise() const
+{
+    return d->autoraise;
+}
+
+/*!
+    \property TQToolButton::textPosition
+    \brief the position of the text label of this button.
+*/
+
+TQToolButton::TextPosition TQToolButton::textPosition() const
+{
+    return d->textPos;
+}
+
+void TQToolButton::setTextPosition( TextPosition pos )
+{
+    d->textPos = pos;
+    updateGeometry();
+    update();
+}
+
+/*! \reimp */
+
+void TQToolButton::setText( const TQString &txt )
+{
+    TQButton::setText( txt );
+    if ( !text().isEmpty() ) {
+	delete s;
+	s = 0;
+    }
+}
+
+#ifndef QT_NO_PALETTE
+/*!
+    \reimp
+*/
+void TQToolButton::paletteChange( const TQPalette & )
+{
+    if ( s )
+	s->clearGenerated();
+}
+#endif
+
+#endif