Added TQt4 HEAD

1 files changed, 1470 insertions, 0 deletions

diff --git a/tqtinterface/qt4/src/styles/tqsgistyle.cpp b/tqtinterface/qt4/src/styles/tqsgistyle.cpp
new file mode 100644
index 0000000..6b8a17b
--- /dev/null
+++ b/tqtinterface/qt4/src/styles/tqsgistyle.cpp
@@ -0,0 +1,1470 @@
+/****************************************************************************
+**
+** Implementation of Motif-like style class
+**
+** Created : 981231
+**
+** Copyright (C) 1998-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 requirements 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 "tqsgistyle.h"
+
+#if !defined(TQT_NO_STYLE_SGI) || defined(TQT_PLUGIN)
+
+#include "tqpopupmenu.h"
+#include "tqapplication.h"
+#include "tqbutton.h"
+#include "tqpainter.h"
+#include "tqdrawutil.h"
+#include "tqpixmap.h"
+#include "tqpalette.h"
+#include "tqwidget.h"
+#include "tqpushbutton.h"
+#include "tqscrollbar.h"
+#include "tqcombobox.h"
+#include "tqslider.h"
+#include "tqtextedit.h"
+#include "tqtoolbar.h"
+#include "tqlineedit.h"
+#include "tqmenubar.h"
+#include <limits.h>
+
+#ifndef TQT_NO_SLIDER
+struct SliderLastPosition
+{
+    SliderLastPosition() : rect(0,-1,0,-1), slider(0) {}
+    TQRect rect;
+    const TQSlider* slider;
+};
+#endif
+
+#ifndef TQT_NO_SCROLLBAR
+struct ScrollbarLastPosition
+{
+    ScrollbarLastPosition() : rect( 0,-1, 0,-1 ), scrollbar(0) {}
+    TQRect rect;
+    const TQScrollBar *scrollbar;
+};
+#endif
+
+class TQSGIStylePrivate
+{
+public:
+    TQSGIStylePrivate()
+	: hotWidget( 0 ), mousePos( -1, -1 )
+    {
+    }
+
+    const TQWidget *hotWidget;
+    TQPoint mousePos;
+#ifndef TQT_NO_SCROLLBAR
+    ScrollbarLastPosition lastScrollbarRect;
+#endif
+#ifndef TQT_NO_SLIDER
+    SliderLastPosition lastSliderRect;
+#endif
+};
+
+/*!
+    \class TQSGIStyle tqsgistyle.h
+    \brief The TQSGIStyle class provides SGI/Irix look and feel.
+
+    \ingroup appearance
+
+    This class implements the SGI look and feel. It resembles the
+    SGI/Irix Motif GUI style as closely as TQStyle allows.
+*/
+
+/*!
+    Constructs a TQSGIStyle.
+
+    If \a useHighlightCols is FALSE (default value), the style will
+    polish the application's color palette to emulate the Motif way of
+    highlighting, which is a simple inversion between the base and the
+    text color.
+
+    \sa TQMotifStyle::useHighlightColors()
+*/
+TQSGIStyle::TQSGIStyle( bool useHighlightCols ) : TQMotifStyle( useHighlightCols ), isApplicationStyle( 0 )
+{
+    d = new TQSGIStylePrivate;
+}
+
+/*!
+    Destroys the style.
+*/
+TQSGIStyle::~TQSGIStyle()
+{
+    delete d;
+}
+
+/*!
+    \reimp
+
+    Changes some application-wide settings to be SGI-like, e.g. sets a
+    bold italic font for menu options.
+*/
+void
+TQSGIStyle::polish( TQApplication* app)
+{
+    isApplicationStyle = 1;
+    TQMotifStyle::polish( app );
+
+    TQPalette pal = TQApplication::palette();
+    // check this on SGI-Boxes
+    //pal.setColor( TQColorGroup::Background, pal.active().midlight() );
+    if (pal.active().button() == pal.active().background())
+        pal.setColor( TQColorGroup::Button, pal.active().button().dark(120) );
+    // darker basecolor in list-widgets
+    pal.setColor( TQColorGroup::Base, pal.active().base().dark(130) );
+    if (! useHighlightColors() ) {
+        pal.setColor( TQPalette::Active, TQColorGroup::Highlight, pal.active().text() );
+        pal.setColor( TQPalette::Active, TQColorGroup::HighlightedText, pal.active().base() );
+        pal.setColor( TQPalette::Inactive, TQColorGroup::Highlight, pal.inactive().text() );
+        pal.setColor( TQPalette::Inactive, TQColorGroup::HighlightedText, pal.inactive().base() );
+        pal.setColor( TQPalette::Disabled, TQColorGroup::Highlight, pal.disabled().text() );
+        pal.setColor( TQPalette::Disabled, TQColorGroup::HighlightedText, pal.disabled().base() );
+    }
+    TQApplication::tqsetPalette( pal, TRUE );
+
+    // different basecolor and highlighting in Q(Multi)LineEdit
+    pal.setColor( TQColorGroup::Base, TQColor(211,181,181) );
+    pal.setColor( TQPalette::Active, TQColorGroup::Highlight, pal.active().midlight() );
+    pal.setColor( TQPalette::Active, TQColorGroup::HighlightedText, pal.active().text() );
+    pal.setColor( TQPalette::Inactive, TQColorGroup::Highlight, pal.inactive().midlight() );
+    pal.setColor( TQPalette::Inactive, TQColorGroup::HighlightedText, pal.inactive().text() );
+    pal.setColor( TQPalette::Disabled, TQColorGroup::Highlight, pal.disabled().midlight() );
+    pal.setColor( TQPalette::Disabled, TQColorGroup::HighlightedText, pal.disabled().text() );
+
+    TQApplication::tqsetPalette( pal, TRUE, "TQLineEdit" );
+    TQApplication::tqsetPalette( pal, TRUE, "TQTextEdit" );
+    TQApplication::tqsetPalette( pal, TRUE, "TQDateTimeEditBase" );
+
+    pal = TQApplication::palette();
+    pal.setColor( TQColorGroup::Button, pal.active().background() );
+    TQApplication::tqsetPalette( pal, TRUE, "TQMenuBar" );
+    TQApplication::tqsetPalette( pal, TRUE, "TQToolBar" );
+    TQApplication::tqsetPalette( pal, TRUE, "TQPopupMenu" );
+}
+
+/*! \reimp
+*/
+void
+TQSGIStyle::unPolish( TQApplication* /* app */ )
+{
+    TQFont f = TQApplication::font();
+    TQApplication::tqsetFont( f, TRUE ); // get rid of the special fonts for special widget classes
+}
+
+/*!
+    \reimp
+
+    Installs an event filter for several widget classes to enable
+    hovering.
+*/
+void
+TQSGIStyle::polish( TQWidget* w )
+{
+    TQMotifStyle::polish(w);
+
+    if ( !isApplicationStyle ) {
+        TQPalette sgiPal = TQApplication::palette();
+
+        sgiPal.setColor( TQColorGroup::Background, sgiPal.active().midlight() );
+        if (sgiPal.active().button() == sgiPal.active().background())
+            sgiPal.setColor( TQColorGroup::Button, sgiPal.active().button().dark(110) );
+        sgiPal.setColor( TQColorGroup::Base, sgiPal.active().base().dark(130) );
+        if (! useHighlightColors() ) {
+            sgiPal.setColor( TQPalette::Active, TQColorGroup::Highlight, sgiPal.active().text() );
+            sgiPal.setColor( TQPalette::Active, TQColorGroup::HighlightedText, sgiPal.active().base() );
+            sgiPal.setColor( TQPalette::Inactive, TQColorGroup::Highlight, sgiPal.inactive().text() );
+            sgiPal.setColor( TQPalette::Inactive, TQColorGroup::HighlightedText, sgiPal.inactive().base() );
+            sgiPal.setColor( TQPalette::Disabled, TQColorGroup::Highlight, sgiPal.disabled().text() );
+            sgiPal.setColor( TQPalette::Disabled, TQColorGroup::HighlightedText, sgiPal.disabled().base() );
+        }
+
+        if ( ::tqqt_cast<TQLineEdit*>(w) || ::tqqt_cast<TQTextEdit*>(w) ) {
+            // different basecolor and highlighting in Q(Multi)LineEdit
+            sgiPal.setColor( TQColorGroup::Base, TQColor(211,181,181) );
+            sgiPal.setColor( TQPalette::Active, TQColorGroup::Highlight, sgiPal.active().midlight() );
+            sgiPal.setColor( TQPalette::Active, TQColorGroup::HighlightedText, sgiPal.active().text() );
+            sgiPal.setColor( TQPalette::Inactive, TQColorGroup::Highlight, sgiPal.inactive().midlight() );
+            sgiPal.setColor( TQPalette::Inactive, TQColorGroup::HighlightedText, sgiPal.inactive().text() );
+            sgiPal.setColor( TQPalette::Disabled, TQColorGroup::Highlight, sgiPal.disabled().midlight() );
+            sgiPal.setColor( TQPalette::Disabled, TQColorGroup::HighlightedText, sgiPal.disabled().text() );
+
+        } else if ( ::tqqt_cast<TQMenuBar*>(w) || ::tqqt_cast<TQToolBar*>(w) ) {
+            sgiPal.setColor( TQColorGroup::Button, sgiPal.active().midlight() );
+        }
+
+        w->setPalette( sgiPal );
+    }
+
+    if ( ::tqqt_cast<TQButton*>(w) || ::tqqt_cast<TQSlider*>(w) || ::tqqt_cast<TQScrollBar*>(w) ) {
+        w->installEventFilter( this );
+        w->setMouseTracking( TRUE );
+#ifndef TQT_NO_SCROLLBAR
+        if ( ::tqqt_cast<TQScrollBar*>(w) )
+            w->setBackgroundMode( TQt::NoBackground );
+#endif
+    } else if ( ::tqqt_cast<TQComboBox*>(w) ) {
+	TQFont f = TQApplication::font();
+	f.setBold( TRUE );
+	f.setItalic( TRUE );
+	w->setFont( f );
+#ifndef TQT_NO_MENUBAR
+    } else if ( ::tqqt_cast<TQMenuBar*>(w) ) {
+        ((TQFrame*) w)->setFrameStyle(TQFrame::StyledPanel | TQFrame::Raised);
+        w->setBackgroundMode( TQt::PaletteBackground );
+	TQFont f = TQApplication::font();
+	f.setBold( TRUE );
+	f.setItalic( TRUE );
+	w->setFont( f );
+#endif
+#ifndef TQT_NO_POPUPMENU
+    } else if ( ::tqqt_cast<TQPopupMenu*>(w) ) {
+        ((TQFrame*) w)->setLineWidth( tqpixelMetric( PM_DefaultFrameWidth ) + 1 );
+	TQFont f = TQApplication::font();
+	f.setBold( TRUE );
+	f.setItalic( TRUE );
+	w->setFont( f );
+#endif
+    } else if ( ::tqqt_cast<TQToolBar*>(w) || w->inherits("TQToolBarSeparator") ) {
+        w->setBackgroundMode( TQt::PaletteBackground );
+    }
+}
+
+/*! \reimp */
+void
+TQSGIStyle::unPolish( TQWidget* w )
+{
+    if ( ::tqqt_cast<TQButton*>(w) || ::tqqt_cast<TQSlider*>(w) || ::tqqt_cast<TQScrollBar*>(w) ) {
+        w->removeEventFilter( this );
+#ifndef TQT_NO_POPUPMENU
+    } else if ( ::tqqt_cast<TQPopupMenu*>(w) ) {
+	((TQFrame*)w)->setLineWidth( tqpixelMetric( PM_DefaultFrameWidth ) );
+	w->setFont( TQApplication::font() );
+#endif
+#if !defined(TQT_NO_MENUBAR) || !defined(TQT_NO_COMBOBOX)
+    } else if ( ::tqqt_cast<TQMenuBar*>(w) || ::tqqt_cast<TQComboBox*>(w) ) {
+	w->setFont( TQApplication::font() );
+#endif
+    }
+}
+
+/*! \reimp */
+bool TQSGIStyle::eventFilter( TQObject* o, TQEvent* e )
+{
+    if ( !o->isWidgetType() || e->type() == TQEvent::Paint )
+	return TQMotifStyle::eventFilter( o, e );
+
+    TQWidget *widget = (TQWidget*)o;
+
+    switch ( e->type() ) {
+    case TQEvent::MouseButtonPress:
+        {
+#ifndef TQT_NO_SCROLLBAR
+	    if ( ::tqqt_cast<TQScrollBar*>(widget) ) {
+		d->lastScrollbarRect.rect = ((TQScrollBar*)widget)->sliderRect();
+		d->lastScrollbarRect.scrollbar = ((TQScrollBar*)widget);
+		widget->tqrepaint( FALSE );
+	    } else
+#endif
+	    {
+#ifndef TQT_NO_SLIDER
+		if ( ::tqqt_cast<TQSlider*>(widget) ) {
+		    d->lastSliderRect.rect = ((TQSlider*)widget)->sliderRect();
+		    d->lastSliderRect.slider = ((TQSlider*)widget);
+		    widget->tqrepaint( FALSE );
+		}
+#endif
+	    }
+        }
+        break;
+
+    case TQEvent::MouseButtonRelease:
+        {
+	    if ( 0 ) {
+#ifndef TQT_NO_SCROLLBAR
+	    } else if ( ::tqqt_cast<TQScrollBar*>(widget) ) {
+		TQRect oldRect = d->lastScrollbarRect.rect;
+		d->lastScrollbarRect.rect = TQRect( 0, -1, 0, -1 );
+		widget->tqrepaint( oldRect, FALSE );
+#endif
+#ifndef TQT_NO_SLIDER
+	    } else if ( ::tqqt_cast<TQSlider*>(widget) ) {
+		TQRect oldRect = d->lastSliderRect.rect;
+		d->lastSliderRect.rect = TQRect( 0, -1, 0, -1 );
+		widget->tqrepaint( oldRect, FALSE );
+#endif
+            }
+        }
+        break;
+
+    case TQEvent::MouseMove:
+	if ( !widget->isActiveWindow() )
+	    break;
+	if ( ((TQMouseEvent*)e)->button() )
+	    break;
+
+	d->hotWidget = widget;
+        d->mousePos = ((TQMouseEvent*)e)->pos();
+	widget->tqrepaint( FALSE );
+        break;
+
+    case TQEvent::Enter:
+	if ( !widget->isActiveWindow() )
+	    break;
+        d->hotWidget = widget;
+        widget->tqrepaint( FALSE );
+        break;
+
+    case TQEvent::Leave:
+	if ( !widget->isActiveWindow() )
+	    break;
+        if ( widget == d->hotWidget) {
+            d->hotWidget = 0;
+            widget->tqrepaint( FALSE );
+        }
+        break;
+
+    default:
+        break;
+    }
+    return TQMotifStyle::eventFilter( o, e );
+}
+
+static const int sgiItemFrame           = 2;    // menu item frame width
+// static const int sgiSepHeight 	= 1;    // separator item height
+static const int sgiItemHMargin         = 3;    // menu item hor text margin
+static const int sgiItemVMargin         = 2;    // menu item ver text margin
+static const int sgiArrowHMargin        = 6;    // arrow horizontal margin
+static const int sgiTabSpacing 		= 12;   // space between text and tab
+// static const int sgiCheckMarkHMargin = 2;    // horiz. margins of check mark ### not used?!?
+static const int sgiCheckMarkSpace      = 20;
+
+/*! \reimp */
+int TQSGIStyle::tqpixelMetric( PixelMetric metric, const TQWidget *widget ) const
+{
+    switch ( metric ) {
+    case PM_DefaultFrameWidth:
+	return 2;
+
+    case PM_ButtonDefaultIndicator:
+	return 4;
+
+    case PM_ScrollBarExtent:
+	return 21;
+
+    case PM_IndicatorWidth:
+    case PM_IndicatorHeight:
+	return 14;
+
+    case PM_ExclusiveIndicatorWidth:
+    case PM_ExclusiveIndicatorHeight:
+	return 12;
+
+    case PM_SplitterWidth:
+	return TQMAX( 10, TQApplication::globalStrut().width() );
+
+    default:
+	break;
+    }
+    return TQMotifStyle::tqpixelMetric( metric, widget );
+}
+
+static void drawPanel( TQPainter *p, int x, int y, int w, int h,
+		const TQColorGroup &g, bool sunken,
+		int lineWidth, const TQBrush* fill)
+{
+    if ( w == 0 || h == 0 )
+	return;
+#if defined(CHECK_RANGE)
+    ASSERT( w > 0 && h > 0 && lineWidth >= 0 );
+#endif
+    TQPen oldPen = p->pen();			// save pen
+    TQPointArray a( 4*lineWidth );
+    if ( sunken )
+	p->setPen( g.dark() );
+    else
+	p->setPen( g.light() );
+    int x1, y1, x2, y2;
+    int i;
+    int n = 0;
+    x1 = x;
+    y1 = y2 = y;
+    x2 = x+w-2;
+    for ( i=0; i<lineWidth; i++ ) {		// top shadow
+	a.setPoint( n++, x1, y1++ );
+	a.setPoint( n++, x2--, y2++ );
+    }
+    x2 = x1;
+    y1 = y+h-2;
+    for ( i=0; i<lineWidth; i++ ) {		// left shadow
+	a.setPoint( n++, x1++, y1 );
+	a.setPoint( n++, x2++, y2-- );
+    }
+    p->drawLineSegments( a );
+    n = 0;
+    if ( sunken )
+	p->setPen( g.light() );
+    else
+	p->setPen( g.dark() );
+    x1 = x;
+    y1 = y2 = y+h-1;
+    x2 = x+w-1;
+    for ( i=0; i<lineWidth; i++ ) {		// bottom shadow
+	a.setPoint( n++, x1++, y1-- );
+	a.setPoint( n++, x2, y2-- );
+    }
+    x1 = x2;
+    y1 = y;
+    y2 = y+h-lineWidth-1;
+    for ( i=0; i<lineWidth; i++ ) {		// right shadow
+	a.setPoint( n++, x1--, y1++ );
+	a.setPoint( n++, x2--, y2 );
+    }
+    p->drawLineSegments( a );
+    if ( fill ) {				// fill with fill color
+	TQBrush oldBrush = p->brush();
+	p->setPen( TQt::NoPen );
+	p->setBrush( *fill );
+	p->drawRect( x+lineWidth, y+lineWidth, w-lineWidth*2, h-lineWidth*2 );
+	p->setBrush( oldBrush );
+    }
+    p->setPen( oldPen );			// restore pen
+}
+
+static void drawSeparator( TQPainter *p, int x1, int y1, int x2, int y2,
+			  const TQColorGroup &g )
+{
+    TQPen oldPen = p->pen();
+
+    p->setPen( g.midlight() );
+    p->drawLine( x1, y1, x2, y2 );
+    p->setPen( g.shadow() );
+    if ( y2-y1 < x2-x1 )
+	p->drawLine( x1, y1+1, x2, y2+1 );
+    else
+	p->drawLine( x1+1, y1, x2+1, y2 );
+
+    p->setPen( oldPen );
+}
+
+static void drawSGIPrefix( TQPainter *p, int x, int y, TQString* miText )
+{
+    if ( miText && (!!(*miText)) ) {
+        int amp = 0;
+        bool nextAmp = FALSE;
+        while ( ( amp = miText->tqfind( '&', amp ) ) != -1 ) {
+            if ( (uint)amp == miText->length()-1 )
+                return;
+            miText->remove( amp,1 );
+            nextAmp = (*miText)[amp] == '&';    // next time if &&
+
+            if ( !nextAmp ) {     // draw special underlining
+                uint ulx = p->fontMetrics().width(*miText, amp);
+
+                uint ulw = p->fontMetrics().width(*miText, amp+1) - ulx;
+
+                p->drawLine( x+ulx, y, x+ulx+ulw, y );
+                p->drawLine( x+ulx, y+1, x+ulx+ulw/2, y+1 );
+                p->drawLine( x+ulx, y+2, x+ulx+ulw/4, y+2 );
+            }
+            amp++;
+        }
+    }
+}
+
+static int get_combo_extra_width( int h, int *return_awh=0 )
+{
+    int awh;
+    if ( h < 8 ) {
+        awh = 6;
+    } else if ( h < 14 ) {
+        awh = h - 2;
+    } else {
+        awh = h/2;
+    }
+    if ( return_awh )
+        *return_awh = awh;
+    return awh*2;
+}
+
+static void get_combo_parameters( const TQRect &r,
+                                  int &ew, int &awh, int &ax,
+                                  int &ay, int &sh, int &dh,
+                                  int &sy )
+{
+    ew = get_combo_extra_width( r.height(), &awh );
+
+    sh = (awh+3)/4;
+    if ( sh < 3 )
+        sh = 3;
+    dh = sh/2 + 1;
+
+    ay = r.y() + (r.height()-awh-sh-dh)/2;
+    if ( ay < 0 ) {
+        //panic mode
+        ay = 0;
+        sy = r.height();
+    } else {
+        sy = ay+awh+dh;
+    }
+    if( TQApplication::reverseLayout() )
+        ax = r.x();
+    else
+        ax = r.x() + r.width() - ew;
+    ax  += (ew-awh)/2;
+}
+
+/*! \reimp */
+void TQSGIStyle::tqdrawPrimitiveBase( TQ_PrimitiveElement pe,
+		    TQPainter *p,
+		    const TQRect &r,
+		    const TQColorGroup &cg,
+		    SFlags flags,
+		    const TQStyleOption& opt ) const
+{
+    const int x = r.x();
+    const int y = r.y();
+    const int w = r.width();
+    const int h = r.height();
+    const bool sunken = flags & ( Style_Sunken | Style_Down | Style_On );
+    const int defaultFrameWidth = tqpixelMetric( PM_DefaultFrameWidth );
+    bool hot = ( flags & Style_MouseOver ) && ( flags & Style_Enabled );
+
+    switch ( pe ) {
+    case PE_ButtonCommand:
+	{
+	    TQBrush fill;
+	    if ( hot ) {
+		if ( sunken )
+		    fill = cg.brush( TQColorGroup::Dark );
+		else
+		    fill = cg.brush( TQColorGroup::Midlight );
+	    } else if ( sunken ) {
+		fill = cg.brush( TQColorGroup::Mid );
+	    } else {
+		fill = cg.brush( TQColorGroup::Button );
+	    }
+
+	    drawPanel( p, x, y, w, h, cg, sunken, defaultFrameWidth, &fill );
+	}
+	break;
+
+    case PE_PanelPopup:
+    case PE_ButtonBevel:
+    case PE_ButtonTool:
+	{
+	    tqdrawPrimitive( PE_ButtonCommand, p, TQRect( x+1, y+1, w-2, h-2 ), cg, flags, opt );
+
+	    TQPen oldPen = p->pen();
+	    TQPointArray a;
+
+	    // draw twocolored rectangle
+	    p->setPen( sunken ? cg.light() : TQT_TQCOLOR_OBJECT(cg.dark().dark(200)) );
+	    a.setPoints( 3, x, y+h-1, x+w-1, y+h-1, x+w-1, y );
+	    p->drawPolyline( a );
+	    p->setPen( cg.dark() );
+	    a.setPoints( 3, x, y+h-2, x, y, x+w-2, y );
+	    p->drawPolyline( a );
+
+	    p->setPen( oldPen );
+	}
+	break;
+
+    case PE_ArrowUp:
+    case PE_ArrowDown:
+    case PE_ArrowLeft:
+    case PE_ArrowRight:
+	{
+	    TQPointArray a;				// arrow polygon
+	    switch ( pe ) {
+	    case PE_ArrowUp:
+		a.setPoints( 3, 0,-5, -5,4, 4,4 );
+		break;
+	    case PE_ArrowDown:
+		a.setPoints( 3, 0,4, -4,-4, 4,-4 );
+		break;
+	    case PE_ArrowLeft:
+		a.setPoints( 3, -4,0, 4,-5, 4,4 );
+		break;
+	    case PE_ArrowRight:
+		a.setPoints( 3, 4,0, -4,-5, -4,4 );
+		break;
+	    default:
+		return;
+	    }
+
+	    p->save();
+	    p->setPen( TQt::NoPen );
+	    a.translate( x+w/2, y+h/2 );
+	    p->setBrush( flags & Style_Enabled ? cg.dark() : cg.light() );
+	    p->drawPolygon( a );			// draw arrow
+	    p->restore();
+	}
+	break;
+
+    case PE_Indicator:
+	{
+	    TQRect er = r;
+	    er.addCoords( 1, 1, -1, -1 );
+	    int iflags = flags & ~Style_On;
+	    tqdrawPrimitive( PE_ButtonBevel, p, er, cg, (QStyle::StateFlag)iflags, opt );
+	    if ( !(flags & TQStyle::Style_Off) ) {
+		er = r;
+		er.addCoords( 1, 2, 1, 1 );
+		tqdrawPrimitive( PE_CheckMark, p, er, cg, flags, opt );
+	    }
+	}
+	break;
+
+    case PE_IndicatorMask:
+	{
+	    TQPen oldPen = p->pen();
+	    TQBrush oldBrush = p->brush();
+
+	    p->setPen( TQt::color1 );
+	    p->setBrush( TQt::color1 );
+	    p->fillRect( x, y, w, h, TQBrush( TQt::color0 ) );
+	    TQRect er = r;
+	    er.addCoords( 1, 1, -1, -1 );
+	    p->fillRect(er, TQBrush(TQt::color1));
+
+	    if ( !(flags & TQStyle::Style_Off) ) {
+		er = r;
+		er.addCoords( 1, 2, 1, 1 );
+		static const TQCOORD check_mark[] = {
+			14,0,  10,0,  11,1,  8,1,  9,2,	 7,2,  8,3,  6,3,
+			7,4,  1,4,  6,5,  1,5,	6,6,  3,6,  5,7,  4,7,
+			5,8,  5,8,  4,3,  2,3,	3,2,  3,2 };
+
+		TQPointArray amark;
+		amark = TQPointArray( sizeof(check_mark)/(sizeof(TQCOORD)*2), check_mark );
+		amark.translate( er.x()+1, er.y()+1 );
+		p->drawLineSegments( amark );
+		amark.translate( -1, -1 );
+		p->drawLineSegments( amark );
+	    }
+
+	    p->setBrush( oldBrush );
+	    p->setPen( oldPen );
+	}
+	break;
+
+#ifndef USE_QT4 // [FIXME]
+    case PE_CheckMark:
+	{
+	    static const TQCOORD check_mark[] = {
+		14,0,  10,0,  11,1,  8,1,  9,2,	 7,2,  8,3,  6,3,
+		7,4,  1,4,  6,5,  1,5,	6,6,  3,6,  5,7,  4,7,
+		5,8,  5,8,  4,3,  2,3,	3,2,  3,2 };
+
+	    TQPen oldPen = p->pen();
+
+	    TQPointArray amark;
+	    amark = TQPointArray( sizeof(check_mark)/(sizeof(TQCOORD)*2), check_mark );
+	    amark.translate( x+1, y+1 );
+
+	    if ( flags & Style_On ) {
+		p->setPen( flags & Style_Enabled ? cg.shadow() : cg.dark() );
+		p->drawLineSegments( amark );
+		amark.translate( -1, -1 );
+		p->setPen( flags & Style_Enabled ? TQColor(255,0,0) : cg.dark() );
+		p->drawLineSegments( amark );
+		p->setPen( oldPen );
+	    } else {
+		p->setPen( flags & Style_Enabled ? cg.dark() : cg.mid() );
+		p->drawLineSegments( amark );
+		amark.translate( -1, -1 );
+		p->setPen( flags & Style_Enabled ? TQColor(230,120,120) : cg.dark() );
+		p->drawLineSegments( amark );
+		p->setPen( oldPen );
+	    }
+	}
+	break;
+#endif // USE_QT4
+
+    case PE_ExclusiveIndicator:
+	{
+	    p->save();
+	    p->eraseRect( x, y, w, h );
+	    p->translate( x, y );
+
+	    p->setPen( cg.button() );
+	    p->setBrush( hot ? cg.midlight() : cg.button() );
+	    TQPointArray a;
+	    a.setPoints( 4, 5,0, 11,6, 6,11, 0,5);
+	    p->drawPolygon( a );
+
+	    p->setPen( cg.dark() );
+	    p->drawLine( 0,5, 5,0 );
+	    p->drawLine( 6,0, 11,5 );
+	    p->setPen( flags & Style_Down ? cg.light() : cg.dark() );
+	    p->drawLine( 11,6, 6,11 );
+	    p->drawLine( 5,11, 0,6 );
+	    p->drawLine( 2,7, 5,10 );
+	    p->drawLine( 6,10, 9,7 );
+	    p->setPen( cg.light() );
+	    p->drawLine( 2,5, 5,2 );
+
+	    if ( flags & Style_On ) {
+		p->setPen( flags & Style_Enabled ? TQt::blue : TQt::darkGray );
+		p->setBrush( flags & Style_Enabled ? TQt::blue : TQt::darkGray  );
+		a.setPoints(3, 6,2, 8,4, 6,6 );
+		p->drawPolygon( a );
+		p->setBrush( TQt::NoBrush );
+
+		p->setPen( cg.shadow() );
+		p->drawLine( 7,7, 9,5 );
+	    } else {
+		p->drawLine( 6,2, 9,5 );
+	    }
+	    p->restore();
+	}
+	break;
+
+    case PE_ExclusiveIndicatorMask:
+	{
+	    p->save();
+	    TQPen oldPen = p->pen();
+	    TQBrush oldBrush = p->brush();
+
+	    p->setPen( TQt::color1 );
+	    p->setBrush( TQt::color1 );
+	    TQPointArray a;
+	    a.setPoints( 8, 0,5, 5,0, 6,0, 11,5, 11,6, 6,11, 5,11, 0,6 );
+	    a.translate( x, y );
+	    p->drawPolygon( a );
+
+	    p->setBrush( oldBrush );
+	    p->setPen( oldPen );
+	    p->restore();
+	}
+	break;
+
+    case PE_Panel:
+	{
+	    const int lineWidth = opt.isDefault() ? defaultFrameWidth : opt.lineWidth();
+	    drawPanel( p, x, y, w, h, cg, flags & (Style_Sunken | Style_Down | Style_On), lineWidth, 0 );
+	    if ( lineWidth <= 1 )
+		return;
+
+	    // draw extra shadinglines
+	    TQPen oldPen = p->pen();
+	    p->setPen( cg.midlight() );
+	    p->drawLine( x+1, y+h-3, x+1, y+1 );
+	    p->drawLine( x+1, y+1, x+w-3, y+1 );
+	    p->setPen( cg.mid() );
+	    p->drawLine( x+1, y+h-2, x+w-2, y+h-2 );
+	    p->drawLine( x+w-2, y+h-2, x+w-2, y+1 );
+	    p->setPen(oldPen);
+	}
+	break;
+
+    case PE_ScrollBarSubLine:
+	if ( !r.tqcontains( d->mousePos ) && !(flags & Style_Active) )
+	    flags &= ~Style_MouseOver;
+	tqdrawPrimitive( PE_ButtonCommand, p, r, cg, flags, opt );
+	tqdrawPrimitive(((flags & Style_Horizontal) ? PE_ArrowLeft : PE_ArrowUp),
+		      p, r, cg, Style_Enabled | flags);
+	break;
+
+    case PE_ScrollBarAddLine:
+	if ( !r.tqcontains( d->mousePos ) )
+	    flags &= ~Style_MouseOver;
+	tqdrawPrimitive( PE_ButtonCommand, p, r, cg, flags, opt );
+	tqdrawPrimitive(((flags & Style_Horizontal) ? PE_ArrowRight : PE_ArrowDown),
+		      p, r, cg, Style_Enabled | flags);
+	break;
+
+    case PE_ScrollBarSubPage:
+    case PE_ScrollBarAddPage:
+	if ( !r.tqcontains( d->mousePos ) )
+	    flags &= ~Style_MouseOver;
+	if ( r.isValid() )
+	    qDrawShadePanel( p, x, y, w, h, cg, FALSE, 1, hot ? &cg.brush( TQColorGroup::Midlight ) : &cg.brush( TQColorGroup::Button ) );
+	break;
+
+    case PE_ScrollBarSlider:
+	{
+	    if ( !r.isValid() )
+		break;
+	    if ( !(r.tqcontains( d->mousePos ) || flags & Style_Active) || !(flags & Style_Enabled ) )
+		flags &= ~Style_MouseOver;
+
+	    TQPixmap pm( r.width(), r.height() );
+	    TQPainter bp( &pm );
+	    tqdrawPrimitive(PE_ButtonBevel, &bp, TQRect(0,0,r.width(),r.height()), cg, flags | Style_Enabled | Style_Raised);
+	    if ( flags & Style_Horizontal ) {
+		const int sliderM =  r.width() / 2;
+		if ( r.width() > 20 ) {
+		    drawSeparator( &bp, sliderM-5, 2, sliderM-5, r.height()-3, cg );
+		    drawSeparator( &bp, sliderM+3, 2, sliderM+3, r.height()-3, cg );
+		}
+		if ( r.width() > 10 )
+		    drawSeparator( &bp, sliderM-1, 2, sliderM-1, r.height()-3, cg );
+
+	    } else {
+		const int sliderM =  r.height() / 2;
+		if ( r.height() > 20 ) {
+		    drawSeparator( &bp, 2, sliderM-5, r.width()-3, sliderM-5, cg );
+		    drawSeparator( &bp, 2, sliderM+3, r.width()-3, sliderM+3, cg );
+		}
+		if ( r.height() > 10 )
+		    drawSeparator( &bp, 2, sliderM-1, r.width()-3, sliderM-1, cg );
+	    }
+	    bp.end();
+	    p->drawPixmap( r.x(), r.y(), pm );
+	}
+
+	break;
+
+    case PE_Splitter:
+	{
+	    const int motifOffset = 10;
+	    int sw = tqpixelMetric( PM_SplitterWidth );
+	    if ( flags & Style_Horizontal ) {
+		int xPos = x + w/2;
+		int kPos = motifOffset;
+		int kSize = sw - 2;
+
+		qDrawShadeLine( p, xPos, kPos + kSize - 1 ,
+			xPos, h, cg );
+
+		tqdrawPrimitive( PE_ButtonBevel, p, TQRect(xPos-sw/2+1, kPos, kSize, kSize+1), cg, flags, opt );
+		qDrawShadeLine( p, xPos+2, 0, xPos, kPos, cg );
+	    } else {
+		int yPos = y + h/2;
+		int kPos = w - motifOffset - sw;
+		int kSize = sw - 2;
+
+		qDrawShadeLine( p, 0, yPos, kPos, yPos, cg );
+		tqdrawPrimitive( PE_ButtonBevel, p, TQRect( kPos, yPos-sw/2+1, kSize+1, kSize ), cg, flags, opt );
+		qDrawShadeLine( p, kPos + kSize+1, yPos, w, yPos, cg );
+	    }
+	}
+	break;
+
+    default:
+	TQMotifStyle::tqdrawPrimitive( pe, p, r, cg, flags, opt );
+	break;
+    }
+}
+
+/*! \reimp */
+void TQSGIStyle::tqdrawControl( TQ_ControlElement element,
+		  TQPainter *p,
+		  const TQWidget *widget,
+		  const TQRect &r,
+		  const TQColorGroup &cg,
+		  SFlags flags,
+		  const TQStyleOption& opt ) const
+{
+    if ( widget == d->hotWidget )
+	flags |= Style_MouseOver;
+
+    switch ( element ) {
+    case CE_PushButton:
+	{
+#ifndef TQT_NO_PUSHBUTTON
+	    const TQPushButton *btn = (TQPushButton*)widget;
+	    int x1, y1, x2, y2;
+	    r.coords( &x1, &y1, &x2, &y2 );
+
+	    p->setPen( cg.foreground() );
+	    p->setBrush( TQBrush( cg.button(), Qt::NoBrush ) );
+	    p->setBrushOrigin( -widget->backgroundOffset().x(),
+			       -widget->backgroundOffset().y() );
+
+	    int diw = tqpixelMetric( TQStyle::PM_ButtonDefaultIndicator );
+	    if ( btn->isDefault() || btn->autoDefault() ) {
+		x1 += diw;
+		y1 += diw;
+		x2 -= diw;
+		y2 -= diw;
+	    }
+
+	    TQPointArray a;
+	    if ( btn->isDefault() ) {
+		if ( diw == 0 ) {
+		    a.setPoints( 9,
+				 x1, y1, x2, y1, x2, y2, x1, y2, x1, y1+1,
+				 x2-1, y1+1, x2-1, y2-1, x1+1, y2-1, x1+1, y1+1 );
+		    p->setPen( cg.shadow() );
+		    p->drawPolyline( a );
+		    x1 += 2;
+		    y1 += 2;
+		    x2 -= 2;
+		    y2 -= 2;
+		} else {
+		    qDrawShadePanel( p, btn->rect(), cg, TRUE );
+		}
+	    }
+
+	    TQBrush fill = cg.brush( TQColorGroup::Button );
+	    if ( !btn->isFlat() || btn->isOn() || btn->isDown() )
+		tqdrawPrimitive( PE_ButtonBevel, p, TQRect( x1, y1, x2-x1+1, y2-y1+1 ), cg, flags, opt );
+
+	    if ( p->brush().style() != TQt::NoBrush )
+		p->setBrush( TQt::NoBrush );
+#endif
+	}
+    break;
+
+    case CE_PopupMenuItem:
+	{
+#ifndef TQT_NO_POPUPMENU
+	    if (! widget || opt.isDefault())
+		break;
+	    TQMenuItem *mi = opt.menuItem();
+	    if ( !mi )
+		break;
+	    const TQPopupMenu *popupmenu = (const TQPopupMenu *) widget;
+	    int tab = opt.tabWidth();
+	    int maxpmw = opt.maxIconWidth();
+	    bool dis = ! (flags & Style_Enabled);
+	    bool checkable = popupmenu->isCheckable();
+	    bool act = flags & Style_Active;
+	    int x, y, w, h;
+
+	    r.rect(&x, &y, &w, &h);
+
+	    if ( checkable )
+		maxpmw = TQMAX( maxpmw, sgiCheckMarkSpace );
+	    int checkcol = maxpmw;
+
+	    if (mi && mi->isSeparator() ) {
+		p->setPen( cg.mid() );
+		p->drawLine(x, y, x+w, y );
+		return;
+	    }
+
+	    int pw = sgiItemFrame;
+
+	    if ( act && !dis ) {
+		if ( tqpixelMetric( PM_DefaultFrameWidth ) > 1 )
+		    drawPanel( p, x, y, w, h, cg, FALSE, pw,
+				     &TQT_TQBRUSH_OBJECT(cg.brush( TQColorGroup::Light )) );
+		else
+		    drawPanel( p, x+1, y+1, w-2, h-2, cg, FALSE, 1,
+				     &TQT_TQBRUSH_OBJECT(cg.brush( TQColorGroup::Light )) );
+	    } else {
+		p->fillRect( x, y, w, h, cg.brush( TQColorGroup::Button ) );
+	    }
+
+	    if ( !mi )
+		return;
+
+	    if ( mi->isChecked() ) {
+		if ( mi->iconSet() ) {
+		    drawPanel( p, x+sgiItemFrame, y+sgiItemFrame, checkcol, h-2*sgiItemFrame,
+				     cg, TRUE, 1, &TQT_TQBRUSH_OBJECT(cg.brush( TQColorGroup::Light )) );
+		}
+	    } else {
+		if ( !act )
+		    p->fillRect( x+sgiItemFrame, y+sgiItemFrame, checkcol, h-2*sgiItemFrame,
+				cg.brush( TQColorGroup::Button ) );
+	    }
+
+	    if ( mi->iconSet() ) {
+		TQIconSet::Mode mode = TQIconSet::Normal;
+		if ( act && !dis )
+		    mode = TQIconSet::Active;
+		TQPixmap pixmap;
+		if ( checkable && mi->isChecked() )
+		    pixmap = mi->iconSet()->pixmap( TQIconSet::Small, mode, TQIconSet::On );
+		else
+		    pixmap = mi->iconSet()->pixmap( TQIconSet::Small, mode );
+
+		int pixw = pixmap.width();
+		int pixh = pixmap.height();
+		TQRect cr( x+sgiItemFrame, y+sgiItemFrame, checkcol, h-2*sgiItemFrame );
+		TQRect pmr( 0, 0, pixw, pixh );
+		pmr.moveCenter( cr.center() );
+		p->setPen( cg.text() );
+		p->drawPixmap( pmr.topLeft(), pixmap );
+	    } else {
+		if ( checkable ) {
+		    SFlags cflags = Style_Default;
+		    if (! dis)
+			cflags |= Style_Enabled;
+		    if (act)
+			cflags |= Style_On;
+
+		    if ( mi->isChecked() ) {
+			TQRect er( x+sgiItemFrame+1, y+sgiItemFrame+3,
+				  tqpixelMetric(PM_IndicatorWidth),
+				  tqpixelMetric(PM_IndicatorHeight) );
+			er.addCoords( 1, 1, -1, -1 );
+			tqdrawPrimitive( PE_ButtonBevel, p, er, cg, cflags, opt );
+			er.addCoords( 0, 1, 1, 1 );
+			tqdrawPrimitive( PE_CheckMark, p, er, cg, cflags | Style_On, opt );
+		    }
+		}
+	    }
+
+	    p->setPen( cg.buttonText() );
+
+	    TQColor discol;
+	    if ( dis ) {
+		discol = cg.text();
+		p->setPen( discol );
+	    }
+
+	    int xm = sgiItemFrame + checkcol + sgiItemHMargin;
+
+	    if ( mi->custom() ) {
+		int m = sgiItemVMargin;
+		p->save();
+		mi->custom()->paint( p, cg, act, !dis,
+				     x+xm, y+m, w-xm-tab+1, h-2*m );
+		p->restore();
+	    }
+
+	    TQString s = mi->text();
+	    if ( !!s ) {
+		int t = s.tqfind( '\t' );
+		int m = sgiItemVMargin;
+		const int text_flags = TQt::AlignVCenter | TQt::DontClip | TQt::SingleLine; //special underline for &x
+
+		TQString miText = s;
+		if ( t>=0 ) {
+		    p->drawText(x+w-tab-sgiItemHMargin-sgiItemFrame,
+				y+m, tab, h-2*m, text_flags, miText.mid( t+1 ) );
+		    miText = s.mid( 0, t );
+		}
+		TQRect br = p->fontMetrics().boundingRect( x+xm, y+m, w-xm-tab+1, h-2*m,
+			text_flags, mi->text() );
+
+		drawSGIPrefix( p, br.x()+p->fontMetrics().leftBearing(miText[0]),
+			br.y()+br.height()+p->fontMetrics().underlinePos()-2, &miText );
+		p->drawText( x+xm, y+m, w-xm-tab+1, h-2*m, text_flags, miText, miText.length() );
+	    } else {
+		if ( mi->pixmap() ) {
+		    TQPixmap *pixmap = mi->pixmap();
+		    if ( pixmap->depth() == 1 )
+			p->setBackgroundMode( Qt::OpaqueMode );
+		    p->drawPixmap( x+xm, y+sgiItemFrame, *pixmap );
+		    if ( pixmap->depth() == 1 )
+			p->setBackgroundMode( Qt::TransparentMode );
+		}
+	    }
+	    if ( mi->popup() ) {
+		int dim = (h-2*sgiItemFrame) / 2;
+		tqdrawPrimitive( PE_ArrowRight, p, TQRect( x+w-sgiArrowHMargin-sgiItemFrame-dim, y+h/2-dim/2, dim, dim ), cg, flags );
+	    }
+#endif
+	}
+	break;
+
+    case CE_MenuBarItem:
+	{
+#ifndef TQT_NO_MENUDATA
+	    if (opt.isDefault())
+		break;
+
+	    TQMenuItem *mi = opt.menuItem();
+
+	    bool active = flags & Style_Active;
+	    int x, y, w, h;
+	    r.rect( &x, &y, &w, &h );
+
+	    if ( active ) {
+		p->setPen( TQPen( cg.shadow(), 1) );
+		p->drawRect( x, y, w, h );
+		qDrawShadePanel( p, TQRect(x+1,y+1,w-2,h-2), cg, FALSE, 2,
+				 &cg.brush( TQColorGroup::Light ));
+	    } else {
+		p->fillRect( x, y, w, h, cg.brush( TQColorGroup::Button ));
+	    }
+
+	    if ( mi->pixmap() )
+		drawItem( p, r, TQt::AlignCenter|TQt::DontClip|TQt::SingleLine,
+			cg, mi->isEnabled(), mi->pixmap(), "", -1, TQT_TQCOLOR_CONST(&cg.buttonText()) );
+
+	    if ( !!mi->text() ) {
+		TQString* text = new TQString(mi->text());
+		TQRect br = p->fontMetrics().boundingRect( x, y-2, w+1, h,
+			TQt::AlignCenter|TQt::DontClip|TQt::SingleLine|TQt::ShowPrefix, mi->text() );
+
+		drawSGIPrefix( p, br.x()+p->fontMetrics().leftBearing((*text)[0]),
+			br.y()+br.height()+p->fontMetrics().underlinePos()-2, text );
+		p->drawText( x, y-2, w+1, h, TQt::AlignCenter|TQt::DontClip|TQt::SingleLine, *text, text->length() );
+		delete text;
+	    }
+#endif
+	}
+	break;
+
+    case CE_CheckBox:
+	TQMotifStyle::tqdrawControl( element, p, widget, r, cg, flags, opt );
+	break;
+
+    default:
+	TQMotifStyle::tqdrawControl( element, p, widget, r, cg, flags, opt );
+	break;
+    }
+}
+
+/*! \reimp */
+void TQSGIStyle::tqdrawComplexControl( TQ_ComplexControl control,
+			 TQPainter *p,
+			 const TQWidget* widget,
+			 const TQRect& r,
+			 const TQColorGroup& cg,
+			 SFlags flags,
+			 SCFlags sub,
+			 SCFlags subActive,
+			 const TQStyleOption& opt ) const
+{
+    if ( widget == d->hotWidget )
+	flags |= Style_MouseOver;
+
+    switch ( control ) {
+    case CC_Slider:
+	{
+#ifndef TQT_NO_SLIDER
+	    const TQSlider * slider = (const TQSlider *) widget;
+
+	    TQRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove,
+						  opt),
+		  handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle,
+						  opt);
+
+	    if ((sub & SC_SliderGroove) && groove.isValid()) {
+		TQRegion region( groove );
+		if ( ( sub & SC_SliderHandle ) && handle.isValid() )
+		    region = region.subtract( handle );
+		if ( d->lastSliderRect.slider == slider && d->lastSliderRect.rect.isValid() )
+		    region = region.subtract( d->lastSliderRect.rect );
+		p->setClipRegion( region );
+
+		TQRect grooveTop = groove;
+		grooveTop.addCoords( 1, 1, -1, -1 );
+		tqdrawPrimitive( PE_ButtonBevel, p, grooveTop, cg, flags & ~Style_MouseOver, opt );
+
+		if ( flags & Style_HasFocus ) {
+		    TQRect fr = subRect( SR_SliderFocusRect, widget );
+		    tqdrawPrimitive( PE_FocusRect, p, fr, cg, flags & ~Style_MouseOver );
+		}
+
+		if ( d->lastSliderRect.slider == slider && d->lastSliderRect.rect.isValid() ) {
+		    if ( ( sub & SC_SliderHandle ) && handle.isValid() ) {
+			region = widget->rect();
+			region = region.subtract( handle );
+			p->setClipRegion( region );
+		    } else {
+			p->setClipping( FALSE );
+		    }
+		    qDrawShadePanel( p, d->lastSliderRect.rect, cg, TRUE, 1, &cg.brush( TQColorGroup::Dark ) );
+		}
+		p->setClipping( FALSE );
+	    }
+
+	    if (( sub & SC_SliderHandle ) && handle.isValid()) {
+		if ( flags & Style_MouseOver && !handle.tqcontains( d->mousePos ) && subActive != SC_SliderHandle )
+		    flags &= ~Style_MouseOver;
+		tqdrawPrimitive( PE_ButtonBevel, p, handle, cg, flags );
+
+		if ( slider->orientation() == Qt::Horizontal ) {
+		    TQCOORD mid = handle.x() + handle.width() / 2;
+		    qDrawShadeLine( p, mid, handle.y(), mid,
+				    handle.y() + handle.height() - 2,
+				    cg, TRUE, 1);
+		} else {
+		    TQCOORD mid = handle.y() + handle.height() / 2;
+		    qDrawShadeLine( p, handle.x(), mid,
+				    handle.x() + handle.width() - 2, mid,
+				    cg, TRUE, 1);
+		}
+	    }
+
+	    if ( sub & SC_SliderTickmarks )
+		TQMotifStyle::tqdrawComplexControl( control, p, widget, r, cg, flags,
+						 SC_SliderTickmarks, subActive,
+						 opt );
+#endif
+	    break;
+	}
+    case CC_ComboBox:
+	{
+#ifndef TQT_NO_COMBOBOX
+	    const TQComboBox * cb = (TQComboBox *) widget;
+
+	    if (sub & SC_ComboBoxFrame) {
+		TQRect fr =
+		    TQStyle::tqvisualRect( querySubControlMetrics( CC_ComboBox, cb,
+								SC_ComboBoxFrame ), cb );
+		tqdrawPrimitive( PE_ButtonBevel, p, fr, cg, flags );
+	    }
+
+	    if ( sub & SC_ComboBoxArrow ) {
+		p->save();
+		TQRect er =
+		    TQStyle::tqvisualRect( querySubControlMetrics( CC_ComboBox, cb, SC_ComboBoxArrow ), cb );
+
+		er.addCoords( 0, 3, 0, 0 );
+
+		tqdrawPrimitive( PE_ArrowDown, p, er, cg, flags | Style_Enabled, opt );
+
+		int awh, ax, ay, sh, sy, dh, ew;
+		get_combo_parameters( widget->rect(), ew, awh, ax, ay, sh, dh, sy );
+
+		TQBrush arrow = cg.brush( TQColorGroup::Dark );
+		p->fillRect( ax, sy-1, awh, sh, arrow );
+
+		p->restore();
+		if ( cb->hasFocus() ) {
+		    TQRect re = TQStyle::tqvisualRect( subRect( SR_ComboBoxFocusRect, cb ), cb );
+		    tqdrawPrimitive( PE_FocusRect, p, re, cg );
+		}
+	    }
+	    if ( sub & SC_ComboBoxEditField ) {
+		if ( cb->editable() ) {
+		    TQRect er =
+			TQStyle::tqvisualRect( querySubControlMetrics( CC_ComboBox, cb,
+								    SC_ComboBoxEditField ), cb );
+		    er.addCoords( -1, -1, 1, 1);
+		    qDrawShadePanel( p, TQRect( er.x()-1, er.y()-1,
+					       er.width()+2, er.height()+2 ),
+				     cg, TRUE, 1, &cg.brush( TQColorGroup::Button ) );
+		}
+	    }
+#endif
+	    p->setPen(cg.buttonText());
+	    break;
+	}
+
+    case CC_ScrollBar:
+	{
+#ifndef TQT_NO_SCROLLBAR
+	    TQScrollBar *scrollbar = (TQScrollBar*)widget;
+	    bool maxedOut = (scrollbar->minValue() == scrollbar->maxValue());
+	    if ( maxedOut )
+		flags &= ~Style_Enabled;
+
+	    TQRect handle = TQStyle::tqvisualRect( querySubControlMetrics( CC_ScrollBar, widget, SC_ScrollBarSlider, opt ), widget );
+
+	    if ( sub & SC_ScrollBarGroove ) {
+	    }
+	    if ( sub & SC_ScrollBarAddLine ) {
+		TQRect er = TQStyle::tqvisualRect( querySubControlMetrics( CC_ScrollBar, widget, SC_ScrollBarAddLine, opt ), widget );
+		tqdrawPrimitive( PE_ScrollBarAddLine, p, er, cg, flags, opt );
+	    }
+	    if ( sub & SC_ScrollBarSubLine ) {
+		TQRect er = TQStyle::tqvisualRect( querySubControlMetrics( CC_ScrollBar, widget, SC_ScrollBarSubLine, opt ), widget );
+		tqdrawPrimitive( PE_ScrollBarSubLine, p, er, cg, flags, opt );
+	    }
+	    if ( sub & SC_ScrollBarAddPage ) {
+		TQRect er = TQStyle::tqvisualRect( querySubControlMetrics( CC_ScrollBar, widget, SC_ScrollBarAddPage, opt ), widget );
+		TQRegion region( er );
+		if ( d->lastScrollbarRect.scrollbar == scrollbar &&
+		     d->lastScrollbarRect.rect.isValid() &&
+		     er.intersects( d->lastScrollbarRect.rect ) ) {
+		    region = region.subtract( d->lastScrollbarRect.rect );
+		    p->setClipRegion( region );
+		}
+		if ( sub & SC_ScrollBarSlider && er.intersects( handle ) ) {
+		    region = region.subtract( handle );
+		    p->setClipRegion( region );
+		}
+
+		tqdrawPrimitive( PE_ScrollBarAddPage, p, er, cg, flags & ~Style_MouseOver, opt );
+
+		if ( d->lastScrollbarRect.scrollbar == scrollbar &&
+		     d->lastScrollbarRect.rect.isValid() &&
+		     er.intersects( d->lastScrollbarRect.rect ) ) {
+		    if ( sub & SC_ScrollBarSlider && handle.isValid() ) {
+			region = er;
+			region.subtract( handle );
+			p->setClipRegion( region );
+		    } else {
+			p->setClipping( FALSE );
+		    }
+		    qDrawShadePanel( p, d->lastScrollbarRect.rect, cg, TRUE, 1, &cg.brush( TQColorGroup::Dark ) );
+		}
+		p->setClipping( FALSE );
+	    }
+	    if ( sub & SC_ScrollBarSubPage ) {
+		TQRect er = TQStyle::tqvisualRect( querySubControlMetrics( CC_ScrollBar, widget, SC_ScrollBarSubPage, opt ), widget );
+		TQRegion region( er );
+		if ( d->lastScrollbarRect.scrollbar == scrollbar &&
+		     d->lastScrollbarRect.rect.isValid() &&
+		     er.intersects( d->lastScrollbarRect.rect ) ) {
+		    region = region.subtract( d->lastScrollbarRect.rect );
+		    p->setClipRegion( region );
+		}
+		if ( sub & SC_ScrollBarSlider && er.intersects( handle ) ) {
+		    region = region.subtract( handle );
+		    p->setClipRegion( region );
+		}
+		tqdrawPrimitive( PE_ScrollBarSubPage, p, er, cg, flags & ~Style_MouseOver, opt );
+		if ( d->lastScrollbarRect.scrollbar == scrollbar &&
+		     d->lastScrollbarRect.rect.isValid() &&
+		     er.intersects( d->lastScrollbarRect.rect ) ) {
+		    if ( sub & SC_ScrollBarSlider && handle.isValid() ) {
+			region = er;
+			region.subtract( handle );
+			p->setClipRegion( region );
+		    } else {
+			p->setClipping( FALSE );
+		    }
+		    qDrawShadePanel( p, d->lastScrollbarRect.rect, cg, TRUE, 1, &cg.brush( TQColorGroup::Dark ) );
+		}
+		p->setClipping( FALSE );
+	    }
+	    if ( sub & SC_ScrollBarSlider ) {
+		p->setClipping( FALSE );
+		if ( subActive == SC_ScrollBarSlider )
+		    flags |= Style_Active;
+
+		tqdrawPrimitive( PE_ScrollBarSlider, p, handle, cg, flags, opt );
+	    }
+#endif
+	}
+	break;
+
+    default:
+	TQMotifStyle::tqdrawComplexControl( control, p, widget, r, cg, flags, sub, subActive, opt );
+	break;
+    }
+}
+
+/*!\reimp
+*/
+TQSize TQSGIStyle::tqsizeFromContents( ContentsType contents,
+				     const TQWidget *widget,
+				     const TQSize &contentsSize,
+				     const TQStyleOption& opt ) const
+{
+    TQSize sz(contentsSize);
+
+    switch(contents) {
+    case CT_PopupMenuItem:
+	{
+#ifndef TQT_NO_POPUPMENU
+	    if (! widget || opt.isDefault())
+		break;
+
+	    TQMenuItem *mi = opt.menuItem();
+	    sz = TQMotifStyle::tqsizeFromContents( contents, widget, contentsSize,
+						opt );
+	    // SGI checkmark items needs a bit more room
+	    const TQPopupMenu *popup = (TQPopupMenu *) widget;
+	    if ( popup && popup->isCheckable() )
+		sz.setWidth( sz.width() + 8 );
+	    // submenu indicator needs a bit more room
+	    if (mi->popup())
+		sz.setWidth( sz.width() + sgiTabSpacing );
+#endif
+	    break;
+	}
+    case CT_ComboBox:
+        sz.rwidth() += 30;
+        break;
+
+    default:
+	sz = TQMotifStyle::tqsizeFromContents( contents, widget, contentsSize, opt );
+	break;
+    }
+
+    return sz;
+}
+
+/*! \reimp */
+TQRect TQSGIStyle::subRect( SubRect r, const TQWidget *widget ) const
+{
+    TQRect rect;
+
+    switch ( r ) {
+    case SR_ComboBoxFocusRect:
+	{
+	    int awh, ax, ay, sh, sy, dh, ew;
+	    int fw = tqpixelMetric( PM_DefaultFrameWidth, widget );
+	    TQRect tr = widget->rect();
+
+	    tr.addCoords( fw, fw, -fw, -fw );
+	    get_combo_parameters( tr, ew, awh, ax, ay, sh, dh, sy );
+	    rect.setRect(ax-2, ay-2, awh+4, awh+sh+dh+4);
+	}
+	break;
+    default:
+	return TQMotifStyle::subRect( r, widget );
+    }
+
+    return rect;
+}
+
+/*! \reimp */
+TQRect TQSGIStyle::querySubControlMetrics( TQ_ComplexControl control,
+					   const TQWidget *widget,
+					   SubControl sub,
+					   const TQStyleOption& opt ) const
+{
+    switch ( control ) {
+    case CC_ComboBox:
+	switch ( sub ) {
+	case SC_ComboBoxFrame:
+	    return widget->rect();
+
+	case SC_ComboBoxArrow: {
+	    int ew, awh, sh, dh, ax, ay, sy;
+	    int fw = tqpixelMetric( PM_DefaultFrameWidth, widget );
+	    TQRect cr = widget->rect();
+	    cr.addCoords( fw, fw, -fw, -fw );
+	    get_combo_parameters( cr, ew, awh, ax, ay, sh, dh, sy );
+	    return TQRect( ax, ay, awh, awh ); }
+
+	case SC_ComboBoxEditField: {
+	    int fw = tqpixelMetric( PM_DefaultFrameWidth, widget );
+	    TQRect rect = widget->rect();
+	    rect.addCoords( fw, fw, -fw, -fw );
+	    int ew = get_combo_extra_width( rect.height() );
+	    rect.addCoords( 1, 1, -1-ew, -1 );
+	    return rect; }
+
+	default:
+	    break;
+	}
+	break;
+	case CC_ScrollBar:
+	    return TQCommonStyle::querySubControlMetrics( control, widget, sub, opt );
+	default: break;
+    }
+    return TQMotifStyle::querySubControlMetrics( control, widget, sub, opt );
+}
+
+#endif // TQT_NO_STYLE_SGI