path: root/tqtinterface/qt4/src/styles/tqcommonstyle.cpp

/****************************************************************************
**
** Implementation of the TQCommonStyle 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 "tqcommonstyle.h"

#ifndef TQT_NO_STYLE

#include "tqmenubar.h"
#include "tqapplication.h"
#include "tqpainter.h"
#include "tqdrawutil.h"
#include "tqpixmap.h"
#include "tqpushbutton.h"
#include "tqtabbar.h"
#include "tqscrollbar.h"
#include "tqtoolbutton.h"
#include "tqtoolbar.h"
#include "tqdockarea.h"
#include "tqheader.h"
#include "tqspinbox.h"
#include "tqrangecontrol.h"
#include "tqgroupbox.h"
#include "tqslider.h"
#include "tqlistview.h"
#include "tqcheckbox.h"
#include "tqradiobutton.h"
#include "tqbitmap.h"
#include "tqprogressbar.h"
#include "private/tqdialogbuttons_p.h"
#include <limits.h>
#include <tqpixmap.h>
#include "../widgets/tqtitlebar_p.h"
#include <tqtoolbox.h>

/*!
    \class TQCommonStyle tqcommonstyle.h
    \brief The TQCommonStyle class encapsulates the common Look and Feel of a GUI.

    \ingroup appearance

    This abstract class implements some of the widget's look and feel
    that is common to all GUI styles provided and shipped as part of
    TQt.

    All the functions are documented in \l TQStyle.
*/

/*!
    \enum TQt::ArrowType

    \value UpArrow
    \value DownArrow
    \value LeftArrow
    \value RightArrow

*/

// the active painter, if any... this is used as an optimzation to
// avoid creating a painter if we have an active one (since
// TQStyle::tqitemRect() needs a painter to operate correctly
static TQPainter *activePainter = 0;

/*!
    Constructs a TQCommonStyle.
*/
TQCommonStyle::TQCommonStyle() : TQStyle()
{
    activePainter = 0;
}

/*! \reimp */
TQCommonStyle::~TQCommonStyle()
{
    activePainter = 0;
}


static const char * const check_list_controller_xpm[] = {
"16 16 4 1",
"	c None",
".	c #000000000000",
"X	c #FFFFFFFF0000",
"o	c #C71BC30BC71B",
"                ",
"                ",
" ..........     ",
" .XXXXXXXX.     ",
" .XXXXXXXX.oo   ",
" .XXXXXXXX.oo   ",
" .XXXXXXXX.oo   ",
" .XXXXXXXX.oo   ",
" .XXXXXXXX.oo   ",
" .XXXXXXXX.oo   ",
" .XXXXXXXX.oo   ",
" ..........oo   ",
"   oooooooooo   ",
"   oooooooooo   ",
"                ",
"                "};

/*! \reimp */
void TQCommonStyle::tqdrawPrimitive( TQ_PrimitiveElement pe,
				  TQPainter *p,
				  const TQRect &r,
				  const TQColorGroup &cg,
				  SFlags flags,
				  const TQStyleOption& opt ) const
{
    activePainter = p;

    switch (pe) {
#ifndef TQT_NO_LISTVIEW
    case TQStyle::PE_CheckListController: {
	p->drawPixmap(r, TQPixmap((const char **)check_list_controller_xpm));
	break; }
    case TQStyle::PE_CheckListExclusiveIndicator: {
	TQCheckListItem *item = opt.checkListItem();
	TQListView *lv = item->listView();
	if(!item)
	    return;
	int x = r.x(), y = r.y();
#define TQCOORDARRLEN(x) sizeof(x)/(sizeof(TQCOORD)*2)
	static const TQCOORD pts1[] = {		// dark lines
	    1,9, 1,8, 0,7, 0,4, 1,3, 1,2, 2,1, 3,1, 4,0, 7,0, 8,1, 9,1 };
	static const TQCOORD pts2[] = {		// black lines
	    2,8, 1,7, 1,4, 2,3, 2,2, 3,2, 4,1, 7,1, 8,2, 9,2 };
	static const TQCOORD pts3[] = {		// background lines
	    2,9, 3,9, 4,10, 7,10, 8,9, 9,9, 9,8, 10,7, 10,4, 9,3 };
	static const TQCOORD pts4[] = {		// white lines
	    2,10, 3,10, 4,11, 7,11, 8,10, 9,10, 10,9, 10,8, 11,7,
	    11,4, 10,3, 10,2 };
	// static const TQCOORD pts5[] = {		// inner fill
	//    4,2, 7,2, 9,4, 9,7, 7,9, 4,9, 2,7, 2,4 };
	//TQPointArray a;
	//	p->eraseRect( x, y, w, h );

	if ( flags & Style_Enabled )
	    p->setPen( cg.text() );
	else
	    p->setPen( TQPen( lv->tqpalette().color( TQPalette::Disabled, TQColorGroup::Text ) ) );
	TQPointArray a( TQCOORDARRLEN(pts1), pts1 );
	a.translate( x, y );
	//p->setPen( cg.dark() );
	p->drawPolyline( a );
	a.setPoints( TQCOORDARRLEN(pts2), pts2 );
	a.translate( x, y );
	p->drawPolyline( a );
	a.setPoints( TQCOORDARRLEN(pts3), pts3 );
	a.translate( x, y );
	//		p->setPen( black );
	p->drawPolyline( a );
	a.setPoints( TQCOORDARRLEN(pts4), pts4 );
	a.translate( x, y );
	//			p->setPen( blue );
	p->drawPolyline( a );
	//		a.setPoints( TQCOORDARRLEN(pts5), pts5 );
	//		a.translate( x, y );
	//	TQColor fillColor = isDown() ? g.background() : g.base();
	//	p->setPen( fillColor );
	//	p->setBrush( fillColor );
	//	p->drawPolygon( a );
	if ( flags & Style_On ) {
	    p->setPen( TQt::NoPen );
	    p->setBrush( cg.text() );
	    p->drawRect( x+5, y+4, 2, 4 );
	    p->drawRect( x+4, y+5, 4, 2 );
	}
	break; }
    case TQStyle::PE_CheckListIndicator: {
	TQCheckListItem *item = opt.checkListItem();
	TQListView *lv = item->listView();
	if(!item)
	    return;
	int x = r.x(), y = r.y(), w = r.width(), h = r.width(), marg = lv->itemMargin();

	if ( flags & Style_Enabled )
	    p->setPen( TQPen( cg.text(), 2 ) );
	else
	    p->setPen( TQPen( lv->tqpalette().color( TQPalette::Disabled, TQColorGroup::Text ),
			     2 ) );
	bool parentControl = FALSE;
	if ( item->tqparent() && item->tqparent()->rtti() == 1  &&
	     ((TQCheckListItem*) item->tqparent())->type() == TQCheckListItem::Controller )
	    parentControl = TRUE;
	if ( flags & Style_Selected && !lv->rootIsDecorated() && !parentControl ) {
	    p->fillRect( 0, 0, x + marg + w + 4, item->height(),
			 cg.brush( TQColorGroup::Highlight ) );
	    if ( item->isEnabled() )
		p->setPen( TQPen( cg.highlightedText(), 2 ) );
	}

	if ( flags & Style_NoChange )
	    p->setBrush( cg.brush( TQColorGroup::Button ) );
	p->drawRect( x+marg, y+2, w-4, h-4 );
	/////////////////////
	x++;
	y++;
	if ( ( flags & Style_On) || ( flags & Style_NoChange ) ) {
	    TQPointArray a( 7*2 );
	    int i, xx = x+1+marg, yy=y+5;
	    for ( i=0; i<3; i++ ) {
		a.setPoint( 2*i,   xx, yy );
		a.setPoint( 2*i+1, xx, yy+2 );
		xx++; yy++;
	    }
	    yy -= 2;
	    for ( i=3; i<7; i++ ) {
		a.setPoint( 2*i,   xx, yy );
		a.setPoint( 2*i+1, xx, yy+2 );
		xx++; yy--;
	    }
	    p->drawLineSegments( a );
	}
	break; }
#endif
    case TQStyle::PE_HeaderArrow:
	p->save();
	if ( flags & Style_Down ) {
	    TQPointArray pa( 3 );
	    p->setPen( cg.light() );
	    p->drawLine( r.x() + r.width(), r.y(), r.x() + r.width() / 2, r.height() );
	    p->setPen( cg.dark() );
	    pa.setPoint( 0, r.x() + r.width() / 2, r.height() );
	    pa.setPoint( 1, r.x(), r.y() );
	    pa.setPoint( 2, r.x() + r.width(), r.y() );
	    p->drawPolyline( pa );
	} else {
	    TQPointArray pa( 3 );
	    p->setPen( cg.light() );
	    pa.setPoint( 0, r.x(), r.height() );
	    pa.setPoint( 1, r.x() + r.width(), r.height() );
	    pa.setPoint( 2, r.x() + r.width() / 2, r.y() );
	    p->drawPolyline( pa );
	    p->setPen( cg.dark() );
	    p->drawLine( r.x(), r.height(), r.x() + r.width() / 2, r.y() );
	}
	p->restore();
	break;

    case TQStyle::PE_StatusBarSection:
	qDrawShadeRect( p, r, cg, TRUE, 1, 0, 0 );
	break;

    case TQStyle::PE_ButtonCommand:
    case TQStyle::PE_ButtonBevel:
    case TQStyle::PE_ButtonTool:
    case TQStyle::PE_ButtonDropDown:
    case TQStyle::PE_HeaderSection:
    case TQStyle::PE_HeaderSectionMenu:
	qDrawShadePanel(p, r, cg, flags & (Style_Sunken | Style_Down | Style_On) , 1,
			&cg.brush(TQColorGroup::Button));
	break;

    case TQStyle::PE_Separator:
	qDrawShadeLine( p, r.left(), r.top(), r.right(), r.bottom(), cg,
			flags & Style_Sunken, 1, 0);
	break;

    case TQStyle::PE_FocusRect: {
	const TQColor *bg = 0;

	if (!opt.isDefault())
	    bg = &opt.color();

	TQPen oldPen = p->pen();

	if (bg) {
	    int h, s, v;
	    bg->hsv(&h, &s, &v);
	    if (v >= 128)
		p->setPen(TQt::black);
	    else
		p->setPen(TQt::white);
	} else
	    p->setPen(cg.foreground());

	if (flags & Style_FocusAtBorder)
	    p->drawRect(TQRect(r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2));
	else
	    p->drawRect(r);

	p->setPen(oldPen);
	break; }

    case TQStyle::PE_SpinWidgetPlus:
    case TQStyle::PE_SpinWidgetMinus: {
	p->save();
	int fw = tqpixelMetric( PM_DefaultFrameWidth, 0 );
	TQRect br;
	br.setRect( r.x() + fw, r.y() + fw, r.width() - fw*2,
		    r.height() - fw*2 );

	p->fillRect( br, cg.brush( TQColorGroup::Button ) );
	p->setPen( cg.buttonText() );
	p->setBrush( cg.buttonText() );

	int length;
	int x = r.x(), y = r.y(), w = r.width(), h = r.height();
	if ( w <= 8 || h <= 6 )
	    length = TQMIN( w-2, h-2 );
	else
	    length = TQMIN( 2*w / 3, 2*h / 3 );

	if ( !(length & 1) )
	    length -=1;
	int xmarg = ( w - length ) / 2;
	int ymarg = ( h - length ) / 2;

	p->drawLine( x + xmarg, ( y + h / 2 - 1 ),
		     x + xmarg + length - 1, ( y + h / 2 - 1 ) );
	if ( pe == TQStyle::PE_SpinWidgetPlus )
	    p->drawLine( ( x+w / 2 ) - 1, y + ymarg,
			 ( x+w / 2 ) - 1, y + ymarg + length - 1 );
	p->restore();
	break; }

    case TQStyle::PE_SpinWidgetUp:
    case TQStyle::PE_SpinWidgetDown: {
	int fw = tqpixelMetric( PM_DefaultFrameWidth, 0 );
	TQRect br;
	br.setRect( r.x() + fw, r.y() + fw, r.width() - fw*2,
		    r.height() - fw*2 );
	p->fillRect( br, cg.brush( TQColorGroup::Button ) );
	int x = r.x(), y = r.y(), w = r.width(), h = r.height();
	int sw = w-4;
	if ( sw < 3 )
	    break;
	else if ( !(sw & 1) )
	    sw--;
	sw -= ( sw / 7 ) * 2;	// Empty border
	int sh = sw/2 + 2;      // Must have empty row at foot of arrow

	int sx = x + w / 2 - sw / 2 - 1;
	int sy = y + h / 2 - sh / 2 - 1;

	TQPointArray a;
	if ( pe == TQStyle::PE_SpinWidgetDown )
	    a.setPoints( 3,  0, 1,  sw-1, 1,  sh-2, sh-1 );
	else
	    a.setPoints( 3,  0, sh-1,  sw-1, sh-1,  sh-2, 1 );
	int bsx = 0;
	int bsy = 0;
	if ( flags & Style_Sunken ) {
	    bsx = tqpixelMetric(PM_ButtonShiftHorizontal);
	    bsy = tqpixelMetric(PM_ButtonShiftVertical);
	}
	p->save();
	p->translate( sx + bsx, sy + bsy );
	p->setPen( cg.buttonText() );
	p->setBrush( cg.buttonText() );
	p->drawPolygon( a );
	p->restore();
	break; }

    case TQStyle::PE_Indicator: {
	if (flags & Style_NoChange) {
	    p->setPen(cg.foreground());
	    p->fillRect(r, cg.brush(TQColorGroup::Button));
	    p->drawRect(r);
	    p->drawLine(r.topLeft(), r.bottomRight());
	} else
	    qDrawShadePanel(p, r.x(), r.y(), r.width(), r.height(),
			    cg, flags & (Style_Sunken | Style_On), 1,
			    &cg.brush(TQColorGroup::Button));
	break; }

    case TQStyle::PE_IndicatorMask: {
	p->fillRect(r, Qt::color1);
	break; }

    case TQStyle::PE_ExclusiveIndicator: {
	TQRect ir = r;
	p->setPen(cg.dark());
	p->drawArc(r, 0, 5760);

	if (flags & (Style_Sunken | Style_On)) {
	    ir.addCoords(2, 2, -2, -2);
	    p->setBrush(cg.foreground());
	    p->drawEllipse(ir);
	}

	break; }

    case TQStyle::PE_ExclusiveIndicatorMask: {
	p->setPen(Qt::color1);
	p->setBrush(Qt::color1);
	p->drawEllipse(r);
	break; }

    case TQStyle::PE_DockWindowHandle: {
	bool highlight = flags & Style_On;

	p->save();
	p->translate( r.x(), r.y() );
	if ( flags & Style_Horizontal ) {
	    int x = r.width() / 3;
	    if ( r.height() > 4 ) {
		qDrawShadePanel( p, x, 2, 3, r.height() - 4,
				 cg, highlight, 1, 0 );
		qDrawShadePanel( p, x+3, 2, 3, r.height() - 4,
				 cg, highlight, 1, 0 );
	    }
	} else {
	    if ( r.width() > 4 ) {
		int y = r.height() / 3;
		qDrawShadePanel( p, 2, y, r.width() - 4, 3,
				 cg, highlight, 1, 0 );
		qDrawShadePanel( p, 2, y+3, r.width() - 4, 3,
				 cg, highlight, 1, 0 );
	    }
	}
	p->restore();
	break;
    }

    case TQStyle::PE_DockWindowSeparator: {
	TQPoint p1, p2;
	if ( flags & Style_Horizontal ) {
	    p1 = TQPoint( r.width()/2, 0 );
	    p2 = TQPoint( p1.x(), r.height() );
	} else {
	    p1 = TQPoint( 0, r.height()/2 );
	    p2 = TQPoint( r.width(), p1.y() );
	}
	qDrawShadeLine( p, p1, p2, cg, 1, 1, 0 );
	break; }

    case TQStyle::PE_Panel:
    case TQStyle::PE_PanelPopup: {
	int lw = opt.isDefault() ? tqpixelMetric(PM_DefaultFrameWidth)
		    : opt.lineWidth();

	qDrawShadePanel(p, r, cg, (flags & Style_Sunken), lw);
	break; }

    case TQStyle::PE_PanelDockWindow: {
	int lw = opt.isDefault() ? tqpixelMetric(PM_DockWindowFrameWidth)
		    : opt.lineWidth();

	qDrawShadePanel(p, r, cg, FALSE, lw);
	break; }

    case TQStyle::PE_PanelMenuBar: {
	int lw = opt.isDefault() ? tqpixelMetric(PM_MenuBarFrameWidth)
		    : opt.lineWidth();

	qDrawShadePanel(p, r, cg, FALSE, lw, &cg.brush(TQColorGroup::Button));
	break; }

    case TQStyle::PE_SizeGrip: {
	p->save();

	int x, y, w, h;
	r.rect(&x, &y, &w, &h);

	int sw = TQMIN( h,w );
	if ( h > w )
	    p->translate( 0, h - w );
	else
	    p->translate( w - h, 0 );

	int sx = x;
	int sy = y;
	int s = sw / 3;

	if ( TQApplication::reverseLayout() ) {
	    sx = x + sw;
	    for ( int i = 0; i < 4; ++i ) {
		p->setPen( TQPen( cg.light(), 1 ) );
		p->drawLine(  x, sy - 1 , sx + 1,  sw );
		p->setPen( TQPen( cg.dark(), 1 ) );
		p->drawLine(  x, sy, sx,  sw );
		p->setPen( TQPen( cg.dark(), 1 ) );
		p->drawLine(  x, sy + 1, sx - 1,  sw );
		sx -= s;
		sy += s;
	    }
	} else {
	    for ( int i = 0; i < 4; ++i ) {
		p->setPen( TQPen( cg.light(), 1 ) );
		p->drawLine(  sx-1, sw, sw,  sy-1 );
		p->setPen( TQPen( cg.dark(), 1 ) );
		p->drawLine(  sx, sw, sw,  sy );
		p->setPen( TQPen( cg.dark(), 1 ) );
		p->drawLine(  sx+1, sw, sw,  sy+1 );
		sx += s;
		sy += s;
	    }
	}

	p->restore();
	break; }

    case TQStyle::PE_CheckMark: {
	const int markW = r.width() > 7 ? 7 : r.width();
	const int markH = markW;
	int posX = r.x() + ( r.width() - markW )/2 + 1;
	int posY = r.y() + ( r.height() - markH )/2;

	// Could do with some optimizing/caching...
	TQPointArray a( markH*2 );
	int i, xx, yy;
	xx = posX;
	yy = 3 + posY;
	for ( i=0; i<markW/2; i++ ) {
	    a.setPoint( 2*i,   xx, yy );
	    a.setPoint( 2*i+1, xx, yy+2 );
	    xx++; yy++;
	}
	yy -= 2;
	for ( ; i<markH; i++ ) {
	    a.setPoint( 2*i,   xx, yy );
	    a.setPoint( 2*i+1, xx, yy+2 );
	    xx++; yy--;
	}
	if ( !(flags & Style_Enabled) && !(flags & Style_On)) {
	    int pnt;
	    p->setPen( cg.highlightedText() );
	    TQPoint offset(1,1);
	    for ( pnt = 0; pnt < (int)a.size(); pnt++ )
		a[pnt] += offset;
	    p->drawLineSegments( a );
	    for ( pnt = 0; pnt < (int)a.size(); pnt++ )
		a[pnt] -= offset;
	}
	p->setPen( cg.text() );
	p->drawLineSegments( a );
	break; }

    case TQStyle::PE_PanelGroupBox: //We really do not need TQStyle::PE_GroupBoxFrame anymore, nasty holdover ###
	tqdrawPrimitive( TQStyle::PE_GroupBoxFrame, p, r, cg, flags, opt );
	break;
    case TQStyle::PE_GroupBoxFrame: {
#ifndef TQT_NO_FRAME
	if ( opt.isDefault() )
	    break;
	int lwidth = opt.lineWidth(), mlwidth = opt.midLineWidth();
	if ( flags & (Style_Sunken|Style_Raised))
	    qDrawShadeRect( p, r.x(), r.y(), r.width(), r.height(), cg, flags & Style_Sunken, lwidth, mlwidth );
	else
	    qDrawPlainRect( p, r.x(), r.y(), r.width(), r.height(), cg.foreground(), lwidth );
#endif
	break; }

    case TQStyle::PE_ProgressBarChunk:
	p->fillRect( r.x(), r.y() + 3, r.width() -2, r.height() - 6,
	    cg.brush(TQColorGroup::Highlight));
	break;

    case TQStyle::PE_PanelLineEdit:
    case TQStyle::PE_PanelTabWidget:
    case TQStyle::PE_WindowFrame:
	tqdrawPrimitive( TQStyle::PE_Panel, p, r, cg, flags, opt );
	break;

    case TQStyle::PE_RubberBand:
	tqdrawPrimitive(TQStyle::PE_FocusRect, p, r, cg, flags, opt);
	break;
    default:
	break;
    }

    activePainter = 0;
}

