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

/****************************************************************************
**
** Implementation of Windows-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 "tqwindowsstyle.h"

#if !defined(TQT_NO_STYLE_WINDOWS) || defined(TQT_PLUGIN)

#include "tqpopupmenu.h"
#include "tqapplication.h"
#include "tqpainter.h"
#include "tqdrawutil.h" // for now
#include "tqpixmap.h" // for now
#include "tqwidget.h"
#include "tqbrush.h"
#include "tqlabel.h"
#include "tqimage.h"
#include "tqpushbutton.h"
#include "tqcombobox.h"
#include "tqlistbox.h"
#include "tqwidget.h"
#include "tqrangecontrol.h"
#include "tqscrollbar.h"
#include "tqslider.h"
#include "tqtabwidget.h"
#include "tqtabbar.h"
#include "tqlistview.h"
#include "tqbitmap.h"
#include "tqcleanuphandler.h"
#include "tqdockwindow.h"
#include "tqobjectlist.h"
#include "tqmenubar.h"

#if defined(TQ_WS_WIN)
#include "tqt_windows.h"
#endif

#include <limits.h>


static const int windowsItemFrame		=  2; // menu item frame width
static const int windowsSepHeight		=  2; // separator item height
static const int windowsItemHMargin		=  3; // menu item hor text margin
static const int windowsItemVMargin		=  2; // menu item ver text margin
static const int windowsArrowHMargin		=  6; // arrow horizontal margin
static const int windowsTabSpacing		= 12; // space between text and tab
static const int windowsCheckMarkHMargin	=  2; // horiz. margins of check mark
static const int windowsRightBorder		= 12; // right border on windows
static const int windowsCheckMarkWidth		= 12; // checkmarks width on windows

static bool use2000style = TRUE;

enum TQSliderDirection { SlUp, SlDown, SlLeft, SlRight };

// A friendly class providing access to TQMenuData's protected member.
class FriendlyMenuData : public TQMenuData
{
    friend class TQWindowsStyle;
};

// Private class
class TQWindowsStyle::Private : public TQObject
{
public:
    Private(TQWindowsStyle *tqparent);

    bool hasSeenAlt(const TQWidget *widget) const;
    bool altDown() const { return alt_down; }

protected:
    bool eventFilter(TQObject *o, TQEvent *e);

private:
    TQPtrList<TQWidget> seenAlt;
    bool alt_down;
    int menuBarTimer;
};

TQWindowsStyle::Private::Private(TQWindowsStyle *tqparent)
: TQObject(tqparent, "TQWindowsStylePrivate"), alt_down(FALSE), menuBarTimer(0)
{
}

// Returns true if the toplevel tqparent of \a widget has seen the Alt-key
bool TQWindowsStyle::Private::hasSeenAlt(const TQWidget *widget) const
{
    widget = widget->tqtopLevelWidget();
    return seenAlt.tqcontains(widget);
}

// Records Alt- and Focus events
bool TQWindowsStyle::Private::eventFilter(TQObject *o, TQEvent *e)
{
    if (!o->isWidgetType())
	return TQObject::eventFilter(o, e);

    TQWidget *widget = ::tqqt_cast<TQWidget*>(o);

    switch(e->type()) {
    case TQEvent::KeyPress:
	if (((TQKeyEvent*)e)->key() == Qt::Key_Alt) {
	    widget = widget->tqtopLevelWidget();

	    // Alt has been pressed - tqfind all widgets that care
	    TQObjectList *l = widget->queryList("TQWidget");
	    TQObjectListIt it( *l );
	    TQWidget *w;
	    while ( (w = (TQWidget*)it.current()) != 0 ) {
		++it;
		if (w->isTopLevel() || !w->isVisible() ||
		    w->tqstyle().tqstyleHint(SH_UnderlineAccelerator, w))
		    l->removeRef(TQT_TQOBJECT(w));
	    }
	    // Update states before repainting
	    seenAlt.append(widget);
	    alt_down = TRUE;

	    // Repaint all relevant widgets
	    it.toFirst();
	    while ( (w = (TQWidget*)it.current()) != 0 ) {
		++it;
		w->tqrepaint(FALSE);
	    }
	    delete l;
	}
	break;
    case TQEvent::KeyRelease:
	if (((TQKeyEvent*)e)->key() == Qt::Key_Alt) {
	    widget = widget->tqtopLevelWidget();

	    // Update state
	    alt_down = FALSE;
	    // Repaint only menubars
	    TQObjectList *l = widget->queryList("TQMenuBar");
	    TQObjectListIt it( *l );
	    TQMenuBar *menuBar;
	    while ( (menuBar = (TQMenuBar*)it.current()) != 0) {
		++it;
		menuBar->tqrepaint(FALSE);
	    }
	}
	break;
    case TQEvent::FocusIn:
    case TQEvent::FocusOut:
	{
	    // Menubars toggle based on focus
	    TQMenuBar *menuBar = ::tqqt_cast<TQMenuBar*>(o);
	    if (menuBar && !menuBarTimer) // delayed tqrepaint to avoid flicker
		menuBarTimer = menuBar->startTimer(0);
	}
	break;
    case TQEvent::Close:
	// Reset widget when closing
	seenAlt.removeRef(TQT_TQWIDGET(widget));
	seenAlt.removeRef(TQT_TQWIDGET(widget->tqtopLevelWidget()));
	break;
    case TQEvent::Timer:
	{
	    TQMenuBar *menuBar = ::tqqt_cast<TQMenuBar*>(o);
	    TQTimerEvent *te = (TQTimerEvent*)e;
	    if (menuBar && te->timerId() == menuBarTimer) {
		menuBar->killTimer(te->timerId());
		menuBarTimer = 0;
		menuBar->tqrepaint(FALSE);
		return TRUE;
	    }
	}
	break;
    default:
	break;
    }

    return TQObject::eventFilter(o, e);
}

/*!
    \class TQWindowsStyle tqwindowsstyle.h
    \brief The TQWindowsStyle class provides a Microsoft Windows-like look and feel.

    \ingroup appearance

    This style is TQt's default GUI style on Windows.
*/

/*!
    Constructs a TQWindowsStyle
*/
TQWindowsStyle::TQWindowsStyle() : TQCommonStyle(), d(0)
{
#if defined(TQ_OS_WIN32)
    use2000style = qWinVersion() != TQt::WV_NT && qWinVersion() != TQt::WV_95;
#endif
}

/*! \reimp */
TQWindowsStyle::~TQWindowsStyle()
{
    delete d;
}

/*! \reimp */
void TQWindowsStyle::polish(TQApplication *app)
{
    // We only need the overhead when shortcuts are sometimes hidden
    if (!tqstyleHint(SH_UnderlineAccelerator, 0)) {
	d = new Private(this);
	app->installEventFilter(d);
    }
}

/*! \reimp */
void TQWindowsStyle::unPolish(TQApplication *)
{
    delete d;
    d = 0;
}

/*! \reimp */
void TQWindowsStyle::polish(TQWidget *widget)
{
    TQCommonStyle::polish(widget);
}

/*! \reimp */
void TQWindowsStyle::unPolish(TQWidget *widget)
{
    TQCommonStyle::polish(widget);
}

/*! \reimp */
void TQWindowsStyle::polish( TQPalette &pal )
{
    TQCommonStyle::polish(pal);
}

