diff options
Diffstat (limited to 'experimental/tqtinterface/qt4/src/styles/tqwindowsstyle.cpp')
-rw-r--r-- | experimental/tqtinterface/qt4/src/styles/tqwindowsstyle.cpp | 2166 |
1 files changed, 2166 insertions, 0 deletions
diff --git a/experimental/tqtinterface/qt4/src/styles/tqwindowsstyle.cpp b/experimental/tqtinterface/qt4/src/styles/tqwindowsstyle.cpp new file mode 100644 index 000000000..aa65a5b94 --- /dev/null +++ b/experimental/tqtinterface/qt4/src/styles/tqwindowsstyle.cpp @@ -0,0 +1,2166 @@ +/**************************************************************************** +** +** 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 |