/*! \reimp */
void TQCommonStyle::tqdrawControl( TQ_ControlElement element,
				TQPainter *p,
				const TQWidget *widget,
				const TQRect &r,
				const TQColorGroup &cg,
				SFlags flags,
				const TQStyleOption& opt ) const
{
#if defined(TQT_CHECK_STATE)
    if (! widget) {
	qWarning("TQCommonStyle::tqdrawControl: widget parameter cannot be zero!");
	return;
    }
#endif

    activePainter = p;

    switch (element) {
    case CE_MenuBarEmptyArea: {
	TQRegion reg;
	if(p->hasClipping()) //ick
	    reg = p->clipRegion();
	else
	    reg = r;
	((TQWidget *)widget)->erase( reg );
	break; }
    case CE_PushButton:
	{
#ifndef TQT_NO_PUSHBUTTON
	    const TQPushButton *button = (const TQPushButton *) widget;
	    TQRect br = r;
	    int dbi = tqpixelMetric(PM_ButtonDefaultIndicator, widget);

	    if (button->isDefault() || button->autoDefault()) {
		if ( button->isDefault())
		    tqdrawPrimitive(TQStyle::PE_ButtonDefault, p, br, cg, flags);

		br.setCoords(br.left()   + dbi,
			     br.top()    + dbi,
			     br.right()  - dbi,
			     br.bottom() - dbi);
	    }

	    p->save();
	    p->setBrushOrigin( -widget->backgroundOffset().x(),
			       -widget->backgroundOffset().y() );
	    tqdrawPrimitive(TQStyle::PE_ButtonCommand, p, br, cg, flags);
	    p->restore();
#endif
	    break;
	}

    case CE_PushButtonLabel:
	{
#ifndef TQT_NO_PUSHBUTTON
	    const TQPushButton *button = (const TQPushButton *) widget;
	    TQRect ir = r;

	    if (button->isDown() || button->isOn()) {
		flags |= Style_Sunken;
		ir.moveBy(tqpixelMetric(PM_ButtonShiftHorizontal, widget),
			  tqpixelMetric(PM_ButtonShiftVertical, widget));
	    }

	    if (button->isMenuButton()) {
		int mbi = tqpixelMetric(PM_MenuButtonIndicator, widget);
		TQRect ar(ir.right() - mbi, ir.y() + 2, mbi - 4, ir.height() - 4);
		tqdrawPrimitive(TQStyle::PE_ArrowDown, p, ar, cg, flags, opt);
		ir.setWidth(ir.width() - mbi);
	    }

	    int tf=TQt::AlignVCenter | TQt::ShowPrefix;
	    if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
		tf |= TQt::NoAccel;

#ifndef TQT_NO_ICONSET
	    if ( button->iconSet() && ! button->iconSet()->isNull() ) {
		TQIconSet::Mode mode =
		    button->isEnabled() ? TQIconSet::Normal : TQIconSet::Disabled;
		if ( mode == TQIconSet::Normal && button->hasFocus() )
		    mode = TQIconSet::Active;

		TQIconSet::State state = TQIconSet::Off;
		if ( button->isToggleButton() && button->isOn() )
		    state = TQIconSet::On;

		TQPixmap pixmap = button->iconSet()->pixmap( TQIconSet::Small, mode, state );
		int pixw = pixmap.width();
		int pixh = pixmap.height();

		//Center the icon if there is neither text nor pixmap
		if ( button->text().isEmpty() && !button->pixmap() )
		    p->drawPixmap( ir.x() + ir.width() / 2 - pixw / 2, ir.y() + ir.height() / 2 - pixh / 2, pixmap );
		else
		    p->drawPixmap( ir.x() + 2, ir.y() + ir.height() / 2 - pixh / 2, pixmap );

		ir.moveBy(pixw + 4, 0);
		ir.setWidth(ir.width() - (pixw + 4));
		// left-align text if there is
		if (!button->text().isEmpty())
		    tf |= TQt::AlignLeft;
		else if (button->pixmap())
		    tf |= TQt::AlignHCenter;
	    } else
#endif //TQT_NO_ICONSET
		tf |= TQt::AlignHCenter;
	    drawItem(p, ir, tf, cg,
		     flags & Style_Enabled, button->pixmap(), button->text(),
		     button->text().length(), TQT_TQCOLOR_CONST(&(cg.buttonText())) );

	    if (flags & Style_HasFocus)
		tqdrawPrimitive(TQStyle::PE_FocusRect, p, subRect(SR_PushButtonFocusRect, widget),
			      cg, flags);
#endif
	    break;
	}

    case CE_CheckBox:
	tqdrawPrimitive(TQStyle::PE_Indicator, p, r, cg, flags, opt);
	break;

    case CE_CheckBoxLabel:
	{
#ifndef TQT_NO_CHECKBOX
	    const TQCheckBox *checkbox = (const TQCheckBox *) widget;

	    int tqalignment = TQApplication::reverseLayout() ? TQt::AlignRight : TQt::AlignLeft;
	    if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
		tqalignment |= TQt::NoAccel;

	    drawItem(p, r, tqalignment | TQt::AlignVCenter | TQt::ShowPrefix, cg,
		     flags & Style_Enabled, checkbox->pixmap(), checkbox->text());

	    if (flags & Style_HasFocus) {
		TQRect fr = tqvisualRect(subRect(SR_CheckBoxFocusRect, widget), widget);
		tqdrawPrimitive(TQStyle::PE_FocusRect, p, fr, cg, flags);
	    }
#endif
	    break;
	}

    case CE_RadioButton:
	tqdrawPrimitive(TQStyle::PE_ExclusiveIndicator, p, r, cg, flags, opt);
	break;

    case CE_RadioButtonLabel:
	{
#ifndef TQT_NO_RADIOBUTTON
	    const TQRadioButton *radiobutton = (const TQRadioButton *) widget;

	    int tqalignment = TQApplication::reverseLayout() ? TQt::AlignRight : TQt::AlignLeft;
	    if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
		tqalignment |= TQt::NoAccel;
	    drawItem(p, r, tqalignment | TQt::AlignVCenter | TQt::ShowPrefix, cg,
		     flags & Style_Enabled, radiobutton->pixmap(), radiobutton->text());

	    if (flags & Style_HasFocus) {
		TQRect fr = tqvisualRect(subRect(SR_RadioButtonFocusRect, widget), widget);
		tqdrawPrimitive(TQStyle::PE_FocusRect, p, fr, cg, flags);
	    }
#endif
	    break;
	}

#ifndef TQT_NO_TABBAR
    case CE_TabBarTab:
	{
	    const TQTabBar * tb = (const TQTabBar *) widget;

	    if ( tb->tqshape() == TQTabBar::TriangularAbove ||
		 tb->tqshape() == TQTabBar::TriangularBelow ) {
		// triangular, above or below
		int y;
		int x;
		TQPointArray a( 10 );
		a.setPoint( 0, 0, -1 );
		a.setPoint( 1, 0, 0 );
		y = r.height()-2;
		x = y/3;
		a.setPoint( 2, x++, y-1 );
		a.setPoint( 3, x++, y );
		a.setPoint( 3, x++, y++ );
		a.setPoint( 4, x, y );

		int i;
		int right = r.width() - 1;
		for ( i = 0; i < 5; i++ )
		    a.setPoint( 9-i, right - a.point( i ).x(), a.point( i ).y() );

		if ( tb->tqshape() == TQTabBar::TriangularAbove )
		    for ( i = 0; i < 10; i++ )
			a.setPoint( i, a.point(i).x(),
				    r.height() - 1 - a.point( i ).y() );

		a.translate( r.left(), r.top() );

		if ( flags & Style_Selected )
		    p->setBrush( cg.base() );
		else
		    p->setBrush( cg.background() );
		p->setPen( cg.foreground() );
		p->drawPolygon( a );
		p->setBrush( TQt::NoBrush );
	    }
	    break;
	}

    case CE_TabBarLabel:
	{
	    if ( opt.isDefault() )
		break;

	    const TQTabBar * tb = (const TQTabBar *) widget;
	    TQTab * t = opt.tab();

	    TQRect tr = r;
	    if ( t->identifier() == tb->currentTab() )
		tr.setBottom( tr.bottom() -
			      tqpixelMetric( TQStyle::PM_DefaultFrameWidth, tb ) );

	    int tqalignment = TQt::AlignCenter | TQt::ShowPrefix;
	    if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
		tqalignment |= TQt::NoAccel;
	    drawItem( p, tr, tqalignment, cg,
		      flags & Style_Enabled, 0, t->text() );

	    if ( (flags & Style_HasFocus) && !t->text().isEmpty() )
		tqdrawPrimitive( TQStyle::PE_FocusRect, p, r, cg );
	    break;
	}
#endif // TQT_NO_TABBAR
#ifndef TQT_NO_TOOLBOX
    case CE_ToolBoxTab:
	{
	    int d = 20 + r.height() - 3;
	    TQPointArray a( 7 );
	    a.setPoint( 0, -1, r.height() + 1 );
	    a.setPoint( 1, -1, 1 );
	    a.setPoint( 2, r.width() - d, 1 );
	    a.setPoint( 3, r.width() - 20, r.height() - 2 );
	    a.setPoint( 4, r.width() - 1, r.height() - 2 );
	    a.setPoint( 5, r.width() - 1, r.height() + 1 );
	    a.setPoint( 6, -1, r.height() + 1 );

	    const TQToolBox *tb = (const TQToolBox*)widget;

	    if ( flags & Style_Selected && tb->currentItem() )
		p->setBrush( tb->currentItem()->paletteBackgroundColor() );
	    else
		p->setBrush( cg.brush(TQColorGroup::Background) );

	    p->setPen( cg.mid().dark( 150 ) );
	    p->drawPolygon( a );
	    p->setPen( cg.light() );
	    p->drawLine( 0, 2, r.width() - d, 2 );
	    p->drawLine( r.width() - d - 1, 2, r.width() - 21, r.height() - 1 );
	    p->drawLine( r.width() - 20, r.height() - 1, r.width(), r.height() - 1 );
	    p->setBrush( TQt::NoBrush );
	    break;
	}
#endif // TQT_NO_TOOLBOX
    case CE_ProgressBarGroove:
	qDrawShadePanel(p, r, cg, TRUE, 1, &cg.brush(TQColorGroup::Background));
	break;

#ifndef TQT_NO_PROGRESSBAR
    case CE_ProgressBarContents:
	{
	    const TQProgressBar *progressbar = (const TQProgressBar *) widget;
	    // Correct the highlight color if same as background,
	    // or else we cannot see the progress...
	    TQColorGroup cgh = cg;
	    if ( cgh.highlight() == cgh.background() )
		cgh.setColor( TQColorGroup::Highlight, progressbar->tqpalette().active().highlight() );
	    bool reverse = TQApplication::reverseLayout();
	    int fw = 2;
	    int w = r.width() - 2*fw;
	    if ( !progressbar->totalSteps() ) {
		// draw busy indicator
		int x = progressbar->progress() % (w * 2);
		if (x > w)
		    x = 2 * w - x;
		x = reverse ? r.right() - x : x + r.x();
		p->setPen( TQPen(cgh.highlight(), 4) );
		p->drawLine(x, r.y() + 1, x, r.height() - fw);
	    } else {
		const int unit_width = tqpixelMetric(PM_ProgressBarChunkWidth, widget);
		int u;
		if ( unit_width > 1 )
		    u = (r.width()+unit_width/3) / unit_width;
		else
		    u = w / unit_width;
		int p_v = progressbar->progress();
		int t_s = progressbar->totalSteps() ? progressbar->totalSteps() : 1;

		if ( u > 0 && p_v >= INT_MAX / u && t_s >= u ) {
		    // scale down to something usable.
		    p_v /= u;
		    t_s /= u;
		}

		// nu < tnu, if last chunk is only a partial chunk
		int tnu, nu;
		tnu = nu = p_v * u / t_s;

		if (nu * unit_width > w)
		    nu--;

		// Draw nu units out of a possible u of unit_width
		// width, each a rectangle bordered by background
		// color, all in a sunken panel with a percentage text
		// display at the end.
		int x = 0;
		int x0 = reverse ? r.right() - ((unit_width > 1) ?
						unit_width : fw) : r.x() + fw;
		for (int i=0; i<nu; i++) {
		    tqdrawPrimitive( TQStyle::PE_ProgressBarChunk, p,
				   TQRect( x0+x, r.y(), unit_width, r.height() ),
				   cgh, Style_Default, opt );
		    x += reverse ? -unit_width: unit_width;
		}

		// Draw the last partial chunk to fill up the
		// progressbar entirely
		if (nu < tnu) {
		    int pixels_left = w - (nu*unit_width);
		    int offset = reverse ? x0+x+unit_width-pixels_left : x0+x;
		    tqdrawPrimitive( TQStyle::PE_ProgressBarChunk, p,
				   TQRect( offset, r.y(), pixels_left,
					  r.height() ), cgh, Style_Default,
				   opt );
		}
	    }
	}
	break;

    case CE_ProgressBarLabel:
	{
	    const TQProgressBar *progressbar = (const TQProgressBar *) widget;
	    TQColor penColor = cg.highlightedText();
	    TQColor *pcolor = 0;
	    if ( progressbar->centerIndicator() && !progressbar->indicatorFollowsStyle() &&
		 progressbar->progress()*2 >= progressbar->totalSteps() )
		pcolor = &penColor;
	    drawItem(p, r, TQt::AlignCenter | TQt::SingleLine, cg, flags & Style_Enabled, 0,
		     progressbar->progressString(), -1, pcolor );
	}
	break;
#endif // TQT_NO_PROGRESSBAR

    case CE_MenuBarItem:
	{
#ifndef TQT_NO_MENUDATA
	    if (opt.isDefault())
		break;

	    TQMenuItem *mi = opt.menuItem();
	    int tqalignment = TQt::AlignCenter|TQt::ShowPrefix|TQt::DontClip|TQt::SingleLine;
	    if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
		tqalignment |= TQt::NoAccel;
	    drawItem( p, r, tqalignment, cg,
		      flags & Style_Enabled, mi->pixmap(), mi->text(), -1,
		      TQT_TQCOLOR_CONST(&cg.buttonText()) );
#endif
	    break;
	}

#ifndef TQT_NO_TOOLBUTTON
    case CE_ToolButtonLabel:
	{
	    const TQToolButton *toolbutton = (const TQToolButton *) widget;
	    TQRect rect = r;
	    TQt::ArrowType arrowType = opt.isDefault()
			? TQt::DownArrow : opt.arrowType();

	    int shiftX = 0;
	    int shiftY = 0;
	    if (flags & (Style_Down | Style_On)) {
		shiftX = tqpixelMetric(PM_ButtonShiftHorizontal, widget);
		shiftY = tqpixelMetric(PM_ButtonShiftVertical, widget);
	    }

	    if (!opt.isDefault()) {
		PrimitiveElement pe;
		switch (arrowType) {
		case TQt::LeftArrow:  pe = TQStyle::PE_ArrowLeft;  break;
		case TQt::RightArrow: pe = TQStyle::PE_ArrowRight; break;
		case TQt::UpArrow:    pe = TQStyle::PE_ArrowUp;    break;
		default:
		case TQt::DownArrow:  pe = TQStyle::PE_ArrowDown;  break;
		}

		rect.moveBy(shiftX, shiftY);
		tqdrawPrimitive(pe, p, rect, cg, flags, opt);
	    } else {
		TQColor btext = toolbutton->paletteForegroundColor();

		if (toolbutton->iconSet().isNull() &&
		    ! toolbutton->text().isNull() &&
		    ! toolbutton->usesTextLabel()) {
		    int tqalignment = TQt::AlignCenter | TQt::ShowPrefix;
		    if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
			tqalignment |= TQt::NoAccel;

		    rect.moveBy(shiftX, shiftY);
		    drawItem(p, rect, tqalignment, cg,
			     flags & Style_Enabled, 0, toolbutton->text(),
			     toolbutton->text().length(), &btext);
		} else {
		    TQPixmap pm;
		    TQIconSet::Size size =
			toolbutton->usesBigPixmap() ? TQIconSet::Large : TQIconSet::Small;
		    TQIconSet::State state =
			toolbutton->isOn() ? TQIconSet::On : TQIconSet::Off;
		    TQIconSet::Mode mode;
		    if (! toolbutton->isEnabled())
			mode = TQIconSet::Disabled;
		    else if ((flags & (Style_Down | Style_On)) ||
			     ((flags & Style_Raised) && (flags & Style_AutoRaise)))
			mode = TQIconSet::Active;
		    else
			mode = TQIconSet::Normal;
		    pm = toolbutton->iconSet().pixmap( size, mode, state );

		    if ( toolbutton->usesTextLabel() ) {
			p->setFont( toolbutton->font() );
			TQRect pr = rect, tr = rect;
			int tqalignment = TQt::ShowPrefix;
			if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
			    tqalignment |= TQt::NoAccel;

			if ( toolbutton->textPosition() == TQToolButton::Under ) {
			    int fh = p->fontMetrics().height();
			    pr.addCoords( 0, 1, 0, -fh-3 );
			    tr.addCoords( 0, pr.bottom(), 0, -3 );
			    pr.moveBy(shiftX, shiftY);
			    drawItem( p, pr, TQt::AlignCenter, cg, TRUE, &pm, TQString::null );
			    tqalignment |= TQt::AlignCenter;
			} else {
			    pr.setWidth( pm.width() + 8 );
			    tr.addCoords( pr.right(), 0, 0, 0 );
			    pr.moveBy(shiftX, shiftY);

			    drawItem( p, pr, TQt::AlignCenter, cg, TRUE, &pm, TQString::null );
			    tqalignment |= TQt::AlignLeft | TQt::AlignVCenter;
			}

			tr.moveBy(shiftX, shiftY);
			drawItem( p, tr, tqalignment, cg,
				  flags & Style_Enabled, 0, toolbutton->textLabel(),
				  toolbutton->textLabel().length(), &btext);
		    } else {
			rect.moveBy(shiftX, shiftY);
			drawItem( p, rect, TQt::AlignCenter, cg, TRUE, &pm, TQString::null );
		    }
		}
	    }

	    break;
	}
#endif // TQT_NO_TOOLBUTTON
#ifndef TQT_NO_HEADER
        case CE_HeaderLabel:
	{
	    TQRect rect = r;
	    const TQHeader* header = (const TQHeader *) widget;
	    int section = opt.headerSection();

	    TQIconSet* icon = header->iconSet( section );
	    if ( icon ) {
		TQPixmap pixmap = icon->pixmap( TQIconSet::Small,
					       flags & Style_Enabled ?
					       TQIconSet::Normal : TQIconSet::Disabled );
		int pixw = pixmap.width();
		int pixh = pixmap.height();
		// "pixh - 1" because of tricky integer division

		TQRect pixRect = rect;
		pixRect.setY( rect.center().y() - (pixh - 1) / 2 );
		drawItem ( p, pixRect, TQt::AlignVCenter, cg, flags & Style_Enabled,
			   &pixmap, TQString::null );
                if (TQApplication::reverseLayout())
                    rect.setRight(rect.right() - pixw - 2);
                else
                    rect.setLeft(rect.left() + pixw + 2);
	    }

            if (rect.isValid())
                drawItem ( p, rect, TQt::AlignVCenter, cg, flags & Style_Enabled,
                           0, header->label( section ), -1, TQT_TQCOLOR_CONST(&(cg.buttonText())) );
	}
#endif // TQT_NO_HEADER
    default:
	break;
    }

    activePainter = 0;
}