/*! \reimp */
void TQWindowsStyle::tqdrawPrimitiveBase( TQ_PrimitiveElement pe,
				   TQPainter *p,
				   const TQRect &r,
				   const TQColorGroup &cg,
				   SFlags flags,
				   const TQStyleOption& opt ) const
{
    TQRect rr( r );
    switch (pe) {
    case PE_ButtonCommand:
	{
	    TQBrush fill;

	    if (! (flags & Style_Down) && (flags & Style_On))
		fill = TQBrush(cg.light(), Qt::Dense4Pattern);
	    else
		fill = cg.brush(TQColorGroup::Button);

	    if (flags & Style_ButtonDefault && flags & Style_Down) {
		p->setPen(cg.dark());
		p->setBrush(fill);
		p->drawRect(r);
	    } else if (flags & (Style_Raised | Style_Down | Style_On | Style_Sunken))
		qDrawWinButton(p, r, cg, flags & (Style_Sunken | Style_Down |
						  Style_On), &fill);
	    else
		p->fillRect(r, fill);
	    break;
	}

    case PE_ButtonBevel:
    case PE_HeaderSection:
	{
	    TQBrush fill;

	    if (! (flags & Style_Down) && (flags & Style_On))
		fill = TQBrush(cg.light(), Qt::Dense4Pattern);
	    else
		fill = cg.brush(TQColorGroup::Button);

	    if (flags & (Style_Raised | Style_Down | Style_On | Style_Sunken))
		qDrawWinButton(p, r, cg, flags & (Style_Down | Style_On), &fill);
	    else
		p->fillRect(r, fill);
	    break;
	}
#if defined(TQ_WS_WIN)
    case PE_HeaderArrow:
	p->save();
	if ( flags & Style_Up ) { // invert logic to follow Windows style guide
	    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;
#endif

    case PE_ButtonDefault:
	p->setPen(cg.shadow());
	p->drawRect(r);
	break;

    case PE_ButtonTool:
	{
	    TQBrush fill;
	    bool stippled = FALSE;

	    if (! (flags & (Style_Down | Style_MouseOver)) &&
		(flags & Style_On) &&
		use2000style) {
		fill = TQBrush(cg.light(), Qt::Dense4Pattern);
		stippled = TRUE;
	    } else
		fill = cg.brush(TQColorGroup::Button);

	    if (flags & (Style_Raised | Style_Down | Style_On)) {
		if (flags & Style_AutoRaise) {
		    qDrawShadePanel(p, r, cg, flags & (Style_Down | Style_On),
				    1, &fill);

		    if (stippled) {
			p->setPen(cg.button());
			p->drawRect(r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2);
		    }
		} else
		    qDrawWinButton(p, r, cg, flags & (Style_Down | Style_On),
				   &fill);
	    } else
		p->fillRect(r, fill);

	    break;
	}

    case PE_FocusRect:
	if (opt.isDefault())
	    p->drawWinFocusRect(r);
#ifndef USE_QT4		// [FIXME]
	else
	    p->drawWinFocusRect(r, opt.color());
#endif // USE_QT4
	break;

    case PE_Indicator:
	{
	    TQBrush fill;
	    if (flags & Style_NoChange) {
		TQBrush b = p->brush();
		TQColor c = p->backgroundColor();
		p->setBackgroundMode( Qt::TransparentMode );
		p->setBackgroundColor( Qt::green );
		fill = TQBrush(cg.base(), Qt::Dense4Pattern);
		p->setBackgroundColor( c );
		p->setBrush( b );
	    } else if (flags & Style_Down)
		fill = cg.brush( TQColorGroup::Button );
	    else if (flags & Style_Enabled)
		fill = cg.brush( TQColorGroup::Base );
	    else
		fill = cg.brush( TQColorGroup::Background );

	    qDrawWinPanel( p, r, cg, TRUE, &fill );

	    if (flags & Style_NoChange )
		p->setPen( cg.dark() );
	    else
		p->setPen( cg.text() );
	} // FALLTHROUGH
    case PE_CheckListIndicator:
	if ( pe == PE_CheckListIndicator ) { //since we fall through from PE_Indicator
	    if ( flags & Style_Enabled )
		p->setPen( TQPen( cg.text(), 1 ) );
	    else
		p->setPen( TQPen( cg.dark(), 1 ) );
	    if ( flags & Style_NoChange )
		p->setBrush( cg.brush( TQColorGroup::Button ) );
	    p->drawRect( r.x()+1, r.y()+1, 11, 11 );
	}
	if (! (flags & Style_Off)) {
	    TQPointArray a( 7*2 );
	    int i, xx, yy;
	    xx = rr.x() + 3;
	    yy = rr.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;

    case PE_ExclusiveIndicator:
	{
#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 };

	    // make sure the indicator is square
	    TQRect ir = r;

	    if (r.width() < r.height()) {
		ir.setTop(r.top() + (r.height() - r.width()) / 2);
		ir.setHeight(r.width());
	    } else if (r.height() < r.width()) {
		ir.setLeft(r.left() + (r.width() - r.height()) / 2);
		ir.setWidth(r.height());
	    }

	    p->eraseRect(ir);
	    bool down = flags & Style_Down;
	    bool enabled = flags & Style_Enabled;
	    bool on = flags & Style_On;
	    TQPointArray a;
	    a.setPoints( TQCOORDARRLEN(pts1), pts1 );
	    a.translate( ir.x(), ir.y() );
	    p->setPen( cg.dark() );
	    p->drawPolyline( a );
	    a.setPoints( TQCOORDARRLEN(pts2), pts2 );
	    a.translate( ir.x(), ir.y() );
	    p->setPen( cg.shadow() );
	    p->drawPolyline( a );
	    a.setPoints( TQCOORDARRLEN(pts3), pts3 );
	    a.translate( ir.x(), ir.y() );
	    p->setPen( cg.midlight() );
	    p->drawPolyline( a );
	    a.setPoints( TQCOORDARRLEN(pts4), pts4 );
	    a.translate( ir.x(), ir.y() );
	    p->setPen( cg.light() );
	    p->drawPolyline( a );
	    a.setPoints( TQCOORDARRLEN(pts5), pts5 );
	    a.translate( ir.x(), ir.y() );
	    TQColor fillColor = ( down || !enabled ) ? cg.button() : cg.base();
	    p->setPen( fillColor );
	    p->setBrush( fillColor  ) ;
	    p->drawPolygon( a );
	    if ( on ) {
		p->setPen( Qt::NoPen );
		p->setBrush( cg.text() );
		p->drawRect( ir.x() + 5, ir.y() + 4, 2, 4 );
		p->drawRect( ir.x() + 4, ir.y() + 5, 4, 2 );
	    }
	    break;
	}

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

	    if (lw == 2) {
		TQColorGroup popupCG = cg;
		if ( pe == PE_PanelPopup ) {
		    popupCG.setColor( TQColorGroup::Light, cg.background() );
		    popupCG.setColor( TQColorGroup::Midlight, cg.light() );
		}
		qDrawWinPanel(p, r, popupCG, flags & Style_Sunken);
	    } else {
		TQCommonStyle::tqdrawPrimitive(pe, p, r, cg, flags, opt);
	    }
	    break;
	}

    case PE_Splitter:
	{
	    TQPen oldPen = p->pen();
	    p->setPen( cg.light() );
	    if ( flags & Style_Horizontal ) {
		p->drawLine( r.x() + 1, r.y(), r.x() + 1, r.height() );
		p->setPen( cg.dark() );
		p->drawLine( r.x(), r.y(), r.x(), r.height() );
		p->drawLine( r.right()-1, r.y(), r.right()-1, r.height() );
		p->setPen( cg.shadow() );
		p->drawLine( r.right(), r.y(), r.right(), r.height() );
	    } else {
		p->drawLine( r.x(), r.y() + 1, r.width(), r.y() + 1 );
		p->setPen( cg.dark() );
		p->drawLine( r.x(), r.bottom() - 1, r.width(), r.bottom() - 1 );
		p->setPen( cg.shadow() );
		p->drawLine( r.x(), r.bottom(), r.width(), r.bottom() );
	    }
	    p->setPen( oldPen );
	    break;
	}
#ifndef USE_QT4		// [FIXME]
    case PE_DockWindowResizeHandle:
	{
	    TQPen oldPen = p->pen();
	    p->setPen( cg.light() );
	    if ( flags & Style_Horizontal ) {
		p->drawLine( r.x(), r.y(), r.width(), r.y() );
		p->setPen( cg.dark() );
		p->drawLine( r.x(), r.bottom() - 1, r.width(), r.bottom() - 1 );
		p->setPen( cg.shadow() );
		p->drawLine( r.x(), r.bottom(), r.width(), r.bottom() );
	    } else {
		p->drawLine( r.x(), r.y(), r.x(), r.height() );
		p->setPen( cg.dark() );
		p->drawLine( r.right()-1, r.y(), r.right()-1, r.height() );
		p->setPen( cg.shadow() );
		p->drawLine( r.right(), r.y(), r.right(), r.height() );
	    }
	    p->setPen( oldPen );
	    break;
	}
#endif // USE_QT4

    case PE_ScrollBarSubLine:
	if (use2000style) {
	    if (flags & Style_Down) {
		p->setPen( cg.dark() );
		p->setBrush( cg.brush( TQColorGroup::Button ) );
		p->drawRect( r );
	    } else
		tqdrawPrimitive(PE_ButtonBevel, p, r, cg, flags | Style_Raised);
	} else
	    tqdrawPrimitive(PE_ButtonBevel, p, r, cg, (flags & Style_Enabled) |
			  ((flags & Style_Down) ? Style_Down : Style_Raised));

	tqdrawPrimitive(((flags & Style_Horizontal) ? PE_ArrowLeft : PE_ArrowUp),
		      p, r, cg, flags);
	break;

    case PE_ScrollBarAddLine:
	if (use2000style) {
	    if (flags & Style_Down) {
		p->setPen( cg.dark() );
		p->setBrush( cg.brush( TQColorGroup::Button ) );
		p->drawRect( r );
	    } else
		tqdrawPrimitive(PE_ButtonBevel, p, r, cg, flags | Style_Raised);
	} else
	    tqdrawPrimitive(PE_ButtonBevel, p, r, cg, (flags & Style_Enabled) |
			  ((flags & Style_Down) ? Style_Down : Style_Raised));

	tqdrawPrimitive(((flags & Style_Horizontal) ? PE_ArrowRight : PE_ArrowDown),
		      p, r, cg, flags);
	break;

    case PE_ScrollBarAddPage:
    case PE_ScrollBarSubPage:
	{
	    TQBrush br;
	    TQColor c = p->backgroundColor();

	    p->setPen(Qt::NoPen);
	    p->setBackgroundMode(Qt::OpaqueMode);

	    if (flags & Style_Down) {
		br = TQBrush(cg.shadow(), Qt::Dense4Pattern);
		p->setBackgroundColor( cg.dark() );
		p->setBrush( TQBrush(cg.shadow(), Qt::Dense4Pattern) );
	    } else {
		br = (TQT_TQBRUSH_OBJECT(cg.brush(TQColorGroup::Light)).pixmap() ?
		      cg.brush(TQColorGroup::Light) :
		      TQBrush(cg.light(), Qt::Dense4Pattern));
		p->setBrush(br);
	    }

	    p->drawRect(r);
	    p->setBackgroundColor(c);
	    break;
	}

    case PE_ScrollBarSlider:
	if (! (flags & Style_Enabled)) {
	    TQBrush br = (TQT_TQBRUSH_OBJECT(cg.brush(TQColorGroup::Light)).pixmap() ?
			 cg.brush(TQColorGroup::Light) :
			 TQBrush(cg.light(), Qt::Dense4Pattern));
	    p->setPen(Qt::NoPen);
	    p->setBrush(br);
	    p->setBackgroundMode(Qt::OpaqueMode);
	    p->drawRect(r);
	} else
	    tqdrawPrimitive(PE_ButtonBevel, p, r, cg, Style_Enabled | Style_Raised);
	break;

    case PE_WindowFrame:
	{
	    TQColorGroup popupCG = cg;
	    popupCG.setColor( TQColorGroup::Light, cg.background() );
	    popupCG.setColor( TQColorGroup::Midlight, cg.light() );
	    qDrawWinPanel(p, r, popupCG, flags & Style_Sunken);
	}
	break;

    default:
	if (pe >= PE_ArrowUp && pe <= PE_ArrowLeft) {
	    TQPointArray a;

	    switch ( pe ) {
	    case PE_ArrowUp:
		a.setPoints( 7, -4,1, 2,1, -3,0, 1,0, -2,-1, 0,-1, -1,-2 );
		break;

	    case PE_ArrowDown:
		a.setPoints( 7, -4,-2, 2,-2, -3,-1, 1,-1, -2,0, 0,0, -1,1 );
		break;

	    case PE_ArrowRight:
		a.setPoints( 7, -2,-3, -2,3, -1,-2, -1,2, 0,-1, 0,1, 1,0 );
		break;

	    case PE_ArrowLeft:
		a.setPoints( 7, 0,-3, 0,3, -1,-2, -1,2, -2,-1, -2,1, -3,0 );
		break;

	    default:
		break;
	    }

	    if (a.isNull())
		return;

	    p->save();
	    if ( flags & Style_Down )
		p->translate( tqpixelMetric( PM_ButtonShiftHorizontal ),
			      tqpixelMetric( PM_ButtonShiftVertical ) );

	    if ( flags & Style_Enabled ) {
		a.translate( r.x() + r.width() / 2, r.y() + r.height() / 2 );
		p->setPen( cg.buttonText() );
		p->drawLineSegments( a, 0, 3 );         // draw arrow
		p->drawPoint( a[6] );
	    } else {
		a.translate( r.x() + r.width() / 2 + 1, r.y() + r.height() / 2 + 1 );
		p->setPen( cg.light() );
		p->drawLineSegments( a, 0, 3 );         // draw arrow
		p->drawPoint( a[6] );
		a.translate( -1, -1 );
		p->setPen( cg.mid() );
		p->drawLineSegments( a, 0, 3 );         // draw arrow
		p->drawPoint( a[6] );
	    }
	    p->restore();
	} else
	    TQCommonStyle::tqdrawPrimitive(pe, p, r, cg, flags, opt);
    }
}


/*!
  \reimp
*/
void TQWindowsStyle::tqdrawControl( TQ_ControlElement element,
				 TQPainter *p,
				 const TQWidget *widget,
				 const TQRect &r,
				 const TQColorGroup &cg,
				 SFlags flags,
				 const TQStyleOption& opt ) const
{
    switch (element) {
#ifndef TQT_NO_TABBAR
    case CE_TabBarTab:
	{
	    if ( !widget || !widget->parentWidget() || !opt.tab() )
		break;

	    const TQTabBar * tb = (const TQTabBar *) widget;
	    const TQTab * t = opt.tab();
	    bool selected = flags & Style_Selected;
	    bool lastTab = (tb->indexOf( t->identifier() ) == tb->count()-1) ?
			   TRUE : FALSE;
	    TQRect r2( r );
	    if ( tb->tqshape()  == TQTabBar::RoundedAbove ) {
		p->setPen( cg.midlight() );

		p->drawLine( r2.left(), r2.bottom(), r2.right(), r2.bottom() );
		p->setPen( cg.light() );
		p->drawLine( r2.left(), r2.bottom()-1, r2.right(), r2.bottom()-1 );
		if ( r2.left() == 0 )
		    p->drawPoint( tb->rect().bottomLeft() );

		if ( selected ) {
		    p->fillRect( TQRect( r2.left()+1, r2.bottom()-1, r2.width()-3, 2),
				 cg.brush( TQColorGroup::Background ));
		    p->setPen( cg.background() );
		    p->drawLine( r2.left()+1, r2.bottom(), r2.left()+1, r2.top()+2 );
		    p->setPen( cg.light() );
		} else {
		    p->setPen( cg.light() );
		    r2.setRect( r2.left() + 2, r2.top() + 2,
			       r2.width() - 4, r2.height() - 2 );
		}

		int x1, x2;
		x1 = r2.left();
		x2 = r2.right() - 2;
		p->drawLine( x1, r2.bottom()-1, x1, r2.top() + 2 );
		x1++;
		p->drawPoint( x1, r2.top() + 1 );
		x1++;
		p->drawLine( x1, r2.top(), x2, r2.top() );
		if ( r2.left() > 0 ) {
		    p->setPen( cg.midlight() );
		}
		x1 = r2.left();
		p->drawPoint( x1, r2.bottom());

		p->setPen( cg.midlight() );
		x1++;
		p->drawLine( x1, r2.bottom(), x1, r2.top() + 2 );
		x1++;
		p->drawLine( x1, r2.top()+1, x2, r2.top()+1 );

		p->setPen( cg.dark() );
		x2 = r2.right() - 1;
		p->drawLine( x2, r2.top() + 2, x2, r2.bottom() - 1 +
			     (selected ? 1:-1) );
		p->setPen( cg.shadow() );
		p->drawPoint( x2, r2.top() + 1 );
		p->drawPoint( x2, r2.top() + 1 );
		x2++;
		p->drawLine( x2, r2.top() + 2, x2, r2.bottom() -
			     (selected ? (lastTab ? 0:1) :2));
	    } else if ( tb->tqshape() == TQTabBar::RoundedBelow ) {
		bool rightAligned = tqstyleHint( SH_TabBar_Alignment, tb ) == TQt::AlignRight;
		bool firstTab = tb->indexOf( t->identifier() ) == 0;
		if ( selected ) {
		    p->fillRect( TQRect( r2.left()+1, r2.top(), r2.width()-3, 1),
				 cg.brush( TQColorGroup::Background ));
		    p->setPen( cg.background() );
		    p->drawLine( r2.left()+1, r2.top(), r2.left()+1, r2.bottom()-2 );
		    p->setPen( cg.dark() );
		} else {
		    p->setPen( cg.shadow() );
		    p->drawLine( r2.left() +
				 (rightAligned && firstTab ? 0 : 1),
				 r2.top() + 1,
				 r2.right() - (lastTab ? 0 : 2),
				 r2.top() + 1 );

		    if ( rightAligned && lastTab )
			p->drawPoint( r2.right(), r2.top() );
		    p->setPen( cg.dark() );
		    p->drawLine( r2.left(), r2.top(), r2.right() - 1,
				 r2.top() );
		    r2.setRect( r2.left() + 2, r2.top(),
				r2.width() - 4, r2.height() - 2 );
		}

		p->drawLine( r2.right() - 1, r2.top() + (selected ? 0: 2),
			     r2.right() - 1, r2.bottom() - 2 );
		p->drawPoint( r2.right() - 2, r2.bottom() - 2 );
		p->drawLine( r2.right() - 2, r2.bottom() - 1,
			     r2.left() + 1, r2.bottom() - 1 );

		p->setPen( cg.midlight() );
		p->drawLine( r2.left() + 1, r2.bottom() - 2,
			     r2.left() + 1, r2.top() + (selected ? 0 : 2) );

		p->setPen( cg.shadow() );
		p->drawLine( r2.right(),
			     r2.top() + (lastTab && rightAligned &&
					 selected) ? 0 : 1,
			     r2.right(), r2.bottom() - 1 );
		p->drawPoint( r2.right() - 1, r2.bottom() - 1 );
		p->drawLine( r2.right() - 1, r2.bottom(),
			     r2.left() + 2, r2.bottom() );

		p->setPen( cg.light() );
		p->drawLine( r2.left(), r2.top() + (selected ? 0 : 2),
			     r2.left(), r2.bottom() - 2 );
	    } else {
		TQCommonStyle::tqdrawControl(element, p, widget, r, cg, flags, opt);
	    }
	    break;
	}
#endif // TQT_NO_TABBAR
    case CE_ToolBoxTab:
	{
	    qDrawShadePanel( p, r, cg, flags & (Style_Sunken | Style_Down | Style_On) , 1,
			     &cg.brush(TQColorGroup::Button));
	    break;
	}

#ifndef TQT_NO_POPUPMENU
    case CE_PopupMenuItem:
	{
	    if (! widget || opt.isDefault())
		break;

	    const TQPopupMenu *popupmenu = (const TQPopupMenu *) widget;
	    TQMenuItem *mi = opt.menuItem();
	    if ( !mi )
		break;

	    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 ) {
		// space for the checkmarks
		if (use2000style)
		    maxpmw = TQMAX( maxpmw, 20 );
		else
		    maxpmw = TQMAX( maxpmw, 12 );
	    }

	    int checkcol = maxpmw;

	    if ( mi && mi->isSeparator() ) {                    // draw separator
		p->setPen( cg.dark() );
		p->drawLine( x, y, x+w, y );
		p->setPen( cg.light() );
		p->drawLine( x, y+1, x+w, y+1 );
		return;
	    }

	    TQBrush fill = (act ?
			   cg.brush( TQColorGroup::Highlight ) :
			   cg.brush( TQColorGroup::Button ));
	    p->fillRect( x, y, w, h, fill);

	    if ( !mi )
		return;

	    int xpos = x;
	    TQRect vrect = tqvisualRect( TQRect( xpos, y, checkcol, h ), r );
	    int xvis = vrect.x();
	    if ( mi->isChecked() ) {
		if ( act && !dis )
		    qDrawShadePanel( p, xvis, y, checkcol, h,
				     cg, TRUE, 1, &cg.brush( TQColorGroup::Button ) );
		else {
		    TQBrush fill( cg.light(), Qt::Dense4Pattern );
		    // set the brush origin for the hash pattern to the x/y coordinate
		    // of the menu item's checkmark... this way, the check marks have
		    // a consistent look
		    TQPoint origin = p->brushOrigin();
		    p->setBrushOrigin( xvis, y );
		    qDrawShadePanel( p, xvis, y, checkcol, h, cg, TRUE, 1,
				     &fill );
		    // restore the previous brush origin
		    p->setBrushOrigin( origin );
		}
	    } else if (! act)
		p->fillRect(xvis, y, checkcol , h, cg.brush( TQColorGroup::Button ));

	    if ( mi->iconSet() ) {              // draw iconset
		TQIconSet::Mode mode = dis ? TQIconSet::Disabled : 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();
		if ( act && !dis && !mi->isChecked() )
		    qDrawShadePanel( p, xvis, y, checkcol, h, cg, FALSE, 1,
				     &cg.brush( TQColorGroup::Button ) );
		TQRect pmr( 0, 0, pixw, pixh );
		pmr.moveCenter( vrect.center() );
		p->setPen( cg.text() );
		p->drawPixmap( pmr.topLeft(), pixmap );

		fill = (act ?
			cg.brush( TQColorGroup::Highlight ) :
			cg.brush( TQColorGroup::Button ));
		int xp = xpos + checkcol + 1;
		p->fillRect( tqvisualRect( TQRect( xp, y, w - checkcol - 1, h ), r ), fill);
	    } else  if ( checkable ) {  // just "checking"...
		if ( mi->isChecked() ) {
		    int xp = xpos + windowsItemFrame;

		    SFlags cflags = Style_Default;
		    if (! dis)
			cflags |= Style_Enabled;
		    if (act)
			cflags |= Style_On;

		    tqdrawPrimitive(PE_CheckMark, p,
				  tqvisualRect( TQRect(xp, y + windowsItemFrame,
					checkcol - 2*windowsItemFrame,
					h - 2*windowsItemFrame), r ), cg, cflags);
		}
	    }

	    p->setPen( act ? cg.highlightedText() : cg.buttonText() );

	    TQColor discol;
	    if ( dis ) {
		discol = cg.text();
		p->setPen( discol );
	    }

	    int xm = windowsItemFrame + checkcol + windowsItemHMargin;
	    xpos += xm;

	    vrect = tqvisualRect( TQRect( xpos, y+windowsItemVMargin, w-xm-tab+1, h-2*windowsItemVMargin ), r );
	    xvis = vrect.x();
	    if ( mi->custom() ) {
		p->save();
		if ( dis && !act ) {
		    p->setPen( cg.light() );
		    mi->custom()->paint( p, cg, act, !dis,
					 xvis+1, y+windowsItemVMargin+1, w-xm-tab+1, h-2*windowsItemVMargin );
		    p->setPen( discol );
		}
		mi->custom()->paint( p, cg, act, !dis,
				     xvis, y+windowsItemVMargin, w-xm-tab+1, h-2*windowsItemVMargin );
		p->restore();
	    }
	    TQString s = mi->text();
	    if ( !s.isNull() ) {                        // draw text
		int t = s.tqfind( '\t' );
		int text_flags = TQt::AlignVCenter|TQt::ShowPrefix | TQt::DontClip | TQt::SingleLine;
		if (!tqstyleHint(SH_UnderlineAccelerator, widget))
		    text_flags |= TQt::NoAccel;
		text_flags |= (TQApplication::reverseLayout() ? TQt::AlignRight : TQt::AlignLeft );
		if ( t >= 0 ) {                         // draw tab text
		    int xp = x + w - tab - windowsItemHMargin - windowsItemFrame + 1;
		    if ( use2000style )
			xp -= 20;
		    else
			xp -= windowsRightBorder;
		    int xoff = tqvisualRect( TQRect( xp, y+windowsItemVMargin, tab, h-2*windowsItemVMargin ), r ).x();
		    if ( dis && !act ) {
			p->setPen( cg.light() );
			p->drawText( xoff+1, y+windowsItemVMargin+1, tab, h-2*windowsItemVMargin, text_flags, s.mid( t+1 ));
			p->setPen( discol );
		    }
		    p->drawText( xoff, y+windowsItemVMargin, tab, h-2*windowsItemVMargin, text_flags, s.mid( t+1 ) );
		    s = s.left( t );
		}
		if ( dis && !act ) {
		    p->setPen( cg.light() );
		    p->drawText( xvis+1, y+windowsItemVMargin+1, w-xm-tab+1, h-2*windowsItemVMargin, text_flags, s, t );
		    p->setPen( discol );
		}
		p->drawText( xvis, y+windowsItemVMargin, w-xm-tab+1, h-2*windowsItemVMargin, text_flags, s, t );
	    } else if ( mi->pixmap() ) {                        // draw pixmap
		TQPixmap *pixmap = mi->pixmap();
		if ( pixmap->depth() == 1 )
		    p->setBackgroundMode( Qt::OpaqueMode );
		p->drawPixmap( xvis, y+windowsItemFrame, *pixmap );
		if ( pixmap->depth() == 1 )
		    p->setBackgroundMode( Qt::TransparentMode );
	    }
	    if ( mi->popup() ) {                        // draw sub menu arrow
		int dim = (h-2*windowsItemFrame) / 2;
		PrimitiveElement arrow;
		arrow = ( TQApplication::reverseLayout() ? PE_ArrowLeft : PE_ArrowRight );
		xpos = x+w - windowsArrowHMargin - windowsItemFrame - dim;
		vrect = tqvisualRect( TQRect(xpos, y + h / 2 - dim / 2, dim, dim), r );
		if ( act ) {
		    TQColorGroup g2 = cg;
		    g2.setColor( TQColorGroup::ButtonText, g2.highlightedText() );
		    tqdrawPrimitive(arrow, p, vrect,
				  g2, dis ? Style_Default : Style_Enabled);
		} else {
		    tqdrawPrimitive(arrow, p, vrect,
				  cg, dis ? Style_Default : Style_Enabled );
		}
	    }

	    break;
	}
#endif

    case CE_MenuBarItem:
	{
	    bool active = flags & Style_Active;
	    bool hasFocus = flags & Style_HasFocus;
	    bool down = flags & Style_Down;
	    TQRect pr = r;

	    p->fillRect( r, cg.brush( TQColorGroup::Button ) );
	    if ( active || hasFocus ) {
		TQBrush b = cg.brush( TQColorGroup::Button );
		if ( active && down )
		    p->setBrushOrigin(p->brushOrigin() + TQPoint(1,1));
		if ( active && hasFocus )
		    qDrawShadeRect( p, r.x(), r.y(), r.width(), r.height(),
				    cg, active && down, 1, 0, &b );
		if ( active && down ) {
		    pr.moveBy( tqpixelMetric(PM_ButtonShiftHorizontal, widget),
			       tqpixelMetric(PM_ButtonShiftVertical, widget) );
		    p->setBrushOrigin(p->brushOrigin() - TQPoint(1,1));
		}
	    }
	    TQCommonStyle::tqdrawControl(element, p, widget, pr, cg, flags, opt);
	    break;
	}

    default:
	TQCommonStyle::tqdrawControl(element, p, widget, r, cg, flags, opt);
    }
}


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

    switch (metric) {
    case PM_ButtonDefaultIndicator:
    case PM_ButtonShiftHorizontal:
    case PM_ButtonShiftVertical:
	ret = 1;
	break;

    case PM_MaximumDragDistance:
	ret = 60;
	break;

#ifndef TQT_NO_SLIDER
    case PM_SliderLength:
	ret = 11;
	break;

	// Returns the number of pixels to use for the business part of the
	// slider (i.e., the non-tickmark portion). The remaining space is shared
	// equally between the tickmark regions.
    case PM_SliderControlThickness:
	{
	    const TQSlider * sl = (const TQSlider *) widget;
	    int space = (sl->orientation() == Qt::Horizontal) ? sl->height()
			: sl->width();
	    int ticks = sl->tickmarks();
	    int n = 0;
	    if ( ticks & TQSlider::Above ) n++;
	    if ( ticks & TQSlider::Below ) n++;
	    if ( !n ) {
		ret = space;
		break;
	    }

	    int thick = 6;	// Magic constant to get 5 + 16 + 5
	    if ( ticks != TQSlider::Both && ticks != TQSlider::NoMarks )
		thick += tqpixelMetric( PM_SliderLength, sl ) / 4;

	    space -= thick;
	    //### the two sides may be unequal in size
	    if ( space > 0 )
		thick += (space * 2) / (n + 2);
	    ret = thick;
	    break;
	}
#endif // TQT_NO_SLIDER

    case PM_MenuBarFrameWidth:
	ret = 0;
	break;

#if defined(TQ_WS_WIN)
    case PM_TitleBarHeight:
	if ( widget && ( widget->testWFlags( WStyle_Tool ) || ::tqqt_cast<TQDockWindow*>(widget) ) ) {
	    // MS always use one less than they say
#if defined(TQ_OS_TEMP)
	    ret = GetSystemMetrics( SM_CYCAPTION ) - 1;
#else
	    ret = GetSystemMetrics( SM_CYSMCAPTION ) - 1;
#endif
	} else {
	    ret = GetSystemMetrics( SM_CYCAPTION ) - 1;
	}
	break;

    case PM_ScrollBarExtent:
	{
#ifndef TQ_OS_TEMP
	    NONCLIENTMETRICS ncm;
	    ncm.cbSize = sizeof(NONCLIENTMETRICS);
	    if ( SystemParametersInfo( SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0 ) )
		ret = TQMAX( ncm.iScrollHeight, ncm.iScrollWidth );
	    else
#endif
		ret = TQCommonStyle::tqpixelMetric( metric, widget );
	}
	break;
#endif

    case PM_SplitterWidth:
	ret = TQMAX( 6, TQApplication::globalStrut().width() );
	break;

#if defined(TQ_WS_WIN)
    case PM_MDIFrameWidth:
	ret = GetSystemMetrics(SM_CYFRAME);
	break;
#endif

    default:
	ret = TQCommonStyle::tqpixelMetric(metric, widget);
	break;
    }

    return ret;
}


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

    switch (contents) {
    case CT_PushButton:
	{
#ifndef TQT_NO_PUSHBUTTON
	    const TQPushButton *button = (const TQPushButton *) widget;
	    sz = TQCommonStyle::tqsizeFromContents(contents, widget, contentsSize, opt);
	    int w = sz.width(), h = sz.height();

	    int defwidth = 0;
	    if (button->isDefault() || button->autoDefault())
		defwidth = 2*tqpixelMetric( PM_ButtonDefaultIndicator, widget );

	    if (w < 80+defwidth && !button->pixmap())
		w = 80+defwidth;
	    if (h < 23+defwidth)
		h = 23+defwidth;

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

    case CT_PopupMenuItem:
	{
#ifndef TQT_NO_POPUPMENU
	    if (! widget || 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 += 2*windowsItemVMargin + 2*windowsItemFrame;
	    } else if ( mi->widget() ) {
	    } else if (mi->isSeparator()) {
		w = 10; // arbitrary
		h = windowsSepHeight;
	    } else {
		if (mi->pixmap())
		    h = TQMAX(h, mi->pixmap()->height() + 2*windowsItemFrame);
		else if (! mi->text().isNull())
		    h = TQMAX(h, popup->fontMetrics().height() + 2*windowsItemVMargin +
			     2*windowsItemFrame);

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

	    if (! mi->text().isNull() && mi->text().tqfind('\t') >= 0) {
		if ( use2000style )
		    w += 20;
		else
		    w += windowsTabSpacing;
	    } else if (mi->popup()) {
		w += 2*windowsArrowHMargin;
	    }

	    if (use2000style) {
		if (checkable && maxpmw < 20)
		    w += 20 - maxpmw;
	    } else {
		if (checkable && maxpmw < windowsCheckMarkWidth)
		    w += windowsCheckMarkWidth - maxpmw;
	    }
	    if (checkable || maxpmw > 0)
		w += windowsCheckMarkHMargin;
	    if (use2000style)
		w += 20;
	    else
		w += windowsRightBorder;

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

    default:
	sz = TQCommonStyle::tqsizeFromContents(contents, widget, sz, opt);
	break;
    }

    return sz;
}

/*! \reimp
*/
void TQWindowsStyle::polishPopupMenu( TQPopupMenu* p)
{
#ifndef TQT_NO_POPUPMENU
    if ( !p->testWState( TQt::WState_Polished ) )
        p->setCheckable( TRUE );
#endif
}

#ifndef TQT_NO_IMAGEIO_XPM
static const char * const qt_close_xpm[] = {
"12 12 2 1",
"# c #000000",
". c None",
"............",
"............",
"..##....##..",
"...##..##...",
"....####....",
".....##.....",
"....####....",
"...##..##...",
"..##....##..",
"............",
"............",
"............"};

static const char * const qt_maximize_xpm[]={
"12 12 2 1",
"# c #000000",
". c None",
"............",
".#########..",
".#########..",
".#.......#..",
".#.......#..",
".#.......#..",
".#.......#..",
".#.......#..",
".#.......#..",
".#########..",
"............",
"............"};


static const char * const qt_minimize_xpm[] = {
"12 12 2 1",
"# c #000000",
". c None",
"............",
"............",
"............",
"............",
"............",
"............",
"............",
"............",
"..######....",
"..######....",
"............",
"............"};

static const char * const qt_normalizeup_xpm[] = {
"12 12 2 1",
"# c #000000",
". c None",
"............",
"....######..",
"....######..",
"....#....#..",
"..######.#..",
"..######.#..",
"..#....###..",
"..#....#....",
"..#....#....",
"..######....",
"............",
"............"};


static const char * const qt_shade_xpm[] = {
"12 12 2 1",
"# c #000000",
". c None",
"............",
"............",
"............",
"............",
"............",
".....#......",
"....###.....",
"...#####....",
"..#######...",
"............",
"............",
"............"};

static const char * const qt_unshade_xpm[] = {
"12 12 2 1",
"# c #000000",
". c None",
"............",
"............",
"............",
"............",
"..#######...",
"...#####....",
"....###.....",
".....#......",
"............",
"............",
"............",
"............"};

static const char * dock_window_close_xpm[] = {
"8 8 2 1",
"# c #000000",
". c None",
"........",
".##..##.",
"..####..",
"...##...",
"..####..",
".##..##.",
"........",
"........"};

/* XPM */
static const char * const information_xpm[]={
"32 32 5 1",
". c None",
"c c #000000",
"* c #999999",
"a c #ffffff",
"b c #0000ff",
"...........********.............",
"........***aaaaaaaa***..........",
"......**aaaaaaaaaaaaaa**........",
".....*aaaaaaaaaaaaaaaaaa*.......",
"....*aaaaaaaabbbbaaaaaaaac......",
"...*aaaaaaaabbbbbbaaaaaaaac.....",
"..*aaaaaaaaabbbbbbaaaaaaaaac....",
".*aaaaaaaaaaabbbbaaaaaaaaaaac...",
".*aaaaaaaaaaaaaaaaaaaaaaaaaac*..",
"*aaaaaaaaaaaaaaaaaaaaaaaaaaaac*.",
"*aaaaaaaaaabbbbbbbaaaaaaaaaaac*.",
"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
".*aaaaaaaaaaabbbbbaaaaaaaaaac***",
".*aaaaaaaaaaabbbbbaaaaaaaaaac***",
"..*aaaaaaaaaabbbbbaaaaaaaaac***.",
"...caaaaaaabbbbbbbbbaaaaaac****.",
"....caaaaaaaaaaaaaaaaaaaac****..",
".....caaaaaaaaaaaaaaaaaac****...",
"......ccaaaaaaaaaaaaaacc****....",
".......*cccaaaaaaaaccc*****.....",
"........***cccaaaac*******......",
"..........****caaac*****........",
".............*caaac**...........",
"...............caac**...........",
"................cac**...........",
".................cc**...........",
"..................***...........",
"...................**..........."};
/* XPM */
static const char* const warning_xpm[]={
"32 32 4 1",
". c None",
"a c #ffff00",
"* c #000000",
"b c #999999",
".............***................",
"............*aaa*...............",
"...........*aaaaa*b.............",
"...........*aaaaa*bb............",
"..........*aaaaaaa*bb...........",
"..........*aaaaaaa*bb...........",
".........*aaaaaaaaa*bb..........",
".........*aaaaaaaaa*bb..........",
"........*aaaaaaaaaaa*bb.........",
"........*aaaa***aaaa*bb.........",
".......*aaaa*****aaaa*bb........",
".......*aaaa*****aaaa*bb........",
"......*aaaaa*****aaaaa*bb.......",
"......*aaaaa*****aaaaa*bb.......",
".....*aaaaaa*****aaaaaa*bb......",
".....*aaaaaa*****aaaaaa*bb......",
"....*aaaaaaaa***aaaaaaaa*bb.....",
"....*aaaaaaaa***aaaaaaaa*bb.....",
"...*aaaaaaaaa***aaaaaaaaa*bb....",
"...*aaaaaaaaaa*aaaaaaaaaa*bb....",
"..*aaaaaaaaaaa*aaaaaaaaaaa*bb...",
"..*aaaaaaaaaaaaaaaaaaaaaaa*bb...",
".*aaaaaaaaaaaa**aaaaaaaaaaa*bb..",
".*aaaaaaaaaaa****aaaaaaaaaa*bb..",
"*aaaaaaaaaaaa****aaaaaaaaaaa*bb.",
"*aaaaaaaaaaaaa**aaaaaaaaaaaa*bb.",
"*aaaaaaaaaaaaaaaaaaaaaaaaaaa*bbb",
"*aaaaaaaaaaaaaaaaaaaaaaaaaaa*bbb",
".*aaaaaaaaaaaaaaaaaaaaaaaaa*bbbb",
"..*************************bbbbb",
"....bbbbbbbbbbbbbbbbbbbbbbbbbbb.",
".....bbbbbbbbbbbbbbbbbbbbbbbbb.."};
/* XPM */
static const char* const critical_xpm[]={
"32 32 4 1",
". c None",
"a c #999999",
"* c #ff0000",
"b c #ffffff",
"...........********.............",
".........************...........",
".......****************.........",
"......******************........",
".....********************a......",
"....**********************a.....",
"...************************a....",
"..*******b**********b*******a...",
"..******bbb********bbb******a...",
".******bbbbb******bbbbb******a..",
".*******bbbbb****bbbbb*******a..",
"*********bbbbb**bbbbb*********a.",
"**********bbbbbbbbbb**********a.",
"***********bbbbbbbb***********aa",
"************bbbbbb************aa",
"************bbbbbb************aa",
"***********bbbbbbbb***********aa",
"**********bbbbbbbbbb**********aa",
"*********bbbbb**bbbbb*********aa",
".*******bbbbb****bbbbb*******aa.",
".******bbbbb******bbbbb******aa.",
"..******bbb********bbb******aaa.",
"..*******b**********b*******aa..",
"...************************aaa..",
"....**********************aaa...",
"....a********************aaa....",
".....a******************aaa.....",
"......a****************aaa......",
".......aa************aaaa.......",
".........aa********aaaaa........",
"...........aaaaaaaaaaa..........",
".............aaaaaaa............"};
/* XPM */
static const char *const question_xpm[] = {
"32 32 5 1",
". c None",
"c c #000000",
"* c #999999",
"a c #ffffff",
"b c #0000ff",
"...........********.............",
"........***aaaaaaaa***..........",
"......**aaaaaaaaaaaaaa**........",
".....*aaaaaaaaaaaaaaaaaa*.......",
"....*aaaaaaaaaaaaaaaaaaaac......",
"...*aaaaaaaabbbbbbaaaaaaaac.....",
"..*aaaaaaaabaaabbbbaaaaaaaac....",
".*aaaaaaaabbaaaabbbbaaaaaaaac...",
".*aaaaaaaabbbbaabbbbaaaaaaaac*..",
"*aaaaaaaaabbbbaabbbbaaaaaaaaac*.",
"*aaaaaaaaaabbaabbbbaaaaaaaaaac*.",
"*aaaaaaaaaaaaabbbbaaaaaaaaaaac**",
"*aaaaaaaaaaaaabbbaaaaaaaaaaaac**",
"*aaaaaaaaaaaaabbaaaaaaaaaaaaac**",
"*aaaaaaaaaaaaabbaaaaaaaaaaaaac**",
"*aaaaaaaaaaaaaaaaaaaaaaaaaaaac**",
".*aaaaaaaaaaaabbaaaaaaaaaaaac***",
".*aaaaaaaaaaabbbbaaaaaaaaaaac***",
"..*aaaaaaaaaabbbbaaaaaaaaaac***.",
"...caaaaaaaaaabbaaaaaaaaaac****.",
"....caaaaaaaaaaaaaaaaaaaac****..",
".....caaaaaaaaaaaaaaaaaac****...",
"......ccaaaaaaaaaaaaaacc****....",
".......*cccaaaaaaaaccc*****.....",
"........***cccaaaac*******......",
"..........****caaac*****........",
".............*caaac**...........",
"...............caac**...........",
"................cac**...........",
".................cc**...........",
"..................***...........",
"...................**...........",
};
#endif //TQT_NO_IMAGEIO_XPM

/*!
 \reimp
 */
TQPixmap TQWindowsStyle::stylePixmap(StylePixmap stylepixmap,
				   const TQWidget *widget,
				   const TQStyleOption& opt) const
{
#ifndef TQT_NO_IMAGEIO_XPM
    switch (stylepixmap) {
    case SP_TitleBarShadeButton:
	return TQPixmap( (const char **)qt_shade_xpm );
    case SP_TitleBarUnshadeButton:
	return TQPixmap( (const char **)qt_unshade_xpm );
    case SP_TitleBarNormalButton:
	return TQPixmap( (const char **)qt_normalizeup_xpm );
    case SP_TitleBarMinButton:
	return TQPixmap( (const char **)qt_minimize_xpm );
    case SP_TitleBarMaxButton:
	return TQPixmap( (const char **)qt_maximize_xpm );
    case SP_TitleBarCloseButton:
	return TQPixmap( (const char **)qt_close_xpm );
    case SP_DockWindowCloseButton:
	return TQPixmap( (const char **)dock_window_close_xpm );
    case SP_MessageBoxInformation:
	return TQPixmap( (const char **)information_xpm);
    case SP_MessageBoxWarning:
	return TQPixmap( (const char **)warning_xpm );
    case SP_MessageBoxCritical:
	return TQPixmap( (const char **)critical_xpm );
    case SP_MessageBoxQuestion:
	return TQPixmap( (const char **)question_xpm );
    default:
	break;
    }
#endif //TQT_NO_IMAGEIO_XPM
    return TQCommonStyle::stylePixmap(stylepixmap, widget, opt);
}

/*!\reimp
*/
void TQWindowsStyle::tqdrawComplexControl( TQ_ComplexControl ctrl, TQPainter *p,
					const TQWidget *widget,
					const TQRect &r,
					const TQColorGroup &cg,
					SFlags flags,
					SCFlags sub,
					SCFlags subActive,
					const TQStyleOption& opt ) const
{
    switch (ctrl) {
#ifndef TQT_NO_LISTVIEW
    case CC_ListView:
	{
	    if ( sub & SC_ListView ) {
		TQCommonStyle::tqdrawComplexControl( ctrl, p, widget, r, cg, flags, sub, subActive, opt );
	    }
	    if ( sub & ( SC_ListViewBranch | SC_ListViewExpand ) ) {
		if (opt.isDefault())
		    break;

		TQListViewItem *item = opt.listViewItem(),
			     *child = item->firstChild();

		int y = r.y();
		int c;
		int dotoffset = 0;
		TQPointArray dotlines;
		if ( subActive == (uint)SC_All && sub == SC_ListViewExpand ) {
		    c = 2;
		    dotlines.resize(2);
		    dotlines[0] = TQPoint( r.right(), r.top() );
		    dotlines[1] = TQPoint( r.right(), r.bottom() );
		} else {
		    int linetop = 0, linebot = 0;
		    // each branch needs at most two lines, ie. four end points
		    dotoffset = (item->itemPos() + item->height() - y) %2;
		    dotlines.resize( item->childCount() * 4 );
		    c = 0;

		    // skip the stuff above the exposed rectangle
		    while ( child && y + child->height() <= 0 ) {
			y += child->totalHeight();
			child = child->nextSibling();
		    }

		    int bx = r.width() / 2;

		    // paint stuff in the magical area
		    TQListView* v = item->listView();
		    while ( child && y < r.height() ) {
			if (child->isVisible()) {
			    int lh;
			    if ( !item->multiLinesEnabled() )
				lh = child->height();
			    else
				lh = p->fontMetrics().height() + 2 * v->itemMargin();
			    lh = TQMAX( lh, TQApplication::globalStrut().height() );
			    if ( lh % 2 > 0 )
				lh++;
			    linebot = y + lh/2;
			    if ( (child->isExpandable() || child->childCount()) &&
				(child->height() > 0) ) {
				// needs a box
				p->setPen( cg.mid() );
				p->drawRect( bx-4, linebot-4, 9, 9 );
				// plus or minus
				p->setPen( cg.text() );
				p->drawLine( bx - 2, linebot, bx + 2, linebot );
				if ( !child->isOpen() )
				    p->drawLine( bx, linebot - 2, bx, linebot + 2 );
				// dotlinery
				p->setPen( cg.mid() );
				dotlines[c++] = TQPoint( bx, linetop );
				dotlines[c++] = TQPoint( bx, linebot - 4 );
				dotlines[c++] = TQPoint( bx + 5, linebot );
				dotlines[c++] = TQPoint( r.width(), linebot );
				linetop = linebot + 5;
			    } else {
				// just dotlinery
				dotlines[c++] = TQPoint( bx+1, linebot -1);
				dotlines[c++] = TQPoint( r.width(), linebot -1);
			    }
			    y += child->totalHeight();
			}
			child = child->nextSibling();
		    }

		    // Expand line height to edge of rectangle if there's any
		    // visible child below
		    while ( child && child->height() <= 0)
			child = child->nextSibling();
		    if ( child )
			linebot = r.height();

		    if ( linetop < linebot ) {
			dotlines[c++] = TQPoint( bx, linetop );
			dotlines[c++] = TQPoint( bx, linebot );
		    }
		}
		p->setPen( cg.text() );

		static TQBitmap *verticalLine = 0, *horizontalLine = 0;
		static TQCleanupHandler<TQBitmap> qlv_cleanup_bitmap;
		if ( !verticalLine ) {
		    // make 128*1 and 1*128 bitmaps that can be used for
		    // drawing the right sort of lines.
		    verticalLine = new TQBitmap( 1, 129, TRUE );
		    horizontalLine = new TQBitmap( 128, 1, TRUE );
		    TQPointArray a( 64 );
		    TQPainter p;
		    p.begin( verticalLine );
		    int i;
		    for( i=0; i<64; i++ )
			a.setPoint( i, 0, i*2+1 );
		    p.setPen( Qt::color1 );
		    p.drawPoints( a );
		    p.end();
		    TQApplication::flushX();
		    verticalLine->setMask( *verticalLine );
		    p.begin( horizontalLine );
		    for( i=0; i<64; i++ )
			a.setPoint( i, i*2+1, 0 );
		    p.setPen( Qt::color1 );
		    p.drawPoints( a );
		    p.end();
		    TQApplication::flushX();
		    horizontalLine->setMask( *horizontalLine );
		    qlv_cleanup_bitmap.add( &verticalLine );
		    qlv_cleanup_bitmap.add( &horizontalLine );
		}

		int line; // index into dotlines
		if ( sub & SC_ListViewBranch ) for( line = 0; line < c; line += 2 ) {
		    // assumptions here: lines are horizontal or vertical.
		    // lines always start with the numerically lowest
		    // coordinate.

		    // point ... relevant coordinate of current point
		    // end ..... same coordinate of the end of the current line
		    // other ... the other coordinate of the current point/line
		    if ( dotlines[line].y() == dotlines[line+1].y() ) {
			int end = dotlines[line+1].x();
			int point = dotlines[line].x();
			int other = dotlines[line].y();
			while( point < end ) {
			    int i = 128;
			    if ( i+point > end )
				i = end-point;
			    p->drawPixmap( point, other, *horizontalLine,
					   0, 0, i, 1 );
			    point += i;
			}
		    } else {
			int end = dotlines[line+1].y();
			int point = dotlines[line].y();
			int other = dotlines[line].x();
			int pixmapoffset = ((point & 1) != dotoffset ) ? 1 : 0;
			while( point < end ) {
			    int i = 128;
			    if ( i+point > end )
				i = end-point;
			    p->drawPixmap( other, point, *verticalLine,
					   0, pixmapoffset, 1, i );
			    point += i;
			}
		    }
		}
	    }
	}
	break;
#endif //TQT_NO_LISTVIEW

#ifndef TQT_NO_COMBOBOX
    case CC_ComboBox:
	if ( sub & SC_ComboBoxArrow ) {
	    SFlags flags = Style_Default;

	    qDrawWinPanel( p, r, cg, TRUE, widget->isEnabled() ?
			   &cg.brush( TQColorGroup::Base ):
			   &cg.brush( TQColorGroup::Background ) );

	    TQRect ar =
		TQStyle::tqvisualRect( querySubControlMetrics( CC_ComboBox, widget,
							    SC_ComboBoxArrow ), widget );
	    if ( subActive == SC_ComboBoxArrow ) {
		p->setPen( cg.dark() );
		p->setBrush( cg.brush( TQColorGroup::Button ) );
		p->drawRect( ar );
	    } else
		qDrawWinPanel( p, ar, cg, FALSE,
			       &cg.brush( TQColorGroup::Button ) );

	    ar.addCoords( 2, 2, -2, -2 );
	    if ( widget->isEnabled() )
		flags |= Style_Enabled;

	    if ( subActive == SC_ComboBoxArrow ) {
		flags |= Style_Sunken;
	    }
	    tqdrawPrimitive( PE_ArrowDown, p, ar, cg, flags );
	}

	if ( sub & SC_ComboBoxEditField ) {
	    const TQComboBox * cb = (const TQComboBox *) widget;
	    TQRect re =
		TQStyle::tqvisualRect( querySubControlMetrics( CC_ComboBox, widget,
							    SC_ComboBoxEditField ), widget );
	    if ( cb->hasFocus() && !cb->editable() )
		p->fillRect( re.x(), re.y(), re.width(), re.height(),
			     cg.brush( TQColorGroup::Highlight ) );

	    if ( cb->hasFocus() ) {
		p->setPen( cg.highlightedText() );
		p->setBackgroundColor( cg.highlight() );

	    } else {
		p->setPen( cg.text() );
		p->setBackgroundColor( cg.background() );
	    }

	    if ( cb->hasFocus() && !cb->editable() ) {
		TQRect re =
		    TQStyle::tqvisualRect( subRect( SR_ComboBoxFocusRect, cb ), widget );
		tqdrawPrimitive( PE_FocusRect, p, re, cg, Style_FocusAtBorder, TQStyleOption(cg.highlight()));
	    }
	}

	break;
#endif	// TQT_NO_COMBOBOX

#ifndef TQT_NO_SLIDER
    case CC_Slider:
	{
	    const TQSlider *sl = (const TQSlider *) widget;
	    int thickness  = tqpixelMetric( PM_SliderControlThickness, widget );
	    int len        = tqpixelMetric( PM_SliderLength, widget );
	    int ticks = sl->tickmarks();

	    TQRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove,
						  opt),
		  handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle,
						  opt);

	    if ((sub & SC_SliderGroove) && groove.isValid()) {
		int mid = thickness / 2;

		if ( ticks & TQSlider::Above )
		    mid += len / 8;
		if ( ticks & TQSlider::Below )
		    mid -= len / 8;

		p->setPen( cg.shadow() );
		if ( sl->orientation() == Qt::Horizontal ) {
		    qDrawWinPanel( p, groove.x(), groove.y() + mid - 2,
				   groove.width(), 4, cg, TRUE );
		    p->drawLine( groove.x() + 1, groove.y() + mid - 1,
				 groove.x() + groove.width() - 3, groove.y() + mid - 1 );
		} else {
		    qDrawWinPanel( p, groove.x() + mid - 2, groove.y(),
				   4, groove.height(), cg, TRUE );
		    p->drawLine( groove.x() + mid - 1, groove.y() + 1,
				 groove.x() + mid - 1,
				 groove.y() + groove.height() - 3 );
		}
	    }

	    if (sub & SC_SliderTickmarks)
		TQCommonStyle::tqdrawComplexControl(ctrl, p, widget, r, cg, flags,
						 SC_SliderTickmarks, subActive,
						 opt );

	    if ( sub & SC_SliderHandle ) {
		// 4444440
		// 4333310
		// 4322210
		// 4322210
		// 4322210
		// 4322210
		// *43210*
		// **410**
		// ***0***
		const TQColor c0 = cg.shadow();
		const TQColor c1 = cg.dark();
		// const TQColor c2 = g.button();
		const TQColor c3 = cg.midlight();
		const TQColor c4 = cg.light();

		int x = handle.x(), y = handle.y(),
		   wi = handle.width(), he = handle.height();

		int x1 = x;
		int x2 = x+wi-1;
		int y1 = y;
		int y2 = y+he-1;

		Qt::Orientation orient = sl->orientation();
		bool tickAbove = sl->tickmarks() == TQSlider::Above;
		bool tickBelow = sl->tickmarks() == TQSlider::Below;

		p->fillRect( x, y, wi, he, cg.brush( TQColorGroup::Background ) );

		if ( flags & Style_HasFocus ) {
		    TQRect re = subRect( SR_SliderFocusRect, sl );
		    tqdrawPrimitive( PE_FocusRect, p, re, cg );
		}

		if ( (tickAbove && tickBelow) || (!tickAbove && !tickBelow) ) {
		    qDrawWinButton( p, TQRect(x,y,wi,he), cg, FALSE,
				    &cg.brush( TQColorGroup::Button ) );
		    return;
		}

		TQSliderDirection dir;

		if ( orient == Qt::Horizontal )
		    if ( tickAbove )
			dir = SlUp;
		    else
			dir = SlDown;
		else
		    if ( tickAbove )
			dir = SlLeft;
		    else
			dir = SlRight;

		TQPointArray a;

		int d = 0;
		switch ( dir ) {
		case SlUp:
		    y1 = y1 + wi/2;
		    d =  (wi + 1) / 2 - 1;
		    a.setPoints(5, x1,y1, x1,y2, x2,y2, x2,y1, x1+d,y1-d );
		    break;
		case SlDown:
		    y2 = y2 - wi/2;
		    d =  (wi + 1) / 2 - 1;
		    a.setPoints(5, x1,y1, x1,y2, x1+d,y2+d, x2,y2, x2,y1 );
		    break;
		case SlLeft:
		    d =  (he + 1) / 2 - 1;
		    x1 = x1 + he/2;
		    a.setPoints(5, x1,y1, x1-d,y1+d, x1,y2, x2,y2, x2,y1);
		    break;
		case SlRight:
		    d =  (he + 1) / 2 - 1;
		    x2 = x2 - he/2;
		    a.setPoints(5, x1,y1, x1,y2, x2,y2, x2+d,y1+d, x2,y1 );
		    break;
		}

		TQBrush oldBrush = p->brush();
		p->setBrush( cg.brush( TQColorGroup::Button ) );
		p->setPen( Qt::NoPen );
		p->drawRect( x1, y1, x2-x1+1, y2-y1+1 );
		p->drawPolygon( a );
		p->setBrush( oldBrush );

		if ( dir != SlUp ) {
		    p->setPen( c4 );
		    p->drawLine( x1, y1, x2, y1 );
		    p->setPen( c3 );
		    p->drawLine( x1, y1+1, x2, y1+1 );
		}
		if ( dir != SlLeft ) {
		    p->setPen( c3 );
		    p->drawLine( x1+1, y1+1, x1+1, y2 );
		    p->setPen( c4 );
		    p->drawLine( x1, y1, x1, y2 );
		}
		if ( dir != SlRight ) {
		    p->setPen( c0 );
		    p->drawLine( x2, y1, x2, y2 );
		    p->setPen( c1 );
		    p->drawLine( x2-1, y1+1, x2-1, y2-1 );
		}
		if ( dir != SlDown ) {
		    p->setPen( c0 );
		    p->drawLine( x1, y2, x2, y2 );
		    p->setPen( c1 );
		    p->drawLine( x1+1, y2-1, x2-1, y2-1 );
		}

		switch ( dir ) {
		case SlUp:
		    p->setPen( c4 );
		    p->drawLine( x1, y1, x1+d, y1-d);
		    p->setPen( c0 );
		    d = wi - d - 1;
		    p->drawLine( x2, y1, x2-d, y1-d);
		    d--;
		    p->setPen( c3 );
		    p->drawLine( x1+1, y1, x1+1+d, y1-d );
		    p->setPen( c1 );
		    p->drawLine( x2-1, y1, x2-1-d, y1-d);
		    break;
		case SlDown:
		    p->setPen( c4 );
		    p->drawLine( x1, y2, x1+d, y2+d);
		    p->setPen( c0 );
		    d = wi - d - 1;
		    p->drawLine( x2, y2, x2-d, y2+d);
		    d--;
		    p->setPen( c3 );
		    p->drawLine( x1+1, y2, x1+1+d, y2+d );
		    p->setPen( c1 );
		    p->drawLine( x2-1, y2, x2-1-d, y2+d);
		    break;
		case SlLeft:
		    p->setPen( c4 );
		    p->drawLine( x1, y1, x1-d, y1+d);
		    p->setPen( c0 );
		    d = he - d - 1;
		    p->drawLine( x1, y2, x1-d, y2-d);
		    d--;
		    p->setPen( c3 );
		    p->drawLine( x1, y1+1, x1-d, y1+1+d );
		    p->setPen( c1 );
		    p->drawLine( x1, y2-1, x1-d, y2-1-d);
		    break;
		case SlRight:
		    p->setPen( c4 );
		    p->drawLine( x2, y1, x2+d, y1+d);
		    p->setPen( c0 );
		    d = he - d - 1;
		    p->drawLine( x2, y2, x2+d, y2-d);
		    d--;
		    p->setPen( c3 );
		    p->drawLine(  x2, y1+1, x2+d, y1+1+d );
		    p->setPen( c1 );
		    p->drawLine( x2, y2-1, x2+d, y2-1-d);
		    break;
		}
	    }

	    break;
	}
#endif // TQT_NO_SLIDER

    default:
	TQCommonStyle::tqdrawComplexControl( ctrl, p, widget, r, cg, flags, sub,
					  subActive, opt );
	break;
    }
}


