/* $Id$ This file is part of the KDE libraries Copyright (C) 1999 Daniel M. Duley KDE3 port (C) 2001-2002 Maksim Orlovich Port version 0.9.7 Includes code portions from the dotNET style, and the KDE HighColor style. dotNET Style Copyright (C) 2001, Chris Lee Carsten Pfeiffer KDE3 HighColor Style Copyright (C) 2001 Karol Szwed (C) 2001 Fredrik H�glund Drawing routines adapted from the KDE2 HCStyle, Copyright (C) 2000 Daniel M. Duley (C) 2000 Dirk Mueller (C) 2001 Martijn Klingens This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License version 2 as published by the Free Software Foundation. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "kthemestyle.h" #include "kthemebase.h" #include #include #include #include #include #include #define INCLUDE_MENUITEM_DEF #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "kstyledirs.h" #include #include #ifdef __GLIBC__ #include #endif static const TQCOORD u_arrow[] = { -1, -3, 0, -3, -2, -2, 1, -2, -3, -1, 2, -1, -4, 0, 3, 0, -4, 1, 3, 1}; static const TQCOORD d_arrow[] = { -4, -2, 3, -2, -4, -1, 3, -1, -3, 0, 2, 0, -2, 1, 1, 1, -1, 2, 0, 2}; static const TQCOORD l_arrow[] = { -3, -1, -3, 0, -2, -2, -2, 1, -1, -3, -1, 2, 0, -4, 0, 3, 1, -4, 1, 3}; static const TQCOORD r_arrow[] = { -2, -4, -2, 3, -1, -4, -1, 3, 0, -3, 0, 2, 1, -2, 1, 1, 2, -1, 2, 0}; const TQCOORD win_style_u_arrow[] = { 0, -2, 0, -2, -1, -1, 1, -1, -2, 0, 2, 0, -3, 1, 3, 1 }; const TQCOORD win_style_d_arrow[] = { -3, -2, 3, -2, -2, -1, 2, -1, -1, 0, 1, 0, 0, 1, 0, 1 }; const TQCOORD win_style_l_arrow[] = { 1, -3, 1, -3, 0, -2, 1, -2, -1, -1, 1, -1, -2, 0, 1, 0, -1, 1, 1, 1, 0, 2, 1, 2, 1, 3, 1, 3 }; const TQCOORD win_style_r_arrow[] = { -2, -3, -2, -3, -2, -2, -1, -2, -2, -1, 0, -1, -2, 0, 1, 0, -2, 1, 0, 1, -2, 2, -1, 2, -2, 3, -2, 3 }; #define TQCOORDARRLEN(x) sizeof(x)/(sizeof(TQCOORD)*2) static const int itemFrame = 2; static const int itemHMargin = 3; static const int itemVMargin = 1; static const int arrowHMargin = 6; static const int rightBorder = 12; /* BUGS: Sliders flash a bit -- anything else? TODO: Nicer disabled buttons. Sliders are not disabled properly */ class KThemeStylePlugin : public TQStylePlugin { public: KThemeStylePlugin() { #ifdef __GLIBC__ dlopen("kthemestyle.so",RTLD_LAZY); //####### Keep reference count up so kdecore w. fast-malloc doesn't get unloaded //####### (Fixes exit crashes with qt-only apps that occur on Linux) //####### This should be rethought after 3.0, //####### as it relies on the implementation-specific behavior //####### of the glibc libdl (finding already loaded libraries based on the //####### soname) #endif } ~KThemeStylePlugin() {} TQStringList keys() const { TQSettings cfg; KStyleDirs::dirs()->addToSearch( "config", cfg ); TQStringList keys; bool ok; keys = cfg.readListEntry( "/kthemestyle/themes", &ok); if ( !ok ) qWarning( "KThemeStyle cache seems corrupt!\n" ); //Too bad one can't i18n this :-( return keys; } TQStyle* create( const TQString& key ) { TQSettings cfg; KStyleDirs::dirs()->addToSearch( "config", cfg ); TQString file = cfg.readEntry( "/kthemestyle/" + key + "/file" ); if ( !key.isEmpty() ) { TQFileInfo fi( file ); return new KThemeStyle( fi.dirPath(), fi.fileName() ); } return 0; } }; KDE_Q_EXPORT_PLUGIN( KThemeStylePlugin ) void kDrawWindowsArrow ( TQPainter *p, const TQStyle* style, TQStyle::PrimitiveElement pe, bool down, int x, int y, int w, int h, const TQColorGroup &cg, bool enabled ) { TQPointArray a; switch ( pe ) { case TQStyle::PE_ArrowUp: a.setPoints( TQCOORDARRLEN( win_style_u_arrow ), win_style_u_arrow ); break; case TQStyle::PE_ArrowDown: a.setPoints( TQCOORDARRLEN( win_style_d_arrow ), win_style_d_arrow ); break; case TQStyle::PE_ArrowLeft: a.setPoints( TQCOORDARRLEN( win_style_l_arrow ), win_style_l_arrow ); break; default: a.setPoints( TQCOORDARRLEN( win_style_r_arrow ), win_style_r_arrow ); } p->save(); if ( down ) { p->translate( style->tqpixelMetric( TQStyle::PM_ButtonShiftHorizontal ), style->tqpixelMetric( TQStyle::PM_ButtonShiftVertical ) ); } if ( enabled ) { a.translate( x + w / 2, y + h / 2 ); p->setPen( cg.buttonText() ); p->drawLineSegments( a ); } else { a.translate( x + w / 2 + 1, y + h / 2 + 1 ); p->setPen( cg.light() ); p->drawLineSegments( a ); a.translate( -1, -1 ); p->setPen( cg.mid() ); p->drawLineSegments( a ); } p->restore(); } TQSize KThemeStyle::tqsizeFromContents( ContentsType contents, const TQWidget* widget, const TQSize &contentSize, const TQStyleOption& opt ) const { switch ( contents ) { // PUSHBUTTON SIZE // ------------------------------------------------------------------ case CT_PushButton: { const TQPushButton * button = ( const TQPushButton* ) widget; int w = contentSize.width(); int h = contentSize.height(); int bm = tqpixelMetric( PM_ButtonMargin, widget ); int fw = tqpixelMetric( PM_DefaultFrameWidth, widget ) * 2; w += bm + fw + 6; // ### Add 6 to make way for bold font. h += bm + fw; // Ensure we stick to standard width and heights. if ( button->isDefault() || button->autoDefault() ) { if ( w < 80 && !button->text().isEmpty() ) w = 80; } if ( h < 22 ) h = 22; return TQSize( w, h ); } // POPUPMENU ITEM SIZE // ----------------------------------------------------------------- case CT_PopupMenuItem: { if ( ! widget || opt.isDefault() ) return contentSize; const TQPopupMenu *popup = ( const TQPopupMenu * ) widget; bool checkable = popup->isCheckable(); TQMenuItem *mi = opt.menuItem(); int maxpmw = opt.maxIconWidth(); int w = contentSize.width(), h = contentSize.height(); if ( mi->custom() ) { w = mi->custom() ->tqsizeHint().width(); h = mi->custom() ->tqsizeHint().height(); if ( ! mi->custom() ->fullSpan() ) h += 2 * itemVMargin + 2 * itemFrame; } else if ( mi->widget() ) {} else if ( mi->isSeparator() ) { w = 10; // Arbitrary h = 2; } else { if ( mi->pixmap() ) h = QMAX( h, mi->pixmap() ->height() + 2 * itemFrame ); else h = QMAX( h, popup->fontMetrics().height() + 2 * itemVMargin + 2 * itemFrame ); if ( mi->iconSet() ) h = QMAX( h, mi->iconSet() ->pixmap( TQIconSet::Small, TQIconSet::Normal ).height() + 2 * itemFrame ); } if ( ! mi->text().isNull() && mi->text().tqfind( '\t' ) >= 0 ) w += 12; else if ( mi->popup() ) w += 2 * arrowHMargin; if ( maxpmw ) w += maxpmw + 6; if ( checkable && maxpmw < 20 ) w += 20 - maxpmw; if ( checkable || maxpmw > 0 ) w += 12; w += rightBorder; return TQSize( w, h ); } default: return KThemeBase::tqsizeFromContents( contents, widget, contentSize, opt ); } } TQRect KThemeStyle::subRect(SubRect sr, const TQWidget* widget) const { if (sr == SR_CheckBoxFocusRect) { const TQCheckBox* cb = static_cast(widget); //Only checkbox, no label if (cb->text().isEmpty() && (cb->pixmap() == 0) ) { TQRect bounding = cb->rect(); int cw = tqpixelMetric(PM_IndicatorWidth, widget); int ch = tqpixelMetric(PM_IndicatorHeight, widget); TQRect checkbox(bounding.x() + 2, bounding.y() + 2 + (bounding.height() - ch)/2, cw - 4, ch - 4); return checkbox; } } return KStyle::subRect(sr, widget); } int KThemeStyle::tqpixelMetric ( PixelMetric metric, const TQWidget * widget ) const { switch ( metric ) { case PM_MenuBarFrameWidth: return 1; case PM_DefaultFrameWidth: return ( frameWidth() ); case PM_ButtonMargin: return decoWidth( PushButton ) > decoWidth( PushButtonDown ) ? 3 + decoWidth( PushButton ) : 3 + decoWidth( PushButtonDown ); case PM_ScrollBarExtent: case PM_SliderThickness: //Should this be 16 always? return getSBExtent(); case PM_ButtonDefaultIndicator: return 0; case PM_ButtonShiftHorizontal: return buttonXShift(); case PM_ButtonShiftVertical: return buttonYShift(); case PM_ExclusiveIndicatorWidth: if ( isPixmap( ExIndicatorOn ) ) return ( uncached( ExIndicatorOn ) ->size().width() ); else return KThemeBase::tqpixelMetric ( metric, widget ); case PM_ExclusiveIndicatorHeight: if ( isPixmap( ExIndicatorOn ) ) return ( uncached( ExIndicatorOn ) ->size().height() ); else return KThemeBase::tqpixelMetric ( metric, widget ); case PM_IndicatorWidth: if ( isPixmap( IndicatorOn ) ) return ( uncached( IndicatorOn ) ->size().width() ); else return KThemeBase::tqpixelMetric ( metric, widget ); case PM_IndicatorHeight: if ( isPixmap( IndicatorOn ) ) return ( uncached( IndicatorOn ) ->size().height() ); else return KThemeBase::tqpixelMetric ( metric, widget ); case PM_SliderLength: return ( sliderButtonLength() ); case PM_SplitterWidth: return ( splitWidth() ); default: return KThemeBase::tqpixelMetric ( metric, widget ); } } KThemeStyle::KThemeStyle( const TQString& configDir, const TQString &configFile ) : KThemeBase( configDir, configFile ), paletteSaved( false ), polishLock( false ), menuCache( 0 ), vsliderCache( 0 ), brushHandle( 0 ), brushHandleSet( false ), kickerMode( false ) { mtfstyle = TQStyleFactory::create( "Motif" ); if ( !mtfstyle ) mtfstyle = TQStyleFactory::create( *( TQStyleFactory::keys().begin() ) ); } KThemeStyle::~KThemeStyle() { delete vsliderCache; delete menuCache; } void KThemeStyle::polish( TQApplication * app ) { if (!qstrcmp(app->argv()[0], "kicker")) kickerMode = true; } void KThemeStyle::polish( TQPalette &p ) { if ( polishLock ) { return ; //Palette polishing disabled ... } if ( !paletteSaved ) { oldPalette = p; paletteSaved = true; } p = overridePalette( p ); if ( isPixmap( Background ) ) { TQBrush bgBrush( p.color( TQPalette::Normal, TQColorGroup::Background ), *uncached( Background ) ); brushHandle = uncached( Background )->handle(); brushHandleSet = true; p.setBrush( TQColorGroup::Background, bgBrush ); } } void KThemeStyle::paletteChanged() { TQPalette p = TQApplication::palette(); polish( p ); TQApplication::setPalette( p ); } void KThemeStyle::unPolish( TQApplication *app ) { app->tqsetPalette( oldPalette, true ); } bool KThemeStyle::eventFilter( TQObject* object, TQEvent* event ) { if( object->inherits("KActiveLabel")) { if(event->type() == TQEvent::Move || event->type() == TQEvent::Resize || event->type() == TQEvent::Show) { TQWidget *w = TQT_TQWIDGET(object); TQPoint pos(0, 0); pos = w->mapTo(w->tqtopLevelWidget(), pos); TQPixmap pix(uncached( Background )->size()); TQPainter p; p.begin(&pix); p.drawTiledPixmap(0, 0, uncached( Background )->width(), uncached( Background )->height() , *uncached( Background ), pos.x(), pos.y()); p.end(); TQPalette pal(w->palette()); TQBrush brush( pal.color( TQPalette::Normal, TQColorGroup::Background), pix ); pal.setBrush(TQColorGroup::Base, brush); w->setPalette(pal); } } if (!qstrcmp(object->name(), "kde toolbar widget") && object->inherits(TQLABEL_OBJECT_NAME_STRING)) { TQWidget* lb = TQT_TQWIDGET(object); if (lb->backgroundMode() == TQt::PaletteButton) lb->setBackgroundMode(TQt::PaletteBackground); lb->removeEventFilter(this); } return KStyle::eventFilter(object, event); } void KThemeStyle::polish( TQWidget *w ) { if (::tqqt_cast(w)) w->setPaletteBackgroundColor(TQApplication::palette().color(TQPalette::Normal, TQColorGroup::Background)); if (::tqqt_cast(w) && !qstrcmp(w->name(), "kde toolbar widget")) w->installEventFilter(this); if (w->backgroundPixmap() && !w->isTopLevel() && (!kickerMode || (!w->inherits("TaskBar") && !w->inherits("TaskBarContainer") && !w->inherits("TaskbarApplet") && !w->inherits("ContainerArea") && !w->inherits("AppletHandle")))) { //The brushHandle check verifies that the bg pixmap is actually the brush.. if (!brushHandleSet || brushHandle == w->backgroundPixmap()->handle()) { w->setBackgroundOrigin( TQWidget::WindowOrigin ); } } if (w->inherits("KActiveLabel")) { if (uncached( Background )) w->installEventFilter(this); } if ( w->inherits( "QTipLabel" ) ) { polishLock = true; TQColorGroup clrGroup( Qt::black, TQColor( 255, 255, 220 ), TQColor( 96, 96, 96 ), Qt::black, Qt::black, Qt::black, TQColor( 255, 255, 220 ) ); TQPalette toolTip ( clrGroup, clrGroup, clrGroup ); TQToolTip::setPalette( toolTip ); polishLock = false; } if ( w->inherits( "KonqIconViewWidget" ) ) //Konqueror background hack/workaround { w->setPalette( oldPalette ); return ; } if ( ::tqqt_cast(w) ) { w->setBackgroundMode( TQWidget::NoBackground ); } else if ( w->inherits( "KToolBarSeparator" ) || w->inherits( "QToolBarSeparator" ) ) { w->setBackgroundMode( TQWidget::PaletteBackground ); } else if ( ::tqqt_cast(w) ) { popupPalette = w->palette(); if ( isColor( MenuItem ) || isColor( MenuItemDown ) ) { TQPalette newPal( w->palette() ); if ( isColor( MenuItem ) ) { newPal.setActive( *tqcolorGroup( newPal.active(), MenuItem ) ); newPal.setDisabled( *tqcolorGroup( newPal.active(), MenuItem ) ); } if ( isColor( MenuItemDown ) ) { newPal.setActive( *tqcolorGroup( newPal.active(), MenuItemDown ) ); } w->setPalette( newPal ); } w->setBackgroundMode( TQWidget::NoBackground ); } else if ( ::tqqt_cast(w) ) { if ( isColor( IndicatorOff ) || isColor( IndicatorOn ) ) { TQPalette newPal( w->palette() ); if ( isColor( IndicatorOff ) ) { newPal.setActive( *tqcolorGroup( newPal.active(), IndicatorOff ) ); newPal.setDisabled( *tqcolorGroup( newPal.active(), IndicatorOff ) ); } if ( isColor( IndicatorOn ) ) newPal.setActive( *tqcolorGroup( newPal.active(), IndicatorOn ) ); w->setPalette( newPal ); } } else if ( ::tqqt_cast(w) ) { if ( isColor( ExIndicatorOff ) || isColor( ExIndicatorOn ) ) { TQPalette newPal( w->palette() ); if ( isColor( ExIndicatorOff ) ) { newPal.setActive( *tqcolorGroup( newPal.active(), ExIndicatorOff ) ); newPal.setDisabled( *tqcolorGroup( newPal.active(), ExIndicatorOff ) ); } if ( isColor( ExIndicatorOn ) ) newPal.setActive( *tqcolorGroup( newPal.active(), ExIndicatorOn ) ); w->setPalette( newPal ); } } KStyle::polish( w ); } void KThemeStyle::unPolish( TQWidget* w ) { if (w->backgroundPixmap() && !w->isTopLevel()) { //The brushHandle check verifies that the bg pixmap is actually the brush.. if (!brushHandleSet || brushHandle ==w->backgroundPixmap()->handle()) { w->setBackgroundOrigin( TQWidget::WidgetOrigin ); } } //Toolbar labels should nornally be PaletteButton if ( ::tqqt_cast(w) && !qstrcmp(w->name(), "kde toolbar widget")) w->setBackgroundMode( TQWidget::PaletteButton ); //The same for menu bars, popup menus else if ( ::tqqt_cast(w) || ::tqqt_cast(w) ) w->setBackgroundMode( TQWidget::PaletteButton ); //For toolbar internal separators, return to button, too (can't use tqqt_cast here since don't have access to the class) else if ( w->inherits( "KToolBarSeparator" ) || w->inherits( "QToolBarSeparator" ) ) w->setBackgroundMode( TQWidget::PaletteButton ); //For scrollbars, we don't do much, since the widget queries the style on the switch //Drop some custom palettes. ### this really should check the serial number to be 100% correct. if ( ::tqqt_cast(w) || ::tqqt_cast(w) || ::tqqt_cast(w) || ::tqqt_cast(w) ) w->unsetPalette(); KStyle::unPolish( w ); } void KThemeStyle::drawBaseButton( TQPainter *p, int x, int y, int w, int h, const TQColorGroup &g, bool sunken, bool rounded, WidgetType type ) const { int offset = borderPixmap( type ) ? 0 : decoWidth( type ) ; //##### This is wrong, but the code relies on it.. TQPen oldPen = p->pen(); // handle reverse bevel here since it uses decowidth differently if ( gradientHint( type ) == GrReverseBevel ) { int i; bitBlt( p->tqdevice(), x, y, TQT_TQPAINTDEVICE(scalePixmap( w, h, type )), 0, 0, w, h, TQt::CopyROP, true ); p->setPen( g.text() ); for ( i = 0; i < borderWidth( type ); ++i, ++x, ++y, w -= 2, h -= 2 ) p->drawRect( x, y, w, h ); } // same with KDE style borders else if ( !borderPixmap( type ) && shade() == KDE ) { kDrawBeButton( p, x, y, w, h, g, sunken ); if ( isPixmap( type ) ) p->drawTiledPixmap( x + 4, y + 4, w - 6, h - 6, *scalePixmap( w - 6, h - 6, type ) ); else p->fillRect( x + 4, y + 4, w - 6, h - offset * 6, g.brush( TQColorGroup::Button ) ); } else { if ( ( w - offset * 2 ) > 0 && ( h - offset * 2 ) > 0 ) { if ( isPixmap( type ) ) if ( rounded ) p->drawTiledPixmap( x, y, w, h, *scalePixmap( w, h, type ) ); else p->drawTiledPixmap( x + offset, y + offset, w - offset * 2, h - offset * 2, *scalePixmap( w - offset * 2, h - offset * 2, type ) ); else if ( 1 ) //##### TODO - Get this optimization working... !borderPixmap( type ) || (( w - decoWidth(type) * 2 ) > 0 && ( h - decoWidth(type) * 2 ) > 0) ) //Sometimes border covers the whole thing - in that case, avoid drawing the base. { p->fillRect( x + offset, y + offset, w - offset * 2, h - offset * 2, g.brush( TQColorGroup::Button ) ); } } if ( borderPixmap( type ) ) { bitBlt( p->tqdevice(), x, y, TQT_TQPAINTDEVICE(scaleBorder( w, h, type )), 0, 0, w, h, TQt::CopyROP, false ); } else drawShade( p, x, y, w, h, g, sunken, rounded, highlightWidth( type ), borderWidth( type ), shade() ); } p->setPen( oldPen ); } void KThemeStyle::drawPrimitive ( PrimitiveElement pe, TQPainter * p, const TQRect & r, const TQColorGroup & g_base, SFlags flags, const TQStyleOption & opt ) const { bool handled = false; int x, y, w, h; r.rect( &x, &y, &w, &h ); bool sunken = ( flags & Style_Sunken ); bool enabled = ( flags & Style_Enabled ); bool down = ( flags & Style_Down ); bool on = flags & Style_On; TQColorGroup g = g_base; switch ( pe ) { case PE_ArrowUp: case PE_ArrowDown: case PE_ArrowRight: case PE_ArrowLeft: { TQRect r( x, y, w, h ); if ( r.width() > 12 ) { r.setRect( r.x() + ( r.width() - 12 ) / 2, r.y(), 12, r.height() ); } if ( r.height() > 12 ) { r.setRect( r.x(), r.y() + ( r.height() - 12 ) / 2, r.width(), 12 ); } r.rect( &x, &y, &w, &h ); // Handles pixmapped arrows. A little inefficient because you can specify // some as pixmaps and some as default types. WidgetType widget; switch ( pe ) { case PE_ArrowUp: widget = enabled ? down ? SunkenArrowUp : ArrowUp : DisArrowUp; break; case PE_ArrowDown: widget = enabled ? down ? SunkenArrowDown : ArrowDown : DisArrowDown; break; case PE_ArrowLeft: widget = enabled ? down ? SunkenArrowLeft : ArrowLeft : DisArrowLeft; break; case PE_ArrowRight: default: widget = enabled ? down ? SunkenArrowRight : ArrowRight : DisArrowRight; break; } if ( isPixmap( widget ) ) { bitBlt( p->device(), x + ( w - uncached( widget ) ->width() ) / 2, y + ( h - uncached( widget ) ->height() ) / 2, uncached( widget ) ); return ; } const TQColorGroup *cg = tqcolorGroup( g, widget ); // Standard arrow types if ( arrowType() == MotifArrow ) { mtfstyle->tqdrawPrimitive( pe, p, r, g, flags, opt ); handled = true; } else if ( arrowType() == SmallArrow ) { // #### FIXME: This should be like the Platinum style - uses HighColor look for now TQPointArray a; switch ( pe ) { case PE_ArrowUp: a.setPoints( TQCOORDARRLEN( u_arrow ), u_arrow ); break; case PE_ArrowDown: a.setPoints( TQCOORDARRLEN( d_arrow ), d_arrow ); break; case PE_ArrowLeft: a.setPoints( TQCOORDARRLEN( l_arrow ), l_arrow ); break; default: a.setPoints( TQCOORDARRLEN( r_arrow ), r_arrow ); } 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 ); } else { a.translate( r.x() + r.width() / 2 + 1, r.y() + r.height() / 2 + 1 ); p->setPen( cg->mid() ); p->drawLineSegments( a ); } p->restore(); } else { TQPointArray a; int x2 = x + w - 1, y2 = y + h - 1; switch ( pe ) { case PE_ArrowUp: a.setPoints( 4, x, y2, x2, y2, x + w / 2, y, x, y2 ); break; case PE_ArrowDown: a.setPoints( 4, x, y, x2, y, x + w / 2, y2, x, y ); break; case PE_ArrowLeft: a.setPoints( 4, x2, y, x2, y2, x, y + h / 2, x2, y ); break; default: a.setPoints( 4, x, y, x, y2, x2, y + h / 2, x, y ); break; } TQBrush oldBrush = p->brush(); TQPen oldPen = p->pen(); p->setBrush( cg->brush( TQColorGroup::Shadow ) ); p->setPen( cg->shadow() ); p->drawPolygon( a ); p->setBrush( oldBrush ); p->setPen( oldPen ); handled = true; } break; } case PE_HeaderSection: { sunken = false; //Never mind this one } case PE_ButtonBevel: { WidgetType type = ( sunken || on || down ) ? BevelDown : Bevel; drawBaseButton( p, x, y, w, h, *tqcolorGroup( g, type ), ( sunken || on || down ), false, type ); handled = true; break; } case PE_ButtonCommand: { drawBaseButton( p, x, y, w, h, g, ( sunken || on || down ), roundButton(), ( sunken || on || down ) ? PushButtonDown : PushButton ); handled = true; break; } case PE_PanelDockWindow: { drawBaseButton( p, x, y, w, h, *tqcolorGroup( g, ToolBar ), false, false, ToolBar ); handled = true; break; } case PE_CheckMark: { if ( isPixmap( CheckMark ) ) { if ( flags & Style_Enabled || flags & Style_On ) bitBlt( p->device(), x + ( w - uncached( CheckMark ) ->width() ) / 2, y + ( h - uncached( CheckMark ) ->height() ) / 2, uncached( CheckMark ) ); handled = true; } else //Small hack to ensure the checkmark gets painter proper color.. { g.setColor( TQColorGroup::Text, g.buttonText() ); } break; } case PE_ExclusiveIndicator: { if ( isPixmap( ( flags & Style_On || flags & Style_Down ) ? ExIndicatorOn : ExIndicatorOff ) ) { p->drawPixmap( x, y, *uncached( ( flags & Style_On || flags & Style_Down ) ? ExIndicatorOn : ExIndicatorOff ) ); handled = true; } break; } case PE_ExclusiveIndicatorMask: { if ( isPixmap( ( flags & Style_On || flags & Style_Down ) ? ExIndicatorOn : ExIndicatorOff ) ) { const TQBitmap * mask = uncached( ( flags & Style_On || flags & Style_Down ) ? ExIndicatorOn : ExIndicatorOff ) ->tqmask(); if ( mask ) { p->setPen( Qt::color1 ); p->drawPixmap( x, y, *mask ); } else p->fillRect( x, y, w, h, TQBrush( color1, SolidPattern ) ); handled = true; } break; } case PE_IndicatorMask: { if ( isPixmap( ( flags & Style_On ) ? IndicatorOn : IndicatorOff ) ) { const TQBitmap * mask = uncached( ( flags & Style_On ) ? IndicatorOn : IndicatorOff ) ->tqmask(); if ( mask ) { p->setPen( Qt::color1 ); p->drawPixmap( x, y, *mask ); } else p->fillRect( x, y, w, h, TQBrush( color1, SolidPattern ) ); handled = true; } break; } case PE_Indicator: { if ( isPixmap( ( flags & Style_On || flags & Style_Down ) ? IndicatorOn : IndicatorOff ) ) { p->drawPixmap( x, y, *uncached( ( flags & Style_On || flags & Style_Down ) ? IndicatorOn : IndicatorOff ) ); handled = true; } break; } case PE_Splitter: { drawBaseButton( p, x, y, w, h, *tqcolorGroup( g, Splitter ), false, false, Splitter ); handled = true; break; } case PE_FocusRect: { if ( is3DFocus() ) { p->setPen( g.dark() ); int i = focusOffset(); p->drawLine( r.x() + i, r.y() + 1 + i, r.x() + i, r.bottom() - 1 - i ); p->drawLine( r.x() + 1 + i, r.y() + i, r.right() - 1 - i, r.y() + i ); p->setPen( g.light() ); p->drawLine( r.right() - i, r.y() + 1 + i, r.right() - i, r.bottom() - 1 - i ); p->drawLine( r.x() + 1 + i, r.bottom() - i, r.right() - 1 - i, r.bottom() - i ); handled = true; } else { handled = true; p->drawWinFocusRect(r); } break; } case PE_PanelMenuBar: { TQPixmap* cache = makeMenuBarCache(w, h); p->drawPixmap( x, y, *cache); handled = true; break; } case PE_ScrollBarAddPage: case PE_ScrollBarSubPage: { WidgetType widget = ( flags & Style_Horizontal ) ? HScrollGroove : VScrollGroove; if ( !isPixmap( widget ) ) { p->fillRect( r, tqcolorGroup( g, widget ) ->brush( TQColorGroup::Background ) ); // Do the borders and frame drawShade( p, r.x(), r.y(), r.width(), r.height(), *tqcolorGroup( g, widget ), true, false, highlightWidth( widget ), borderWidth( widget ), shade() ); } else { // If the groove is pixmapped we make a full-sized image (it gets // cached) then bitBlt it to the appropriate rect. p->drawTiledPixmap( r.x(), r.y(), r.width(), r.height(), *scalePixmap( r.width(), r.height(), widget ) ); drawShade( p, r.x(), r.y(), r.width(), r.height(), *tqcolorGroup( g, widget ), true, false, highlightWidth( widget ), borderWidth( widget ), shade() ); } handled = true; break; } case PE_ScrollBarAddLine: { bool horizontal = ( flags & Style_Horizontal ); drawBaseButton( p, r.x(), r.y(), r.width(), r.height(), *tqcolorGroup( g, down ? ScrollButtonDown : ScrollButton ), down, false, down ? ScrollButtonDown : ScrollButton ); tqdrawPrimitive( ( horizontal ) ? PE_ArrowRight : PE_ArrowDown, p , TQRect( r.x() + 3, r.y() + 3, r.width() - 6, r.height() - 6 ), *tqcolorGroup( g, down ? ScrollButtonDown : ScrollButton ), flags ); handled = true; break; } case PE_ScrollBarSubLine: { bool horizontal = ( flags & Style_Horizontal ); drawBaseButton( p, r.x(), r.y(), r.width(), r.height(), *tqcolorGroup( g, down ? ScrollButtonDown : ScrollButton ), down, false, down ? ScrollButtonDown : ScrollButton ); tqdrawPrimitive( ( horizontal ) ? PE_ArrowLeft : PE_ArrowUp, p , TQRect( r.x() + 3, r.y() + 3, r.width() - 6, r.height() - 6 ), *tqcolorGroup( g, down ? ScrollButtonDown : ScrollButton ), flags ); handled = true; break; } case PE_ScrollBarSlider: { bool active = ( flags & Style_Active ) || ( flags & Style_Down ); //activeControl == TQStyle::AddLine; bool horizontal = ( flags & Style_Horizontal ); int offsetH = horizontal ? 0: decoWidth(VScrollGroove) ; int offsetV = horizontal ? decoWidth(HScrollGroove):0; WidgetType widget = horizontal ? active ? HScrollBarSliderDown : HScrollBarSlider : active ? VScrollBarSliderDown : VScrollBarSlider; drawBaseButton( p, r.x()+offsetH, r.y()+offsetV, r.width()-2*offsetH, r.height()-2*offsetV, *tqcolorGroup( g, widget ), active, false, widget ); int spaceW = horizontal ? r.width() - decoWidth( widget ) - 4 : r.width(); int spaceH = horizontal ? r.height() : r.height() - decoWidth( widget ) - 4; widget = active ? horizontal ? HScrollDecoDown : VScrollDecoDown : horizontal ? HScrollDeco : VScrollDeco; if ( isPixmap( widget ) ) { if ( spaceW >= uncached( widget ) ->width() && spaceH >= uncached( widget ) ->height() ) { bitBlt( p->device(), r.x() + ( r.width() - uncached( widget ) ->width() ) / 2, r.y() + ( r.height() - uncached( widget ) ->height() ) / 2, uncached( widget ) ); } } handled = true; break; } default: handled = false; } if ( !handled ) KThemeBase::drawPrimitive ( pe, p, r, g, flags, opt ); } TQPixmap* KThemeStyle::makeMenuBarCache(int w, int h) const { if (menuCache) { if (menuCache->width() != w || menuCache->height() != h ) { delete menuCache; } else return menuCache; } const TQColorGroup *g = tqcolorGroup( TQApplication::tqpalette().active(), MenuBar); menuCache = new TQPixmap ( w, h ); TQPainter p(menuCache); drawBaseButton( &p, 0, 0, w, h, *g, false, false, MenuBar ); p.end(); return menuCache; } void KThemeStyle::tqdrawControl( ControlElement element, TQPainter *p, const TQWidget *widget, const TQRect &r, const TQColorGroup &cg, SFlags how , const TQStyleOption& opt ) const { bool handled = false; int x, y, w, h; r.rect( &x, &y, &w, &h ); switch ( element ) { case CE_PushButton: { const TQPushButton * btn = ( const TQPushButton* ) widget; bool sunken = btn->isOn() || btn->isDown(); int diw = tqpixelMetric( PM_ButtonDefaultIndicator, btn ); drawBaseButton( p, diw, diw, w - 2 * diw, h - 2 * diw, *tqcolorGroup( btn->tqcolorGroup(), sunken ? PushButtonDown : PushButton ), sunken, roundButton(), sunken ? PushButtonDown : PushButton ); // TODO if diw, draw fancy default button indicator handled = true; break; } case CE_PushButtonLabel: { const TQPushButton* button = ( const TQPushButton* ) widget; bool active = button->isOn() || button->isDown(); int x, y, w, h; r.rect( &x, &y, &w, &h ); // Shift button contents if pushed. if ( active ) { x += tqpixelMetric( PM_ButtonShiftHorizontal, widget ); y += tqpixelMetric( PM_ButtonShiftVertical, widget ); how |= Style_Sunken; } // Does the button have a popup menu? if ( button->isMenuButton() ) { int dx = tqpixelMetric( PM_MenuButtonIndicator, widget ); tqdrawPrimitive( PE_ArrowDown, p, TQRect( x + w - dx - 2, y + 2, dx, h - 4 ), cg, how, opt ); w -= dx; } // Draw the icon if there is one if ( button->iconSet() && !button->iconSet() ->isNull() ) { TQIconSet::Mode mode = TQIconSet::Disabled; TQIconSet::State state = TQIconSet::Off; if ( button->isEnabled() ) mode = button->hasFocus() ? TQIconSet::Active : TQIconSet::Normal; if ( button->isToggleButton() && button->isOn() ) state = TQIconSet::On; TQPixmap pixmap = button->iconSet() ->pixmap( TQIconSet::Small, mode, state ); // Center the iconset if there's no text or pixmap if (button->text().isEmpty() && !button->pixmap()) p->drawPixmap( x + (w - pixmap.width()) / 2, y + (h - pixmap.height()) / 2, pixmap ); else p->drawPixmap( x + 4, y + (h - pixmap.height()) / 2, pixmap ); int pw = pixmap.width(); x += pw + 4; w -= pw + 4; } // Make the label indicate if the button is a default button or not if ( active || button->isDefault() && button->isEnabled() ) { // Draw "fake" bold text - this enables the font metrics to remain // the same as computed in TQPushButton::tqsizeHint(), but gives // a reasonable bold effect. int i; // Text shadow for ( i = 0; i < 2; i++ ) drawItem( p, TQRect( x + i + 1, y + 1, w, h ), AlignCenter | ShowPrefix, button->tqcolorGroup(), button->isEnabled(), NULL, button->text(), -1, active ? &button->tqcolorGroup().dark() : &button->tqcolorGroup().mid() ); // Normal Text for ( i = 0; i < 2; i++ ) drawItem( p, TQRect( x + i, y, w, h ), AlignCenter | ShowPrefix, button->tqcolorGroup(), true, i == 0 ? button->pixmap() : NULL, button->text(), -1, active ? &button->tqcolorGroup().light() : &button->tqcolorGroup().buttonText() ); } else { if ( button->isEnabled() ) { drawItem( p, TQRect( x, y, w, h ), AlignCenter | ShowPrefix, button->tqcolorGroup(), true, button->pixmap(), button->text(), -1, active ? &button->tqcolorGroup().light() : &button->tqcolorGroup().buttonText() ); } else { //TODO: Handle reversed drawItem( p, TQRect( x + 1, y + 1, w, h ), AlignCenter | ShowPrefix, button->tqcolorGroup(), true, button->pixmap(), button->text(), -1, &button->tqcolorGroup().light() ); drawItem( p, TQRect( x, y, w, h ), AlignCenter | ShowPrefix, button->tqcolorGroup(), true, button->pixmap(), button->text(), -1, &button->tqcolorGroup().buttonText() ); } } // Draw a focus rect if the button has focus if ( how & Style_HasFocus ) tqdrawPrimitive( PE_FocusRect, p, TQStyle::tqvisualRect( subRect( SR_PushButtonFocusRect, widget ), widget ), cg, how ); handled = true; break; } case CE_MenuBarEmptyArea: { //Expand to cover entire region tqdrawPrimitive(PE_PanelMenuBar, p, TQRect(0,0,r.width()+r.x()*2, r.height()+r.y()*2), cg, Style_Default); handled = true; break; } case CE_TabBarTab: { const TQTabBar* tb = ( const TQTabBar* ) widget; TQTabBar::Shape tbs = tb->tqshape(); bool selected = how & Style_Selected; WidgetType widget = selected ? ActiveTab : InactiveTab; const TQColorGroup *cg = tqcolorGroup( tb->tqcolorGroup(), widget ); int i; int x2 = x + w - 1, y2 = y + h - 1; int bWidth = borderWidth( widget ); int hWidth = highlightWidth( widget ); handled = true; if ( tbs == TQTabBar::RoundedAbove || tbs == TQTabBar::TriangularAbove ) { if ( !selected ) { p->fillRect( x, y, x2 - x + 1, 2, tb->tqpalette().active().brush( TQColorGroup::Background ) ); y += 2; } p->setPen( cg->text() ); i = 0; if ( i < bWidth ) { p->drawLine( x, y + 1, x, y2 ); p->drawLine( x2, y + 1, x2, y2 ); p->drawLine( x + 1, y, x2 - 1, y ); if ( selected ? activeTabLine() : inactiveTabLine() ) { p->drawLine( x, y2, x2, y2 ); --y2; } ++i, ++x, ++y, --x2; } for ( ; i < bWidth; ++i, ++x, ++y, --x2 ) { p->drawLine( x, y, x, y2 ); p->drawLine( x2, y, x2, y2 ); p->drawLine( x, y, x2, y ); if ( selected ? activeTabLine() : inactiveTabLine() ) { p->drawLine( x, y2, x2, y2 ); --y2; } } i = 0; if ( i < hWidth && bWidth == 0 ) { p->setPen( cg->light() ); p->drawLine( x, y + 1, x, y2 ); p->drawLine( x + 1, y, x2 - 1, y ); p->setPen( cg->dark() ); p->drawLine( x2, y + 1, x2, y2 ); if ( selected ? activeTabLine() : inactiveTabLine() ) { p->drawLine( x, y2, x2, y2 ); --y2; } ++i, ++x, ++y, --x2; } for ( ; i < hWidth; ++i, ++x, ++y, --x2 ) { p->setPen( cg->light() ); p->drawLine( x, y, x, y2 ); p->drawLine( x, y, x2, y ); p->setPen( cg->dark() ); p->drawLine( x2, y + 1, x2, y2 ); if ( selected ? activeTabLine() : inactiveTabLine() ) { p->drawLine( x, y2, x2, y2 ); --y2; } } if ( isPixmap( widget ) ) p->drawTiledPixmap( x, y, x2 - x + 1, y2 - y + 1, *scalePixmap( x2 - x + 1, y2 - y + 1, widget ) ); else p->fillRect( x, y, x2 - x + 1, y2 - y + 1, cg->background() ); } else if ( tb->tqshape() == TQTabBar::RoundedBelow || tb->tqshape() == TQTabBar::TriangularBelow ) { if ( widget == ActiveTab ) widget = RotActiveTab; else widget = RotInactiveTab; if ( !selected ) { p->fillRect( x, y2 - 2, x2 - x + 1, 2, tb->tqpalette().active().brush( TQColorGroup::Background ) ); y2 -= 2; } p->setPen( cg->text() ); i = 0; if ( i < bWidth ) { p->drawLine( x, y, x, y2 - 1 ); p->drawLine( x2, y, x2, y2 - 1 ); p->drawLine( x + 1, y2, x2 - 1, y2 ); if ( selected ? activeTabLine() : inactiveTabLine() ) { p->drawLine( x, y, x2, y ); ++y; } } for ( ; i < bWidth; ++i, ++x, --x2, --y2 ) { p->drawLine( x, y, x, y2 ); p->drawLine( x2, y, x2, y2 ); p->drawLine( x, y2, x2, y2 ); if ( selected ? activeTabLine() : inactiveTabLine() ) { p->drawLine( x, y, x2, y ); ++y; } } i = 0; if ( i < hWidth && bWidth == 0 ) { p->setPen( cg->dark() ); p->drawLine( x + 1, y2, x2 - 1, y2 ); p->drawLine( x2, y, x2, y2 - 1 ); p->setPen( cg->light() ); p->drawLine( x, y, x, y2 - 1 ); if ( selected ? activeTabLine() : inactiveTabLine() ) { p->drawLine( x, y, x2, y ); ++y; } ++i, ++x, --x2, --y2; } for ( ; i < hWidth; ++i, ++x, --x2, --y2 ) { p->setPen( cg->dark() ); p->drawLine( x, y2, x2, y2 ); p->drawLine( x2, y, x2, y2 ); p->setPen( cg->light() ); p->drawLine( x, y, x, y2 ); if ( selected ? activeTabLine() : inactiveTabLine() ) { p->drawLine( x, y, x2, y ); ++y; } } if ( isPixmap( widget ) ) p->drawTiledPixmap( x, y, x2 - x + 1, y2 - y + 1, *scalePixmap( x2 - x + 1, y2 - y + 1, widget ) ); else p->fillRect( x, y, x2 - x + 1, y2 - y + 1, cg->background() ); } break; } case CE_MenuBarItem: { r.rect( &x, &y, &w, &h ); TQMenuItem *mi = opt.menuItem(); TQMenuBar *mb = ( TQMenuBar* ) widget; TQRect pr = mb->rect(); bool active = how & Style_Active; //bool focused = how & Style_HasFocus; const TQColorGroup *g = tqcolorGroup( cg, active ? MenuBarItem : MenuBar ); TQColor btext = g->buttonText(); TQPixmap* cache = makeMenuBarCache(pr.width(), pr.height()); TQPixmap buf( w, pr.height() ); bitBlt(&buf, 0, 0, cache, x, y, w, pr.height()); TQPainter p2( &buf ); if ( active ) { drawBaseButton( &p2, 0, 0, w, h, *g, false, false, MenuBarItem ); } p2.end(); p->drawPixmap( x, y, buf, 0, 0, w, h ); drawItem( p, TQRect(x,y,w,h), AlignCenter | AlignVCenter | ShowPrefix | DontClip | SingleLine, *g, mi->isEnabled(), mi->pixmap(), mi->text(), -1, &btext ); handled = true; break; } case CE_PopupMenuItem: { bool separator = false; int x, y, w, h; r.rect( &x, &y, &w, &h ); const TQPopupMenu *popupmenu = ( const TQPopupMenu * ) widget; TQMenuItem *mi = opt.menuItem(); if ( mi ) { separator = mi->isSeparator(); } int tab = opt.tabWidth(); int checkcol = opt.maxIconWidth(); bool enabled = (mi? mi->isEnabled():true); bool checkable = popupmenu->isCheckable(); bool active = how & Style_Active; bool etchtext = tqstyleHint( SH_EtchDisabledText, 0 ); bool reverse = TQApplication::reverseLayout(); const TQColorGroup& cg_ours = *tqcolorGroup( cg, active ? MenuItemDown : MenuItem ); //TQColor btext = cg_ours.buttonText(); if ( checkable ) checkcol = QMAX( checkcol, 20 ); // Are we a menu item separator? if ( separator ) { p->setPen( cg_ours.dark() ); p->drawLine( x, y, x + w, y ); p->setPen( cg_ours.light() ); p->drawLine( x, y + 1, x + w, y + 1 ); break; } // Draw the menu item background if ( active ) drawBaseButton( p, x, y, w, h, cg_ours, true, false, MenuItemDown ); else { drawShade( p, x, y, w, h, *tqcolorGroup( cg_ours, MenuItem ), false, false, highlightWidth( MenuItem ), borderWidth( MenuItem ), shade() ); int dw = decoWidth( MenuItem ); if ( !isPixmap( MenuItem ) ) { p->fillRect( x + dw, y + dw, w - dw * 2, h - dw * 2, cg_ours.brush( TQColorGroup::Background ) ); //cg.brush( TQColorGroup::Background )); //tqcolorGroup( cg_ours, MenuItem ) ->brush( TQColorGroup::Background ) ); } else { // process inactive item pixmaps as one large item p->drawTiledPixmap( x + dw, y + dw, w - dw * 2, h - dw * 2, *scalePixmap ( w, p->window().height(), MenuItem ), x, y ); } } if (!mi) break; // Do we have an icon? if ( mi->iconSet() ) { TQIconSet::Mode mode; TQRect cr = tqvisualRect( TQRect( x, y, checkcol, h ), r ); // Select the correct icon from the iconset if ( active ) mode = enabled ? TQIconSet::Active : TQIconSet::Disabled; else mode = enabled ? TQIconSet::Normal : TQIconSet::Disabled; // Do we have an icon and are checked at the same time? // Then draw a "pressed" background behind the icon if ( checkable && mi->isChecked() ) //!active && -- ?? drawBaseButton( p, cr.x(), cr.y(), cr.width(), cr.height(), *tqcolorGroup( cg_ours, BevelDown ), true, false, BevelDown ); // Draw the icon TQPixmap pixmap = mi->iconSet() ->pixmap( TQIconSet::Small, mode ); int pixw = pixmap.width(); int pixh = pixmap.height(); TQRect pmr( 0, 0, pixw, pixh ); pmr.moveCenter( cr.center() ); p->setPen( cg_ours.highlightedText() ); p->drawPixmap( pmr.topLeft(), pixmap ); } // Are we checked? (This time without an icon) else if ( checkable && mi->isChecked() ) { int cx = reverse ? x + w - checkcol : x; // We only have to draw the background if the menu item is inactive - // if it's active the "pressed" background is already drawn //if ( ! active ) // qDrawShadePanel( p, cx, y, checkcol, h, cg_ours, true, 1, // &cg_ours.brush(TQColorGroup::Midlight) ); // Draw the checkmark SFlags cflags = Style_Default; cflags |= active ? Style_Enabled : Style_On; tqdrawPrimitive( PE_CheckMark, p, TQRect( cx + itemFrame, y + itemFrame, checkcol - itemFrame * 2, h - itemFrame * 2 ), cg_ours, cflags ); } // Time to draw the menu item label... int xm = itemFrame + checkcol + itemHMargin; // X position margin int xp = reverse ? // X position x + tab + rightBorder + itemHMargin + itemFrame - 1 : x + xm; int offset = reverse ? -1 : 1; // Shadow offset for etched text // Label width (minus the width of the accelerator portion) int tw = w - xm - tab - arrowHMargin - itemHMargin * 3 - itemFrame + 1; // Set the color for enabled and disabled text // (used for both active and inactive menu items) p->setPen( enabled ? cg_ours.buttonText() : cg_ours.mid() ); // This color will be used instead of the above if the menu item // is active and disabled at the same time. (etched text) TQColor discol = cg_ours.mid(); // Does the menu item draw it's own label? if ( mi->custom() ) { int m = itemVMargin; // Save the painter state in case the custom // paint method changes it in some way p->save(); // Draw etched text if we're inactive and the menu item is disabled if ( etchtext && !enabled && !active ) { p->setPen( cg_ours.light() ); mi->custom() ->paint( p, cg_ours, active, enabled, xp + offset, y + m + 1, tw, h - 2 * m ); p->setPen( discol ); } mi->custom() ->paint( p, cg_ours, active, enabled, xp, y + m, tw, h - 2 * m ); p->restore(); } else { // The menu item doesn't draw it's own label TQString s = mi->text(); // Does the menu item have a text label? if ( !s.isNull() ) { int t = s.tqfind( '\t' ); int m = itemVMargin; int text_flags = AlignVCenter | ShowPrefix | DontClip | SingleLine; text_flags |= reverse ? AlignRight : AlignLeft; // Does the menu item have a tabstop? (for the accelerator text) if ( t >= 0 ) { int tabx = reverse ? x + rightBorder + itemHMargin + itemFrame : x + w - tab - rightBorder - itemHMargin - itemFrame; // Draw the right part of the label (accelerator text) if ( etchtext && !enabled && !active ) { // Draw etched text if we're inactive and the menu item is disabled p->setPen( cg_ours.light() ); p->drawText( tabx + offset, y + m + 1, tab, h - 2 * m, text_flags, s.mid( t + 1 ) ); p->setPen( discol ); } p->drawText( tabx, y + m, tab, h - 2 * m, text_flags, s.mid( t + 1 ) ); s = s.left( t ); } // Draw the left part of the label (or the whole label // if there's no accelerator) if ( etchtext && !enabled && !active ) { // Etched text again for inactive disabled menu items... p->setPen( cg_ours.light() ); p->drawText( xp + offset, y + m + 1, tw, h - 2 * m, text_flags, s, t ); p->setPen( discol ); } p->drawText( xp, y + m, tw, h - 2 * m, text_flags, s, t ); } // The menu item doesn't have a text label // Check if it has a pixmap instead else if ( mi->pixmap() ) { TQPixmap * pixmap = mi->pixmap(); // Draw the pixmap if ( pixmap->depth() == 1 ) p->setBackgroundMode( Qt::OpaqueMode ); int diffw = ( ( w - pixmap->width() ) / 2 ) + ( ( w - pixmap->width() ) % 2 ); p->drawPixmap( x + diffw, y + itemFrame, *pixmap ); if ( pixmap->depth() == 1 ) p->setBackgroundMode( Qt::TransparentMode ); } } // Does the menu item have a submenu? if ( mi->popup() ) { PrimitiveElement arrow = reverse ? PE_ArrowLeft : PE_ArrowRight; int dim = 10 - itemFrame; //We're not very useful to inherit off, so just hardcode.. TQRect vr = tqvisualRect( TQRect( x + w - arrowHMargin - itemFrame - dim, y + h / 2 - dim / 2, dim, dim ), r ); // Draw an arrow at the far end of the menu item if ( active ) { if ( enabled ) discol = cg_ours.buttonText(); TQColorGroup g2( discol, cg_ours.highlight(), white, white, enabled ? white : discol, discol, white ); tqdrawPrimitive( arrow, p, vr, g2, Style_Enabled | Style_Down ); } else tqdrawPrimitive( arrow, p, vr, cg_ours, enabled ? Style_Enabled : Style_Default ); } handled = true; break; } case CE_ProgressBarGroove: { TQBrush bg; const TQColorGroup * cg2 = tqcolorGroup( cg, ProgressBg ); qDrawWinPanel( p, r, *cg2, true ); bg.setColor( cg2->color( TQColorGroup::Background ) ); if ( isPixmap( ProgressBg ) ) bg.setPixmap( *uncached( ProgressBg ) ); p->fillRect( x + 2, y + 2, w - 4, h - 4, bg ); handled = true; break; } case CE_ProgressBarContents: { const TQProgressBar* pb = (const TQProgressBar*)widget; TQRect cr = subRect(SR_ProgressBarContents, widget); double progress = pb->progress(); bool reverse = TQApplication::reverseLayout(); int steps = pb->totalSteps(); int pstep = 0; if (!cr.isValid()) return; // Draw progress bar if (progress > 0 || steps == 0) { double pg = (steps == 0) ? 0.1 : progress / steps; int width = QMIN(cr.width(), (int)(pg * cr.width())); if (steps == 0) { //Busy indicator if (width < 1) width = 1; //A busy indicator with width 0 is kind of useless int remWidth = cr.width() - width; //Never disappear completely if (remWidth <= 0) remWidth = 1; //Do something non-crashy when too small... pstep = int(progress) % ( 2 * remWidth ); if ( pstep > remWidth ) { //Bounce about.. We're remWidth + some delta, we want to be remWidth - delta... // - ( (remWidth + some delta) - 2* remWidth ) = - (some deleta - remWidth) = remWidth - some delta.. pstep = - (pstep - 2 * remWidth ); } } if ( !reverse ) drawBaseButton( p, x + pstep, y, width, h, *tqcolorGroup( cg, ProgressBar ), false, false, ProgressBar ); else { //TODO:Optimize TQPixmap buf( width, h ); TQPainter p2( &buf ); drawBaseButton( &p2, 0, 0, width, h, *tqcolorGroup( cg, ProgressBar ), false, false, ProgressBar ); p2.end(); TQPixmap mirroredPix = TQPixmap( TQImage(buf.convertToImage()).mirror( true, false ) ); bitBlt( p->device(), x + w - width - pstep, y, &mirroredPix ); } } handled = true; break; } default: handled = false; }; if ( !handled ) KThemeBase::tqdrawControl( element, p, widget, r, cg, how, opt ); } void KThemeStyle::tqdrawControlMask( ControlElement element, TQPainter *p, const TQWidget *widget, const TQRect &r, const TQStyleOption& opt ) const { bool handled = false; int x, y, w, h; r.rect( &x, &y, &w, &h ); switch ( element ) { case CE_PushButton: { //Is this correct? drawBaseMask( p, x, y, w, h, roundButton() ); handled = true; break; } default: handled = false; }; if ( !handled ) KThemeBase::tqdrawControlMask( element, p, widget, r, opt ); } void KThemeStyle::drawKStylePrimitive( KStylePrimitive kpe, TQPainter* p, const TQWidget* widget, const TQRect &r, const TQColorGroup &cg, SFlags flags, const TQStyleOption& opt ) const { bool handled = false; int x, y, w, h; r.rect( &x, &y, &w, &h ); switch ( kpe ) { case KPE_SliderGroove: { if ( !roundSlider() ) { const TQSlider * slider = ( const TQSlider* ) widget; bool horizontal = slider->orientation() == Qt::Horizontal; if ( horizontal ) { drawBaseButton( p, x, y, w, h, *tqcolorGroup( cg, SliderGroove ), true, false, SliderGroove ); } else { drawBaseButton( p, x, y, w, h, *tqcolorGroup( cg, RotSliderGroove ), true, false, RotSliderGroove ); } } else { //This code is from HighColorDefault.. const TQSlider* slider = ( const TQSlider* ) widget; bool horizontal = slider->orientation() == Qt::Horizontal; int gcenter = ( horizontal ? r.height() : r.width() ) / 2; TQRect gr; if ( horizontal ) gr = TQRect( r.x(), r.y() + gcenter - 3, r.width(), 7 ); else gr = TQRect( r.x() + gcenter - 3, r.y(), 7, r.height() ); int x, y, w, h; gr.rect( &x, &y, &w, &h ); int x2 = x + w - 1; int y2 = y + h - 1; // Draw the slider groove. p->setPen( cg.dark() ); p->drawLine( x + 2, y, x2 - 2, y ); p->drawLine( x, y + 2, x, y2 - 2 ); p->fillRect( x + 2, y + 2, w - 4, h - 4, slider->isEnabled() ? cg.dark() : cg.mid() ); p->setPen( cg.shadow() ); p->drawRect( x + 1, y + 1, w - 2, h - 2 ); p->setPen( cg.light() ); p->drawPoint( x + 1, y2 - 1 ); p->drawPoint( x2 - 1, y2 - 1 ); p->drawLine( x2, y + 2, x2, y2 - 2 ); p->drawLine( x + 2, y2, x2 - 2, y2 ); } handled = true; break; } case KPE_SliderHandle: { if ( isPixmap( Slider ) ) { const TQSlider * slider = ( const TQSlider* ) widget; bool horizontal = slider->orientation() == Qt::Horizontal; if ( horizontal ) { bitBlt( p->device(), x, y + ( h - uncached( Slider ) ->height() ) / 2, uncached( Slider ) ); } else { if ( !vsliderCache ) { TQWMatrix r270; r270.rotate( 270 ); vsliderCache = new TQPixmap( uncached( Slider ) ->xForm( r270 ) ); if ( uncached( Slider ) ->tqmask() ) vsliderCache->setMask( uncached( Slider ) ->tqmask() ->xForm( r270 ) ); } bitBlt( p->device(), x + ( w - vsliderCache->width() ) / 2, y, vsliderCache ); } } else { //This code again from HighColor.. //...except sans the gradient.. const TQSlider* slider = ( const TQSlider* ) widget; bool horizontal = slider->orientation() == Qt::Horizontal; int x, y, w, h; r.rect( &x, &y, &w, &h ); int x2 = x + w - 1; int y2 = y + h - 1; p->setPen( cg.mid() ); p->drawLine( x + 1, y, x2 - 1, y ); p->drawLine( x, y + 1, x, y2 - 1 ); p->setPen( cg.shadow() ); p->drawLine( x + 1, y2, x2 - 1, y2 ); p->drawLine( x2, y + 1, x2, y2 - 1 ); p->setPen( cg.light() ); p->drawLine( x + 1, y + 1, x2 - 1, y + 1 ); p->drawLine( x + 1, y + 1, x + 1, y2 - 1 ); p->setPen( cg.dark() ); p->drawLine( x + 2, y2 - 1, x2 - 1, y2 - 1 ); p->drawLine( x2 - 1, y + 2, x2 - 1, y2 - 1 ); p->setPen( cg.midlight() ); p->drawLine( x + 2, y + 2, x2 - 2, y + 2 ); p->drawLine( x + 2, y + 2, x + 2, y2 - 2 ); p->setPen( cg.mid() ); p->drawLine( x + 3, y2 - 2, x2 - 2, y2 - 2 ); p->drawLine( x2 - 2, y + 3, x2 - 2, y2 - 2 ); p->fillRect( TQRect( x + 3, y + 3, w - 6, h - 6 ), cg.button() ); // Paint riffles if ( horizontal ) { p->setPen( cg.light() ); p->drawLine( x + 5, y + 4, x + 5, y2 - 4 ); p->drawLine( x + 8, y + 4, x + 8, y2 - 4 ); p->drawLine( x + 11, y + 4, x + 11, y2 - 4 ); p->setPen( slider->isEnabled() ? cg.shadow() : cg.mid() ); p->drawLine( x + 6, y + 4, x + 6, y2 - 4 ); p->drawLine( x + 9, y + 4, x + 9, y2 - 4 ); p->drawLine( x + 12, y + 4, x + 12, y2 - 4 ); } else { p->setPen( cg.light() ); p->drawLine( x + 4, y + 5, x2 - 4, y + 5 ); p->drawLine( x + 4, y + 8, x2 - 4, y + 8 ); p->drawLine( x + 4, y + 11, x2 - 4, y + 11 ); p->setPen( slider->isEnabled() ? cg.shadow() : cg.mid() ); p->drawLine( x + 4, y + 6, x2 - 4, y + 6 ); p->drawLine( x + 4, y + 9, x2 - 4, y + 9 ); p->drawLine( x + 4, y + 12, x2 - 4, y + 12 ); } } handled = true; break; } //case KPE_DockWindowHandle: case KPE_ToolBarHandle: case KPE_GeneralHandle: { if ( w > h ) drawBaseButton( p, x, y, w, h, *tqcolorGroup( cg, HBarHandle ), false, false, HBarHandle ); else drawBaseButton( p, x, y, w, h, *tqcolorGroup( cg, VBarHandle ), false, false, VBarHandle ); handled = true; break; } default: handled = false; } if ( !handled ) { KThemeBase::drawKStylePrimitive( kpe, p, widget, r, cg, flags, opt ); } } void KThemeStyle::tqdrawComplexControl ( TQ_ComplexControl control, TQPainter * p, const TQWidget * widget, const TQRect & r, const TQColorGroup & g, SFlags how , SCFlags controls, SCFlags active, const TQStyleOption & opt ) const { bool handled = false; int x, y, w, h; r.rect( &x, &y, &w, &h ); bool down = how & Style_Down; bool on = how & Style_On; // bool enabled = ( how & Style_Enabled ); switch ( control ) { case CC_ToolButton: { const TQToolButton * toolbutton = ( const TQToolButton * ) widget; TQRect button, menu; button = querySubControlMetrics( control, widget, SC_ToolButton, opt ); menu = querySubControlMetrics( control, widget, SC_ToolButtonMenu, opt ); if ( controls & SC_ToolButton ) { WidgetType widget = ( down || on ) ? ToolButtonDown : ToolButton; drawBaseButton( p, button.x(), button.y(), button.width(), button.height(), *tqcolorGroup( g, widget ), down || on, false, widget ); // int m = decoWidth( widget ); } if ( controls & SC_ToolButtonMenu ) { tqdrawPrimitive( PE_ArrowDown, p, menu, g, how ); /* if ( enabled ) kDrawWindowsArrow(p, this, PE_ArrowDown, false, menu.x(), menu.y(), menu.width(), menu.height(), g, true ); else kDrawWindowsArrow(p, this, PE_ArrowDown, false, menu.x(), menu.y(), menu.width(), menu.height(), g, false );*/ } if ( toolbutton->hasFocus() && !toolbutton->focusProxy() ) { TQRect fr = toolbutton->rect(); fr.addCoords( 3, 3, -3, -3 ); tqdrawPrimitive( PE_FocusRect, p, fr, g ); } handled = true; break; } case CC_ComboBox: { if ( controls & SC_ComboBoxFrame ) { //TODO: Anyway of detecting when the popup is there -- would look nicer if sunken then too.. bool sunken = ( active == SC_ComboBoxArrow ); //No frame, edit box and button for now? WidgetType widget = sunken ? ComboBoxDown : ComboBox; drawBaseButton( p, x, y, w, h, *tqcolorGroup( g, widget ), sunken, roundComboBox(), widget ); controls ^= SC_ComboBoxFrame; } if ( controls & SC_ComboBoxArrow ) { bool sunken = ( active == SC_ComboBoxArrow ); TQRect ar = TQStyle::tqvisualRect( querySubControlMetrics( CC_ComboBox, widget, SC_ComboBoxArrow ), widget ); ar.rect( &x, &y, &w, &h ); WidgetType widget = sunken ? ComboBoxDown : ComboBox; if ( !sunken && isPixmap( ComboDeco ) ) bitBlt( p->device(), x + ( w - uncached( ComboDeco ) ->width() - decoWidth( ComboBox ) / 2 ), y + ( h - uncached( ComboDeco ) ->height() ) / 2, uncached( ComboDeco ) ); else if ( sunken && isPixmap( ComboDecoDown ) ) bitBlt( p->device(), x + ( w - uncached( ComboDecoDown ) ->width() - decoWidth( ComboBoxDown ) ) / 2, y + ( h - uncached( ComboDecoDown ) ->height() ) / 2, uncached( ComboDecoDown ) ); else { mtfstyle->tqdrawPrimitive( PE_ArrowDown, p, TQRect( x, y, w, h ), *tqcolorGroup( g, widget ), sunken ? ( how | Style_Sunken ) : how, opt ); qDrawShadeRect( p, x, y, w, h, *tqcolorGroup( g, widget ) ); //w-14, y+7+(h-15), 10, 3, } controls ^= SC_ComboBoxArrow; } break; } case CC_ScrollBar: { const TQScrollBar *sb = ( const TQScrollBar* ) widget; bool maxedOut = ( sb->minValue() == sb->maxValue() ); bool horizontal = ( sb->orientation() == Qt::Horizontal ); SFlags sflags = ( ( horizontal ? Style_Horizontal : Style_Default ) | ( maxedOut ? Style_Default : Style_Enabled ) ); //Here, we don't do add page, subpage, etc., TQRect addline, subline, subline2, groove, slider; subline = querySubControlMetrics( control, widget, SC_ScrollBarSubLine, opt ); addline = querySubControlMetrics( control, widget, SC_ScrollBarAddLine, opt ); groove = querySubControlMetrics( control, widget, SC_ScrollBarGroove, opt ); slider = querySubControlMetrics( control, widget, SC_ScrollBarSlider, opt ); subline2 = addline; TQPixmap buf( sb->width(), sb->height() ); TQPainter p2( &buf ); if ( groove.isValid() ) { p2.fillRect( groove, TQColor( 255, 0, 0 ) ); tqdrawPrimitive( PE_ScrollBarSubPage, &p2, groove, g, sflags | ( ( active == SC_ScrollBarSubPage ) ? Style_Down : Style_Default ) ); } // Draw the up/left button set if ( subline.isValid() ) { tqdrawPrimitive( PE_ScrollBarSubLine, &p2, subline, g, sflags | ( active == SC_ScrollBarSubLine ? Style_Down : Style_Default ) ); } if ( addline.isValid() ) tqdrawPrimitive( PE_ScrollBarAddLine, &p2, addline, g, sflags | ( ( active == SC_ScrollBarAddLine ) ? Style_Down : Style_Default ) ); if ( slider.isValid() ) { //(controls & SC_ScrollBarSlider) && tqdrawPrimitive( PE_ScrollBarSlider, &p2, slider, g, sflags | ( ( active == SC_ScrollBarSlider ) ? Style_Down : Style_Default ) ); // Draw focus rect if ( sb->hasFocus() ) { TQRect fr( slider.x() + 2, slider.y() + 2, slider.width() - 5, slider.height() - 5 ); tqdrawPrimitive( PE_FocusRect, &p2, fr, g, Style_Default ); } p2.end(); bitBlt( p->device(), x, y, &buf ); handled = true; } break; } default: handled = false; } if ( !handled ) { KThemeBase::tqdrawComplexControl ( control, p, widget, r, g, how , controls, active, opt ); } } void KThemeStyle::drawBaseMask( TQPainter *p, int x, int y, int w, int h, bool round ) const { // round edge fills static const TQCOORD btm_left_fill[] = { 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 0, 1, 1, 1, 2, 1, 3, 1, 4, 1, 1, 2, 2, 2, 3, 2, 4, 2, 2, 3, 3, 3, 4, 3, 3, 4, 4, 4 }; static const TQCOORD btm_right_fill[] = { 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 0, 1, 1, 1, 2, 1, 3, 1, 4, 1, 0, 2, 1, 2, 2, 2, 3, 2, 0, 3, 1, 3, 2, 3, 0, 4, 1, 4 }; static const TQCOORD top_left_fill[] = { 3, 0, 4, 0, 2, 1, 3, 1, 4, 1, 1, 2, 2, 2, 3, 2, 4, 2, 0, 3, 1, 3, 2, 3, 3, 3, 4, 3, 0, 4, 1, 4, 2, 4, 3, 4, 4, 4 }; static const TQCOORD top_right_fill[] = { 0, 0, 1, 0, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 2, 2, 3, 2, 0, 3, 1, 3, 2, 3, 3, 3, 4, 3, 0, 4, 1, 4, 2, 4, 3, 4, 4, 4 }; TQBrush fillBrush( color1, SolidPattern ); p->setPen( color1 ); if ( round && w > 19 && h > 19 ) { int x2 = x + w - 1; int y2 = y + h - 1; TQPointArray a( TQCOORDARRLEN( top_left_fill ), top_left_fill ); a.translate( 1, 1 ); p->drawPoints( a ); a.setPoints( TQCOORDARRLEN( btm_left_fill ), btm_left_fill ); a.translate( 1, h - 6 ); p->drawPoints( a ); a.setPoints( TQCOORDARRLEN( top_right_fill ), top_right_fill ); a.translate( w - 6, 1 ); p->drawPoints( a ); a.setPoints( TQCOORDARRLEN( btm_right_fill ), btm_right_fill ); a.translate( w - 6, h - 6 ); p->drawPoints( a ); p->fillRect( x + 6, y, w - 12, h, fillBrush ); p->fillRect( x, y + 6, x + 6, h - 12, fillBrush ); p->fillRect( x2 - 6, y + 6, x2, h - 12, fillBrush ); p->drawLine( x + 6, y, x2 - 6, y ); p->drawLine( x + 6, y2, x2 - 6, y2 ); p->drawLine( x, y + 6, x, y2 - 6 ); p->drawLine( x2, y + 6, x2, y2 - 6 ); } else p->fillRect( x, y, w, h, fillBrush ); } int KThemeStyle::tqstyleHint( StyleHint sh, const TQWidget *w, const TQStyleOption &opt, QStyleHintReturn *shr ) const { switch ( sh ) { case SH_EtchDisabledText: case SH_Slider_SnapToValue: case SH_PrintDialog_RightAlignButtons: case SH_FontDialog_SelectAssociatedText: case SH_PopupMenu_AllowActiveAndDisabled: case SH_MenuBar_AltKeyNavigation: case SH_MenuBar_MouseTracking: case SH_PopupMenu_MouseTracking: case SH_ComboBox_ListMouseTracking: return 1; case SH_GUIStyle: return WindowsStyle; case SH_ScrollBar_BackgroundMode: return NoBackground; default: return KThemeBase::tqstyleHint( sh, w, opt, shr ); }; } /* This is where we draw the borders and highlights. The new round button * code is a pain in the arse. We don't want to be calculating arcs so * use a whole lotta QPointArray's ;-) The code is made a lot more complex * because you can have variable width border and highlights... * I may want to cache this if round buttons are used, but am concerned * about excessive cache misses. This is a memory/speed tradeoff that I * have to test. */ void KThemeStyle::drawShade( TQPainter *p, int x, int y, int w, int h, const TQColorGroup &g, bool sunken, bool rounded, int hWidth, int bWidth, ShadeStyle style ) const { int i, sc, bc, x2, y2; TQPen highPen, lowPen; if ( style == Motif ) { highPen.setColor( sunken ? g.dark() : g.light() ); lowPen.setColor( sunken ? g.light() : g.dark() ); } else { highPen.setColor( sunken ? g.shadow() : g.light() ); lowPen.setColor( sunken ? g.light() : g.shadow() ); } // Advanced round buttons if ( rounded && w > 19 && h > 19 ) { x2 = x + w - 1, y2 = y + h - 1; TQPointArray bPntArray, hPntArray, lPntArray; TQPointArray bLineArray, hLineArray, lLineArray; // borders for ( i = 0, bc = 0; i < bWidth; ++i ) { bPntArray.putPoints( bc, 24, x + 4, y + 1, x + 5, y + 1, x + 3, y + 2, x + 2, y + 3, x + 1, y + 4, x + 1, y + 5, x + 1, y2 - 5, x + 1, y2 - 4, x + 2, y2 - 3, x2 - 5, y + 1, x2 - 4, y + 1, x2 - 3, y + 2, x2 - 5, y2 - 1, x2 - 4, y2 - 1, x2 - 3, y2 - 2, x2 - 2, y2 - 3, x2 - 1, y2 - 5, x2 - 1, y2 - 4, x + 3, y2 - 2, x + 4, y2 - 1, x + 5, y2 - 1, x2 - 2, y + 3, x2 - 1, y + 4, x2 - 1, y + 5 ); bc += 24; // ellispe edges don't match exactly, so fill in blanks if ( i < bWidth - 1 || hWidth != 0 ) { bPntArray.putPoints( bc, 20, x + 6, y + 1, x + 4, y + 2, x + 3, y + 3, x + 2, y + 4, x + 1, y + 6, x2 - 6, y + 1, x2 - 4, y + 2, x2 - 3, y + 3, x + 2, y2 - 4, x + 1, y2 - 6, x2 - 6, y2 - 1, x2 - 4, y2 - 2, x2 - 3, y2 - 3, x2 - 2, y2 - 4, x2 - 1, y2 - 6, x + 6, y2 - 1, x + 4, y2 - 2, x + 3, y2 - 3, x2 - 1, y + 6, x2 - 2, y + 4 ); bc += 20; } bLineArray.putPoints( i * 8, 8, x + 6, y, x2 - 6, y, x, y + 6, x, y2 - 6, x + 6, y2, x2 - 6, y2, x2, y + 6, x2, y2 - 6 ); ++x, ++y; --x2, --y2; } // highlights for ( i = 0, sc = 0; i < hWidth; ++i ) { hPntArray.putPoints( sc, 12, x + 4, y + 1, x + 5, y + 1, // top left x + 3, y + 2, x + 2, y + 3, x + 1, y + 4, x + 1, y + 5, x + 1, y2 - 5, x + 1, y2 - 4, x + 2, y2 - 3, // half corners x2 - 5, y + 1, x2 - 4, y + 1, x2 - 3, y + 2 ); lPntArray.putPoints( sc, 12, x2 - 5, y2 - 1, x2 - 4, y2 - 1, // btm right x2 - 3, y2 - 2, x2 - 2, y2 - 3, x2 - 1, y2 - 5, x2 - 1, y2 - 4, x + 3, y2 - 2, x + 4, y2 - 1, x + 5, y2 - 1, //half corners x2 - 2, y + 3, x2 - 1, y + 4, x2 - 1, y + 5 ); sc += 12; if ( i < hWidth - 1 ) { hPntArray.putPoints( sc, 10, x + 6, y + 1, x + 4, y + 2, // top left x + 3, y + 3, x + 2, y + 4, x + 1, y + 6, x2 - 6, y + 1, x2 - 4, y + 2, // half corners x2 - 3, y + 3, x + 2, y2 - 4, x + 1, y2 - 6 ); lPntArray.putPoints( sc, 10, x2 - 6, y2 - 1, x2 - 4, y2 - 2, // btm right x2 - 3, y2 - 3, x2 - 2, y2 - 4, x2 - 1, y2 - 6, x + 6, y2 - 1, x + 4, y2 - 2, // half corners x + 3, y2 - 3, x2 - 1, y + 6, x2 - 2, y + 4 ); sc += 10; } hLineArray.putPoints( i * 4, 4, x + 6, y, x2 - 6, y, x, y + 6, x, y2 - 6 ); lLineArray.putPoints( i * 4, 4, x + 6, y2, x2 - 6, y2, x2, y + 6, x2, y2 - 6 ); ++x, ++y; --x2, --y2; } p->setPen( Qt::black ); p->drawPoints( bPntArray ); p->drawLineSegments( bLineArray ); p->setPen( highPen ); p->drawPoints( hPntArray ); p->drawLineSegments( hLineArray ); p->setPen( lowPen ); p->drawPoints( lPntArray ); p->drawLineSegments( lLineArray ); } // Rectangular buttons else { TQPointArray highShade( hWidth * 4 ); TQPointArray lowShade( hWidth * 4 ); p->setPen( g.shadow() ); for ( i = 0; i < bWidth && w > 2 && h > 2; ++i, ++x, ++y, w -= 2, h -= 2 ) p->drawRect( x, y , w, h ); if ( !hWidth ) return ; x2 = x + w - 1, y2 = y + h - 1; for ( i = 0; i < hWidth; ++i, ++x, ++y, --x2, --y2 ) { highShade.putPoints( i * 4, 4, x, y, x2, y, x, y, x, y2 ); lowShade.putPoints( i * 4, 4, x, y2, x2, y2, x2, y, x2, y2 ); } if ( style == Windows && hWidth > 1 ) { p->setPen( highPen ); p->drawLineSegments( highShade, 0, 2 ); p->setPen( lowPen ); p->drawLineSegments( lowShade, 0, 2 ); p->setPen( ( sunken ) ? g.dark() : g.mid() ); p->drawLineSegments( highShade, 4 ); p->setPen( ( sunken ) ? g.mid() : g.dark() ); p->drawLineSegments( lowShade, 4 ); } else { p->setPen( ( sunken ) ? g.dark() : g.light() ); p->drawLineSegments( highShade ); p->setPen( ( sunken ) ? g.light() : g.dark() ); p->drawLineSegments( lowShade ); } } } int KThemeStyle::popupMenuItemHeight( bool /*checkable*/, TQMenuItem *mi, const TQFontMetrics &fm ) { int h2, h = 0; int offset = QMAX( decoWidth( MenuItemDown ), decoWidth( MenuItem ) ) + 4; if ( mi->isSeparator() ) return ( 2 ); if ( mi->isChecked() ) h = isPixmap( CheckMark ) ? uncached( CheckMark ) ->height() + offset : offset + 16; if ( mi->pixmap() ) { h2 = mi->pixmap() ->height() + offset; h = h2 > h ? h2 : h; } if ( mi->iconSet() ) { h2 = mi->iconSet() -> pixmap( TQIconSet::Small, TQIconSet::Normal ).height() + offset; h = h2 > h ? h2 : h; } h2 = fm.height() + offset; h = h2 > h ? h2 : h; return ( h ); } #include "kthemestyle.moc" // kate: indent-width 4; replace-tabs off; tab-width 4; space-indent on;