/*! \reimp */
void TQCommonStyle::tqdrawControlMask( TQ_ControlElement control,
				    TQPainter *p,
				    const TQWidget *widget,
				    const TQRect &r,
				    const TQStyleOption& opt ) const
{
    TQ_UNUSED(widget);

    activePainter = p;

    TQColorGroup cg(Qt::color1,Qt::color1,Qt::color1,Qt::color1,Qt::color1,Qt::color1,Qt::color1,Qt::color1,Qt::color0);

    switch (control) {
    case CE_PushButton:
	tqdrawPrimitive(TQStyle::PE_ButtonCommand, p, r, cg, Style_Default, opt);
	break;

    case CE_CheckBox:
	tqdrawPrimitive(TQStyle::PE_IndicatorMask, p, r, cg, Style_Default, opt);
	break;

    case CE_RadioButton:
	tqdrawPrimitive(TQStyle::PE_ExclusiveIndicatorMask, p, r, cg, Style_Default, opt);
	break;

    default:
	p->fillRect(r, Qt::color1);
	break;
    }

    activePainter = 0;
}

/*! \reimp */
TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
{
#if defined(TQT_CHECK_STATE)
    if (! widget) {
	qWarning("TQCommonStyle::subRect: widget parameter cannot be zero!");
	return TQRect();
    }
#endif

    TQRect rect, wrect(widget->rect());

    switch (r) {
#ifndef TQT_NO_DIALOGBUTTONS
    case SR_DialogButtonAbort:
    case SR_DialogButtonRetry:
    case SR_DialogButtonIgnore:
    case SR_DialogButtonAccept:
    case SR_DialogButtonReject:
    case SR_DialogButtonApply:
    case SR_DialogButtonHelp:
    case SR_DialogButtonAll:
    case SR_DialogButtonCustom: {
	TQDialogButtons::Button srch = TQDialogButtons::None;
	if(r == SR_DialogButtonAccept)
	    srch = TQDialogButtons::Accept;
	else if(r == SR_DialogButtonReject)
	    srch = TQDialogButtons::Reject;
	else if(r == SR_DialogButtonAll)
	    srch = TQDialogButtons::All;
	else if(r == SR_DialogButtonApply)
	    srch = TQDialogButtons::Apply;
	else if(r == SR_DialogButtonHelp)
	    srch = TQDialogButtons::Help;
	else if(r == SR_DialogButtonRetry)
	    srch = TQDialogButtons::Retry;
	else if(r == SR_DialogButtonIgnore)
	    srch = TQDialogButtons::Ignore;
	else if(r == SR_DialogButtonAbort)
	    srch = TQDialogButtons::Abort;

	const int bwidth = tqpixelMetric(PM_DialogButtonsButtonWidth, widget),
		 bheight = tqpixelMetric(PM_DialogButtonsButtonHeight, widget),
		  bspace = tqpixelMetric(PM_DialogButtonsSeparator, widget),
		      fw = tqpixelMetric(PM_DefaultFrameWidth, widget);
	const TQDialogButtons *dbtns = (const TQDialogButtons *) widget;
	int start = fw;
	if(dbtns->orientation() == Qt::Horizontal)
	    start = wrect.right() - fw;
	TQDialogButtons::Button btns[] = { TQDialogButtons::All, TQDialogButtons::Reject, TQDialogButtons::Accept, //reverse order (right to left)
					  TQDialogButtons::Apply, TQDialogButtons::Retry, TQDialogButtons::Ignore, TQDialogButtons::Abort,
					  TQDialogButtons::Help };
	for(unsigned int i = 0, cnt = 0; i < (sizeof(btns)/sizeof(btns[0])); i++) {
	    if(dbtns->isButtonVisible(btns[i])) {
		TQSize szH = dbtns->tqsizeHint(btns[i]);
		int mwidth = TQMAX(bwidth, szH.width()), mheight = TQMAX(bheight, szH.height());
		if(dbtns->orientation() == Qt::Horizontal) {
		    start -= mwidth;
		    if(cnt)
			start -= bspace;
		} else if(cnt) {
		    start += mheight;
		    start += bspace;
		}
		cnt++;
		if(btns[i] == srch) {
		    if(dbtns->orientation() == Qt::Horizontal)
			return TQRect(start, wrect.bottom() - fw - mheight, mwidth, mheight);
		    else
			return TQRect(fw, start, mwidth, mheight);
		}
	    }
	}
	if(r == SR_DialogButtonCustom) {
	    if(dbtns->orientation() == Qt::Horizontal)
		return TQRect(fw, fw, start - fw - bspace, wrect.height() - (fw*2));
	    else
		return TQRect(fw, start, wrect.width() - (fw*2), wrect.height() - start - (fw*2));
	}
	return TQRect(); }
#endif //TQT_NO_DIALOGBUTTONS
    case SR_PushButtonContents:
	{
#ifndef TQT_NO_PUSHBUTTON
	    const TQPushButton *button = (const TQPushButton *) widget;
	    int dx1, dx2;

	    dx1 = tqpixelMetric(PM_DefaultFrameWidth, widget);
	    if (button->isDefault() || button->autoDefault())
		dx1 += tqpixelMetric(PM_ButtonDefaultIndicator, widget);
	    dx2 = dx1 * 2;

	    rect.setRect(wrect.x()      + dx1,
			 wrect.y()      + dx1,
			 wrect.width()  - dx2,
			 wrect.height() - dx2);
#endif
	    break;
	}

    case SR_PushButtonFocusRect:
	{
#ifndef TQT_NO_PUSHBUTTON
	    const TQPushButton *button = (const TQPushButton *) widget;
	    int dbw1 = 0, dbw2 = 0;
	    if (button->isDefault() || button->autoDefault()) {
		dbw1 = tqpixelMetric(PM_ButtonDefaultIndicator, widget);
		dbw2 = dbw1 * 2;
	    }

	    int dfw1 = tqpixelMetric(PM_DefaultFrameWidth, widget) * 2,
		dfw2 = dfw1 * 2;

	    rect.setRect(wrect.x()      + dfw1 + dbw1,
			 wrect.y()      + dfw1 + dbw1,
			 wrect.width()  - dfw2 - dbw2,
			 wrect.height() - dfw2 - dbw2);
#endif
	    break;
	}

    case SR_CheckBoxIndicator:
	{
	    int h = tqpixelMetric( PM_IndicatorHeight, widget );
	    rect.setRect(0, ( wrect.height() - h ) / 2,
			 tqpixelMetric( PM_IndicatorWidth, widget ), h );
	    break;
	}

    case SR_CheckBoxContents:
	{
#ifndef TQT_NO_CHECKBOX
	    TQRect ir = subRect(SR_CheckBoxIndicator, widget);
	    rect.setRect(ir.right() + 6, wrect.y(),
			 wrect.width() - ir.width() - 6, wrect.height());
#endif
	    break;
	}

    case SR_CheckBoxFocusRect:
	{
#ifndef TQT_NO_CHECKBOX
	    const TQCheckBox *checkbox = (const TQCheckBox *) widget;
	    if ( !checkbox->pixmap() && checkbox->text().isEmpty() ) {
		rect = subRect( SR_CheckBoxIndicator, widget );
		rect.addCoords( 1, 1, -1, -1 );
		break;
	    }
	    TQRect cr = subRect(SR_CheckBoxContents, widget);

	    // don't create a painter if we have an active one
	    TQPainter *p = 0;
	    if (! activePainter)
		p = new TQPainter(checkbox);
	    rect = tqitemRect((activePainter ? activePainter : p),
			    cr, TQt::AlignLeft | TQt::AlignVCenter | TQt::ShowPrefix,
			    checkbox->isEnabled(),
			    checkbox->pixmap(),
			    checkbox->text());

	    delete p;

	    rect.addCoords( -3, -2, 3, 2 );
	    rect = rect.intersect(wrect);
#endif
	    break;
	}

    case SR_RadioButtonIndicator:
	{
	    int h = tqpixelMetric( PM_ExclusiveIndicatorHeight, widget );
	    rect.setRect(0, ( wrect.height() - h ) / 2,
			 tqpixelMetric( PM_ExclusiveIndicatorWidth, widget ), h );
	    break;
	}

    case SR_RadioButtonContents:
	{
	    TQRect ir = subRect(SR_RadioButtonIndicator, widget);
	    rect.setRect(ir.right() + 6, wrect.y(),
			 wrect.width() - ir.width() - 6, wrect.height());
	    break;
	}

    case SR_RadioButtonFocusRect:
	{
#ifndef TQT_NO_RADIOBUTTON
	    const TQRadioButton *radiobutton = (const TQRadioButton *) widget;
	    if ( !radiobutton->pixmap() && radiobutton->text().isEmpty() ) {
		rect = subRect( SR_RadioButtonIndicator, widget );
		rect.addCoords( 1, 1, -1, -1 );
		break;
	    }
	    TQRect cr = subRect(SR_RadioButtonContents, widget);

	    // don't create a painter if we have an active one
	    TQPainter *p = 0;
	    if (! activePainter)
		p = new TQPainter(radiobutton);
	    rect = tqitemRect((activePainter ? activePainter : p),
			    cr, TQt::AlignLeft | TQt::AlignVCenter | TQt::ShowPrefix,
			    radiobutton->isEnabled(),
			    radiobutton->pixmap(),
			    radiobutton->text());
	    delete p;

	    rect.addCoords( -3, -2, 3, 2 );
	    rect = rect.intersect(wrect);
#endif
	    break;
	}

    case SR_ComboBoxFocusRect:
	rect.setRect(3, 3, widget->width()-6-16, widget->height()-6);
	break;

#ifndef TQT_NO_SLIDER
    case SR_SliderFocusRect:
	{
	    const TQSlider * sl = (const TQSlider *) widget;
	    int tickOffset = tqpixelMetric( PM_SliderTickmarkOffset, sl );
	    int thickness  = tqpixelMetric( PM_SliderControlThickness, sl );

	    if ( sl->orientation() == Qt::Horizontal )
		rect.setRect( 0, tickOffset-1, sl->width(), thickness+2 );
	    else
		rect.setRect( tickOffset-1, 0, thickness+2, sl->height() );
	    rect = rect.intersect( sl->rect() ); // ## is this really necessary?
	    break;
	}
#endif // TQT_NO_SLIDER

#ifndef TQT_NO_MAINWINDOW
    case SR_DockWindowHandleRect:
	{
	    if (! widget->parentWidget())
		break;

	    const TQDockWindow * dw = (const TQDockWindow *) widget->parentWidget();

	    if ( !dw->area() || !dw->isCloseEnabled() )
		rect.setRect( 0, 0, widget->width(), widget->height() );
	    else {
		if ( dw->area()->orientation() == Qt::Horizontal )
		    rect.setRect(0, 15, widget->width(), widget->height() - 15);
		else
		    rect.setRect(0, 1, widget->width() - 15, widget->height() - 1);
	    }
	    break;
	}
#endif // TQT_NO_MAINWINDOW

    case SR_ProgressBarGroove:
    case SR_ProgressBarContents:
	{
#ifndef TQT_NO_PROGRESSBAR
	    TQFontMetrics fm( ( widget ? widget->fontMetrics() :
			       TQApplication::fontMetrics() ) );
	    const TQProgressBar *progressbar = (const TQProgressBar *) widget;
	    int textw = 0;
	    if (progressbar->percentageVisible())
		textw = fm.width("100%") + 6;

	    if (progressbar->indicatorFollowsStyle() ||
		! progressbar->centerIndicator())
		rect.setCoords(wrect.left(), wrect.top(),
			       wrect.right() - textw, wrect.bottom());
	    else
		rect = wrect;
#endif
	    break;
	}

    case SR_ProgressBarLabel:
	{
#ifndef TQT_NO_PROGRESSBAR
	    TQFontMetrics fm( ( widget ? widget->fontMetrics() :
			       TQApplication::fontMetrics() ) );
	    const TQProgressBar *progressbar = (const TQProgressBar *) widget;
	    int textw = 0;
	    if (progressbar->percentageVisible())
		textw = fm.width("100%") + 6;

	    if (progressbar->indicatorFollowsStyle() ||
		! progressbar->centerIndicator())
		rect.setCoords(wrect.right() - textw, wrect.top(),
			       wrect.right(), wrect.bottom());
	    else
		rect = wrect;
#endif
	    break;
	}

    case SR_ToolButtonContents:
	rect = querySubControlMetrics(CC_ToolButton, widget, SC_ToolButton);
	break;

    case SR_ToolBoxTabContents:
	rect = wrect;
	rect.addCoords( 0, 0, -30, 0 );
	break;

    default:
	rect = wrect;
	break;
    }

    return rect;
}