/*! \reimp */
int TQWindowsStyle::tqstyleHint( TQ_StyleHint hint,
			      const TQWidget *widget,
			      const TQStyleOption &opt,
			      TQStyleHintReturn *returnData ) const
{
    int ret;

    switch (hint) {
    case SH_EtchDisabledText:
    case SH_Slider_SnapToValue:
    case SH_PrintDialog_RightAlignButtons:
    case SH_MainWindow_SpaceBelowMenuBar:
    case SH_FontDialog_SelectAssociatedText:
    case SH_PopupMenu_AllowActiveAndDisabled:
    case SH_MenuBar_AltKeyNavigation:
    case SH_MenuBar_MouseTracking:
    case SH_PopupMenu_MouseTracking:
    case SH_ComboBox_ListMouseTracking:
    case SH_ScrollBar_StopMouseOverSlider:
	ret = 1;
	break;

    case SH_ItemView_ChangeHighlightOnFocus:
#if defined(TQ_WS_WIN)
	if ( qWinVersion() != WV_95 && qWinVersion() != WV_NT )
	    ret = 1;
	else
#endif
	    ret = 0;
	break;

    case SH_ToolBox_SelectedPageTitleBold:
	ret = 0;
	break;

#if defined(TQ_WS_WIN)
    case SH_UnderlineAccelerator:
	ret = 1;
	if ( qWinVersion() != WV_95 && qWinVersion() != WV_98 && qWinVersion() != WV_NT ) {
	    BOOL cues;
	    SystemParametersInfo(SPI_GETKEYBOARDCUES, 0, &cues, 0);
	    ret = cues ? 1 : 0;
	    // Do nothing if we always paint underlines
	    if (!ret && widget && d) {
		TQMenuBar *menuBar = ::tqqt_cast<TQMenuBar*>(widget);
		TQPopupMenu *popupMenu = 0;
		if (!menuBar)
		    popupMenu = ::tqqt_cast<TQPopupMenu*>(widget);

		// If we paint a menubar draw underlines if it has focus, or if alt is down,
		// or if a popup menu belonging to the menubar is active and paints underlines
		if (menuBar) {
		    if (menuBar->hasFocus()) {
			ret = 1;
		    } else if (d->altDown()) {
			ret = 1;
		    } else if (tqApp->tqfocusWidget() && tqApp->tqfocusWidget()->isPopup()) {
			popupMenu = ::tqqt_cast<TQPopupMenu*>(tqApp->tqfocusWidget());
			TQMenuData *pm = popupMenu ? (TQMenuData*)popupMenu->tqqt_cast("TQMenuData") : 0;
			if (pm && ((FriendlyMenuData*)pm)->parentMenu == menuBar) {
			    if (d->hasSeenAlt(menuBar))
				ret = 1;
			}
		    }
		// If we paint a popup menu draw underlines if the respective menubar does
		} else if (popupMenu) {
		    TQMenuData *pm = (TQMenuData*)popupMenu->tqqt_cast("TQMenuData");
		    while (pm) {
			if (((FriendlyMenuData*)pm)->isMenuBar) {
			    menuBar = (TQMenuBar*)pm;
			    if (d->hasSeenAlt(menuBar))
				ret = 1;
			    break;
			}
			pm = ((FriendlyMenuData*)pm)->parentMenu;
		    }
		// Otherwise draw underlines if the toplevel widget has seen an alt-press
		} else if (d->hasSeenAlt(widget)) {
		    ret = 1;
		}
	    }

	}
	break;
#endif

    default:
	ret = TQCommonStyle::tqstyleHint(hint, widget, opt, returnData);
	break;
    }

    return ret;
}

/*! \reimp */
TQRect TQWindowsStyle::subRect(SubRect r, const TQWidget *widget) const
{
    TQRect rect;

    switch (r) {
#ifndef TQT_NO_SLIDER
    case SR_SliderFocusRect:
	{
	    rect = widget->rect();
	    break;
	}
#endif // TQT_NO_SLIDER
    case SR_ToolBoxTabContents:
	rect = widget->rect();
	break;
    default:
	rect = TQCommonStyle::subRect( r, widget );
	break;
    }

    return rect;
}

#endif