diff options
Diffstat (limited to 'experimental/tqtinterface/qt4/src/styles/tqcommonstyle.cpp')
| -rw-r--r-- | experimental/tqtinterface/qt4/src/styles/tqcommonstyle.cpp | 2726 |
1 files changed, 2726 insertions, 0 deletions
diff --git a/experimental/tqtinterface/qt4/src/styles/tqcommonstyle.cpp b/experimental/tqtinterface/qt4/src/styles/tqcommonstyle.cpp new file mode 100644 index 000000000..c69fea7f2 --- /dev/null +++ b/experimental/tqtinterface/qt4/src/styles/tqcommonstyle.cpp @@ -0,0 +1,2726 @@ +/**************************************************************************** +** +** Implementation of the TQCommonStyle class +** +** Created : 981231 +** +** Copyright (C) 1998-2008 Trolltech ASA. All rights reserved. +** +** This file is part of the widgets module of the TQt GUI Toolkit. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free TQt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#include "tqcommonstyle.h" + +#ifndef TQT_NO_STYLE + +#include "tqmenubar.h" +#include "tqapplication.h" +#include "tqpainter.h" +#include "tqdrawutil.h" +#include "tqpixmap.h" +#include "tqpushbutton.h" +#include "tqtabbar.h" +#include "tqscrollbar.h" +#include "tqtoolbutton.h" +#include "tqtoolbar.h" +#include "tqdockarea.h" +#include "tqheader.h" +#include "tqspinbox.h" +#include "tqrangecontrol.h" +#include "tqgroupbox.h" +#include "tqslider.h" +#include "tqlistview.h" +#include "tqcheckbox.h" +#include "tqradiobutton.h" +#include "tqbitmap.h" +#include "tqprogressbar.h" +#include "private/tqdialogbuttons_p.h" +#include <limits.h> +#include <tqpixmap.h> +#include "../widgets/tqtitlebar_p.h" +#include <tqtoolbox.h> + +/*! + \class TQCommonStyle tqcommonstyle.h + \brief The TQCommonStyle class encapsulates the common Look and Feel of a GUI. + + \ingroup appearance + + This abstract class implements some of the widget's look and feel + that is common to all GUI styles provided and shipped as part of + TQt. + + All the functions are documented in \l TQStyle. +*/ + +/*! + \enum TQt::ArrowType + + \value UpArrow + \value DownArrow + \value LeftArrow + \value RightArrow + +*/ + +// the active painter, if any... this is used as an optimzation to +// avoid creating a painter if we have an active one (since +// TQStyle::tqitemRect() needs a painter to operate correctly +static TQPainter *activePainter = 0; + +/*! + Constructs a TQCommonStyle. +*/ +TQCommonStyle::TQCommonStyle() : TQStyle() +{ + activePainter = 0; +} + +/*! \reimp */ +TQCommonStyle::~TQCommonStyle() +{ + activePainter = 0; +} + + +static const char * const check_list_controller_xpm[] = { +"16 16 4 1", +" c None", +". c #000000000000", +"X c #FFFFFFFF0000", +"o c #C71BC30BC71B", +" ", +" ", +" .......... ", +" .XXXXXXXX. ", +" .XXXXXXXX.oo ", +" .XXXXXXXX.oo ", +" .XXXXXXXX.oo ", +" .XXXXXXXX.oo ", +" .XXXXXXXX.oo ", +" .XXXXXXXX.oo ", +" .XXXXXXXX.oo ", +" ..........oo ", +" oooooooooo ", +" oooooooooo ", +" ", +" "}; + +/*! \reimp */ +void TQCommonStyle::tqdrawPrimitive( TQ_PrimitiveElement pe, + TQPainter *p, + const TQRect &r, + const TQColorGroup &cg, + SFlags flags, + const TQStyleOption& opt ) const +{ + activePainter = p; + + switch (pe) { +#ifndef TQT_NO_LISTVIEW + case TQStyle::PE_CheckListController: { + p->drawPixmap(r, TQPixmap((const char **)check_list_controller_xpm)); + break; } + case TQStyle::PE_CheckListExclusiveIndicator: { + TQCheckListItem *item = opt.checkListItem(); + TQListView *lv = item->listView(); + if(!item) + return; + int x = r.x(), y = r.y(); +#define TQCOORDARRLEN(x) sizeof(x)/(sizeof(TQCOORD)*2) + static const TQCOORD pts1[] = { // dark lines + 1,9, 1,8, 0,7, 0,4, 1,3, 1,2, 2,1, 3,1, 4,0, 7,0, 8,1, 9,1 }; + static const TQCOORD pts2[] = { // black lines + 2,8, 1,7, 1,4, 2,3, 2,2, 3,2, 4,1, 7,1, 8,2, 9,2 }; + static const TQCOORD pts3[] = { // background lines + 2,9, 3,9, 4,10, 7,10, 8,9, 9,9, 9,8, 10,7, 10,4, 9,3 }; + static const TQCOORD pts4[] = { // white lines + 2,10, 3,10, 4,11, 7,11, 8,10, 9,10, 10,9, 10,8, 11,7, + 11,4, 10,3, 10,2 }; + // static const TQCOORD pts5[] = { // inner fill + // 4,2, 7,2, 9,4, 9,7, 7,9, 4,9, 2,7, 2,4 }; + //TQPointArray a; + // p->eraseRect( x, y, w, h ); + + if ( flags & Style_Enabled ) + p->setPen( cg.text() ); + else + p->setPen( TQPen( lv->tqpalette().color( TQPalette::Disabled, TQColorGroup::Text ) ) ); + TQPointArray a( TQCOORDARRLEN(pts1), pts1 ); + a.translate( x, y ); + //p->setPen( cg.dark() ); + p->drawPolyline( a ); + a.setPoints( TQCOORDARRLEN(pts2), pts2 ); + a.translate( x, y ); + p->drawPolyline( a ); + a.setPoints( TQCOORDARRLEN(pts3), pts3 ); + a.translate( x, y ); + // p->setPen( black ); + p->drawPolyline( a ); + a.setPoints( TQCOORDARRLEN(pts4), pts4 ); + a.translate( x, y ); + // p->setPen( blue ); + p->drawPolyline( a ); + // a.setPoints( TQCOORDARRLEN(pts5), pts5 ); + // a.translate( x, y ); + // TQColor fillColor = isDown() ? g.background() : g.base(); + // p->setPen( fillColor ); + // p->setBrush( fillColor ); + // p->drawPolygon( a ); + if ( flags & Style_On ) { + p->setPen( TQt::NoPen ); + p->setBrush( cg.text() ); + p->drawRect( x+5, y+4, 2, 4 ); + p->drawRect( x+4, y+5, 4, 2 ); + } + break; } + case TQStyle::PE_CheckListIndicator: { + TQCheckListItem *item = opt.checkListItem(); + TQListView *lv = item->listView(); + if(!item) + return; + int x = r.x(), y = r.y(), w = r.width(), h = r.width(), marg = lv->itemMargin(); + + if ( flags & Style_Enabled ) + p->setPen( TQPen( cg.text(), 2 ) ); + else + p->setPen( TQPen( lv->tqpalette().color( TQPalette::Disabled, TQColorGroup::Text ), + 2 ) ); + bool parentControl = FALSE; + if ( item->tqparent() && item->tqparent()->rtti() == 1 && + ((TQCheckListItem*) item->tqparent())->type() == TQCheckListItem::Controller ) + parentControl = TRUE; + if ( flags & Style_Selected && !lv->rootIsDecorated() && !parentControl ) { + p->fillRect( 0, 0, x + marg + w + 4, item->height(), + cg.brush( TQColorGroup::Highlight ) ); + if ( item->isEnabled() ) + p->setPen( TQPen( cg.highlightedText(), 2 ) ); + } + + if ( flags & Style_NoChange ) + p->setBrush( cg.brush( TQColorGroup::Button ) ); + p->drawRect( x+marg, y+2, w-4, h-4 ); + ///////////////////// + x++; + y++; + if ( ( flags & Style_On) || ( flags & Style_NoChange ) ) { + TQPointArray a( 7*2 ); + int i, xx = x+1+marg, yy=y+5; + for ( i=0; i<3; i++ ) { + a.setPoint( 2*i, xx, yy ); + a.setPoint( 2*i+1, xx, yy+2 ); + xx++; yy++; + } + yy -= 2; + for ( i=3; i<7; i++ ) { + a.setPoint( 2*i, xx, yy ); + a.setPoint( 2*i+1, xx, yy+2 ); + xx++; yy--; + } + p->drawLineSegments( a ); + } + break; } +#endif + case TQStyle::PE_HeaderArrow: + p->save(); + if ( flags & Style_Down ) { + TQPointArray pa( 3 ); + p->setPen( cg.light() ); + p->drawLine( r.x() + r.width(), r.y(), r.x() + r.width() / 2, r.height() ); + p->setPen( cg.dark() ); + pa.setPoint( 0, r.x() + r.width() / 2, r.height() ); + pa.setPoint( 1, r.x(), r.y() ); + pa.setPoint( 2, r.x() + r.width(), r.y() ); + p->drawPolyline( pa ); + } else { + TQPointArray pa( 3 ); + p->setPen( cg.light() ); + pa.setPoint( 0, r.x(), r.height() ); + pa.setPoint( 1, r.x() + r.width(), r.height() ); + pa.setPoint( 2, r.x() + r.width() / 2, r.y() ); + p->drawPolyline( pa ); + p->setPen( cg.dark() ); + p->drawLine( r.x(), r.height(), r.x() + r.width() / 2, r.y() ); + } + p->restore(); + break; + + case TQStyle::PE_StatusBarSection: + qDrawShadeRect( p, r, cg, TRUE, 1, 0, 0 ); + break; + + case TQStyle::PE_ButtonCommand: + case TQStyle::PE_ButtonBevel: + case TQStyle::PE_ButtonTool: + case TQStyle::PE_ButtonDropDown: + case TQStyle::PE_HeaderSection: + qDrawShadePanel(p, r, cg, flags & (Style_Sunken | Style_Down | Style_On) , 1, + &cg.brush(TQColorGroup::Button)); + break; + + case TQStyle::PE_Separator: + qDrawShadeLine( p, r.left(), r.top(), r.right(), r.bottom(), cg, + flags & Style_Sunken, 1, 0); + break; + + case TQStyle::PE_FocusRect: { + const TQColor *bg = 0; + + if (!opt.isDefault()) + bg = &opt.color(); + + TQPen oldPen = p->pen(); + + if (bg) { + int h, s, v; + bg->hsv(&h, &s, &v); + if (v >= 128) + p->setPen(TQt::black); + else + p->setPen(TQt::white); + } else + p->setPen(cg.foreground()); + + if (flags & Style_FocusAtBorder) + p->drawRect(TQRect(r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2)); + else + p->drawRect(r); + + p->setPen(oldPen); + break; } + + case TQStyle::PE_SpinWidgetPlus: + case TQStyle::PE_SpinWidgetMinus: { + p->save(); + int fw = tqpixelMetric( PM_DefaultFrameWidth, 0 ); + TQRect br; + br.setRect( r.x() + fw, r.y() + fw, r.width() - fw*2, + r.height() - fw*2 ); + + p->fillRect( br, cg.brush( TQColorGroup::Button ) ); + p->setPen( cg.buttonText() ); + p->setBrush( cg.buttonText() ); + + int length; + int x = r.x(), y = r.y(), w = r.width(), h = r.height(); + if ( w <= 8 || h <= 6 ) + length = TQMIN( w-2, h-2 ); + else + length = TQMIN( 2*w / 3, 2*h / 3 ); + + if ( !(length & 1) ) + length -=1; + int xmarg = ( w - length ) / 2; + int ymarg = ( h - length ) / 2; + + p->drawLine( x + xmarg, ( y + h / 2 - 1 ), + x + xmarg + length - 1, ( y + h / 2 - 1 ) ); + if ( pe == TQStyle::PE_SpinWidgetPlus ) + p->drawLine( ( x+w / 2 ) - 1, y + ymarg, + ( x+w / 2 ) - 1, y + ymarg + length - 1 ); + p->restore(); + break; } + + case TQStyle::PE_SpinWidgetUp: + case TQStyle::PE_SpinWidgetDown: { + int fw = tqpixelMetric( PM_DefaultFrameWidth, 0 ); + TQRect br; + br.setRect( r.x() + fw, r.y() + fw, r.width() - fw*2, + r.height() - fw*2 ); + p->fillRect( br, cg.brush( TQColorGroup::Button ) ); + int x = r.x(), y = r.y(), w = r.width(), h = r.height(); + int sw = w-4; + if ( sw < 3 ) + break; + else if ( !(sw & 1) ) + sw--; + sw -= ( sw / 7 ) * 2; // Empty border + int sh = sw/2 + 2; // Must have empty row at foot of arrow + + int sx = x + w / 2 - sw / 2 - 1; + int sy = y + h / 2 - sh / 2 - 1; + + TQPointArray a; + if ( pe == TQStyle::PE_SpinWidgetDown ) + a.setPoints( 3, 0, 1, sw-1, 1, sh-2, sh-1 ); + else + a.setPoints( 3, 0, sh-1, sw-1, sh-1, sh-2, 1 ); + int bsx = 0; + int bsy = 0; + if ( flags & Style_Sunken ) { + bsx = tqpixelMetric(PM_ButtonShiftHorizontal); + bsy = tqpixelMetric(PM_ButtonShiftVertical); + } + p->save(); + p->translate( sx + bsx, sy + bsy ); + p->setPen( cg.buttonText() ); + p->setBrush( cg.buttonText() ); + p->drawPolygon( a ); + p->restore(); + break; } + + case TQStyle::PE_Indicator: { + if (flags & Style_NoChange) { + p->setPen(cg.foreground()); + p->fillRect(r, cg.brush(TQColorGroup::Button)); + p->drawRect(r); + p->drawLine(r.topLeft(), r.bottomRight()); + } else + qDrawShadePanel(p, r.x(), r.y(), r.width(), r.height(), + cg, flags & (Style_Sunken | Style_On), 1, + &cg.brush(TQColorGroup::Button)); + break; } + + case TQStyle::PE_IndicatorMask: { + p->fillRect(r, Qt::color1); + break; } + + case TQStyle::PE_ExclusiveIndicator: { + TQRect ir = r; + p->setPen(cg.dark()); + p->drawArc(r, 0, 5760); + + if (flags & (Style_Sunken | Style_On)) { + ir.addCoords(2, 2, -2, -2); + p->setBrush(cg.foreground()); + p->drawEllipse(ir); + } + + break; } + + case TQStyle::PE_ExclusiveIndicatorMask: { + p->setPen(Qt::color1); + p->setBrush(Qt::color1); + p->drawEllipse(r); + break; } + + case TQStyle::PE_DockWindowHandle: { + bool highlight = flags & Style_On; + + p->save(); + p->translate( r.x(), r.y() ); + if ( flags & Style_Horizontal ) { + int x = r.width() / 3; + if ( r.height() > 4 ) { + qDrawShadePanel( p, x, 2, 3, r.height() - 4, + cg, highlight, 1, 0 ); + qDrawShadePanel( p, x+3, 2, 3, r.height() - 4, + cg, highlight, 1, 0 ); + } + } else { + if ( r.width() > 4 ) { + int y = r.height() / 3; + qDrawShadePanel( p, 2, y, r.width() - 4, 3, + cg, highlight, 1, 0 ); + qDrawShadePanel( p, 2, y+3, r.width() - 4, 3, + cg, highlight, 1, 0 ); + } + } + p->restore(); + break; + } + + case TQStyle::PE_DockWindowSeparator: { + TQPoint p1, p2; + if ( flags & Style_Horizontal ) { + p1 = TQPoint( r.width()/2, 0 ); + p2 = TQPoint( p1.x(), r.height() ); + } else { + p1 = TQPoint( 0, r.height()/2 ); + p2 = TQPoint( r.width(), p1.y() ); + } + qDrawShadeLine( p, p1, p2, cg, 1, 1, 0 ); + break; } + + case TQStyle::PE_Panel: + case TQStyle::PE_PanelPopup: { + int lw = opt.isDefault() ? tqpixelMetric(PM_DefaultFrameWidth) + : opt.lineWidth(); + + qDrawShadePanel(p, r, cg, (flags & Style_Sunken), lw); + break; } + + case TQStyle::PE_PanelDockWindow: { + int lw = opt.isDefault() ? tqpixelMetric(PM_DockWindowFrameWidth) + : opt.lineWidth(); + + qDrawShadePanel(p, r, cg, FALSE, lw); + break; } + + case TQStyle::PE_PanelMenuBar: { + int lw = opt.isDefault() ? tqpixelMetric(PM_MenuBarFrameWidth) + : opt.lineWidth(); + + qDrawShadePanel(p, r, cg, FALSE, lw, &cg.brush(TQColorGroup::Button)); + break; } + + case TQStyle::PE_SizeGrip: { + p->save(); + + int x, y, w, h; + r.rect(&x, &y, &w, &h); + + int sw = TQMIN( h,w ); + if ( h > w ) + p->translate( 0, h - w ); + else + p->translate( w - h, 0 ); + + int sx = x; + int sy = y; + int s = sw / 3; + + if ( TQApplication::reverseLayout() ) { + sx = x + sw; + for ( int i = 0; i < 4; ++i ) { + p->setPen( TQPen( cg.light(), 1 ) ); + p->drawLine( x, sy - 1 , sx + 1, sw ); + p->setPen( TQPen( cg.dark(), 1 ) ); + p->drawLine( x, sy, sx, sw ); + p->setPen( TQPen( cg.dark(), 1 ) ); + p->drawLine( x, sy + 1, sx - 1, sw ); + sx -= s; + sy += s; + } + } else { + for ( int i = 0; i < 4; ++i ) { + p->setPen( TQPen( cg.light(), 1 ) ); + p->drawLine( sx-1, sw, sw, sy-1 ); + p->setPen( TQPen( cg.dark(), 1 ) ); + p->drawLine( sx, sw, sw, sy ); + p->setPen( TQPen( cg.dark(), 1 ) ); + p->drawLine( sx+1, sw, sw, sy+1 ); + sx += s; + sy += s; + } + } + + p->restore(); + break; } + + case TQStyle::PE_CheckMark: { + const int markW = r.width() > 7 ? 7 : r.width(); + const int markH = markW; + int posX = r.x() + ( r.width() - markW )/2 + 1; + int posY = r.y() + ( r.height() - markH )/2; + + // Could do with some optimizing/caching... + TQPointArray a( markH*2 ); + int i, xx, yy; + xx = posX; + yy = 3 + posY; + for ( i=0; i<markW/2; i++ ) { + a.setPoint( 2*i, xx, yy ); + a.setPoint( 2*i+1, xx, yy+2 ); + xx++; yy++; + } + yy -= 2; + for ( ; i<markH; i++ ) { + a.setPoint( 2*i, xx, yy ); + a.setPoint( 2*i+1, xx, yy+2 ); + xx++; yy--; + } + if ( !(flags & Style_Enabled) && !(flags & Style_On)) { + int pnt; + p->setPen( cg.highlightedText() ); + TQPoint offset(1,1); + for ( pnt = 0; pnt < (int)a.size(); pnt++ ) + a[pnt] += offset; + p->drawLineSegments( a ); + for ( pnt = 0; pnt < (int)a.size(); pnt++ ) + a[pnt] -= offset; + } + p->setPen( cg.text() ); + p->drawLineSegments( a ); + break; } + + case TQStyle::PE_PanelGroupBox: //We really do not need TQStyle::PE_GroupBoxFrame anymore, nasty holdover ### + tqdrawPrimitive( TQStyle::PE_GroupBoxFrame, p, r, cg, flags, opt ); + break; + case TQStyle::PE_GroupBoxFrame: { +#ifndef TQT_NO_FRAME + if ( opt.isDefault() ) + break; + int lwidth = opt.lineWidth(), mlwidth = opt.midLineWidth(); + if ( flags & (Style_Sunken|Style_Raised)) + qDrawShadeRect( p, r.x(), r.y(), r.width(), r.height(), cg, flags & Style_Sunken, lwidth, mlwidth ); + else + qDrawPlainRect( p, r.x(), r.y(), r.width(), r.height(), cg.foreground(), lwidth ); +#endif + break; } + + case TQStyle::PE_ProgressBarChunk: + p->fillRect( r.x(), r.y() + 3, r.width() -2, r.height() - 6, + cg.brush(TQColorGroup::Highlight)); + break; + + case TQStyle::PE_PanelLineEdit: + case TQStyle::PE_PanelTabWidget: + case TQStyle::PE_WindowFrame: + tqdrawPrimitive( TQStyle::PE_Panel, p, r, cg, flags, opt ); + break; + + case TQStyle::PE_RubberBand: + tqdrawPrimitive(TQStyle::PE_FocusRect, p, r, cg, flags, opt); + break; + default: + break; + } + + activePainter = 0; +} + +/*! \reimp */ +void TQCommonStyle::tqdrawControl( TQ_ControlElement element, + TQPainter *p, + const TQWidget *widget, + const TQRect &r, + const TQColorGroup &cg, + SFlags flags, + const TQStyleOption& opt ) const +{ +#if defined(TQT_CHECK_STATE) + if (! widget) { + qWarning("TQCommonStyle::tqdrawControl: widget parameter cannot be zero!"); + return; + } +#endif + + activePainter = p; + + switch (element) { + case CE_MenuBarEmptyArea: { + TQRegion reg; + if(p->hasClipping()) //ick + reg = p->clipRegion(); + else + reg = r; + ((TQWidget *)widget)->erase( reg ); + break; } + case CE_PushButton: + { +#ifndef TQT_NO_PUSHBUTTON + const TQPushButton *button = (const TQPushButton *) widget; + TQRect br = r; + int dbi = tqpixelMetric(PM_ButtonDefaultIndicator, widget); + + if (button->isDefault() || button->autoDefault()) { + if ( button->isDefault()) + tqdrawPrimitive(TQStyle::PE_ButtonDefault, p, br, cg, flags); + + br.setCoords(br.left() + dbi, + br.top() + dbi, + br.right() - dbi, + br.bottom() - dbi); + } + + p->save(); + p->setBrushOrigin( -widget->backgroundOffset().x(), + -widget->backgroundOffset().y() ); + tqdrawPrimitive(TQStyle::PE_ButtonCommand, p, br, cg, flags); + p->restore(); +#endif + break; + } + + case CE_PushButtonLabel: + { +#ifndef TQT_NO_PUSHBUTTON + const TQPushButton *button = (const TQPushButton *) widget; + TQRect ir = r; + + if (button->isDown() || button->isOn()) { + flags |= Style_Sunken; + ir.moveBy(tqpixelMetric(PM_ButtonShiftHorizontal, widget), + tqpixelMetric(PM_ButtonShiftVertical, widget)); + } + + if (button->isMenuButton()) { + int mbi = tqpixelMetric(PM_MenuButtonIndicator, widget); + TQRect ar(ir.right() - mbi, ir.y() + 2, mbi - 4, ir.height() - 4); + tqdrawPrimitive(TQStyle::PE_ArrowDown, p, ar, cg, flags, opt); + ir.setWidth(ir.width() - mbi); + } + + int tf=TQt::AlignVCenter | TQt::ShowPrefix; + if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0)) + tf |= TQt::NoAccel; + +#ifndef TQT_NO_ICONSET + if ( button->iconSet() && ! button->iconSet()->isNull() ) { + TQIconSet::Mode mode = + button->isEnabled() ? TQIconSet::Normal : TQIconSet::Disabled; + if ( mode == TQIconSet::Normal && button->hasFocus() ) + mode = TQIconSet::Active; + + TQIconSet::State state = TQIconSet::Off; + if ( button->isToggleButton() && button->isOn() ) + state = TQIconSet::On; + + TQPixmap pixmap = button->iconSet()->pixmap( TQIconSet::Small, mode, state ); + int pixw = pixmap.width(); + int pixh = pixmap.height(); + + //Center the icon if there is neither text nor pixmap + if ( button->text().isEmpty() && !button->pixmap() ) + p->drawPixmap( ir.x() + ir.width() / 2 - pixw / 2, ir.y() + ir.height() / 2 - pixh / 2, pixmap ); + else + p->drawPixmap( ir.x() + 2, ir.y() + ir.height() / 2 - pixh / 2, pixmap ); + + ir.moveBy(pixw + 4, 0); + ir.setWidth(ir.width() - (pixw + 4)); + // left-align text if there is + if (!button->text().isEmpty()) + tf |= TQt::AlignLeft; + else if (button->pixmap()) + tf |= TQt::AlignHCenter; + } else +#endif //TQT_NO_ICONSET + tf |= TQt::AlignHCenter; + drawItem(p, ir, tf, cg, + flags & Style_Enabled, button->pixmap(), button->text(), + button->text().length(), TQT_TQCOLOR_CONST(&(cg.buttonText())) ); + + if (flags & Style_HasFocus) + tqdrawPrimitive(TQStyle::PE_FocusRect, p, subRect(SR_PushButtonFocusRect, widget), + cg, flags); +#endif + break; + } + + case CE_CheckBox: + tqdrawPrimitive(TQStyle::PE_Indicator, p, r, cg, flags, opt); + break; + + case CE_CheckBoxLabel: + { +#ifndef TQT_NO_CHECKBOX + const TQCheckBox *checkbox = (const TQCheckBox *) widget; + + int tqalignment = TQApplication::reverseLayout() ? TQt::AlignRight : TQt::AlignLeft; + if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0)) + tqalignment |= TQt::NoAccel; + + drawItem(p, r, tqalignment | TQt::AlignVCenter | TQt::ShowPrefix, cg, + flags & Style_Enabled, checkbox->pixmap(), checkbox->text()); + + if (flags & Style_HasFocus) { + TQRect fr = tqvisualRect(subRect(SR_CheckBoxFocusRect, widget), widget); + tqdrawPrimitive(TQStyle::PE_FocusRect, p, fr, cg, flags); + } +#endif + break; + } + + case CE_RadioButton: + tqdrawPrimitive(TQStyle::PE_ExclusiveIndicator, p, r, cg, flags, opt); + break; + + case CE_RadioButtonLabel: + { +#ifndef TQT_NO_RADIOBUTTON + const TQRadioButton *radiobutton = (const TQRadioButton *) widget; + + int tqalignment = TQApplication::reverseLayout() ? TQt::AlignRight : TQt::AlignLeft; + if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0)) + tqalignment |= TQt::NoAccel; + drawItem(p, r, tqalignment | TQt::AlignVCenter | TQt::ShowPrefix, cg, + flags & Style_Enabled, radiobutton->pixmap(), radiobutton->text()); + + if (flags & Style_HasFocus) { + TQRect fr = tqvisualRect(subRect(SR_RadioButtonFocusRect, widget), widget); + tqdrawPrimitive(TQStyle::PE_FocusRect, p, fr, cg, flags); + } +#endif + break; + } + +#ifndef TQT_NO_TABBAR + case CE_TabBarTab: + { + const TQTabBar * tb = (const TQTabBar *) widget; + + if ( tb->tqshape() == TQTabBar::TriangularAbove || + tb->tqshape() == TQTabBar::TriangularBelow ) { + // triangular, above or below + int y; + int x; + TQPointArray a( 10 ); + a.setPoint( 0, 0, -1 ); + a.setPoint( 1, 0, 0 ); + y = r.height()-2; + x = y/3; + a.setPoint( 2, x++, y-1 ); + a.setPoint( 3, x++, y ); + a.setPoint( 3, x++, y++ ); + a.setPoint( 4, x, y ); + + int i; + int right = r.width() - 1; + for ( i = 0; i < 5; i++ ) + a.setPoint( 9-i, right - a.point( i ).x(), a.point( i ).y() ); + + if ( tb->tqshape() == TQTabBar::TriangularAbove ) + for ( i = 0; i < 10; i++ ) + a.setPoint( i, a.point(i).x(), + r.height() - 1 - a.point( i ).y() ); + + a.translate( r.left(), r.top() ); + + if ( flags & Style_Selected ) + p->setBrush( cg.base() ); + else + p->setBrush( cg.background() ); + p->setPen( cg.foreground() ); + p->drawPolygon( a ); + p->setBrush( TQt::NoBrush ); + } + break; + } + + case CE_TabBarLabel: + { + if ( opt.isDefault() ) + break; + + const TQTabBar * tb = (const TQTabBar *) widget; + TQTab * t = opt.tab(); + + TQRect tr = r; + if ( t->identifier() == tb->currentTab() ) + tr.setBottom( tr.bottom() - + tqpixelMetric( TQStyle::PM_DefaultFrameWidth, tb ) ); + + int tqalignment = TQt::AlignCenter | TQt::ShowPrefix; + if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0)) + tqalignment |= TQt::NoAccel; + drawItem( p, tr, tqalignment, cg, + flags & Style_Enabled, 0, t->text() ); + + if ( (flags & Style_HasFocus) && !t->text().isEmpty() ) + tqdrawPrimitive( TQStyle::PE_FocusRect, p, r, cg ); + break; + } +#endif // TQT_NO_TABBAR +#ifndef TQT_NO_TOOLBOX + case CE_ToolBoxTab: + { + int d = 20 + r.height() - 3; + TQPointArray a( 7 ); + a.setPoint( 0, -1, r.height() + 1 ); + a.setPoint( 1, -1, 1 ); + a.setPoint( 2, r.width() - d, 1 ); + a.setPoint( 3, r.width() - 20, r.height() - 2 ); + a.setPoint( 4, r.width() - 1, r.height() - 2 ); + a.setPoint( 5, r.width() - 1, r.height() + 1 ); + a.setPoint( 6, -1, r.height() + 1 ); + + const TQToolBox *tb = (const TQToolBox*)widget; + + if ( flags & Style_Selected && tb->currentItem() ) + p->setBrush( tb->currentItem()->paletteBackgroundColor() ); + else + p->setBrush( cg.brush(TQColorGroup::Background) ); + + p->setPen( cg.mid().dark( 150 ) ); + p->drawPolygon( a ); + p->setPen( cg.light() ); + p->drawLine( 0, 2, r.width() - d, 2 ); + p->drawLine( r.width() - d - 1, 2, r.width() - 21, r.height() - 1 ); + p->drawLine( r.width() - 20, r.height() - 1, r.width(), r.height() - 1 ); + p->setBrush( TQt::NoBrush ); + break; + } +#endif // TQT_NO_TOOLBOX + case CE_ProgressBarGroove: + qDrawShadePanel(p, r, cg, TRUE, 1, &cg.brush(TQColorGroup::Background)); + break; + +#ifndef TQT_NO_PROGRESSBAR + case CE_ProgressBarContents: + { + const TQProgressBar *progressbar = (const TQProgressBar *) widget; + // Correct the highlight color if same as background, + // or else we cannot see the progress... + TQColorGroup cgh = cg; + if ( cgh.highlight() == cgh.background() ) + cgh.setColor( TQColorGroup::Highlight, progressbar->tqpalette().active().highlight() ); + bool reverse = TQApplication::reverseLayout(); + int fw = 2; + int w = r.width() - 2*fw; + if ( !progressbar->totalSteps() ) { + // draw busy indicator + int x = progressbar->progress() % (w * 2); + if (x > w) + x = 2 * w - x; + x = reverse ? r.right() - x : x + r.x(); + p->setPen( TQPen(cgh.highlight(), 4) ); + p->drawLine(x, r.y() + 1, x, r.height() - fw); + } else { + const int unit_width = tqpixelMetric(PM_ProgressBarChunkWidth, widget); + int u; + if ( unit_width > 1 ) + u = (r.width()+unit_width/3) / unit_width; + else + u = w / unit_width; + int p_v = progressbar->progress(); + int t_s = progressbar->totalSteps() ? progressbar->totalSteps() : 1; + + if ( u > 0 && p_v >= INT_MAX / u && t_s >= u ) { + // scale down to something usable. + p_v /= u; + t_s /= u; + } + + // nu < tnu, if last chunk is only a partial chunk + int tnu, nu; + tnu = nu = p_v * u / t_s; + + if (nu * unit_width > w) + nu--; + + // Draw nu units out of a possible u of unit_width + // width, each a rectangle bordered by background + // color, all in a sunken panel with a percentage text + // display at the end. + int x = 0; + int x0 = reverse ? r.right() - ((unit_width > 1) ? + unit_width : fw) : r.x() + fw; + for (int i=0; i<nu; i++) { + tqdrawPrimitive( TQStyle::PE_ProgressBarChunk, p, + TQRect( x0+x, r.y(), unit_width, r.height() ), + cgh, Style_Default, opt ); + x += reverse ? -unit_width: unit_width; + } + + // Draw the last partial chunk to fill up the + // progressbar entirely + if (nu < tnu) { + int pixels_left = w - (nu*unit_width); + int offset = reverse ? x0+x+unit_width-pixels_left : x0+x; + tqdrawPrimitive( TQStyle::PE_ProgressBarChunk, p, + TQRect( offset, r.y(), pixels_left, + r.height() ), cgh, Style_Default, + opt ); + } + } + } + break; + + case CE_ProgressBarLabel: + { + const TQProgressBar *progressbar = (const TQProgressBar *) widget; + TQColor penColor = cg.highlightedText(); + TQColor *pcolor = 0; + if ( progressbar->centerIndicator() && !progressbar->indicatorFollowsStyle() && + progressbar->progress()*2 >= progressbar->totalSteps() ) + pcolor = &penColor; + drawItem(p, r, TQt::AlignCenter | TQt::SingleLine, cg, flags & Style_Enabled, 0, + progressbar->progressString(), -1, pcolor ); + } + break; +#endif // TQT_NO_PROGRESSBAR + + case CE_MenuBarItem: + { +#ifndef TQT_NO_MENUDATA + if (opt.isDefault()) + break; + + TQMenuItem *mi = opt.menuItem(); + int tqalignment = TQt::AlignCenter|TQt::ShowPrefix|TQt::DontClip|TQt::SingleLine; + if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0)) + tqalignment |= TQt::NoAccel; + drawItem( p, r, tqalignment, cg, + flags & Style_Enabled, mi->pixmap(), mi->text(), -1, + TQT_TQCOLOR_CONST(&cg.buttonText()) ); +#endif + break; + } + +#ifndef TQT_NO_TOOLBUTTON + case CE_ToolButtonLabel: + { + const TQToolButton *toolbutton = (const TQToolButton *) widget; + TQRect rect = r; + TQt::ArrowType arrowType = opt.isDefault() + ? TQt::DownArrow : opt.arrowType(); + + int shiftX = 0; + int shiftY = 0; + if (flags & (Style_Down | Style_On)) { + shiftX = tqpixelMetric(PM_ButtonShiftHorizontal, widget); + shiftY = tqpixelMetric(PM_ButtonShiftVertical, widget); + } + + if (!opt.isDefault()) { + PrimitiveElement pe; + switch (arrowType) { + case TQt::LeftArrow: pe = TQStyle::PE_ArrowLeft; break; + case TQt::RightArrow: pe = TQStyle::PE_ArrowRight; break; + case TQt::UpArrow: pe = TQStyle::PE_ArrowUp; break; + default: + case TQt::DownArrow: pe = TQStyle::PE_ArrowDown; break; + } + + rect.moveBy(shiftX, shiftY); + tqdrawPrimitive(pe, p, rect, cg, flags, opt); + } else { + TQColor btext = toolbutton->paletteForegroundColor(); + + if (toolbutton->iconSet().isNull() && + ! toolbutton->text().isNull() && + ! toolbutton->usesTextLabel()) { + int tqalignment = TQt::AlignCenter | TQt::ShowPrefix; + if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0)) + tqalignment |= TQt::NoAccel; + + rect.moveBy(shiftX, shiftY); + drawItem(p, rect, tqalignment, cg, + flags & Style_Enabled, 0, toolbutton->text(), + toolbutton->text().length(), &btext); + } else { + TQPixmap pm; + TQIconSet::Size size = + toolbutton->usesBigPixmap() ? TQIconSet::Large : TQIconSet::Small; + TQIconSet::State state = + toolbutton->isOn() ? TQIconSet::On : TQIconSet::Off; + TQIconSet::Mode mode; + if (! toolbutton->isEnabled()) + mode = TQIconSet::Disabled; + else if ((flags & (Style_Down | Style_On)) || + ((flags & Style_Raised) && (flags & Style_AutoRaise))) + mode = TQIconSet::Active; + else + mode = TQIconSet::Normal; + pm = toolbutton->iconSet().pixmap( size, mode, state ); + + if ( toolbutton->usesTextLabel() ) { + p->setFont( toolbutton->font() ); + TQRect pr = rect, tr = rect; + int tqalignment = TQt::ShowPrefix; + if (!tqstyleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0)) + tqalignment |= TQt::NoAccel; + + if ( toolbutton->textPosition() == TQToolButton::Under ) { + int fh = p->fontMetrics().height(); + pr.addCoords( 0, 1, 0, -fh-3 ); + tr.addCoords( 0, pr.bottom(), 0, -3 ); + pr.moveBy(shiftX, shiftY); + drawItem( p, pr, TQt::AlignCenter, cg, TRUE, &pm, TQString::null ); + tqalignment |= TQt::AlignCenter; + } else { + pr.setWidth( pm.width() + 8 ); + tr.addCoords( pr.right(), 0, 0, 0 ); + pr.moveBy(shiftX, shiftY); + + drawItem( p, pr, TQt::AlignCenter, cg, TRUE, &pm, TQString::null ); + tqalignment |= TQt::AlignLeft | TQt::AlignVCenter; + } + + tr.moveBy(shiftX, shiftY); + drawItem( p, tr, tqalignment, cg, + flags & Style_Enabled, 0, toolbutton->textLabel(), + toolbutton->textLabel().length(), &btext); + } else { + rect.moveBy(shiftX, shiftY); + drawItem( p, rect, TQt::AlignCenter, cg, TRUE, &pm, TQString::null ); + } + } + } + + break; + } +#endif // TQT_NO_TOOLBUTTON +#ifndef TQT_NO_HEADER + case CE_HeaderLabel: + { + TQRect rect = r; + const TQHeader* header = (const TQHeader *) widget; + int section = opt.headerSection(); + + TQIconSet* icon = header->iconSet( section ); + if ( icon ) { + TQPixmap pixmap = icon->pixmap( TQIconSet::Small, + flags & Style_Enabled ? + TQIconSet::Normal : TQIconSet::Disabled ); + int pixw = pixmap.width(); + int pixh = pixmap.height(); + // "pixh - 1" because of tricky integer division + + TQRect pixRect = rect; + pixRect.setY( rect.center().y() - (pixh - 1) / 2 ); + drawItem ( p, pixRect, TQt::AlignVCenter, cg, flags & Style_Enabled, + &pixmap, TQString::null ); + if (TQApplication::reverseLayout()) + rect.setRight(rect.right() - pixw - 2); + else + rect.setLeft(rect.left() + pixw + 2); + } + + if (rect.isValid()) + drawItem ( p, rect, TQt::AlignVCenter, cg, flags & Style_Enabled, + 0, header->label( section ), -1, TQT_TQCOLOR_CONST(&(cg.buttonText())) ); + } +#endif // TQT_NO_HEADER + default: + break; + } + + activePainter = 0; +} + +/*! \reimp */ +void TQCommonStyle::tqdrawControlMask( TQ_ControlElement control, + TQPainter *p, + const TQWidget *widget, + const TQRect &r, + const TQStyleOption& opt ) const +{ + TQ_UNUSED(widget); + + activePainter = p; + + TQColorGroup cg(Qt::color1,Qt::color1,Qt::color1,Qt::color1,Qt::color1,Qt::color1,Qt::color1,Qt::color1,Qt::color0); + + switch (control) { + case CE_PushButton: + tqdrawPrimitive(TQStyle::PE_ButtonCommand, p, r, cg, Style_Default, opt); + break; + + case CE_CheckBox: + tqdrawPrimitive(TQStyle::PE_IndicatorMask, p, r, cg, Style_Default, opt); + break; + + case CE_RadioButton: + tqdrawPrimitive(TQStyle::PE_ExclusiveIndicatorMask, p, r, cg, Style_Default, opt); + break; + + default: + p->fillRect(r, Qt::color1); + break; + } + + activePainter = 0; +} + +/*! \reimp */ +TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const +{ +#if defined(TQT_CHECK_STATE) + if (! widget) { + qWarning("TQCommonStyle::subRect: widget parameter cannot be zero!"); + return TQRect(); + } +#endif + + TQRect rect, wrect(widget->rect()); + + switch (r) { +#ifndef TQT_NO_DIALOGBUTTONS + case SR_DialogButtonAbort: + case SR_DialogButtonRetry: + case SR_DialogButtonIgnore: + case SR_DialogButtonAccept: + case SR_DialogButtonReject: + case SR_DialogButtonApply: + case SR_DialogButtonHelp: + case SR_DialogButtonAll: + case SR_DialogButtonCustom: { + TQDialogButtons::Button srch = TQDialogButtons::None; + if(r == SR_DialogButtonAccept) + srch = TQDialogButtons::Accept; + else if(r == SR_DialogButtonReject) + srch = TQDialogButtons::Reject; + else if(r == SR_DialogButtonAll) + srch = TQDialogButtons::All; + else if(r == SR_DialogButtonApply) + srch = TQDialogButtons::Apply; + else if(r == SR_DialogButtonHelp) + srch = TQDialogButtons::Help; + else if(r == SR_DialogButtonRetry) + srch = TQDialogButtons::Retry; + else if(r == SR_DialogButtonIgnore) + srch = TQDialogButtons::Ignore; + else if(r == SR_DialogButtonAbort) + srch = TQDialogButtons::Abort; + + const int bwidth = tqpixelMetric(PM_DialogButtonsButtonWidth, widget), + bheight = tqpixelMetric(PM_DialogButtonsButtonHeight, widget), + bspace = tqpixelMetric(PM_DialogButtonsSeparator, widget), + fw = tqpixelMetric(PM_DefaultFrameWidth, widget); + const TQDialogButtons *dbtns = (const TQDialogButtons *) widget; + int start = fw; + if(dbtns->orientation() == Qt::Horizontal) + start = wrect.right() - fw; + TQDialogButtons::Button btns[] = { TQDialogButtons::All, TQDialogButtons::Reject, TQDialogButtons::Accept, //reverse order (right to left) + TQDialogButtons::Apply, TQDialogButtons::Retry, TQDialogButtons::Ignore, TQDialogButtons::Abort, + TQDialogButtons::Help }; + for(unsigned int i = 0, cnt = 0; i < (sizeof(btns)/sizeof(btns[0])); i++) { + if(dbtns->isButtonVisible(btns[i])) { + TQSize szH = dbtns->tqsizeHint(btns[i]); + int mwidth = TQMAX(bwidth, szH.width()), mheight = TQMAX(bheight, szH.height()); + if(dbtns->orientation() == Qt::Horizontal) { + start -= mwidth; + if(cnt) + start -= bspace; + } else if(cnt) { + start += mheight; + start += bspace; + } + cnt++; + if(btns[i] == srch) { + if(dbtns->orientation() == Qt::Horizontal) + return TQRect(start, wrect.bottom() - fw - mheight, mwidth, mheight); + else + return TQRect(fw, start, mwidth, mheight); + } + } + } + if(r == SR_DialogButtonCustom) { + if(dbtns->orientation() == Qt::Horizontal) + return TQRect(fw, fw, start - fw - bspace, wrect.height() - (fw*2)); + else + return TQRect(fw, start, wrect.width() - (fw*2), wrect.height() - start - (fw*2)); + } + return TQRect(); } +#endif //TQT_NO_DIALOGBUTTONS + case SR_PushButtonContents: + { +#ifndef TQT_NO_PUSHBUTTON + const TQPushButton *button = (const TQPushButton *) widget; + int dx1, dx2; + + dx1 = tqpixelMetric(PM_DefaultFrameWidth, widget); + if (button->isDefault() || button->autoDefault()) + dx1 += tqpixelMetric(PM_ButtonDefaultIndicator, widget); + dx2 = dx1 * 2; + + rect.setRect(wrect.x() + dx1, + wrect.y() + dx1, + wrect.width() - dx2, + wrect.height() - dx2); +#endif + break; + } + + case SR_PushButtonFocusRect: + { +#ifndef TQT_NO_PUSHBUTTON + const TQPushButton *button = (const TQPushButton *) widget; + int dbw1 = 0, dbw2 = 0; + if (button->isDefault() || button->autoDefault()) { + dbw1 = tqpixelMetric(PM_ButtonDefaultIndicator, widget); + dbw2 = dbw1 * 2; + } + + int dfw1 = tqpixelMetric(PM_DefaultFrameWidth, widget) * 2, + dfw2 = dfw1 * 2; + + rect.setRect(wrect.x() + dfw1 + dbw1, + wrect.y() + dfw1 + dbw1, + wrect.width() - dfw2 - dbw2, + wrect.height() - dfw2 - dbw2); +#endif + break; + } + + case SR_CheckBoxIndicator: + { + int h = tqpixelMetric( PM_IndicatorHeight, widget ); + rect.setRect(0, ( wrect.height() - h ) / 2, + tqpixelMetric( PM_IndicatorWidth, widget ), h ); + break; + } + + case SR_CheckBoxContents: + { +#ifndef TQT_NO_CHECKBOX + TQRect ir = subRect(SR_CheckBoxIndicator, widget); + rect.setRect(ir.right() + 6, wrect.y(), + wrect.width() - ir.width() - 6, wrect.height()); +#endif + break; + } + + case SR_CheckBoxFocusRect: + { +#ifndef TQT_NO_CHECKBOX + const TQCheckBox *checkbox = (const TQCheckBox *) widget; + if ( !checkbox->pixmap() && checkbox->text().isEmpty() ) { + rect = subRect( SR_CheckBoxIndicator, widget ); + rect.addCoords( 1, 1, -1, -1 ); + break; + } + TQRect cr = subRect(SR_CheckBoxContents, widget); + + // don't create a painter if we have an active one + TQPainter *p = 0; + if (! activePainter) + p = new TQPainter(checkbox); + rect = tqitemRect((activePainter ? activePainter : p), + cr, TQt::AlignLeft | TQt::AlignVCenter | TQt::ShowPrefix, + checkbox->isEnabled(), + checkbox->pixmap(), + checkbox->text()); + + delete p; + + rect.addCoords( -3, -2, 3, 2 ); + rect = rect.intersect(wrect); +#endif + break; + } + + case SR_RadioButtonIndicator: + { + int h = tqpixelMetric( PM_ExclusiveIndicatorHeight, widget ); + rect.setRect(0, ( wrect.height() - h ) / 2, + tqpixelMetric( PM_ExclusiveIndicatorWidth, widget ), h ); + break; + } + + case SR_RadioButtonContents: + { + TQRect ir = subRect(SR_RadioButtonIndicator, widget); + rect.setRect(ir.right() + 6, wrect.y(), + wrect.width() - ir.width() - 6, wrect.height()); + break; + } + + case SR_RadioButtonFocusRect: + { +#ifndef TQT_NO_RADIOBUTTON + const TQRadioButton *radiobutton = (const TQRadioButton *) widget; + if ( !radiobutton->pixmap() && radiobutton->text().isEmpty() ) { + rect = subRect( SR_RadioButtonIndicator, widget ); + rect.addCoords( 1, 1, -1, -1 ); + break; + } + TQRect cr = subRect(SR_RadioButtonContents, widget); + + // don't create a painter if we have an active one + TQPainter *p = 0; + if (! activePainter) + p = new TQPainter(radiobutton); + rect = tqitemRect((activePainter ? activePainter : p), + cr, TQt::AlignLeft | TQt::AlignVCenter | TQt::ShowPrefix, + radiobutton->isEnabled(), + radiobutton->pixmap(), + radiobutton->text()); + delete p; + + rect.addCoords( -3, -2, 3, 2 ); + rect = rect.intersect(wrect); +#endif + break; + } + + case SR_ComboBoxFocusRect: + rect.setRect(3, 3, widget->width()-6-16, widget->height()-6); + break; + +#ifndef TQT_NO_SLIDER + case SR_SliderFocusRect: + { + const TQSlider * sl = (const TQSlider *) widget; + int tickOffset = tqpixelMetric( PM_SliderTickmarkOffset, sl ); + int thickness = tqpixelMetric( PM_SliderControlThickness, sl ); + + if ( sl->orientation() == Qt::Horizontal ) + rect.setRect( 0, tickOffset-1, sl->width(), thickness+2 ); + else + rect.setRect( tickOffset-1, 0, thickness+2, sl->height() ); + rect = rect.intersect( sl->rect() ); // ## is this really necessary? + break; + } +#endif // TQT_NO_SLIDER + +#ifndef TQT_NO_MAINWINDOW + case SR_DockWindowHandleRect: + { + if (! widget->parentWidget()) + break; + + const TQDockWindow * dw = (const TQDockWindow *) widget->parentWidget(); + + if ( !dw->area() || !dw->isCloseEnabled() ) + rect.setRect( 0, 0, widget->width(), widget->height() ); + else { + if ( dw->area()->orientation() == Qt::Horizontal ) + rect.setRect(0, 15, widget->width(), widget->height() - 15); + else + rect.setRect(0, 1, widget->width() - 15, widget->height() - 1); + } + break; + } +#endif // TQT_NO_MAINWINDOW + + case SR_ProgressBarGroove: + case SR_ProgressBarContents: + { +#ifndef TQT_NO_PROGRESSBAR + TQFontMetrics fm( ( widget ? widget->fontMetrics() : + TQApplication::fontMetrics() ) ); + const TQProgressBar *progressbar = (const TQProgressBar *) widget; + int textw = 0; + if (progressbar->percentageVisible()) + textw = fm.width("100%") + 6; + + if (progressbar->indicatorFollowsStyle() || + ! progressbar->centerIndicator()) + rect.setCoords(wrect.left(), wrect.top(), + wrect.right() - textw, wrect.bottom()); + else + rect = wrect; +#endif + break; + } + + case SR_ProgressBarLabel: + { +#ifndef TQT_NO_PROGRESSBAR + TQFontMetrics fm( ( widget ? widget->fontMetrics() : + TQApplication::fontMetrics() ) ); + const TQProgressBar *progressbar = (const TQProgressBar *) widget; + int textw = 0; + if (progressbar->percentageVisible()) + textw = fm.width("100%") + 6; + + if (progressbar->indicatorFollowsStyle() || + ! progressbar->centerIndicator()) + rect.setCoords(wrect.right() - textw, wrect.top(), + wrect.right(), wrect.bottom()); + else + rect = wrect; +#endif + break; + } + + case SR_ToolButtonContents: + rect = querySubControlMetrics(CC_ToolButton, widget, SC_ToolButton); + break; + + case SR_ToolBoxTabContents: + rect = wrect; + rect.addCoords( 0, 0, -30, 0 ); + break; + + default: + rect = wrect; + break; + } + + return rect; +} + +#ifndef TQT_NO_RANGECONTROL +/* + I really need this and I don't want to expose it in TQRangeControl.. +*/ +static int qPositionFromValue( const TQRangeControl * rc, int logical_val, + int span ) +{ + if ( span <= 0 || logical_val < rc->minValue() || + rc->maxValue() <= rc->minValue() ) + return 0; + if ( logical_val > rc->maxValue() ) + return span; + + uint range = rc->maxValue() - rc->minValue(); + uint p = logical_val - rc->minValue(); + + if ( range > (uint)INT_MAX/4096 ) { + const int scale = 4096*2; + return ( (p/scale) * span ) / (range/scale); + // ### the above line is probably not 100% correct + // ### but fixing it isn't worth the extreme pain... + } else if ( range > (uint)span ) { + return (2*p*span + range) / (2*range); + } else { + uint div = span / range; + uint mod = span % range; + return p*div + (2*p*mod + range) / (2*range); + } + //equiv. to (p*span)/range + 0.5 + // no overflow because of this implicit assumption: + // span <= 4096 +} +#endif // TQT_NO_RANGECONTROL + +/*! \reimp */ +void TQCommonStyle::tqdrawComplexControl( TQ_ComplexControl control, + TQPainter *p, + const TQWidget *widget, + const TQRect &r, + const TQColorGroup &cg, + SFlags flags, + SCFlags controls, + SCFlags active, + const TQStyleOption& opt ) const +{ +#if defined(TQT_CHECK_STATE) + if (! widget) { + qWarning("TQCommonStyle::tqdrawComplexControl: widget parameter cannot be zero!"); + return; + } +#endif + + activePainter = p; + + switch (control) { +#ifndef TQT_NO_SCROLLBAR + case CC_ScrollBar: + { + const TQScrollBar *scrollbar = (const TQScrollBar *) widget; + TQRect addline, subline, addpage, subpage, slider, first, last; + bool maxedOut = (scrollbar->minValue() == scrollbar->maxValue()); + + subline = querySubControlMetrics(control, widget, SC_ScrollBarSubLine, opt); + addline = querySubControlMetrics(control, widget, SC_ScrollBarAddLine, opt); + subpage = querySubControlMetrics(control, widget, SC_ScrollBarSubPage, opt); + addpage = querySubControlMetrics(control, widget, SC_ScrollBarAddPage, opt); + slider = querySubControlMetrics(control, widget, SC_ScrollBarSlider, opt); + first = querySubControlMetrics(control, widget, SC_ScrollBarFirst, opt); + last = querySubControlMetrics(control, widget, SC_ScrollBarLast, opt); + + if ((controls & SC_ScrollBarSubLine) && subline.isValid()) + tqdrawPrimitive(TQStyle::PE_ScrollBarSubLine, p, subline, cg, + (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) | + ((active == SC_ScrollBarSubLine) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0))); + if ((controls & SC_ScrollBarAddLine) && addline.isValid()) + tqdrawPrimitive(TQStyle::PE_ScrollBarAddLine, p, addline, cg, + (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) | + ((active == SC_ScrollBarAddLine) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0))); + if ((controls & SC_ScrollBarSubPage) && subpage.isValid()) + tqdrawPrimitive(TQStyle::PE_ScrollBarSubPage, p, subpage, cg, + (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) | + ((active == SC_ScrollBarSubPage) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0))); + if ((controls & SC_ScrollBarAddPage) && addpage.isValid()) + tqdrawPrimitive(TQStyle::PE_ScrollBarAddPage, p, addpage, cg, + (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) | + ((active == SC_ScrollBarAddPage) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0))); + if ((controls & SC_ScrollBarFirst) && first.isValid()) + tqdrawPrimitive(TQStyle::PE_ScrollBarFirst, p, first, cg, + (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) | + ((active == SC_ScrollBarFirst) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0))); + if ((controls & SC_ScrollBarLast) && last.isValid()) + tqdrawPrimitive(TQStyle::PE_ScrollBarLast, p, last, cg, + (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) | + ((active == SC_ScrollBarLast) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0))); + if ((controls & SC_ScrollBarSlider) && slider.isValid()) { + tqdrawPrimitive(TQStyle::PE_ScrollBarSlider, p, slider, cg, + (SFlags)(((maxedOut) ? Style_Default : Style_Enabled) | + ((active == SC_ScrollBarSlider) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0))); + + // ### perhaps this should not be able to accept focus if maxedOut? + if (scrollbar->hasFocus()) { + TQRect fr(slider.x() + 2, slider.y() + 2, + slider.width() - 5, slider.height() - 5); + tqdrawPrimitive(TQStyle::PE_FocusRect, p, fr, cg, Style_Default); + } + } + + break; + } +#endif // TQT_NO_SCROLLBAR + +#ifndef TQT_NO_TOOLBUTTON + case CC_ToolButton: + { + const TQToolButton *toolbutton = (const TQToolButton *) widget; + + TQColorGroup c = cg; + if ( toolbutton->backgroundMode() != TQt::PaletteButton ) + c.setBrush( TQColorGroup::Button, + toolbutton->paletteBackgroundColor() ); + TQRect button, menuarea; + button = tqvisualRect( querySubControlMetrics(control, widget, SC_ToolButton, opt), widget ); + menuarea = tqvisualRect( querySubControlMetrics(control, widget, SC_ToolButtonMenu, opt), widget ); + + SFlags bflags = flags, + mflags = flags; + + if (active & SC_ToolButton) + bflags |= Style_Down; + if (active & SC_ToolButtonMenu) + mflags |= Style_Down; + + if (controls & SC_ToolButton) { + if (bflags & (Style_Down | Style_On | Style_Raised)) { + tqdrawPrimitive(TQStyle::PE_ButtonTool, p, button, c, bflags, opt); + } else if ( toolbutton->parentWidget() && + toolbutton->parentWidget()->backgroundPixmap() && + ! toolbutton->parentWidget()->backgroundPixmap()->isNull() ) { + TQPixmap pixmap = + *(toolbutton->parentWidget()->backgroundPixmap()); + + p->drawTiledPixmap( r, pixmap, toolbutton->pos() ); + } + } + + if (controls & SC_ToolButtonMenu) { + if (mflags & (Style_Down | Style_On | Style_Raised)) + tqdrawPrimitive(TQStyle::PE_ButtonDropDown, p, menuarea, c, mflags, opt); + tqdrawPrimitive(TQStyle::PE_ArrowDown, p, menuarea, c, mflags, opt); + } + + if (toolbutton->hasFocus() && !toolbutton->focusProxy()) { + TQRect fr = toolbutton->rect(); + fr.addCoords(3, 3, -3, -3); + tqdrawPrimitive(TQStyle::PE_FocusRect, p, fr, c); + } + + break; + } +#endif // TQT_NO_TOOLBUTTON + +#ifndef TQT_NO_TITLEBAR + case CC_TitleBar: + { + const TQTitleBar *titlebar = (const TQTitleBar *) widget; + if ( controls & SC_TitleBarLabel ) { + TQColorGroup cgroup = titlebar->usesActiveColor() ? + titlebar->tqpalette().active() : titlebar->tqpalette().inactive(); + + TQColor left = cgroup.highlight(); + TQColor right = cgroup.base(); + + if ( left != right ) { + double rS = left.red(); + double gS = left.green(); + double bS = left.blue(); + + const double rD = double(right.red() - rS) / titlebar->width(); + const double gD = double(right.green() - gS) / titlebar->width(); + const double bD = double(right.blue() - bS) / titlebar->width(); + + const int w = titlebar->width(); + for ( int sx = 0; sx < w; sx++ ) { + rS+=rD; + gS+=gD; + bS+=bD; + p->setPen( TQColor( (int)rS, (int)gS, (int)bS ) ); + p->drawLine( sx, 0, sx, titlebar->height() ); + } + } else { + p->fillRect( titlebar->rect(), left ); + } + + TQRect ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarLabel ), widget ); + + p->setPen( cgroup.highlightedText() ); + p->drawText(ir.x()+2, ir.y(), ir.width()-2, ir.height(), + TQt::AlignAuto | TQt::AlignVCenter | TQt::SingleLine, titlebar->visibleText() ); + } + + TQRect ir; + bool down = FALSE; + TQPixmap pm; + + if ( controls & SC_TitleBarCloseButton ) { + ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarCloseButton ), widget ); + down = active & SC_TitleBarCloseButton; + if ( widget->testWFlags( TQt::WStyle_Tool ) +#ifndef TQT_NO_MAINWINDOW + || ::tqqt_cast<TQDockWindow*>(widget) +#endif + ) + pm = stylePixmap(SP_DockWindowCloseButton, widget); + else + pm = stylePixmap(SP_TitleBarCloseButton, widget); + tqdrawPrimitive(TQStyle::PE_ButtonTool, p, ir, titlebar->tqcolorGroup(), + down ? Style_Down : Style_Raised); + + p->save(); + if( down ) + p->translate( tqpixelMetric(PM_ButtonShiftHorizontal, widget), + tqpixelMetric(PM_ButtonShiftVertical, widget) ); + drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, &pm, TQString::null ); + p->restore(); + } + + if ( titlebar->window() ) { + if ( controls & SC_TitleBarMaxButton ) { + ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarMaxButton ), widget ); + + down = active & SC_TitleBarMaxButton; + pm = TQPixmap(stylePixmap(SP_TitleBarMaxButton, widget)); + tqdrawPrimitive(TQStyle::PE_ButtonTool, p, ir, titlebar->tqcolorGroup(), + down ? Style_Down : Style_Raised); + + p->save(); + if( down ) + p->translate( tqpixelMetric(PM_ButtonShiftHorizontal, widget), + tqpixelMetric(PM_ButtonShiftVertical, widget) ); + drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, &pm, TQString::null ); + p->restore(); + } + + if ( controls & SC_TitleBarNormalButton || controls & SC_TitleBarMinButton ) { + ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarMinButton ), widget ); + TQStyle::SubControl ctrl = (controls & SC_TitleBarNormalButton ? + SC_TitleBarNormalButton : + SC_TitleBarMinButton); + TQStyle::StylePixmap spixmap = (controls & SC_TitleBarNormalButton ? + SP_TitleBarNormalButton : + SP_TitleBarMinButton); + down = active & ctrl; + pm = TQPixmap(stylePixmap(spixmap, widget)); + tqdrawPrimitive(TQStyle::PE_ButtonTool, p, ir, titlebar->tqcolorGroup(), + down ? Style_Down : Style_Raised); + + p->save(); + if( down ) + p->translate( tqpixelMetric(PM_ButtonShiftHorizontal, widget), + tqpixelMetric(PM_ButtonShiftVertical, widget) ); + drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, &pm, TQString::null ); + p->restore(); + } + + if ( controls & SC_TitleBarShadeButton ) { + ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarShadeButton ), widget ); + + down = active & SC_TitleBarShadeButton; + pm = TQPixmap(stylePixmap(SP_TitleBarShadeButton, widget)); + tqdrawPrimitive(TQStyle::PE_ButtonTool, p, ir, titlebar->tqcolorGroup(), + down ? Style_Down : Style_Raised); + p->save(); + if( down ) + p->translate( tqpixelMetric(PM_ButtonShiftHorizontal, widget), + tqpixelMetric(PM_ButtonShiftVertical, widget) ); + drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, &pm, TQString::null ); + p->restore(); + } + + if ( controls & SC_TitleBarUnshadeButton ) { + ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarUnshadeButton ), widget ); + + down = active & SC_TitleBarUnshadeButton; + pm = TQPixmap(stylePixmap(SP_TitleBarUnshadeButton, widget)); + tqdrawPrimitive(TQStyle::PE_ButtonTool, p, ir, titlebar->tqcolorGroup(), + down ? Style_Down : Style_Raised); + p->save(); + if( down ) + p->translate( tqpixelMetric(PM_ButtonShiftHorizontal, widget), + tqpixelMetric(PM_ButtonShiftVertical, widget) ); + drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, &pm, TQString::null ); + p->restore(); + } + } +#ifndef TQT_NO_WIDGET_TOPEXTRA + if ( controls & SC_TitleBarSysMenu ) { + if ( titlebar->icon() ) { + ir = tqvisualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarSysMenu ), widget ); + drawItem( p, ir, TQt::AlignCenter, titlebar->tqcolorGroup(), TRUE, titlebar->icon(), TQString::null ); + } + } +#endif + break; + } +#endif //TQT_NO_TITLEBAR + + case CC_SpinWidget: { +#ifndef TQT_NO_SPINWIDGET + const TQSpinWidget * sw = (const TQSpinWidget *) widget; + SFlags flags; + PrimitiveElement pe; + + if ( controls & SC_SpinWidgetFrame ) + qDrawWinPanel( p, r, cg, TRUE ); //cstyle == Sunken ); + + if ( controls & SC_SpinWidgetUp ) { + flags = Style_Default | Style_Enabled; + if (active == SC_SpinWidgetUp ) { + flags |= Style_On; + flags |= Style_Sunken; + } else + flags |= Style_Raised; + if ( sw->buttonSymbols() == TQSpinWidget::PlusMinus ) + pe = TQStyle::PE_SpinWidgetPlus; + else + pe = TQStyle::PE_SpinWidgetUp; + + TQRect re = sw->upRect(); + TQColorGroup ucg = sw->isUpEnabled() ? cg : sw->tqpalette().disabled(); + tqdrawPrimitive(TQStyle::PE_ButtonBevel, p, re, ucg, flags); + tqdrawPrimitive(pe, p, re, ucg, flags); + } + + if ( controls & SC_SpinWidgetDown ) { + flags = Style_Default | Style_Enabled; + if (active == SC_SpinWidgetDown ) { + flags |= Style_On; + flags |= Style_Sunken; + } else + flags |= Style_Raised; + if ( sw->buttonSymbols() == TQSpinWidget::PlusMinus ) + pe = TQStyle::PE_SpinWidgetMinus; + else + pe = TQStyle::PE_SpinWidgetDown; + + TQRect re = sw->downRect(); + TQColorGroup dcg = sw->isDownEnabled() ? cg : sw->tqpalette().disabled(); + tqdrawPrimitive(TQStyle::PE_ButtonBevel, p, re, dcg, flags); + tqdrawPrimitive(pe, p, re, dcg, flags); + } +#endif + break; } + +#ifndef TQT_NO_SLIDER + case CC_Slider: + switch ( controls ) { + case SC_SliderTickmarks: { + const TQSlider * sl = (const TQSlider *) widget; + int tickOffset = tqpixelMetric( PM_SliderTickmarkOffset, sl ); + int ticks = sl->tickmarks(); + int thickness = tqpixelMetric( PM_SliderControlThickness, sl ); + int len = tqpixelMetric( PM_SliderLength, sl ); + int available = tqpixelMetric( PM_SliderSpaceAvailable, sl ); + int interval = sl->tickInterval(); + + if ( interval <= 0 ) { + interval = sl->lineStep(); + if ( qPositionFromValue( sl, interval, available ) - + qPositionFromValue( sl, 0, available ) < 3 ) + interval = sl->pageStep(); + } + + int fudge = len / 2; + int pos; + + if ( ticks & TQSlider::Above ) { + p->setPen( cg.foreground() ); + int v = sl->minValue(); + if ( !interval ) + interval = 1; + while ( v <= sl->maxValue() + 1 ) { + pos = qPositionFromValue( sl, v, available ) + fudge; + if ( sl->orientation() == Qt::Horizontal ) + p->drawLine( pos, 0, pos, tickOffset-2 ); + else + p->drawLine( 0, pos, tickOffset-2, pos ); + v += interval; + } + } + + if ( ticks & TQSlider::Below ) { + p->setPen( cg.foreground() ); + int v = sl->minValue(); + if ( !interval ) + interval = 1; + while ( v <= sl->maxValue() + 1 ) { + pos = qPositionFromValue( sl, v, available ) + fudge; + if ( sl->orientation() == Qt::Horizontal ) + p->drawLine( pos, tickOffset+thickness+1, pos, + tickOffset+thickness+1 + available-2 ); + else + p->drawLine( tickOffset+thickness+1, pos, + tickOffset+thickness+1 + available-2, + pos ); + v += interval; + } + + } + + break; } + } + break; +#endif // TQT_NO_SLIDER +#ifndef TQT_NO_LISTVIEW + case CC_ListView: + if ( controls & SC_ListView ) { + TQListView *listview = (TQListView*)widget; + p->fillRect( r, listview->viewport()->backgroundBrush() ); + } + break; +#endif //TQT_NO_LISTVIEW + default: + break; + } + + activePainter = 0; +} + + +/*! \reimp */ +void TQCommonStyle::tqdrawComplexControlMask( TQ_ComplexControl control, + TQPainter *p, + const TQWidget *widget, + const TQRect &r, + const TQStyleOption& opt ) const +{ + TQ_UNUSED(control); + TQ_UNUSED(widget); + TQ_UNUSED(opt); + + p->fillRect(r, Qt::color1); +} + + +/*! \reimp */ +TQRect TQCommonStyle::querySubControlMetrics( TQ_ComplexControl control, + const TQWidget *widget, + SubControl sc, + const TQStyleOption &opt ) const +{ +#if defined(TQT_CHECK_STATE) + if (! widget) { + qWarning("TQCommonStyle::querySubControlMetrics: widget parameter cannot be zero!"); + return TQRect(); + } +#endif + + switch ( control ) { + case CC_SpinWidget: { + int fw = tqpixelMetric( PM_SpinBoxFrameWidth, widget); + TQSize bs; + bs.setHeight( widget->height()/2 - fw ); + if ( bs.height() < 8 ) + bs.setHeight( 8 ); + bs.setWidth( TQMIN( bs.height() * 8 / 5, widget->width() / 4 ) ); // 1.6 -approximate golden mean + bs = bs.expandedTo( TQApplication::globalStrut() ); + int y = fw; + int x, lx, rx; + x = widget->width() - y - bs.width(); + lx = fw; + rx = x - fw; + switch ( sc ) { + case SC_SpinWidgetUp: + return TQRect(x, y, bs.width(), bs.height()); + case SC_SpinWidgetDown: + return TQRect(x, y + bs.height(), bs.width(), bs.height()); + case SC_SpinWidgetButtonField: + return TQRect(x, y, bs.width(), widget->height() - 2*fw); + case SC_SpinWidgetEditField: + return TQRect(lx, fw, rx, widget->height() - 2*fw); + case SC_SpinWidgetFrame: + return widget->rect(); + default: + break; + } + break; } + + case CC_ComboBox: { + int x = 0, y = 0, wi = widget->width(), he = widget->height(); + int xpos = x; + xpos += wi - 2 - 16; + + switch ( sc ) { + case SC_ComboBoxFrame: + return widget->rect(); + case SC_ComboBoxArrow: + return TQRect(xpos, y+2, 16, he-4); + case SC_ComboBoxEditField: + return TQRect(x+3, y+3, wi-6-16, he-6); + case SC_ComboBoxListBoxPopup: + return opt.rect(); + default: + break; + } + break; } + +#ifndef TQT_NO_SCROLLBAR + case CC_ScrollBar: { + const TQScrollBar *scrollbar = (const TQScrollBar *) widget; + int sliderstart = 0; + int sbextent = tqpixelMetric(PM_ScrollBarExtent, widget); + int maxlen = ((scrollbar->orientation() == Qt::Horizontal) ? + scrollbar->width() : scrollbar->height()) - (sbextent * 2); + int sliderlen; + + sliderstart = scrollbar->sliderStart(); + + // calculate slider length + if (scrollbar->maxValue() != scrollbar->minValue()) { + uint range = scrollbar->maxValue() - scrollbar->minValue(); + sliderlen = (TQ_LLONG(scrollbar->pageStep()) * maxlen) / (range + scrollbar->pageStep()); + + int slidermin = tqpixelMetric( PM_ScrollBarSliderMin, widget ); + if ( sliderlen < slidermin || range > INT_MAX / 2 ) + sliderlen = slidermin; + if ( sliderlen > maxlen ) + sliderlen = maxlen; + } else + sliderlen = maxlen; + + switch (sc) { + case SC_ScrollBarSubLine: // top/left button + if (scrollbar->orientation() == Qt::Horizontal) { + int buttonWidth = TQMIN(scrollbar->width()/2, sbextent); + return TQRect( 0, 0, buttonWidth, sbextent ); + } else { + int buttonHeight = TQMIN(scrollbar->height()/2, sbextent); + return TQRect( 0, 0, sbextent, buttonHeight ); + } + + case SC_ScrollBarAddLine: // bottom/right button + if (scrollbar->orientation() == Qt::Horizontal) { + int buttonWidth = TQMIN(scrollbar->width()/2, sbextent); + return TQRect( scrollbar->width() - buttonWidth, 0, buttonWidth, sbextent ); + } else { + int buttonHeight = TQMIN(scrollbar->height()/2, sbextent); + return TQRect( 0, scrollbar->height() - buttonHeight, sbextent, buttonHeight ); + } + + case SC_ScrollBarSubPage: // between top/left button and slider + if (scrollbar->orientation() == Qt::Horizontal) + return TQRect(sbextent, 0, sliderstart - sbextent, sbextent); + return TQRect(0, sbextent, sbextent, sliderstart - sbextent); + + case SC_ScrollBarAddPage: // between bottom/right button and slider + if (scrollbar->orientation() == Qt::Horizontal) + return TQRect(sliderstart + sliderlen, 0, + maxlen - sliderstart - sliderlen + sbextent, sbextent); + return TQRect(0, sliderstart + sliderlen, + sbextent, maxlen - sliderstart - sliderlen + sbextent); + + case SC_ScrollBarGroove: + if (scrollbar->orientation() == Qt::Horizontal) + return TQRect(sbextent, 0, scrollbar->width() - sbextent * 2, + scrollbar->height()); + return TQRect(0, sbextent, scrollbar->width(), + scrollbar->height() - sbextent * 2); + + case SC_ScrollBarSlider: + if (scrollbar->orientation() == Qt::Horizontal) + return TQRect(sliderstart, 0, sliderlen, sbextent); + return TQRect(0, sliderstart, sbextent, sliderlen); + + default: break; + } + + break; } +#endif // TQT_NO_SCROLLBAR + +#ifndef TQT_NO_SLIDER + case CC_Slider: { + const TQSlider * sl = (const TQSlider *) widget; + int tickOffset = tqpixelMetric( PM_SliderTickmarkOffset, sl ); + int thickness = tqpixelMetric( PM_SliderControlThickness, sl ); + + switch ( sc ) { + case SC_SliderHandle: { + int sliderPos = 0; + int len = tqpixelMetric( PM_SliderLength, sl ); + + sliderPos = sl->sliderStart(); + + if ( sl->orientation() == Qt::Horizontal ) + return TQRect( sliderPos, tickOffset, len, thickness ); + return TQRect( tickOffset, sliderPos, thickness, len ); } + case SC_SliderGroove: { + if ( sl->orientation() == Qt::Horizontal ) + return TQRect( 0, tickOffset, sl->width(), thickness ); + return TQRect( tickOffset, 0, thickness, sl->height() ); } + + default: + break; + } + break; } +#endif // TQT_NO_SLIDER + +#if !defined(TQT_NO_TOOLBUTTON) && !defined(TQT_NO_POPUPMENU) + case CC_ToolButton: { + const TQToolButton *toolbutton = (const TQToolButton *) widget; + int mbi = tqpixelMetric(PM_MenuButtonIndicator, widget); + + TQRect rect = toolbutton->rect(); + switch (sc) { + case SC_ToolButton: + if (toolbutton->popup() && ! toolbutton->popupDelay()) + rect.addCoords(0, 0, -mbi, 0); + return rect; + + case SC_ToolButtonMenu: + if (toolbutton->popup() && ! toolbutton->popupDelay()) + rect.addCoords(rect.width() - mbi, 0, 0, 0); + return rect; + + default: break; + } + break; + } +#endif // TQT_NO_TOOLBUTTON && TQT_NO_POPUPMENU + +#ifndef TQT_NO_TITLEBAR + case CC_TitleBar: { + const TQTitleBar *titlebar = (const TQTitleBar *) widget; + const int controlTop = 2; + const int controlHeight = widget->height() - controlTop * 2; + + switch (sc) { + case SC_TitleBarLabel: { + const TQTitleBar *titlebar = (TQTitleBar*)widget; + TQRect ir( 0, 0, titlebar->width(), titlebar->height() ); + if ( titlebar->testWFlags( TQt::WStyle_Tool ) ) { + if ( titlebar->testWFlags( TQt::WStyle_SysMenu ) ) + ir.addCoords( 0, 0, -controlHeight-3, 0 ); + if ( titlebar->testWFlags( TQt::WStyle_MinMax ) ) + ir.addCoords( 0, 0, -controlHeight-2, 0 ); + } else { + if ( titlebar->testWFlags( TQt::WStyle_SysMenu ) ) + ir.addCoords( controlHeight+3, 0, -controlHeight-3, 0 ); + if ( titlebar->testWFlags( TQt::WStyle_Minimize ) ) + ir.addCoords( 0, 0, -controlHeight-2, 0 ); + if ( titlebar->testWFlags( TQt::WStyle_Maximize ) ) + ir.addCoords( 0, 0, -controlHeight-2, 0 ); + } + return ir; } + + case SC_TitleBarCloseButton: + return TQRect( titlebar->width() - ( controlHeight + controlTop ), + controlTop, controlHeight, controlHeight ); + + case SC_TitleBarMaxButton: + case SC_TitleBarShadeButton: + case SC_TitleBarUnshadeButton: + return TQRect( titlebar->width() - ( ( controlHeight + controlTop ) * 2 ), + controlTop, controlHeight, controlHeight ); + + case SC_TitleBarMinButton: + case SC_TitleBarNormalButton: { + int offset = controlHeight + controlTop; + if ( !titlebar->testWFlags( TQt::WStyle_Maximize ) ) + offset *= 2; + else + offset *= 3; + return TQRect( titlebar->width() - offset, controlTop, controlHeight, controlHeight ); + } + + case SC_TitleBarSysMenu: + return TQRect( 3, controlTop, controlHeight, controlHeight); + + default: break; + } + break; } +#endif //TQT_NO_TITLEBAR + + default: + break; + } + return TQRect(); +} + + +/*! \reimp */ +TQStyle::SubControl TQCommonStyle::querySubControl(TQ_ComplexControl control, + const TQWidget *widget, + const TQPoint &pos, + const TQStyleOption& opt ) const +{ + SubControl ret = SC_None; + + switch (control) { +#ifndef TQT_NO_LISTVIEW + case CC_ListView: + { + if(pos.x() >= 0 && pos.x() < + opt.listViewItem()->listView()->treeStepSize()) + ret = SC_ListViewExpand; + break; + } +#endif +#ifndef TQT_NO_SCROLLBAR + case CC_ScrollBar: + { + TQRect r; + uint ctrl = SC_ScrollBarAddLine; + + // we can do this because subcontrols were designed to be masks as well... + while (ret == SC_None && ctrl <= SC_ScrollBarGroove) { + r = querySubControlMetrics(control, widget, + (TQStyle::SubControl) ctrl, opt); + if (r.isValid() && r.tqcontains(pos)) + ret = (TQStyle::SubControl) ctrl; + + ctrl <<= 1; + } + + break; + } +#endif + case CC_TitleBar: + { +#ifndef TQT_NO_TITLEBAR + const TQTitleBar *titlebar = (TQTitleBar*)widget; + TQRect r; + uint ctrl = SC_TitleBarLabel; + + // we can do this because subcontrols were designed to be masks as well... + while (ret == SC_None && ctrl <= SC_TitleBarUnshadeButton) { + r = tqvisualRect( querySubControlMetrics( control, widget, (TQStyle::SubControl) ctrl, opt ), widget ); + if (r.isValid() && r.tqcontains(pos)) + ret = (TQStyle::SubControl) ctrl; + + ctrl <<= 1; + } + if ( titlebar->window() ) { + if (titlebar->testWFlags( TQt::WStyle_Tool )) { + if ( ret == SC_TitleBarMinButton || ret == SC_TitleBarMaxButton ) { + if ( titlebar->window()->isMinimized() ) + ret = SC_TitleBarUnshadeButton; + else + ret = SC_TitleBarShadeButton; + } + } else if ( ret == SC_TitleBarMinButton && titlebar->window()->isMinimized() ) { + ret = TQStyle::SC_TitleBarNormalButton; + } + } +#endif + break; + } + + default: + break; + } + + return ret; +} + + +/*! \reimp */ +int TQCommonStyle::tqpixelMetric(PixelMetric m, const TQWidget *widget) const +{ + int ret; + + switch (m) { + case PM_DialogButtonsSeparator: + ret = 5; + break; + case PM_DialogButtonsButtonWidth: + ret = 70; + break; + case PM_DialogButtonsButtonHeight: + ret = 30; + break; + case PM_CheckListControllerSize: + case PM_CheckListButtonSize: + ret = 16; + break; + case PM_TitleBarHeight: { + if ( widget ) { + if ( widget->testWFlags( TQt::WStyle_Tool ) ) { + ret = TQMAX( widget->fontMetrics().lineSpacing(), 16 ); +#ifndef TQT_NO_MAINWINDOW + } else if ( ::tqqt_cast<TQDockWindow*>(widget) ) { + ret = TQMAX( widget->fontMetrics().lineSpacing(), 13 ); +#endif + } else { + ret = TQMAX( widget->fontMetrics().lineSpacing(), 18 ); + } + } else { + ret = 0; + } + + break; } + case PM_ScrollBarSliderMin: + ret = 9; + break; + + case PM_ButtonMargin: + ret = 6; + break; + + case PM_ButtonDefaultIndicator: + ret = 0; + break; + + case PM_MenuButtonIndicator: + if (! widget) + ret = 12; + else + ret = TQMAX(12, (widget->height() - 4) / 3); + break; + + case PM_ButtonShiftHorizontal: + case PM_ButtonShiftVertical: + ret = 0; + break; + + case PM_SpinBoxFrameWidth: + case PM_DefaultFrameWidth: + ret = 2; + break; + + case PM_MDIFrameWidth: + ret = 2; + break; + + case PM_MDIMinimizedWidth: + ret = 196; + break; + +#ifndef TQT_NO_SCROLLBAR + case PM_ScrollBarExtent: + if ( !widget ) { + ret = 16; + } else { + const TQScrollBar *bar = (const TQScrollBar*)widget; + int s = bar->orientation() == Qt::Horizontal ? + TQApplication::globalStrut().height() + : TQApplication::globalStrut().width(); + ret = TQMAX( 16, s ); + } + break; +#endif + case PM_MaximumDragDistance: + ret = -1; + break; + +#ifndef TQT_NO_SLIDER + case PM_SliderThickness: + ret = 16; + break; + + case PM_SliderTickmarkOffset: + { + if (! widget) { + ret = 0; + break; + } + + const TQSlider * sl = (const TQSlider *) widget; + int space = (sl->orientation() == Qt::Horizontal) ? sl->height() : + sl->width(); + int thickness = tqpixelMetric( PM_SliderControlThickness, sl ); + int ticks = sl->tickmarks(); + + if ( ticks == TQSlider::Both ) + ret = (space - thickness) / 2; + else if ( ticks == TQSlider::Above ) + ret = space - thickness; + else + ret = 0; + break; + } + + case PM_SliderSpaceAvailable: + { + const TQSlider * sl = (const TQSlider *) widget; + if ( sl->orientation() == Qt::Horizontal ) + ret = sl->width() - tqpixelMetric( PM_SliderLength, sl ); + else + ret = sl->height() - tqpixelMetric( PM_SliderLength, sl ); + break; + } +#endif // TQT_NO_SLIDER + + case PM_DockWindowSeparatorExtent: + ret = 6; + break; + + case PM_DockWindowHandleExtent: + ret = 8; + break; + + case PM_DockWindowFrameWidth: + ret = 1; + break; + + case PM_MenuBarFrameWidth: + ret = 2; + break; + + case PM_MenuBarItemSpacing: + case PM_ToolBarItemSpacing: + ret = 0; + break; + + case PM_TabBarTabOverlap: + ret = 3; + break; + + case PM_TabBarBaseHeight: + ret = 0; + break; + + case PM_TabBarBaseOverlap: + ret = 0; + break; + + case PM_TabBarTabHSpace: + ret = 24; + break; + + case PM_TabBarTabShiftHorizontal: + case PM_TabBarTabShiftVertical: + ret = 2; + break; + +#ifndef TQT_NO_TABBAR + case PM_TabBarTabVSpace: + { + const TQTabBar * tb = (const TQTabBar *) widget; + if ( tb && ( tb->tqshape() == TQTabBar::RoundedAbove || + tb->tqshape() == TQTabBar::RoundedBelow ) ) + ret = 10; + else + ret = 0; + break; + } +#endif + + case PM_ProgressBarChunkWidth: + ret = 9; + break; + + case PM_IndicatorWidth: + ret = 13; + break; + + case PM_IndicatorHeight: + ret = 13; + break; + + case PM_ExclusiveIndicatorWidth: + ret = 12; + break; + + case PM_ExclusiveIndicatorHeight: + ret = 12; + break; + + case PM_PopupMenuFrameHorizontalExtra: + case PM_PopupMenuFrameVerticalExtra: + ret = 0; + break; + + case PM_HeaderMargin: + ret = 4; + break; + case PM_HeaderMarkSize: + ret = 32; + break; + case PM_HeaderGripMargin: + ret = 4; + break; + case PM_TabBarScrollButtonWidth: + ret = 16; + break; + default: + ret = 0; + break; + } + + return ret; +} + + +/*! \reimp */ +TQSize TQCommonStyle::tqsizeFromContents(ContentsType contents, + const TQWidget *widget, + const TQSize &contentsSize, + const TQStyleOption& opt ) const +{ + TQSize sz(contentsSize); + +#if defined(TQT_CHECK_STATE) + if (! widget) { + qWarning("TQCommonStyle::tqsizeFromContents: widget parameter cannot be zero!"); + return sz; + } +#endif + + switch (contents) { +#ifndef TQT_NO_DIALOGBUTTONS + case CT_DialogButtons: { + const TQDialogButtons *dbtns = (const TQDialogButtons *)widget; + int w = contentsSize.width(), h = contentsSize.height(); + const int bwidth = tqpixelMetric(PM_DialogButtonsButtonWidth, widget), + bspace = tqpixelMetric(PM_DialogButtonsSeparator, widget), + bheight = tqpixelMetric(PM_DialogButtonsButtonHeight, widget); + if(dbtns->orientation() == Qt::Horizontal) { + if(!w) + w = bwidth; + } else { + if(!h) + h = bheight; + } + TQDialogButtons::Button btns[] = { TQDialogButtons::All, TQDialogButtons::Reject, TQDialogButtons::Accept, //reverse order (right to left) + TQDialogButtons::Apply, TQDialogButtons::Retry, TQDialogButtons::Ignore, TQDialogButtons::Abort, + TQDialogButtons::Help }; + for(unsigned int i = 0, cnt = 0; i < (sizeof(btns)/sizeof(btns[0])); i++) { + if(dbtns->isButtonVisible(btns[i])) { + TQSize szH = dbtns->tqsizeHint(btns[i]); + int mwidth = TQMAX(bwidth, szH.width()), mheight = TQMAX(bheight, szH.height()); + if(dbtns->orientation() == Qt::Horizontal) + h = TQMAX(h, mheight); + else + w = TQMAX(w, mwidth); + + if(cnt) + w += bspace; + cnt++; + if(dbtns->orientation() == Qt::Horizontal) + w += mwidth; + else + h += mheight; + } + } + const int fw = tqpixelMetric(PM_DefaultFrameWidth, widget) * 2; + sz = TQSize(w + fw, h + fw); + break; } +#endif //TQT_NO_DIALOGBUTTONS + case CT_PushButton: + { +#ifndef TQT_NO_PUSHBUTTON + const TQPushButton *button = (const TQPushButton *) widget; + int w = contentsSize.width(), + h = contentsSize.height(), + bm = tqpixelMetric(PM_ButtonMargin, widget), + fw = tqpixelMetric(PM_DefaultFrameWidth, widget) * 2; + + w += bm + fw; + h += bm + fw; + + if (button->isDefault() || button->autoDefault()) { + int dbw = tqpixelMetric(PM_ButtonDefaultIndicator, widget) * 2; + w += dbw; + h += dbw; + } + + sz = TQSize(w, h); +#endif + break; + } + + case CT_CheckBox: + { +#ifndef TQT_NO_CHECKBOX + const TQCheckBox *checkbox = (const TQCheckBox *) widget; + TQRect irect = subRect(SR_CheckBoxIndicator, widget); + int h = tqpixelMetric( PM_IndicatorHeight, widget ); + int margins = (!checkbox->pixmap() && checkbox->text().isEmpty()) ? 0 : 10; + sz += TQSize(irect.right() + margins, 4 ); + sz.setHeight( TQMAX( sz.height(), h ) ); +#endif + break; + } + + case CT_RadioButton: + { +#ifndef TQT_NO_RADIOBUTTON + const TQRadioButton *radiobutton = (const TQRadioButton *) widget; + TQRect irect = subRect(SR_RadioButtonIndicator, widget); + int h = tqpixelMetric( PM_ExclusiveIndicatorHeight, widget ); + int margins = (!radiobutton->pixmap() && radiobutton->text().isEmpty()) ? 0 : 10; + sz += TQSize(irect.right() + margins, 4 ); + sz.setHeight( TQMAX( sz.height(), h ) ); +#endif + break; + } + + case CT_ToolButton: + { + sz = TQSize(sz.width() + 6, sz.height() + 5); + break; + } + + case CT_ComboBox: + { + int dfw = tqpixelMetric(PM_DefaultFrameWidth, widget) * 2; + sz = TQSize(sz.width() + dfw + 21, sz.height() + dfw ); + break; + } + + case CT_PopupMenuItem: + { +#ifndef TQT_NO_POPUPMENU + if (opt.isDefault()) + break; + + const TQPopupMenu *popup = (const TQPopupMenu *) widget; + bool checkable = popup->isCheckable(); + TQMenuItem *mi = opt.menuItem(); + int maxpmw = opt.maxIconWidth(); + int w = sz.width(), h = sz.height(); + + if (mi->custom()) { + w = mi->custom()->tqsizeHint().width(); + h = mi->custom()->tqsizeHint().height(); + if (! mi->custom()->fullSpan()) + h += 8; + } else if ( mi->widget() ) { + } else if (mi->isSeparator()) { + w = 10; + h = 2; + } else { + if (mi->pixmap()) + h = TQMAX(h, mi->pixmap()->height() + 4); + else + h = TQMAX(h, popup->fontMetrics().height() + 8); + + if (mi->iconSet() != 0) + h = TQMAX(h, mi->iconSet()->pixmap(TQIconSet::Small, + TQIconSet::Normal).height() + 4); + } + + if (! mi->text().isNull()) { + if (mi->text().tqfind('\t') >= 0) + w += 12; + } + + if (maxpmw) + w += maxpmw + 6; + if (checkable && maxpmw < 20) + w += 20 - maxpmw; + if (checkable || maxpmw > 0) + w += 2; + w += 12; + + sz = TQSize(w, h); +#endif + break; + } + + case CT_LineEdit: + case CT_Header: + case CT_Slider: + case CT_ProgressBar: + // just return the contentsSize for now + // fall through intended + + default: + break; + } + + return sz; +} + + +/*! \reimp */ +int TQCommonStyle::tqstyleHint(TQ_StyleHint sh, const TQWidget * w, const TQStyleOption &, TQStyleHintReturn *) const +{ + int ret; + + switch (sh) { +#ifndef TQT_NO_DIALOGBUTTONS + case SH_DialogButtons_DefaultButton: + ret = TQDialogButtons::Accept; + break; +#endif + case SH_GroupBox_TextLabelVerticalAlignment: + ret = TQt::TQt::AlignVCenter; + break; + + case SH_GroupBox_TextLabelColor: + ret = (int) ( w ? w->paletteForegroundColor().rgb() : 0 ); + break; + + case SH_ListViewExpand_SelectMouseType: + case SH_TabBar_SelectMouseType: + ret = TQEvent::MouseButtonPress; + break; + + case SH_GUIStyle: + ret = TQt::WindowsStyle; + break; + + case SH_ScrollBar_BackgroundMode: + ret = TQt::PaletteBackground; + break; + + case SH_TabBar_Alignment: + case SH_Header_ArrowAlignment: + ret = TQt::AlignLeft; + break; + + case SH_PopupMenu_SubMenuPopupDelay: + ret = 256; + break; + + case SH_ProgressDialog_TextLabelAlignment: + ret = TQt::AlignCenter; + break; + + case SH_BlinkCursorWhenTextSelected: + ret = 1; + break; + + case SH_Table_GridLineColor: + ret = -1; + break; + + case SH_LineEdit_PasswordCharacter: + ret = '*'; + break; + + case SH_ToolBox_SelectedPageTitleBold: + ret = 1; + break; + + case SH_UnderlineAccelerator: + ret = 1; + break; + + case SH_ToolButton_Uses3D: + ret = 1; + break; + + default: + ret = 0; + break; + } + + return ret; +} + +/*! \reimp */ +TQPixmap TQCommonStyle::stylePixmap(StylePixmap, const TQWidget *, const TQStyleOption&) const +{ + return TQPixmap(); +} + + +#endif // TQT_NO_STYLE |