#ifndef TQT_NO_RANGECONTROL
/*
  I really need this and I don't want to expose it in TQRangeControl..
*/
static int qPositionFromValue( const TQRangeControl * rc, int logical_val,
			       int span )
{
    if ( span <= 0 || logical_val < rc->minValue() ||
	 rc->maxValue() <= rc->minValue() )
	return 0;
    if ( logical_val > rc->maxValue() )
	return span;

    uint range = rc->maxValue() - rc->minValue();
    uint p = logical_val - rc->minValue();

    if ( range > (uint)INT_MAX/4096 ) {
	const int scale = 4096*2;
	return ( (p/scale) * span ) / (range/scale);
	// ### the above line is probably not 100% correct
	// ### but fixing it isn't worth the extreme pain...
    } else if ( range > (uint)span ) {
	return (2*p*span + range) / (2*range);
    } else {
	uint div = span / range;
	uint mod = span % range;
	return p*div + (2*p*mod + range) / (2*range);
    }
    //equiv. to (p*span)/range + 0.5
    // no overflow because of this implicit assumption:
    // span <= 4096
}
#endif // TQT_NO_RANGECONTROL

/*! \reimp */
void TQCommonStyle::tqdrawComplexControl( TQ_ComplexControl control,
				       TQPainter *p,
				       const TQWidget *widget,
				       const TQRect &r,
				       const TQColorGroup &cg,
				       SFlags flags,
				       SCFlags controls,
				       SCFlags active,
				       const TQStyleOption& opt ) const
{
#if defined(TQT_CHECK_STATE)
    if (! widget) {
	qWarning("TQCommonStyle::tqdrawComplexControl: widget parameter cannot be zero!");
	return;
    }
#endif

    activePainter = p;

    switch (control) {
#ifndef TQT_NO_SCROLLBAR
    case CC_ScrollBar:
	{
	    const TQScrollBar *scrollbar = (const TQScrollBar *) widget;
	    TQRect addline, subline, addpage, subpage, slider, first, last;
	    bool maxedOut = (scrollbar->minValue() == scrollbar->maxValue());

	    subline = querySubControlMetrics(control, widget, SC_ScrollBarSubLine, opt);
	    addline = querySubControlMetrics(control, widget, SC_ScrollBarAddLine, opt);
	    subpage = querySubControlMetrics(control, widget, SC_ScrollBarSubPage, opt);
	    addpage = querySubControlMetrics(control, widget, SC_ScrollBarAddPage, opt);
	    slider  = querySubControlMetrics(control, widget, SC_ScrollBarSlider,  opt);
	    first   = querySubControlMetrics(control, widget, SC_ScrollBarFirst,   opt);
	    last    = querySubControlMetrics(control, widget, SC_ScrollBarLast,    opt);

       	    if ((controls & SC_ScrollBarSubLine) && subline.isValid())
		tqdrawPrimitive(TQStyle::PE_ScrollBarSubLine, p, subline, cg,
			      (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) |
			      ((active == SC_ScrollBarSubLine) ?
			       Style_Down : Style_Default) |
			      ((scrollbar->orientation() == Qt::Horizontal) ?
			       Style_Horizontal : 0)));
	    if ((controls & SC_ScrollBarAddLine) && addline.isValid())
		tqdrawPrimitive(TQStyle::PE_ScrollBarAddLine, p, addline, cg,
			      (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) |
			      ((active == SC_ScrollBarAddLine) ?
			       Style_Down : Style_Default) |
			      ((scrollbar->orientation() == Qt::Horizontal) ?
			       Style_Horizontal : 0)));
	    if ((controls & SC_ScrollBarSubPage) && subpage.isValid())
		tqdrawPrimitive(TQStyle::PE_ScrollBarSubPage, p, subpage, cg,
			      (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) |
			      ((active == SC_ScrollBarSubPage) ?
			       Style_Down : Style_Default) |
			      ((scrollbar->orientation() == Qt::Horizontal) ?
			       Style_Horizontal : 0)));
	    if ((controls & SC_ScrollBarAddPage) && addpage.isValid())
		tqdrawPrimitive(TQStyle::PE_ScrollBarAddPage, p, addpage, cg,
			      (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) |
			      ((active == SC_ScrollBarAddPage) ?
			       Style_Down : Style_Default) |
			      ((scrollbar->orientation() == Qt::Horizontal) ?
			       Style_Horizontal : 0)));
       	    if ((controls & SC_ScrollBarFirst) && first.isValid())
		tqdrawPrimitive(TQStyle::PE_ScrollBarFirst, p, first, cg,
			      (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) |
			      ((active == SC_ScrollBarFirst) ?
			       Style_Down : Style_Default) |
			      ((scrollbar->orientation() == Qt::Horizontal) ?
			       Style_Horizontal : 0)));
	    if ((controls & SC_ScrollBarLast) && last.isValid())
		tqdrawPrimitive(TQStyle::PE_ScrollBarLast, p, last, cg,
			      (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) |
			      ((active == SC_ScrollBarLast) ?
			       Style_Down : Style_Default) |
			      ((scrollbar->orientation() == Qt::Horizontal) ?
			       Style_Horizontal : 0)));
	    if ((controls & SC_ScrollBarSlider) && slider.isValid()) {
		tqdrawPrimitive(TQStyle::PE_ScrollBarSlider, p, slider, cg,
			      (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) |
			      ((active == SC_ScrollBarSlider) ?
			       Style_Down : Style_Default) |
			      ((scrollbar->orientation() == Qt::Horizontal) ?
			       Style_Horizontal : 0)));

		// ### perhaps this should not be able to accept focus if maxedOut?
		if (scrollbar->hasFocus()) {
		    TQRect fr(slider.x() + 2, slider.y() + 2,
			     slider.width() - 5, slider.height() - 5);
		    tqdrawPrimitive(TQStyle::PE_FocusRect, p, fr, cg, Style_Default);
		}
	    }

	    break;
	}
#endif // TQT_NO_SCROLLBAR

#ifndef TQT_NO_TOOLBUTTON
    case CC_ToolButton:
	{
	    const TQToolButton *toolbutton = (const TQToolButton *) widget;

	    TQColorGroup c = cg;
	    if ( toolbutton->backgroundMode() != TQt::PaletteButton )
		c.setBrush( TQColorGroup::Button,
			    toolbutton->paletteBackgroundColor() );
	    TQRect button, menuarea;
	    button   = tqvisualRect( querySubControlMetrics(control, widget, SC_ToolButton, opt), widget );
	    menuarea = tqvisualRect( querySubControlMetrics(control, widget, SC_ToolButtonMenu, opt), widget );

	    SFlags bflags = flags,
		   mflags = flags;

	    if (active & SC_ToolButton)
		bflags |= Style_Down;
	    if (active & SC_ToolButtonMenu)
		mflags |= Style_Down;

	    if (controls & SC_ToolButton) {
		if (bflags & (Style_Down | Style_On | Style_Raised)) {
		    tqdrawPrimitive(TQStyle::PE_ButtonTool, p, button, c, bflags, opt);
		} else if ( toolbutton->parentWidget() &&
			  toolbutton->parentWidget()->backgroundPixmap() &&
			  ! toolbutton->parentWidget()->backgroundPixmap()->isNull() ) {
		    TQPixmap pixmap =
			*(toolbutton->parentWidget()->backgroundPixmap());

		    p->drawTiledPixmap( r, pixmap, toolbutton->pos() );
		}
	    }

	    if (controls & SC_ToolButtonMenu) {
		if (mflags & (Style_Down | Style_On | Style_Raised))
		    tqdrawPrimitive(TQStyle::PE_ButtonDropDown, p, menuarea, c, mflags, opt);
		tqdrawPrimitive(TQStyle::PE_ArrowDown, p, menuarea, c, mflags, opt);
	    }

	    if (toolbutton->hasFocus() && !toolbutton->focusProxy()) {
		TQRect fr = toolbutton->rect();
		fr.addCoords(3, 3, -3, -3);
		tqdrawPrimitive(TQStyle::PE_FocusRect, p, fr, c);
	    }

	    break;
	}
#endif // TQT_NO_TOOLBUTTON

#ifndef TQT_NO_TITLEBAR
    case CC_TitleBar:
	{
	    const TQTitleBar *titlebar = (const TQTitleBar *) widget;
	    if ( controls & SC_TitleBarLabel ) {
		TQColorGroup cgroup = titlebar->usesActiveColor() ?
		    titlebar->tqpalette().active() : titlebar->tqpalette().inactive();

		TQColor left = cgroup.highlight();
		TQColor right = cgroup.base();

		if ( left != right ) {
		    double rS = left.red();
		    double gS = left.green();
		    double bS = left.blue();

		    const double rD = double(right.red() - rS) / titlebar->width();
		    const double gD = double(right.green() - gS) / titlebar->width();
		    const double bD = double(right.blue() - bS) / titlebar->width();

		    const int w = titlebar->width();
		    for ( int sx = 0; sx < w; sx++ ) {
			rS+=rD;
			gS+=gD;
			bS+=bD;
			p->setPen( TQColor( (int)rS, (int)gS, (int)bS ) );
			p->drawLine( sx, 0, sx, titlebar->height() );
		    }
		} else {
		    p->fillRect( titlebar->rect(), left );
		}

		TQRect ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarLabel ), widget );

		p->setPen( cgroup.highlightedText() );
		p->drawText(ir.x()+2, ir.y(), ir.width()-2, ir.height(),
			    TQt::AlignAuto | TQt::AlignVCenter | TQt::SingleLine, titlebar->visibleText() );
	    }

	    TQRect ir;
	    bool down = FALSE;
	    TQPixmap pm;

	    if ( controls & SC_TitleBarCloseButton ) {
		ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarCloseButton ), widget );
		down = active & SC_TitleBarCloseButton;
		if ( widget->testWFlags( TQt::WStyle_Tool )
#ifndef TQT_NO_MAINWINDOW
		     || ::tqqt_cast<TQDockWindow*>(widget)
#endif
		    )
		    pm = stylePixmap(SP_DockWindowCloseButton, widget);
		else
		    pm = stylePixmap(SP_TitleBarCloseButton, widget);
    		tqdrawPrimitive(TQStyle::PE_ButtonTool, p, ir, titlebar->tqcolorGroup(),
			      down ? Style_Down : Style_Raised);

		p->save();
		if( down )
		    p->translate( tqpixelMetric(PM_ButtonShiftHorizontal, widget),
				  tqpixelMetric(PM_ButtonShiftVertical, widget) );
		drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, &pm, TQString::null );
		p->restore();
	    }

	    if ( titlebar->window() ) {
		if ( controls & SC_TitleBarMaxButton ) {
		    ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarMaxButton ), widget );

		    down = active & SC_TitleBarMaxButton;
		    pm = TQPixmap(stylePixmap(SP_TitleBarMaxButton, widget));
		    tqdrawPrimitive(TQStyle::PE_ButtonTool, p, ir, titlebar->tqcolorGroup(),
				  down ? Style_Down : Style_Raised);

		    p->save();
		    if( down )
			p->translate( tqpixelMetric(PM_ButtonShiftHorizontal, widget),
				      tqpixelMetric(PM_ButtonShiftVertical, widget) );
    		    drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, &pm, TQString::null );
		    p->restore();
		}

		if ( controls & SC_TitleBarNormalButton || controls & SC_TitleBarMinButton ) {
		    ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarMinButton ), widget );
		    TQStyle::SubControl ctrl = (controls & SC_TitleBarNormalButton ?
					       SC_TitleBarNormalButton :
					       SC_TitleBarMinButton);
		    TQStyle::StylePixmap spixmap = (controls & SC_TitleBarNormalButton ?
						   SP_TitleBarNormalButton :
						   SP_TitleBarMinButton);
		    down = active & ctrl;
		    pm = TQPixmap(stylePixmap(spixmap, widget));
		    tqdrawPrimitive(TQStyle::PE_ButtonTool, p, ir, titlebar->tqcolorGroup(),
				  down ? Style_Down : Style_Raised);

		    p->save();
		    if( down )
			p->translate( tqpixelMetric(PM_ButtonShiftHorizontal, widget),
				      tqpixelMetric(PM_ButtonShiftVertical, widget) );
		    drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, &pm, TQString::null );
		    p->restore();
		}

		if ( controls & SC_TitleBarShadeButton ) {
		    ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarShadeButton ), widget );

		    down = active & SC_TitleBarShadeButton;
		    pm = TQPixmap(stylePixmap(SP_TitleBarShadeButton, widget));
		    tqdrawPrimitive(TQStyle::PE_ButtonTool, p, ir, titlebar->tqcolorGroup(),
				  down ? Style_Down : Style_Raised);
		    p->save();
		    if( down )
			p->translate( tqpixelMetric(PM_ButtonShiftHorizontal, widget),
				      tqpixelMetric(PM_ButtonShiftVertical, widget) );
		    drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, &pm, TQString::null );
		    p->restore();
		}

		if ( controls & SC_TitleBarUnshadeButton ) {
		    ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarUnshadeButton ), widget );

		    down = active & SC_TitleBarUnshadeButton;
		    pm = TQPixmap(stylePixmap(SP_TitleBarUnshadeButton, widget));
		    tqdrawPrimitive(TQStyle::PE_ButtonTool, p, ir, titlebar->tqcolorGroup(),
				  down ? Style_Down : Style_Raised);
		    p->save();
		    if( down )
			p->translate( tqpixelMetric(PM_ButtonShiftHorizontal, widget),
				      tqpixelMetric(PM_ButtonShiftVertical, widget) );
		    drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, &pm, TQString::null );
		    p->restore();
		}
	    }
#ifndef TQT_NO_WIDGET_TOPEXTRA
	    if ( controls & SC_TitleBarSysMenu ) {
		if ( titlebar->icon() ) {
		    ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarSysMenu ), widget );
		    drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, titlebar->icon(), TQString::null );
		}
	    }
#endif
	    break;
	}
#endif //TQT_NO_TITLEBAR

    case CC_SpinWidget: {
#ifndef TQT_NO_SPINWIDGET
	const TQSpinWidget * sw = (const TQSpinWidget *) widget;
	SFlags flags;
	PrimitiveElement pe;

	if ( controls & SC_SpinWidgetFrame )
	    qDrawWinPanel( p, r, cg, TRUE ); //cstyle == Sunken );

	if ( controls & SC_SpinWidgetUp ) {
	    flags = Style_Default | Style_Enabled;
	    if (active == SC_SpinWidgetUp ) {
		flags |= Style_On;
		flags |= Style_Sunken;
	    } else
		flags |= Style_Raised;
	    if ( sw->buttonSymbols() == TQSpinWidget::PlusMinus )
		pe = TQStyle::PE_SpinWidgetPlus;
	    else
		pe = TQStyle::PE_SpinWidgetUp;

	    TQRect re = sw->upRect();
	    TQColorGroup ucg = sw->isUpEnabled() ? cg : sw->tqpalette().disabled();
	    tqdrawPrimitive(TQStyle::PE_ButtonBevel, p, re, ucg, flags);
	    tqdrawPrimitive(pe, p, re, ucg, flags);
	}

	if ( controls & SC_SpinWidgetDown ) {
	    flags = Style_Default | Style_Enabled;
	    if (active == SC_SpinWidgetDown ) {
		flags |= Style_On;
		flags |= Style_Sunken;
	    } else
		flags |= Style_Raised;
	    if ( sw->buttonSymbols() == TQSpinWidget::PlusMinus )
		pe = TQStyle::PE_SpinWidgetMinus;
	    else
		pe = TQStyle::PE_SpinWidgetDown;

	    TQRect re = sw->downRect();
	    TQColorGroup dcg = sw->isDownEnabled() ? cg : sw->tqpalette().disabled();
	    tqdrawPrimitive(TQStyle::PE_ButtonBevel, p, re, dcg, flags);
	    tqdrawPrimitive(pe, p, re, dcg, flags);
	}
#endif
	break; }

#ifndef TQT_NO_SLIDER
    case CC_Slider:
	switch ( controls ) {
	case SC_SliderTickmarks: {
	    const TQSlider * sl = (const TQSlider *) widget;
	    int tickOffset = tqpixelMetric( PM_SliderTickmarkOffset, sl );
	    int ticks = sl->tickmarks();
	    int thickness = tqpixelMetric( PM_SliderControlThickness, sl );
	    int len = tqpixelMetric( PM_SliderLength, sl );
	    int available = tqpixelMetric( PM_SliderSpaceAvailable, sl );
	    int interval = sl->tickInterval();

	    if ( interval <= 0 ) {
		interval = sl->lineStep();
		if ( qPositionFromValue( sl, interval, available ) -
		     qPositionFromValue( sl, 0, available ) < 3 )
		    interval = sl->pageStep();
	    }

	    int fudge = len / 2;
	    int pos;

	    if ( ticks & TQSlider::Above ) {
		p->setPen( cg.foreground() );
		int v = sl->minValue();
		if ( !interval )
		    interval = 1;
		while ( v <= sl->maxValue() + 1 ) {
		    pos = qPositionFromValue( sl, v, available ) + fudge;
		    if ( sl->orientation() == Qt::Horizontal )
			p->drawLine( pos, 0, pos, tickOffset-2 );
		    else
			p->drawLine( 0, pos, tickOffset-2, pos );
		    v += interval;
		}
	    }

	    if ( ticks & TQSlider::Below ) {
		p->setPen( cg.foreground() );
		int v = sl->minValue();
		if ( !interval )
		    interval = 1;
		while ( v <= sl->maxValue() + 1 ) {
		    pos = qPositionFromValue( sl, v, available ) + fudge;
		    if ( sl->orientation() == Qt::Horizontal )
			p->drawLine( pos, tickOffset+thickness+1, pos,
				     tickOffset+thickness+1 + available-2 );
		    else
			p->drawLine( tickOffset+thickness+1, pos,
				     tickOffset+thickness+1 + available-2,
				     pos );
		    v += interval;
		}

	    }

	    break; }
	}
	break;
#endif // TQT_NO_SLIDER
#ifndef TQT_NO_LISTVIEW
    case CC_ListView:
	if ( controls & SC_ListView ) {
	    TQListView *listview = (TQListView*)widget;
	    p->fillRect( r, listview->viewport()->backgroundBrush() );
	}
	break;
#endif //TQT_NO_LISTVIEW
    default:
	break;
    }

    activePainter = 0;
}


/*! \reimp */
void TQCommonStyle::tqdrawComplexControlMask( TQ_ComplexControl control,
					   TQPainter *p,
					   const TQWidget *widget,
					   const TQRect &r,
					   const TQStyleOption& opt ) const
{
    TQ_UNUSED(control);
    TQ_UNUSED(widget);
    TQ_UNUSED(opt);

    p->fillRect(r, Qt::color1);
}


/*! \reimp */
TQRect TQCommonStyle::querySubControlMetrics( TQ_ComplexControl control,
					    const TQWidget *widget,
					    SubControl sc,
					    const TQStyleOption &opt ) const
{
#if defined(TQT_CHECK_STATE)
    if (! widget) {
	qWarning("TQCommonStyle::querySubControlMetrics: widget parameter cannot be zero!");
	return TQRect();
    }
#endif

    switch ( control ) {
    case CC_SpinWidget: {
	int fw = tqpixelMetric( PM_SpinBoxFrameWidth, widget);
	TQSize bs;
	bs.setHeight( widget->height()/2 - fw );
	if ( bs.height() < 8 )
	    bs.setHeight( 8 );
	bs.setWidth( TQMIN( bs.height() * 8 / 5, widget->width() / 4 ) ); // 1.6 -approximate golden mean
	bs = bs.expandedTo( TQApplication::globalStrut() );
	int y = fw;
	int x, lx, rx;
	x = widget->width() - y - bs.width();
	lx = fw;
	rx = x - fw;
	switch ( sc ) {
	case SC_SpinWidgetUp:
	    return TQRect(x, y, bs.width(), bs.height());
	case SC_SpinWidgetDown:
	    return TQRect(x, y + bs.height(), bs.width(), bs.height());
	case SC_SpinWidgetButtonField:
	    return TQRect(x, y, bs.width(), widget->height() - 2*fw);
	case SC_SpinWidgetEditField:
	    return TQRect(lx, fw, rx, widget->height() - 2*fw);
	case SC_SpinWidgetFrame:
	    return widget->rect();
	default:
	    break;
	}
	break; }

    case CC_ComboBox: {
	int x = 0, y = 0, wi = widget->width(), he = widget->height();
	int xpos = x;
	xpos += wi - 2 - 16;

	switch ( sc ) {
	case SC_ComboBoxFrame:
	    return widget->rect();
	case SC_ComboBoxArrow:
	    return TQRect(xpos, y+2, 16, he-4);
	case SC_ComboBoxEditField:
	    return TQRect(x+3, y+3, wi-6-16, he-6);
	case SC_ComboBoxListBoxPopup:
	    return opt.rect();
	default:
	    break;
	}
	break; }

#ifndef TQT_NO_SCROLLBAR
    case CC_ScrollBar: {
	const TQScrollBar *scrollbar = (const TQScrollBar *) widget;
	int sliderstart = 0;
	int sbextent = tqpixelMetric(PM_ScrollBarExtent, widget);
	int maxlen = ((scrollbar->orientation() == Qt::Horizontal) ?
		      scrollbar->width() : scrollbar->height()) - (sbextent * 2);
	int sliderlen;

	sliderstart = scrollbar->sliderStart();

	// calculate slider length
	if (scrollbar->maxValue() != scrollbar->minValue()) {
	    uint range = scrollbar->maxValue() - scrollbar->minValue();
	    sliderlen = (TQ_LLONG(scrollbar->pageStep()) * maxlen) / (range + scrollbar->pageStep());

	    int slidermin = tqpixelMetric( PM_ScrollBarSliderMin, widget );
	    if ( sliderlen < slidermin || range > INT_MAX / 2 )
		sliderlen = slidermin;
	    if ( sliderlen > maxlen )
		sliderlen = maxlen;
	} else
	    sliderlen = maxlen;

	switch (sc) {
	case SC_ScrollBarSubLine:	    // top/left button
	    if (scrollbar->orientation() == Qt::Horizontal) {
		int buttonWidth = TQMIN(scrollbar->width()/2, sbextent);
		return TQRect( 0, 0, buttonWidth, sbextent );
	    } else {
		int buttonHeight = TQMIN(scrollbar->height()/2, sbextent);
		return TQRect( 0, 0, sbextent, buttonHeight );
	    }

	case SC_ScrollBarAddLine:	    // bottom/right button
	    if (scrollbar->orientation() == Qt::Horizontal) {
		int buttonWidth = TQMIN(scrollbar->width()/2, sbextent);
		return TQRect( scrollbar->width() - buttonWidth, 0, buttonWidth, sbextent );
	    } else {
		int buttonHeight = TQMIN(scrollbar->height()/2, sbextent);
		return TQRect( 0, scrollbar->height() - buttonHeight, sbextent, buttonHeight );
	    }

	case SC_ScrollBarSubPage:	    // between top/left button and slider
	    if (scrollbar->orientation() == Qt::Horizontal)
		return TQRect(sbextent, 0, sliderstart - sbextent, sbextent);
	    return TQRect(0, sbextent, sbextent, sliderstart - sbextent);

	case SC_ScrollBarAddPage:	    // between bottom/right button and slider
	    if (scrollbar->orientation() == Qt::Horizontal)
		return TQRect(sliderstart + sliderlen, 0,
			     maxlen - sliderstart - sliderlen + sbextent, sbextent);
	    return TQRect(0, sliderstart + sliderlen,
			 sbextent, maxlen - sliderstart - sliderlen + sbextent);

	case SC_ScrollBarGroove:
	    if (scrollbar->orientation() == Qt::Horizontal)
		return TQRect(sbextent, 0, scrollbar->width() - sbextent * 2,
			     scrollbar->height());
	    return TQRect(0, sbextent, scrollbar->width(),
			 scrollbar->height() - sbextent * 2);

	case SC_ScrollBarSlider:
	    if (scrollbar->orientation() == Qt::Horizontal)
		return TQRect(sliderstart, 0, sliderlen, sbextent);
	    return TQRect(0, sliderstart, sbextent, sliderlen);

	default: break;
	}

	break; }
#endif // TQT_NO_SCROLLBAR

#ifndef TQT_NO_SLIDER
    case CC_Slider: {
	    const TQSlider * sl = (const TQSlider *) widget;
	    int tickOffset = tqpixelMetric( PM_SliderTickmarkOffset, sl );
	    int thickness = tqpixelMetric( PM_SliderControlThickness, sl );

	    switch ( sc ) {
	    case SC_SliderHandle: {
		    int sliderPos = 0;
		    int len   = tqpixelMetric( PM_SliderLength, sl );

		    sliderPos = sl->sliderStart();

		    if ( sl->orientation() == Qt::Horizontal )
			return TQRect( sliderPos, tickOffset, len, thickness );
		    return TQRect( tickOffset, sliderPos, thickness, len ); }
	    case SC_SliderGroove: {
		if ( sl->orientation() == Qt::Horizontal )
		    return TQRect( 0, tickOffset, sl->width(), thickness );
		return TQRect( tickOffset, 0, thickness, sl->height() );	}

	    default:
		break;
	    }
	    break; }
#endif // TQT_NO_SLIDER

#if !defined(TQT_NO_TOOLBUTTON) && !defined(TQT_NO_POPUPMENU)
    case CC_ToolButton: {
	    const TQToolButton *toolbutton = (const TQToolButton *) widget;
	    int mbi = tqpixelMetric(PM_MenuButtonIndicator, widget);

	    TQRect rect = toolbutton->rect();
	    switch (sc) {
	    case SC_ToolButton:
		if (toolbutton->popup() && ! toolbutton->popupDelay())
		    rect.addCoords(0, 0, -mbi, 0);
		return rect;

	    case SC_ToolButtonMenu:
		if (toolbutton->popup() && ! toolbutton->popupDelay())
		    rect.addCoords(rect.width() - mbi, 0, 0, 0);
		return rect;

	    default: break;
	    }
	    break;
	}
#endif // TQT_NO_TOOLBUTTON && TQT_NO_POPUPMENU

#ifndef TQT_NO_TITLEBAR
    case CC_TitleBar: {
	    const TQTitleBar *titlebar = (const TQTitleBar *) widget;
	    const int controlTop = 2;
	    const int controlHeight = widget->height() - controlTop * 2;

	    switch (sc) {
	    case SC_TitleBarLabel: {
		const TQTitleBar *titlebar = (TQTitleBar*)widget;
		TQRect ir( 0, 0, titlebar->width(), titlebar->height() );
		if ( titlebar->testWFlags( TQt::WStyle_Tool ) ) {
		    if ( titlebar->testWFlags( TQt::WStyle_SysMenu ) )
			ir.addCoords( 0, 0, -controlHeight-3, 0 );
		    if ( titlebar->testWFlags( TQt::WStyle_MinMax ) )
			ir.addCoords( 0, 0, -controlHeight-2, 0 );
		} else {
		    if ( titlebar->testWFlags( TQt::WStyle_SysMenu ) )
			ir.addCoords( controlHeight+3, 0, -controlHeight-3, 0 );
		    if ( titlebar->testWFlags( TQt::WStyle_Minimize ) )
			ir.addCoords( 0, 0, -controlHeight-2, 0 );
		    if ( titlebar->testWFlags( TQt::WStyle_Maximize ) )
			ir.addCoords( 0, 0, -controlHeight-2, 0 );
		}
		return ir; }

	    case SC_TitleBarCloseButton:
		return TQRect( titlebar->width() - ( controlHeight + controlTop ),
			      controlTop, controlHeight, controlHeight );

	    case SC_TitleBarMaxButton:
	    case SC_TitleBarShadeButton:
	    case SC_TitleBarUnshadeButton:
		return TQRect( titlebar->width() - ( ( controlHeight + controlTop ) * 2 ),
			      controlTop, controlHeight, controlHeight );

	    case SC_TitleBarMinButton:
	    case SC_TitleBarNormalButton: {
		int offset = controlHeight + controlTop;
		if ( !titlebar->testWFlags( TQt::WStyle_Maximize ) )
		    offset *= 2;
		else
		    offset *= 3;
		return TQRect( titlebar->width() - offset, controlTop, controlHeight, controlHeight );
	    }

	    case SC_TitleBarSysMenu:
		return TQRect( 3, controlTop, controlHeight, controlHeight);

	    default: break;
	    }
	    break; }
#endif //TQT_NO_TITLEBAR

    default:
	break;
    }
    return TQRect();
}


/*! \reimp */
TQStyle::SubControl TQCommonStyle::querySubControl(TQ_ComplexControl control,
						 const TQWidget *widget,
						 const TQPoint &pos,
						 const TQStyleOption& opt ) const
{
    SubControl ret = SC_None;

    switch (control) {
#ifndef TQT_NO_LISTVIEW
    case CC_ListView:
	{
	    if(pos.x() >= 0 && pos.x() <
	       opt.listViewItem()->listView()->treeStepSize())
		ret = SC_ListViewExpand;
	    break;
	}
#endif
#ifndef TQT_NO_SCROLLBAR
    case CC_ScrollBar:
	{
	    TQRect r;
	    uint ctrl = SC_ScrollBarAddLine;

	    // we can do this because subcontrols were designed to be masks as well...
	    while (ret == SC_None && ctrl <= SC_ScrollBarGroove) {
		r = querySubControlMetrics(control, widget,
					   (TQStyle::SubControl) ctrl, opt);
		if (r.isValid() && r.contains(pos))
		    ret = (TQStyle::SubControl) ctrl;

		ctrl <<= 1;
	    }

	    break;
	}
#endif
    case CC_TitleBar:
	{
#ifndef TQT_NO_TITLEBAR
	    const TQTitleBar *titlebar = (TQTitleBar*)widget;
	    TQRect r;
	    uint ctrl = SC_TitleBarLabel;

	    // we can do this because subcontrols were designed to be masks as well...
	    while (ret == SC_None && ctrl <= SC_TitleBarUnshadeButton) {
		r = tqvisualRect( querySubControlMetrics( control, widget, (TQStyle::SubControl) ctrl, opt ), widget );
		if (r.isValid() && r.contains(pos))
		    ret = (TQStyle::SubControl) ctrl;

		ctrl <<= 1;
	    }
	    if ( titlebar->window() ) {
		if (titlebar->testWFlags( TQt::WStyle_Tool )) {
		    if ( ret == SC_TitleBarMinButton || ret == SC_TitleBarMaxButton ) {
			if ( titlebar->window()->isMinimized() )
			    ret = SC_TitleBarUnshadeButton;
			else
			    ret = SC_TitleBarShadeButton;
		    }
		} else if ( ret == SC_TitleBarMinButton && titlebar->window()->isMinimized() ) {
			ret = TQStyle::SC_TitleBarNormalButton;
		}
	    }
#endif
	    break;
	}

    default:
	break;
    }

    return ret;
}


/*! \reimp */
int TQCommonStyle::tqpixelMetric(PixelMetric m, const TQWidget *widget) const
{
    int ret;

    switch (m) {
    case PM_DialogButtonsSeparator:
	ret = 5;
	break;
    case PM_DialogButtonsButtonWidth:
	ret = 70;
	break;
    case PM_DialogButtonsButtonHeight:
	ret = 30;
	break;
    case PM_CheckListControllerSize:
    case PM_CheckListButtonSize:
	ret = 16;
	break;
    case PM_TitleBarHeight: {
	if ( widget ) {
	    if ( widget->testWFlags( TQt::WStyle_Tool ) ) {
		ret = TQMAX( widget->fontMetrics().lineSpacing(), 16 );
#ifndef TQT_NO_MAINWINDOW
	    } else if ( ::tqqt_cast<TQDockWindow*>(widget) ) {
		ret = TQMAX( widget->fontMetrics().lineSpacing(), 13 );
#endif
	    } else {
		ret = TQMAX( widget->fontMetrics().lineSpacing(), 18 );
	    }
	} else {
	    ret = 0;
	}

	break; }
    case PM_ScrollBarSliderMin:
	ret = 9;
	break;

    case PM_ButtonMargin:
	ret = 6;
	break;

    case PM_ButtonDefaultIndicator:
	ret = 0;
	break;

    case PM_MenuButtonIndicator:
	if (! widget)
	    ret = 12;
	else
	    ret = TQMAX(12, (widget->height() - 4) / 3);
	break;

    case PM_ButtonShiftHorizontal:
    case PM_ButtonShiftVertical:
	ret = 0;
	break;

    case PM_SpinBoxFrameWidth:
    case PM_DefaultFrameWidth:
	ret = 2;
	break;

    case PM_MDIFrameWidth:
	ret = 2;
	break;

    case PM_MDIMinimizedWidth:
	ret = 196;
	break;

#ifndef TQT_NO_SCROLLBAR
    case PM_ScrollBarExtent:
	if ( !widget ) {
	    ret = 16;
	} else {
	    const TQScrollBar *bar = (const TQScrollBar*)widget;
	    int s = bar->orientation() == Qt::Horizontal ?
		    TQApplication::globalStrut().height()
		    : TQApplication::globalStrut().width();
	    ret = TQMAX( 16, s );
	}
	break;
#endif
    case PM_MaximumDragDistance:
	ret = -1;
	break;

#ifndef TQT_NO_SLIDER
    case PM_SliderThickness:
	ret = 16;
	break;

    case PM_SliderTickmarkOffset:
	{
	    if (! widget) {
		ret = 0;
		break;
	    }

	    const TQSlider * sl = (const TQSlider *) widget;
	    int space = (sl->orientation() == Qt::Horizontal) ? sl->height() :
			sl->width();
	    int thickness = tqpixelMetric( PM_SliderControlThickness, sl );
	    int ticks = sl->tickmarks();

	    if ( ticks == TQSlider::Both )
		ret = (space - thickness) / 2;
	    else if ( ticks == TQSlider::Above )
		ret = space - thickness;
	    else
		ret = 0;
	    break;
	}

    case PM_SliderSpaceAvailable:
	{
	    const TQSlider * sl = (const TQSlider *) widget;
	    if ( sl->orientation() == Qt::Horizontal )
		ret = sl->width() - tqpixelMetric( PM_SliderLength, sl );
	    else
		ret = sl->height() - tqpixelMetric( PM_SliderLength, sl );
	    break;
	}
#endif // TQT_NO_SLIDER

    case PM_DockWindowSeparatorExtent:
	ret = 6;
	break;

    case PM_DockWindowHandleExtent:
	ret = 8;
	break;

    case PM_DockWindowFrameWidth:
	ret = 1;
	break;

    case PM_MenuBarFrameWidth:
	ret = 2;
	break;

    case PM_MenuBarItemSpacing:
    case PM_ToolBarItemSpacing:
	ret = 0;
	break;

    case PM_TabBarTabOverlap:
	ret = 3;
	break;

    case PM_TabBarBaseHeight:
	ret = 0;
	break;

    case PM_TabBarBaseOverlap:
	ret = 0;
	break;

    case PM_TabBarTabHSpace:
	ret = 24;
	break;

    case PM_TabBarTabShiftHorizontal:
    case PM_TabBarTabShiftVertical:
	ret = 2;
	break;

#ifndef TQT_NO_TABBAR
    case PM_TabBarTabVSpace:
	{
	    const TQTabBar * tb = (const TQTabBar *) widget;
	    if ( tb && ( tb->tqshape() == TQTabBar::RoundedAbove ||
			 tb->tqshape() == TQTabBar::RoundedBelow ) )
		ret = 10;
	    else
		ret = 0;
	    break;
	}
#endif

    case PM_ProgressBarChunkWidth:
	ret = 9;
	break;

    case PM_IndicatorWidth:
	ret = 13;
	break;

    case PM_IndicatorHeight:
	ret = 13;
	break;

    case PM_ExclusiveIndicatorWidth:
	ret = 12;
	break;

    case PM_ExclusiveIndicatorHeight:
	ret = 12;
	break;

    case PM_PopupMenuFrameHorizontalExtra:
    case PM_PopupMenuFrameVerticalExtra:
	ret = 0;
	break;

    case PM_HeaderMargin:
	ret = 4;
	break;
    case PM_HeaderMarkSize:
	ret = 32;
	break;
    case PM_HeaderGripMargin:
	ret = 4;
	break;
    case PM_TabBarScrollButtonWidth:
	ret = 16;
	break;
    default:
	ret = 0;
	break;
    }

    return ret;
}


/*! \reimp */
TQSize TQCommonStyle::tqsizeFromContents(ContentsType contents,
				     const TQWidget *widget,
				     const TQSize &contentsSize,
				     const TQStyleOption& opt ) const
{
    TQSize sz(contentsSize);

#if defined(TQT_CHECK_STATE)
    if (! widget) {
	qWarning("TQCommonStyle::tqsizeFromContents: widget parameter cannot be zero!");
	return sz;
    }
#endif

    switch (contents) {
#ifndef TQT_NO_DIALOGBUTTONS
    case CT_DialogButtons: {
	const TQDialogButtons *dbtns = (const TQDialogButtons *)widget;
	int w = contentsSize.width(), h = contentsSize.height();
	const int bwidth = tqpixelMetric(PM_DialogButtonsButtonWidth, widget),
		  bspace = tqpixelMetric(PM_DialogButtonsSeparator, widget),
		 bheight = tqpixelMetric(PM_DialogButtonsButtonHeight, widget);
	if(dbtns->orientation() == Qt::Horizontal) {
	    if(!w)
		w = bwidth;
	} else {
	    if(!h)
		h = bheight;
	}
	TQDialogButtons::Button btns[] = { TQDialogButtons::All, TQDialogButtons::Reject, TQDialogButtons::Accept, //reverse order (right to left)
					  TQDialogButtons::Apply, TQDialogButtons::Retry, TQDialogButtons::Ignore, TQDialogButtons::Abort,
					  TQDialogButtons::Help };
	for(unsigned int i = 0, cnt = 0; i < (sizeof(btns)/sizeof(btns[0])); i++) {
	    if(dbtns->isButtonVisible(btns[i])) {
		TQSize szH = dbtns->tqsizeHint(btns[i]);
		int mwidth = TQMAX(bwidth, szH.width()), mheight = TQMAX(bheight, szH.height());
		if(dbtns->orientation() == Qt::Horizontal)
		    h = TQMAX(h, mheight);
		else
		    w = TQMAX(w, mwidth);

		if(cnt)
		    w += bspace;
		cnt++;
		if(dbtns->orientation() == Qt::Horizontal)
		    w += mwidth;
		else
		    h += mheight;
	    }
	}
	const int fw = tqpixelMetric(PM_DefaultFrameWidth, widget) * 2;
	sz = TQSize(w + fw, h + fw);
	break; }
#endif //TQT_NO_DIALOGBUTTONS
    case CT_PushButton:
	{
#ifndef TQT_NO_PUSHBUTTON
	    const TQPushButton *button = (const TQPushButton *) widget;
	    int w = contentsSize.width(),
		h = contentsSize.height(),
	       bm = tqpixelMetric(PM_ButtonMargin, widget),
	       fw = tqpixelMetric(PM_DefaultFrameWidth, widget) * 2;

	    w += bm + fw;
	    h += bm + fw;

	    if (button->isDefault() || button->autoDefault()) {
		int dbw = tqpixelMetric(PM_ButtonDefaultIndicator, widget) * 2;
		w += dbw;
		h += dbw;
	    }

	    sz = TQSize(w, h);
#endif
	    break;
	}

    case CT_CheckBox:
	{
#ifndef TQT_NO_CHECKBOX
	    const TQCheckBox *checkbox = (const TQCheckBox *) widget;
	    TQRect irect = subRect(SR_CheckBoxIndicator, widget);
	    int h = tqpixelMetric( PM_IndicatorHeight, widget );
	    int margins = (!checkbox->pixmap() && checkbox->text().isEmpty()) ? 0 : 10;
	    sz += TQSize(irect.right() + margins, 4 );
	    sz.setHeight( TQMAX( sz.height(), h ) );
#endif
	    break;
	}

    case CT_RadioButton:
	{
#ifndef TQT_NO_RADIOBUTTON
	    const TQRadioButton *radiobutton = (const TQRadioButton *) widget;
	    TQRect irect = subRect(SR_RadioButtonIndicator, widget);
	    int h = tqpixelMetric( PM_ExclusiveIndicatorHeight, widget );
	    int margins = (!radiobutton->pixmap() && radiobutton->text().isEmpty()) ? 0 : 10;
	    sz += TQSize(irect.right() + margins, 4 );
	    sz.setHeight( TQMAX( sz.height(), h ) );
#endif
	    break;
	}

    case CT_ToolButton:
	{
	    sz = TQSize(sz.width() + 6, sz.height() + 5);
	    break;
	}

    case CT_ComboBox:
	{
	    int dfw = tqpixelMetric(PM_DefaultFrameWidth, widget) * 2;
	    sz = TQSize(sz.width() + dfw + 21, sz.height() + dfw );
	    break;
	}

    case CT_PopupMenuItem:
	{
#ifndef TQT_NO_POPUPMENU
	    if (opt.isDefault())
		break;

	    const TQPopupMenu *popup = (const TQPopupMenu *) widget;
	    bool checkable = popup->isCheckable();
	    TQMenuItem *mi = opt.menuItem();
	    int maxpmw = opt.maxIconWidth();
	    int w = sz.width(), h = sz.height();

	    if (mi->custom()) {
		w = mi->custom()->tqsizeHint().width();
		h = mi->custom()->tqsizeHint().height();
		if (! mi->custom()->fullSpan())
		    h += 8;
	    } else if ( mi->widget() ) {
	    } else if (mi->isSeparator()) {
		w = 10;
		h = 2;
	    } else {
		if (mi->pixmap())
		    h = TQMAX(h, mi->pixmap()->height() + 4);
		else
		    h = TQMAX(h, popup->fontMetrics().height() + 8);

		if (mi->iconSet() != 0)
		    h = TQMAX(h, mi->iconSet()->pixmap(TQIconSet::Small,
						      TQIconSet::Normal).height() + 4);
	    }

	    if (! mi->text().isNull()) {
		if (mi->text().find('\t') >= 0)
		    w += 12;
	    }

	    if (maxpmw)
		w += maxpmw + 6;
	    if (checkable && maxpmw < 20)
		w += 20 - maxpmw;
	    if (checkable || maxpmw > 0)
		w += 2;
	    w += 12;

	    sz = TQSize(w, h);
#endif
	    break;
	}

    case CT_LineEdit:
    case CT_Header:
    case CT_Slider:
    case CT_ProgressBar:
	// just return the contentsSize for now
	// fall through intended

    default:
	break;
    }

    return sz;
}


/*! \reimp */
int TQCommonStyle::tqstyleHint(TQ_StyleHint sh, const TQWidget * w, const TQStyleOption &, TQStyleHintReturn *) const
{
    int ret;

    switch (sh) {
#ifndef TQT_NO_DIALOGBUTTONS
    case SH_DialogButtons_DefaultButton:
	ret = TQDialogButtons::Accept;
	break;
#endif
    case SH_GroupBox_TextLabelVerticalAlignment:
	ret = TQt::TQt::AlignVCenter;
	break;

    case SH_GroupBox_TextLabelColor:
	ret = (int) ( w ? w->paletteForegroundColor().rgb() : 0 );
	break;

    case SH_ListViewExpand_SelectMouseType:
    case SH_TabBar_SelectMouseType:
	ret = TQEvent::MouseButtonPress;
	break;

    case SH_GUIStyle:
	ret = TQt::WindowsStyle;
	break;

    case SH_ScrollBar_BackgroundMode:
	ret = TQt::PaletteBackground;
	break;

    case SH_TabBar_Alignment:
    case SH_Header_ArrowAlignment:
	ret = TQt::AlignLeft;
	break;

    case SH_PopupMenu_SubMenuPopupDelay:
	ret = 256;
	break;

    case SH_ProgressDialog_TextLabelAlignment:
	ret = TQt::AlignCenter;
	break;

    case SH_BlinkCursorWhenTextSelected:
	ret = 1;
	break;

    case SH_Table_GridLineColor:
	ret = -1;
	break;

    case SH_LineEdit_PasswordCharacter:
	ret = '*';
	break;

    case SH_ToolBox_SelectedPageTitleBold:
	ret = 1;
	break;

    case SH_UnderlineAccelerator:
	ret = 1;
	break;

    case SH_ToolButton_Uses3D:
	ret = 1;
	break;

    default:
	ret = 0;
	break;
    }

    return ret;
}

/*! \reimp */
TQPixmap TQCommonStyle::stylePixmap(StylePixmap, const TQWidget *, const TQStyleOption&) const
{
    return TQPixmap();
}


#endif // TQT_NO_STYLE