diff --git a/kstyle/breezehelper.cpp b/kstyle/breezehelper.cpp index 08d93a73..0b470233 100644 --- a/kstyle/breezehelper.cpp +++ b/kstyle/breezehelper.cpp @@ -1,1648 +1,1607 @@ /************************************************************************* * Copyright (C) 2014 by Hugo Pereira Da Costa * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program 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 General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . * *************************************************************************/ #include "breezehelper.h" #include "breeze.h" #include "breezestyleconfigdata.h" #include #include #include #include #if BREEZE_HAVE_X11 #include #endif #include namespace Breeze { //* contrast for arrow and treeline rendering static const qreal arrowShade = 0.15; //____________________________________________________________________ Helper::Helper( KSharedConfig::Ptr config ): _config( std::move( config ) ) - { init(); } + {} //____________________________________________________________________ KSharedConfig::Ptr Helper::config() const { return _config; } //____________________________________________________________________ void Helper::loadConfig() { _viewFocusBrush = KStatefulBrush( KColorScheme::View, KColorScheme::FocusColor ); _viewHoverBrush = KStatefulBrush( KColorScheme::View, KColorScheme::HoverColor ); _viewNegativeTextBrush = KStatefulBrush( KColorScheme::View, KColorScheme::NegativeText ); const QPalette palette( QApplication::palette() ); const KConfigGroup group( _config->group( "WM" ) ); _activeTitleBarColor = group.readEntry( "activeBackground", palette.color( QPalette::Active, QPalette::Highlight ) ); _activeTitleBarTextColor = group.readEntry( "activeForeground", palette.color( QPalette::Active, QPalette::HighlightedText ) ); _inactiveTitleBarColor = group.readEntry( "inactiveBackground", palette.color( QPalette::Disabled, QPalette::Highlight ) ); _inactiveTitleBarTextColor = group.readEntry( "inactiveForeground", palette.color( QPalette::Disabled, QPalette::HighlightedText ) ); } //____________________________________________________________________ QColor Helper::frameOutlineColor( const QPalette& palette, bool mouseOver, bool hasFocus, qreal opacity, AnimationMode mode ) const { QColor outline( KColorUtils::mix( palette.color( QPalette::Window ), palette.color( QPalette::WindowText ), 0.25 ) ); // focus takes precedence over hover if( mode == AnimationFocus ) { const QColor focus( focusColor( palette ) ); const QColor hover( hoverColor( palette ) ); if( mouseOver ) outline = KColorUtils::mix( hover, focus, opacity ); else outline = KColorUtils::mix( outline, focus, opacity ); } else if( hasFocus ) { outline = focusColor( palette ); } else if( mode == AnimationHover ) { const QColor hover( hoverColor( palette ) ); outline = KColorUtils::mix( outline, hover, opacity ); } else if( mouseOver ) { outline = hoverColor( palette ); } return outline; } //____________________________________________________________________ QColor Helper::focusOutlineColor( const QPalette& palette ) const { return KColorUtils::mix( focusColor( palette ), palette.color( QPalette::WindowText ), 0.15 ); } //____________________________________________________________________ QColor Helper::hoverOutlineColor( const QPalette& palette ) const { return KColorUtils::mix( hoverColor( palette ), palette.color( QPalette::WindowText ), 0.15 ); } //____________________________________________________________________ QColor Helper::buttonFocusOutlineColor( const QPalette& palette ) const { return KColorUtils::mix( focusColor( palette ), palette.color( QPalette::ButtonText ), 0.15 ); } //____________________________________________________________________ QColor Helper::buttonHoverOutlineColor( const QPalette& palette ) const { return KColorUtils::mix( hoverColor( palette ), palette.color( QPalette::ButtonText ), 0.15 ); } //____________________________________________________________________ QColor Helper::sidePanelOutlineColor( const QPalette& palette, bool hasFocus, qreal opacity, AnimationMode mode ) const { QColor outline( palette.color( QPalette::Inactive, QPalette::Highlight ) ); const QColor &focus = palette.color( QPalette::Active, QPalette::Highlight ); if( mode == AnimationFocus ) { outline = KColorUtils::mix( outline, focus, opacity ); } else if( hasFocus ) { outline = focus; } return outline; } //____________________________________________________________________ QColor Helper::frameBackgroundColor( const QPalette& palette, QPalette::ColorGroup group ) const { return KColorUtils::mix( palette.color( group, QPalette::Window ), palette.color( group, QPalette::Base ), 0.3 ); } //____________________________________________________________________ QColor Helper::arrowColor( const QPalette& palette, QPalette::ColorGroup group, QPalette::ColorRole role ) const { switch( role ) { case QPalette::Text: return KColorUtils::mix( palette.color( group, QPalette::Text ), palette.color( group, QPalette::Base ), arrowShade ); case QPalette::WindowText: return KColorUtils::mix( palette.color( group, QPalette::WindowText ), palette.color( group, QPalette::Window ), arrowShade ); case QPalette::ButtonText: return KColorUtils::mix( palette.color( group, QPalette::ButtonText ), palette.color( group, QPalette::Button ), arrowShade ); default: return palette.color( group, role ); } } //____________________________________________________________________ QColor Helper::arrowColor( const QPalette& palette, bool mouseOver, bool hasFocus, qreal opacity, AnimationMode mode ) const { QColor outline( arrowColor( palette, QPalette::WindowText ) ); if( mode == AnimationHover ) { const QColor focus( focusColor( palette ) ); const QColor hover( hoverColor( palette ) ); if( hasFocus ) outline = KColorUtils::mix( focus, hover, opacity ); else outline = KColorUtils::mix( outline, hover, opacity ); } else if( mouseOver ) { outline = hoverColor( palette ); } else if( mode == AnimationFocus ) { const QColor focus( focusColor( palette ) ); outline = KColorUtils::mix( outline, focus, opacity ); } else if( hasFocus ) { outline = focusColor( palette ); } return outline; } //____________________________________________________________________ QColor Helper::buttonOutlineColor( const QPalette& palette, bool mouseOver, bool hasFocus, qreal opacity, AnimationMode mode ) const { QColor outline( KColorUtils::mix( palette.color( QPalette::Button ), palette.color( QPalette::ButtonText ), 0.3 ) ); if( mode == AnimationHover ) { if( hasFocus ) { const QColor focus( buttonFocusOutlineColor( palette ) ); const QColor hover( buttonHoverOutlineColor( palette ) ); outline = KColorUtils::mix( focus, hover, opacity ); } else { const QColor hover( hoverColor( palette ) ); outline = KColorUtils::mix( outline, hover, opacity ); } } else if( mouseOver ) { if( hasFocus ) outline = buttonHoverOutlineColor( palette ); else outline = hoverColor( palette ); } else if( mode == AnimationFocus ) { const QColor focus( buttonFocusOutlineColor( palette ) ); outline = KColorUtils::mix( outline, focus, opacity ); } else if( hasFocus ) { outline = buttonFocusOutlineColor( palette ); } return outline; } //____________________________________________________________________ QColor Helper::buttonBackgroundColor( const QPalette& palette, bool mouseOver, bool hasFocus, bool sunken, qreal opacity, AnimationMode mode ) const { QColor background( sunken ? KColorUtils::mix( palette.color( QPalette::Button ), palette.color( QPalette::ButtonText ), 0.2 ): palette.color( QPalette::Button ) ); if( mode == AnimationHover ) { const QColor focus( focusColor( palette ) ); const QColor hover( hoverColor( palette ) ); if( hasFocus ) background = KColorUtils::mix( focus, hover, opacity ); } else if( mouseOver && hasFocus ) { background = hoverColor( palette ); } else if( mode == AnimationFocus ) { const QColor focus( focusColor( palette ) ); background = KColorUtils::mix( background, focus, opacity ); } else if( hasFocus ) { background = focusColor( palette ); } return background; } //____________________________________________________________________ QColor Helper::toolButtonColor( const QPalette& palette, bool mouseOver, bool hasFocus, bool sunken, qreal opacity, AnimationMode mode ) const { QColor outline; const QColor hoverColor( this->hoverColor( palette ) ); const QColor focusColor( this->focusColor( palette ) ); const QColor sunkenColor = alphaColor( palette.color( QPalette::WindowText ), 0.2 ); // hover takes precedence over focus if( mode == AnimationHover ) { if( hasFocus ) outline = KColorUtils::mix( focusColor, hoverColor, opacity ); else if( sunken ) outline = sunkenColor; else outline = alphaColor( hoverColor, opacity ); } else if( mouseOver ) { outline = hoverColor; } else if( mode == AnimationFocus ) { if( sunken ) outline = KColorUtils::mix( sunkenColor, focusColor, opacity ); else outline = alphaColor( focusColor, opacity ); } else if( hasFocus ) { outline = focusColor; } else if( sunken ) { outline = sunkenColor; } return outline; } //____________________________________________________________________ QColor Helper::sliderOutlineColor( const QPalette& palette, bool mouseOver, bool hasFocus, qreal opacity, AnimationMode mode ) const { QColor outline( KColorUtils::mix( palette.color( QPalette::Window ), palette.color( QPalette::WindowText ), 0.4 ) ); // hover takes precedence over focus if( mode == AnimationHover ) { const QColor hover( hoverColor( palette ) ); const QColor focus( focusColor( palette ) ); if( hasFocus ) outline = KColorUtils::mix( focus, hover, opacity ); else outline = KColorUtils::mix( outline, hover, opacity ); } else if( mouseOver ) { outline = hoverColor( palette ); } else if( mode == AnimationFocus ) { const QColor focus( focusColor( palette ) ); outline = KColorUtils::mix( outline, focus, opacity ); } else if( hasFocus ) { outline = focusColor( palette ); } return outline; } //____________________________________________________________________ QColor Helper::scrollBarHandleColor( const QPalette& palette, bool mouseOver, bool hasFocus, qreal opacity, AnimationMode mode ) const { QColor color( alphaColor( palette.color( QPalette::WindowText ), 0.5 ) ); // hover takes precedence over focus if( mode == AnimationHover ) { const QColor hover( hoverColor( palette ) ); const QColor focus( focusColor( palette ) ); if( hasFocus ) color = KColorUtils::mix( focus, hover, opacity ); else color = KColorUtils::mix( color, hover, opacity ); } else if( mouseOver ) { color = hoverColor( palette ); } else if( mode == AnimationFocus ) { const QColor focus( focusColor( palette ) ); color = KColorUtils::mix( color, focus, opacity ); } else if( hasFocus ) { color = focusColor( palette ); } return color; } //______________________________________________________________________________ QColor Helper::checkBoxIndicatorColor( const QPalette& palette, bool mouseOver, bool active, qreal opacity, AnimationMode mode ) const { QColor color( KColorUtils::mix( palette.color( QPalette::Window ), palette.color( QPalette::WindowText ), 0.6 ) ); if( mode == AnimationHover ) { const QColor focus( focusColor( palette ) ); const QColor hover( hoverColor( palette ) ); if( active ) color = KColorUtils::mix( focus, hover, opacity ); else color = KColorUtils::mix( color, hover, opacity ); } else if( mouseOver ) { color = hoverColor( palette ); } else if( active ) { color = focusColor( palette ); } return color; } //______________________________________________________________________________ QColor Helper::separatorColor( const QPalette& palette ) const { return KColorUtils::mix( palette.color( QPalette::Window ), palette.color( QPalette::WindowText ), 0.25 ); } //______________________________________________________________________________ QPalette Helper::disabledPalette( const QPalette& source, qreal ratio ) const { QPalette copy( source ); const QList roles = { QPalette::Background, QPalette::Highlight, QPalette::WindowText, QPalette::ButtonText, QPalette::Text, QPalette::Button }; foreach( const QPalette::ColorRole& role, roles ) { copy.setColor( role, KColorUtils::mix( source.color( QPalette::Active, role ), source.color( QPalette::Disabled, role ), 1.0-ratio ) ); } return copy; } //____________________________________________________________________ QColor Helper::alphaColor( QColor color, qreal alpha ) const { if( alpha >= 0 && alpha < 1.0 ) { color.setAlphaF( alpha*color.alphaF() ); } return color; } //______________________________________________________________________________ void Helper::renderDebugFrame( QPainter* painter, const QRect& rect ) const { painter->save(); painter->setRenderHints( QPainter::Antialiasing ); painter->setBrush( Qt::NoBrush ); painter->setPen( Qt::red ); painter->drawRect( strokedRect( rect ) ); painter->restore(); } //______________________________________________________________________________ void Helper::renderFocusRect( QPainter* painter, const QRect& rect, const QColor& color, const QColor& outline, Sides sides ) const { if( !color.isValid() ) return; painter->save(); painter->setRenderHints( QPainter::Antialiasing ); painter->setBrush( color ); if( !( outline.isValid() && sides ) ) { painter->setPen( Qt::NoPen ); painter->drawRect( rect ); } else { painter->setClipRect( rect ); QRectF copy( strokedRect( rect ) ); const qreal radius( frameRadius( PenWidth::Frame, -1 ) ); if( !(sides&SideTop) ) copy.adjust( 0, -radius, 0, 0 ); if( !(sides&SideBottom) ) copy.adjust( 0, 0, 0, radius ); if( !(sides&SideLeft) ) copy.adjust( -radius, 0, 0, 0 ); if( !(sides&SideRight) ) copy.adjust( 0, 0, radius, 0 ); painter->setPen( outline ); // painter->setBrush( Qt::NoBrush ); painter->drawRoundedRect( copy, radius, radius ); } painter->restore(); } //______________________________________________________________________________ void Helper::renderFocusLine( QPainter* painter, const QRect& rect, const QColor& color ) const { if( !color.isValid() ) return; painter->save(); painter->setRenderHint( QPainter::Antialiasing, false ); painter->setBrush( Qt::NoBrush ); painter->setPen( color ); painter->translate( 0, 2 ); painter->drawLine( rect.bottomLeft(), rect.bottomRight() ); painter->restore(); } //______________________________________________________________________________ void Helper::renderFrame( QPainter* painter, const QRect& rect, const QColor& color, const QColor& outline ) const { painter->setRenderHint( QPainter::Antialiasing ); QRectF frameRect( rect.adjusted( 1, 1, -1, -1 ) ); qreal radius( frameRadius( PenWidth::NoPen, -1 ) ); // set pen if( outline.isValid() ) { painter->setPen( outline ); frameRect = strokedRect( frameRect ); radius = frameRadiusForNewPenWidth( radius, PenWidth::Frame ); } else { painter->setPen( Qt::NoPen ); } // set brush if( color.isValid() ) painter->setBrush( color ); else painter->setBrush( Qt::NoBrush ); // render painter->drawRoundedRect( frameRect, radius, radius ); } //______________________________________________________________________________ void Helper::renderSidePanelFrame( QPainter* painter, const QRect& rect, const QColor& outline, Side side ) const { // check color if( !outline.isValid() ) return; // adjust rect QRectF frameRect( strokedRect( rect ) ); // setup painter painter->setRenderHint( QPainter::Antialiasing ); painter->setPen( outline ); // render switch( side ) { default: case SideLeft: painter->drawLine( frameRect.topRight(), frameRect.bottomRight() ); break; case SideTop: painter->drawLine( frameRect.topLeft(), frameRect.topRight() ); break; case SideRight: painter->drawLine( frameRect.topLeft(), frameRect.bottomLeft() ); break; case SideBottom: painter->drawLine( frameRect.bottomLeft(), frameRect.bottomRight() ); break; case AllSides: { const qreal radius( frameRadius( PenWidth::Frame, -1 ) ); painter->drawRoundedRect( frameRect, radius, radius ); break; } } } //______________________________________________________________________________ void Helper::renderMenuFrame( QPainter* painter, const QRect& rect, const QColor& color, const QColor& outline, bool roundCorners ) const { // set brush if( color.isValid() ) painter->setBrush( color ); else painter->setBrush( Qt::NoBrush ); if( roundCorners ) { painter->setRenderHint( QPainter::Antialiasing ); QRectF frameRect( rect ); qreal radius( frameRadius( PenWidth::NoPen, -1 ) ); // set pen if( outline.isValid() ) { painter->setPen( outline ); frameRect = strokedRect( frameRect ); radius = frameRadiusForNewPenWidth( radius, PenWidth::Frame ); } else painter->setPen( Qt::NoPen ); // render painter->drawRoundedRect( frameRect, radius, radius ); } else { painter->setRenderHint( QPainter::Antialiasing, false ); QRect frameRect( rect ); if( outline.isValid() ) { painter->setPen( outline ); frameRect.adjust( 0, 0, -1, -1 ); } else painter->setPen( Qt::NoPen ); painter->drawRect( frameRect ); } } //______________________________________________________________________________ void Helper::renderButtonFrame( QPainter* painter, const QRect& rect, const QColor& color, const QColor& outline, const QColor& shadow, bool hasFocus, bool sunken ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); // copy rect QRectF frameRect( rect ); frameRect.adjust( 1, 1, -1, -1 ); qreal radius( frameRadius( PenWidth::NoPen, -1 ) ); // shadow if( sunken ) { frameRect.translate( 1, 1 ); } else { renderRoundedRectShadow( painter, frameRect, shadow, radius ); } if( outline.isValid() ) { QLinearGradient gradient( frameRect.topLeft(), frameRect.bottomLeft() ); gradient.setColorAt( 0, outline.lighter( hasFocus ? 103:101 ) ); gradient.setColorAt( 1, outline.darker( hasFocus ? 110:103 ) ); painter->setPen( QPen( QBrush( gradient ), 1.0 ) ); frameRect = strokedRect( frameRect ); radius = frameRadiusForNewPenWidth( radius, PenWidth::Frame ); } else painter->setPen( Qt::NoPen ); // content if( color.isValid() ) { QLinearGradient gradient( frameRect.topLeft(), frameRect.bottomLeft() ); gradient.setColorAt( 0, color.lighter( hasFocus ? 103:101 ) ); gradient.setColorAt( 1, color.darker( hasFocus ? 110:103 ) ); painter->setBrush( gradient ); } else painter->setBrush( Qt::NoBrush ); // render painter->drawRoundedRect( frameRect, radius, radius ); } //______________________________________________________________________________ void Helper::renderToolButtonFrame( QPainter* painter, const QRect& rect, const QColor& color, bool sunken ) const { // do nothing for invalid color if( !color.isValid() ) return; // setup painter painter->setRenderHints( QPainter::Antialiasing ); const QRectF baseRect( rect.adjusted( 1, 1, -1, -1 ) ); if( sunken ) { const qreal radius( frameRadius( PenWidth::NoPen ) ); painter->setPen( Qt::NoPen ); painter->setBrush( color ); painter->drawRoundedRect( baseRect, radius, radius ); } else { const qreal radius( frameRadius( PenWidth::Frame ) ); painter->setPen( color ); painter->setBrush( Qt::NoBrush ); const QRectF outlineRect( strokedRect( baseRect ) ); painter->drawRoundedRect( outlineRect, radius, radius ); } } //______________________________________________________________________________ void Helper::renderToolBoxFrame( QPainter* painter, const QRect& rect, int tabWidth, const QColor& outline ) const { if( !outline.isValid() ) return; // round radius const qreal radius( frameRadius( PenWidth::Frame ) ); const QSizeF cornerSize( 2*radius, 2*radius ); // if rect - tabwidth is even, need to increase tabWidth by 1 unit // for anti aliasing if( !((rect.width() - tabWidth)%2) ) ++tabWidth; // adjust rect for antialiasing QRectF baseRect( strokedRect( rect ) ); // create path QPainterPath path; path.moveTo( 0, baseRect.height()-1 ); path.lineTo( ( baseRect.width() - tabWidth )/2 - radius, baseRect.height()-1 ); path.arcTo( QRectF( QPointF( ( baseRect.width() - tabWidth )/2 - 2*radius, baseRect.height()-1 - 2*radius ), cornerSize ), 270, 90 ); path.lineTo( ( baseRect.width() - tabWidth )/2, radius ); path.arcTo( QRectF( QPointF( ( baseRect.width() - tabWidth )/2, 0 ), cornerSize ), 180, -90 ); path.lineTo( ( baseRect.width() + tabWidth )/2 -1 - radius, 0 ); path.arcTo( QRectF( QPointF( ( baseRect.width() + tabWidth )/2 - 1 - 2*radius, 0 ), cornerSize ), 90, -90 ); path.lineTo( ( baseRect.width() + tabWidth )/2 -1, baseRect.height()-1 - radius ); path.arcTo( QRectF( QPointF( ( baseRect.width() + tabWidth )/2 -1, baseRect.height()-1 - 2*radius ), cornerSize ), 180, 90 ); path.lineTo( baseRect.width()-1, baseRect.height()-1 ); // render painter->setRenderHints( QPainter::Antialiasing ); painter->setBrush( Qt::NoBrush ); painter->setPen( outline ); painter->translate( baseRect.topLeft() ); painter->drawPath( path ); } //______________________________________________________________________________ void Helper::renderTabWidgetFrame( QPainter* painter, const QRect& rect, const QColor& color, const QColor& outline, Corners corners ) const { painter->setRenderHint( QPainter::Antialiasing ); QRectF frameRect( rect.adjusted( 1, 1, -1, -1 ) ); qreal radius( frameRadius( PenWidth::NoPen, -1 ) ); // set pen if( outline.isValid() ) { painter->setPen( outline ); frameRect = strokedRect( frameRect ); radius = frameRadiusForNewPenWidth( radius, PenWidth::Frame ); } else painter->setPen( Qt::NoPen ); // set brush if( color.isValid() ) painter->setBrush( color ); else painter->setBrush( Qt::NoBrush ); // render QPainterPath path( roundedPath( frameRect, corners, radius ) ); painter->drawPath( path ); } //______________________________________________________________________________ void Helper::renderSelection( QPainter* painter, const QRect& rect, const QColor& color ) const { painter->setRenderHint( QPainter::Antialiasing ); painter->setPen( Qt::NoPen ); painter->setBrush( color ); painter->drawRect( rect ); } //______________________________________________________________________________ void Helper::renderSeparator( QPainter* painter, const QRect& rect, const QColor& color, bool vertical ) const { painter->setRenderHint( QPainter::Antialiasing, false ); painter->setBrush( Qt::NoBrush ); painter->setPen( color ); if( vertical ) { painter->translate( rect.width()/2, 0 ); painter->drawLine( rect.topLeft(), rect.bottomLeft() ); } else { painter->translate( 0, rect.height()/2 ); painter->drawLine( rect.topLeft(), rect.topRight() ); } } //______________________________________________________________________________ void Helper::renderCheckBoxBackground( QPainter* painter, const QRect& rect, const QColor& color, bool sunken ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); // copy rect and radius QRectF frameRect( rect ); frameRect.adjust( 3, 3, -3, -3 ); if( sunken ) frameRect.translate(1, 1); painter->setPen( Qt::NoPen ); painter->setBrush( color ); painter->drawRect( frameRect ); } //______________________________________________________________________________ void Helper::renderCheckBox( QPainter* painter, const QRect& rect, const QColor& color, const QColor& shadow, bool sunken, CheckBoxState state, qreal animation ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); // copy rect and radius QRectF frameRect( rect ); frameRect.adjust( 2, 2, -2, -2 ); qreal radius( frameRadius( PenWidth::NoPen, -1 ) ); // shadow if( sunken ) { frameRect.translate(1, 1); } else { renderRoundedRectShadow( painter, frameRect, shadow, radius ); } // content { painter->setPen( QPen( color, PenWidth::Frame ) ); painter->setBrush( Qt::NoBrush ); radius = frameRadiusForNewPenWidth( radius, PenWidth::Frame ); const QRectF contentRect( strokedRect( frameRect ) ); painter->drawRoundedRect( contentRect, radius, radius ); } // mark if( state == CheckOn ) { painter->setBrush( color ); painter->setPen( Qt::NoPen ); const QRectF markerRect( frameRect.adjusted( 3, 3, -3, -3 ) ); painter->drawRect( markerRect ); } else if( state == CheckPartial ) { QPen pen( color, 2 ); pen.setJoinStyle( Qt::MiterJoin ); painter->setPen( pen ); const QRectF markerRect( frameRect.adjusted( 4, 4, -4, -4 ) ); painter->drawRect( markerRect ); painter->setPen( Qt::NoPen ); painter->setBrush( color ); painter->setRenderHint( QPainter::Antialiasing, false ); QPainterPath path; path.moveTo( markerRect.topLeft() ); path.lineTo( markerRect.right() - 1, markerRect.top() ); path.lineTo( markerRect.left(), markerRect.bottom()-1 ); painter->drawPath( path ); } else if( state == CheckAnimated ) { const QRectF markerRect( frameRect.adjusted( 3, 3, -3, -3 ) ); QPainterPath path; path.moveTo( markerRect.topRight() ); path.lineTo( markerRect.center() + animation*( markerRect.topLeft() - markerRect.center() ) ); path.lineTo( markerRect.bottomLeft() ); path.lineTo( markerRect.center() + animation*( markerRect.bottomRight() - markerRect.center() ) ); path.closeSubpath(); painter->setBrush( color ); painter->setPen( Qt::NoPen ); painter->drawPath( path ); } } //______________________________________________________________________________ void Helper::renderRadioButtonBackground( QPainter* painter, const QRect& rect, const QColor& color, bool sunken ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); // copy rect QRectF frameRect( rect ); frameRect.adjust( 3, 3, -3, -3 ); if( sunken ) frameRect.translate(1, 1); painter->setPen( Qt::NoPen ); painter->setBrush( color ); painter->drawEllipse( frameRect ); } //______________________________________________________________________________ void Helper::renderRadioButton( QPainter* painter, const QRect& rect, const QColor& color, const QColor& shadow, bool sunken, RadioButtonState state, qreal animation ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); // copy rect QRectF frameRect( rect ); frameRect.adjust( 2, 2, -2, -2 ); // shadow if( sunken ) { frameRect.translate( 1, 1 ); } else { renderEllipseShadow( painter, frameRect, shadow ); } // content { painter->setPen( QPen( color, PenWidth::Frame ) ); painter->setBrush( Qt::NoBrush ); const QRectF contentRect( strokedRect( frameRect ) ); painter->drawEllipse( contentRect ); } // mark if( state == RadioOn ) { painter->setBrush( color ); painter->setPen( Qt::NoPen ); const QRectF markerRect( frameRect.adjusted( 3, 3, -3, -3 ) ); painter->drawEllipse( markerRect ); } else if( state == RadioAnimated ) { painter->setBrush( color ); painter->setPen( Qt::NoPen ); QRectF markerRect( frameRect.adjusted( 3, 3, -3, -3 ) ); painter->translate( markerRect.center() ); painter->rotate( 45 ); markerRect.setWidth( markerRect.width()*animation ); markerRect.translate( -markerRect.center() ); painter->drawEllipse( markerRect ); } } //______________________________________________________________________________ void Helper::renderSliderGroove( QPainter* painter, const QRect& rect, const QColor& color ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); const QRectF baseRect( rect ); const qreal radius( 0.5*Metrics::Slider_GrooveThickness ); // content if( color.isValid() ) { painter->setPen( Qt::NoPen ); painter->setBrush( color ); painter->drawRoundedRect( baseRect, radius, radius ); } } //______________________________________________________________________________ void Helper::renderDialGroove( QPainter* painter, const QRect& rect, const QColor& color, qreal first, qreal last ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); const QRectF baseRect( rect ); // content if( color.isValid() ) { const qreal penWidth( Metrics::Slider_GrooveThickness ); const QRectF grooveRect( rect.adjusted( penWidth/2, penWidth/2, -penWidth/2, -penWidth/2 ) ); // setup angles const int angleStart( first * 180 * 16 / M_PI ); const int angleSpan( (last - first ) * 180 * 16 / M_PI ); // setup pen if( angleSpan != 0 ) { QPen pen( color, penWidth ); pen.setCapStyle( Qt::RoundCap ); painter->setPen( pen ); painter->setBrush( Qt::NoBrush ); painter->drawArc( grooveRect, angleStart, angleSpan ); } } } //______________________________________________________________________________ void Helper::renderDialContents( QPainter* painter, const QRect& rect, const QColor& color, qreal first, qreal second ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); const QRectF baseRect( rect ); // content if( color.isValid() ) { // setup groove rect const qreal penWidth( Metrics::Slider_GrooveThickness ); const QRectF grooveRect( rect.adjusted( penWidth/2, penWidth/2, -penWidth/2, -penWidth/2 ) ); // setup angles const int angleStart( first * 180 * 16 / M_PI ); const int angleSpan( (second - first ) * 180 * 16 / M_PI ); // setup pen if( angleSpan != 0 ) { QPen pen( color, penWidth ); pen.setCapStyle( Qt::RoundCap ); painter->setPen( pen ); painter->setBrush( Qt::NoBrush ); painter->drawArc( grooveRect, angleStart, angleSpan ); } } } //______________________________________________________________________________ void Helper::renderSliderHandle( QPainter* painter, const QRect& rect, const QColor& color, const QColor& outline, const QColor& shadow, bool sunken ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); // copy rect QRectF frameRect( rect ); frameRect.adjust( 1, 1, -1, -1 ); // shadow if( !sunken ) { renderEllipseShadow( painter, frameRect, shadow ); } // set pen if( outline.isValid() ) { painter->setPen( outline ); frameRect = strokedRect( frameRect ); } else painter->setPen( Qt::NoPen ); // set brush if( color.isValid() ) painter->setBrush( color ); else painter->setBrush( Qt::NoBrush ); // render painter->drawEllipse( frameRect ); } //______________________________________________________________________________ void Helper::renderProgressBarGroove( QPainter* painter, const QRect& rect, const QColor& color ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); const QRectF baseRect( rect ); const qreal radius( 0.5*Metrics::ProgressBar_Thickness ); // content if( color.isValid() ) { painter->setPen( Qt::NoPen ); painter->setBrush( color ); painter->drawRoundedRect( baseRect, radius, radius ); } } //______________________________________________________________________________ void Helper::renderProgressBarBusyContents( QPainter* painter, const QRect& rect, const QColor& first, const QColor& second, bool horizontal, bool reverse, int progress ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); const QRectF baseRect( rect ); const qreal radius( 0.5*Metrics::ProgressBar_Thickness ); // setup brush QPixmap pixmap( horizontal ? 2*Metrics::ProgressBar_BusyIndicatorSize : 1, horizontal ? 1:2*Metrics::ProgressBar_BusyIndicatorSize ); pixmap.fill( second ); if( horizontal ) { QPainter painter( &pixmap ); painter.setBrush( first ); painter.setPen( Qt::NoPen ); progress %= 2*Metrics::ProgressBar_BusyIndicatorSize; if( reverse ) progress = 2*Metrics::ProgressBar_BusyIndicatorSize - progress - 1; painter.drawRect( QRect( 0, 0, Metrics::ProgressBar_BusyIndicatorSize, 1 ).translated( progress, 0 ) ); if( progress > Metrics::ProgressBar_BusyIndicatorSize ) { painter.drawRect( QRect( 0, 0, Metrics::ProgressBar_BusyIndicatorSize, 1 ).translated( progress - 2*Metrics::ProgressBar_BusyIndicatorSize, 0 ) ); } } else { QPainter painter( &pixmap ); painter.setBrush( first ); painter.setPen( Qt::NoPen ); progress %= 2*Metrics::ProgressBar_BusyIndicatorSize; progress = 2*Metrics::ProgressBar_BusyIndicatorSize - progress - 1; painter.drawRect( QRect( 0, 0, 1, Metrics::ProgressBar_BusyIndicatorSize ).translated( 0, progress ) ); if( progress > Metrics::ProgressBar_BusyIndicatorSize ) { painter.drawRect( QRect( 0, 0, 1, Metrics::ProgressBar_BusyIndicatorSize ).translated( 0, progress - 2*Metrics::ProgressBar_BusyIndicatorSize ) ); } } painter->setPen( Qt::NoPen ); painter->setBrush( pixmap ); painter->drawRoundedRect( baseRect, radius, radius ); } //______________________________________________________________________________ void Helper::renderScrollBarHandle( QPainter* painter, const QRect& rect, const QColor& color ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); const QRectF baseRect( rect ); const qreal radius( 0.5 * std::min({baseRect.width(), baseRect.height(), (qreal)Metrics::ScrollBar_SliderWidth}) ); // content if( color.isValid() ) { painter->setPen( Qt::NoPen ); painter->setBrush( color ); painter->drawRoundedRect( baseRect, radius, radius ); } } //______________________________________________________________________________ void Helper::renderScrollBarBorder( QPainter* painter, const QRect& rect, const QColor& color ) const { // content if( color.isValid() ) { painter->setPen( Qt::NoPen ); painter->setBrush( color ); painter->drawRect( rect ); } } //______________________________________________________________________________ void Helper::renderTabBarTab( QPainter* painter, const QRect& rect, const QColor& color, const QColor& outline, Corners corners ) const { // setup painter painter->setRenderHint( QPainter::Antialiasing, true ); QRectF frameRect( rect ); qreal radius( frameRadius( PenWidth::NoPen, -1 ) ); // pen if( outline.isValid() ) { painter->setPen( outline ); frameRect = strokedRect( frameRect ); radius = frameRadiusForNewPenWidth( radius, PenWidth::Frame ); } else painter->setPen( Qt::NoPen ); // brush if( color.isValid() ) painter->setBrush( color ); else painter->setBrush( Qt::NoBrush ); // render QPainterPath path( roundedPath( frameRect, corners, radius ) ); painter->drawPath( path ); } //______________________________________________________________________________ void Helper::renderArrow( QPainter* painter, const QRect& rect, const QColor& color, ArrowOrientation orientation ) const { // define polygon QPolygonF arrow; switch( orientation ) { /* The inner points of the normal arrows are not on half pixels because * they need to have an even width (up/down) or height (left/right). * An even width/height makes them easier to align with other UI elements. */ case ArrowUp: arrow = QVector{QPointF( -4.5, 1.5 ), QPointF( 0, -3 ), QPointF( 4.5, 1.5 )}; break; case ArrowDown: arrow = QVector{QPointF( -4.5, -1.5 ), QPointF( 0, 3 ), QPointF( 4.5, -1.5 )}; break; case ArrowLeft: arrow = QVector{QPointF( 1.5, -4.5 ), QPointF( -3, 0 ), QPointF( 1.5, 4.5 )}; break; case ArrowRight: arrow = QVector{QPointF( -1.5, -4.5 ), QPointF( 3, 0 ), QPointF( -1.5, 4.5 )}; break; case ArrowDown_Small: arrow = QVector{QPointF( 1.5, 3.5 ), QPointF( 3.5, 5.5 ), QPointF( 5.5, 3.5 )}; break; default: break; } painter->save(); painter->setRenderHints( QPainter::Antialiasing ); painter->translate( QRectF( rect ).center() ); painter->setBrush( Qt::NoBrush ); QPen pen( color, PenWidth::Symbol ); pen.setCapStyle(Qt::SquareCap); pen.setJoinStyle(Qt::MiterJoin); painter->setPen( pen ); painter->drawPolyline( arrow ); painter->restore(); } //______________________________________________________________________________ void Helper::renderDecorationButton( QPainter* painter, const QRect& rect, const QColor& color, ButtonType buttonType, bool inverted ) const { painter->save(); painter->setViewport( rect ); painter->setWindow( 0, 0, 18, 18 ); painter->setRenderHints( QPainter::Antialiasing ); // initialize pen QPen pen; pen.setCapStyle( Qt::RoundCap ); pen.setJoinStyle( Qt::MiterJoin ); if( inverted ) { // render circle painter->setPen( Qt::NoPen ); painter->setBrush( color ); painter->drawEllipse( QRectF( 0, 0, 18, 18 ) ); // take out the inner part painter->setCompositionMode( QPainter::CompositionMode_DestinationOut ); painter->setBrush( Qt::NoBrush ); pen.setColor( Qt::black ); } else { painter->setBrush( Qt::NoBrush ); pen.setColor( color ); } pen.setCapStyle( Qt::RoundCap ); pen.setJoinStyle( Qt::MiterJoin ); pen.setWidthF( PenWidth::Symbol*qMax(1.0, 18.0/rect.width() ) ); painter->setPen( pen ); switch( buttonType ) { case ButtonClose: { painter->drawLine( QPointF( 5, 5 ), QPointF( 13, 13 ) ); painter->drawLine( 13, 5, 5, 13 ); break; } case ButtonMaximize: { painter->drawPolyline( QVector{ QPointF( 4, 11 ), QPointF( 9, 6 ), QPointF( 14, 11 )}); break; } case ButtonMinimize: { painter->drawPolyline(QVector{ QPointF( 4, 7 ), QPointF( 9, 12 ), QPointF( 14, 7 )} ); break; } case ButtonRestore: { pen.setJoinStyle( Qt::RoundJoin ); painter->setPen( pen ); painter->drawPolygon( QVector{ QPointF( 4.5, 9 ), QPointF( 9, 4.5 ), QPointF( 13.5, 9 ), QPointF( 9, 13.5 )}); break; } default: break; } painter->restore(); } //______________________________________________________________________________ void Helper::renderRoundedRectShadow( QPainter* painter, const QRectF& rect, const QColor& color, qreal radius ) const { if( !color.isValid() ) return; painter->save(); qreal translation = 0.5 * PenWidth::Shadow; // Translate for the pen /* Clipping prevents shadows from being visible inside checkboxes. * Clipping away unneeded parts here also improves performance by 40-60% * versus using just an outline of a rectangle. * Tested by looking at the paint analyser in GammaRay. */ // Right side QRegion clip( rect.right() - std::ceil( radius ), rect.top(), std::ceil( radius ) + PenWidth::Shadow, rect.height() ); // Bottom side clip = clip.united( QRegion( rect.left(), rect.bottom() - std::ceil( radius ), rect.width(), std::ceil( radius ) + PenWidth::Shadow ) ); painter->setClipRegion( clip ); painter->setPen( color ); painter->setBrush( Qt::NoBrush ); painter->drawRoundedRect( rect.translated( translation, translation ), radius, radius ); painter->restore(); } //______________________________________________________________________________ void Helper::renderEllipseShadow( QPainter* painter, const QRectF& rect, const QColor& color ) const { if( !color.isValid() ) return; painter->save(); // Clipping does not improve performance here qreal adjustment = 0.5 * PenWidth::Shadow; // Adjust for the pen qreal radius = rect.width() / 2 - adjustment; /* The right side is offset by +0.5 for the visible part of the shadow. * The other sides are offset by +0.5 or -0.5 because of the pen. */ QRectF shadowRect = rect.adjusted( adjustment, adjustment, adjustment, -adjustment ); painter->translate( rect.center() ); painter->rotate( 45 ); painter->translate( -rect.center() ); painter->setPen( color ); painter->setBrush( Qt::NoBrush ); painter->drawRoundedRect( shadowRect, radius, radius ); painter->restore(); } //______________________________________________________________________________ bool Helper::isX11() { #if BREEZE_HAVE_X11 static const bool s_isX11 = KWindowSystem::isPlatformX11(); return s_isX11; #endif return false; } //______________________________________________________________________________ bool Helper::isWayland() { static const bool s_isWayland = KWindowSystem::isPlatformWayland(); return s_isWayland; } //______________________________________________________________________________ QRectF Helper::strokedRect( const QRectF &rect, const int penWidth ) const { /* With a pen stroke width of 1, the rectangle should have each of its * sides moved inwards by half a pixel. This allows the stroke to be * pixel perfect instead of blurry from sitting between pixels and * prevents the rectangle with a stroke from becoming larger than the * original size of the rectangle. */ qreal adjustment = 0.5 * penWidth; return QRectF( rect ).adjusted( adjustment, adjustment, -adjustment, -adjustment ); } QRectF Helper::strokedRect( const QRect &rect, const int penWidth ) const { return strokedRect(QRectF(rect), penWidth); } //______________________________________________________________________________ QPainterPath Helper::roundedPath( const QRectF& rect, Corners corners, qreal radius ) const { QPainterPath path; // simple cases if( corners == 0 ) { path.addRect( rect ); return path; } if( corners == AllCorners ) { path.addRoundedRect( rect, radius, radius ); return path; } const QSizeF cornerSize( 2*radius, 2*radius ); // rotate counterclockwise // top left corner if( corners & CornerTopLeft ) { path.moveTo( rect.topLeft() + QPointF( radius, 0 ) ); path.arcTo( QRectF( rect.topLeft(), cornerSize ), 90, 90 ); } else path.moveTo( rect.topLeft() ); // bottom left corner if( corners & CornerBottomLeft ) { path.lineTo( rect.bottomLeft() - QPointF( 0, radius ) ); path.arcTo( QRectF( rect.bottomLeft() - QPointF( 0, 2*radius ), cornerSize ), 180, 90 ); } else path.lineTo( rect.bottomLeft() ); // bottom right corner if( corners & CornerBottomRight ) { path.lineTo( rect.bottomRight() - QPointF( radius, 0 ) ); path.arcTo( QRectF( rect.bottomRight() - QPointF( 2*radius, 2*radius ), cornerSize ), 270, 90 ); } else path.lineTo( rect.bottomRight() ); // top right corner if( corners & CornerTopRight ) { path.lineTo( rect.topRight() + QPointF( 0, radius ) ); path.arcTo( QRectF( rect.topRight() - QPointF( 2*radius, 0 ), cornerSize ), 0, 90 ); } else path.lineTo( rect.topRight() ); path.closeSubpath(); return path; } //________________________________________________________________________________________________________ bool Helper::compositingActive() const { #if BREEZE_HAVE_X11 if( isX11() ) - { - // direct call to X - xcb_get_selection_owner_cookie_t cookie( xcb_get_selection_owner( QX11Info::connection(), _compositingManagerAtom ) ); - ScopedPointer reply( xcb_get_selection_owner_reply( QX11Info::connection(), cookie, nullptr ) ); - return reply && reply->owner; - - } + { return QX11Info::isCompositingManagerRunning( QX11Info::appScreen() ); } #endif // use KWindowSystem return KWindowSystem::compositingActive(); } //____________________________________________________________________ bool Helper::hasAlphaChannel( const QWidget* widget ) const { return compositingActive() && widget && widget->testAttribute( Qt::WA_TranslucentBackground ); } //______________________________________________________________________________________ QPixmap Helper::highDpiPixmap( int width, int height ) const { const qreal dpiRatio( qApp->devicePixelRatio() ); QPixmap pixmap( width*dpiRatio, height*dpiRatio ); pixmap.setDevicePixelRatio( dpiRatio ); return pixmap; } //______________________________________________________________________________________ qreal Helper::devicePixelRatio( const QPixmap& pixmap ) const { return pixmap.devicePixelRatio(); } - #if BREEZE_HAVE_X11 - - //____________________________________________________________________ - xcb_atom_t Helper::createAtom( const QString& name ) const - { - if( isX11() ) - { - - xcb_connection_t* connection( QX11Info::connection() ); - xcb_intern_atom_cookie_t cookie( xcb_intern_atom( connection, false, name.size(), qPrintable( name ) ) ); - ScopedPointer reply( xcb_intern_atom_reply( connection, cookie, nullptr) ); - return reply ? reply->atom:0; - - } else return 0; - - } - - #endif - - //____________________________________________________________________ - void Helper::init() - { - #if BREEZE_HAVE_X11 - - if( isX11() ) - { - // create compositing screen - const QString atomName( QStringLiteral( "_NET_WM_CM_S%1" ).arg( QX11Info::appScreen() ) ); - _compositingManagerAtom = createAtom( atomName ); - } - - #endif - - } - } diff --git a/kstyle/breezehelper.h b/kstyle/breezehelper.h index 04c26ecd..2e3ef837 100644 --- a/kstyle/breezehelper.h +++ b/kstyle/breezehelper.h @@ -1,356 +1,330 @@ #ifndef breeze_helper_h #define breeze_helper_h /************************************************************************* * Copyright (C) 2014 by Hugo Pereira Da Costa * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program 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 General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . * *************************************************************************/ #include "breeze.h" #include "breezeanimationdata.h" #include "config-breeze.h" #include #include #include #include -#if BREEZE_HAVE_X11 -#include -#endif - namespace Breeze { //* breeze style helper class. /** contains utility functions used at multiple places in both breeze style and breeze window decoration */ class Helper { public: //* constructor explicit Helper( KSharedConfig::Ptr ); //* destructor virtual ~Helper() {} //* load configuration virtual void loadConfig(); //* pointer to shared config KSharedConfig::Ptr config() const; //*@name color utilities //@{ //* add alpha channel multiplier to color QColor alphaColor( QColor color, qreal alpha ) const; //* mouse over color QColor hoverColor( const QPalette& palette ) const { return _viewHoverBrush.brush( palette ).color(); } //* focus color QColor focusColor( const QPalette& palette ) const { return _viewFocusBrush.brush( palette ).color(); } //* negative text color (used for close button) QColor negativeText( const QPalette& palette ) const { return _viewNegativeTextBrush.brush( palette ).color(); } //* shadow QColor shadowColor( const QPalette& palette ) const { return alphaColor( palette.color( QPalette::Shadow ), 0.15 ); } //* titlebar color const QColor& titleBarColor( bool active ) const { return active ? _activeTitleBarColor:_inactiveTitleBarColor; } //* titlebar text color const QColor& titleBarTextColor( bool active ) const { return active ? _activeTitleBarTextColor:_inactiveTitleBarTextColor; } //* frame outline color, using animations QColor frameOutlineColor( const QPalette&, bool mouseOver = false, bool hasFocus = false, qreal opacity = AnimationData::OpacityInvalid, AnimationMode = AnimationNone ) const; //* focus outline color, using animations QColor focusOutlineColor( const QPalette& ) const; //* hover outline color, using animations QColor hoverOutlineColor( const QPalette& ) const; //* focus outline color, using animations QColor buttonFocusOutlineColor( const QPalette& ) const; //* hover outline color, using animations QColor buttonHoverOutlineColor( const QPalette& ) const; //* side panel outline color, using animations QColor sidePanelOutlineColor( const QPalette&, bool hasFocus = false, qreal opacity = AnimationData::OpacityInvalid, AnimationMode = AnimationNone ) const; //* frame background color QColor frameBackgroundColor( const QPalette& palette ) const { return frameBackgroundColor( palette, palette.currentColorGroup() ); } //* frame background color QColor frameBackgroundColor( const QPalette&, QPalette::ColorGroup ) const; //* arrow outline color QColor arrowColor( const QPalette&, QPalette::ColorGroup, QPalette::ColorRole ) const; //* arrow outline color QColor arrowColor( const QPalette& palette, QPalette::ColorRole role ) const { return arrowColor( palette, palette.currentColorGroup(), role ); } //* arrow outline color, using animations QColor arrowColor( const QPalette&, bool mouseOver, bool hasFocus, qreal opacity = AnimationData::OpacityInvalid, AnimationMode = AnimationNone ) const; //* button outline color, using animations QColor buttonOutlineColor( const QPalette&, bool mouseOver, bool hasFocus, qreal opacity = AnimationData::OpacityInvalid, AnimationMode = AnimationNone ) const; //* button panel color, using animations QColor buttonBackgroundColor( const QPalette&, bool mouseOver, bool hasFocus, bool sunken, qreal opacity = AnimationData::OpacityInvalid, AnimationMode = AnimationNone ) const; //* tool button color QColor toolButtonColor( const QPalette&, bool mouseOver, bool hasFocus, bool sunken, qreal opacity = AnimationData::OpacityInvalid, AnimationMode = AnimationNone ) const; //* slider outline color, using animations QColor sliderOutlineColor( const QPalette&, bool mouseOver, bool hasFocus, qreal opacity = AnimationData::OpacityInvalid, AnimationMode = AnimationNone ) const; //* scrollbar handle color, using animations QColor scrollBarHandleColor( const QPalette&, bool mouseOver, bool hasFocus, qreal opacity = AnimationData::OpacityInvalid, AnimationMode = AnimationNone ) const; //* checkbox indicator, using animations QColor checkBoxIndicatorColor( const QPalette&, bool mouseOver, bool active, qreal opacity = AnimationData::OpacityInvalid, AnimationMode = AnimationNone ) const; //* separator color QColor separatorColor( const QPalette& ) const; //* merge active and inactive palettes based on ratio, for smooth enable state change transition QPalette disabledPalette( const QPalette&, qreal ratio ) const; //@} //*@name rendering utilities //@{ //* debug frame void renderDebugFrame( QPainter*, const QRect& ) const; //* focus rect void renderFocusRect( QPainter*, const QRect&, const QColor&, const QColor& outline = QColor(), Sides = {} ) const; //* focus line void renderFocusLine( QPainter*, const QRect&, const QColor& ) const; //* generic frame void renderFrame( QPainter*, const QRect&, const QColor& color, const QColor& outline = QColor() ) const; //* side panel frame void renderSidePanelFrame( QPainter*, const QRect&, const QColor& outline, Side ) const; //* menu frame void renderMenuFrame( QPainter*, const QRect&, const QColor& color, const QColor& outline, bool roundCorners = true ) const; //* button frame void renderButtonFrame( QPainter*, const QRect&, const QColor& color, const QColor& outline, const QColor& shadow, bool focus, bool sunken ) const; //* toolbutton frame void renderToolButtonFrame( QPainter*, const QRect&, const QColor& color, bool sunken ) const; //* toolbutton frame void renderToolBoxFrame( QPainter*, const QRect&, int tabWidth, const QColor& color ) const; //* tab widget frame void renderTabWidgetFrame( QPainter*, const QRect&, const QColor& color, const QColor& outline, Corners ) const; //* selection frame void renderSelection( QPainter*, const QRect&, const QColor& ) const; //* separator void renderSeparator( QPainter*, const QRect&, const QColor&, bool vertical = false ) const; //* checkbox void renderCheckBoxBackground( QPainter*, const QRect&, const QColor& color, bool sunken ) const; //* checkbox void renderCheckBox( QPainter*, const QRect&, const QColor& color, const QColor& shadow, bool sunken, CheckBoxState state, qreal animation = AnimationData::OpacityInvalid ) const; //* radio button void renderRadioButtonBackground( QPainter*, const QRect&, const QColor& color, bool sunken ) const; //* radio button void renderRadioButton( QPainter*, const QRect&, const QColor& color, const QColor& shadow, bool sunken, RadioButtonState state, qreal animation = AnimationData::OpacityInvalid ) const; //* slider groove void renderSliderGroove( QPainter*, const QRect&, const QColor& ) const; //* slider handle void renderSliderHandle( QPainter*, const QRect&, const QColor&, const QColor& outline, const QColor& shadow, bool sunken ) const; //* dial groove void renderDialGroove( QPainter*, const QRect&, const QColor&, qreal first, qreal last ) const; //* dial groove void renderDialContents( QPainter*, const QRect&, const QColor&, qreal first, qreal second ) const; //* progress bar groove void renderProgressBarGroove( QPainter*, const QRect&, const QColor& ) const; //* progress bar contents void renderProgressBarContents( QPainter* painter, const QRect& rect, const QColor& color ) const { return renderProgressBarGroove( painter, rect, color ); } //* progress bar contents (animated) void renderProgressBarBusyContents( QPainter* painter, const QRect& rect, const QColor& first, const QColor& second, bool horizontal, bool reverse, int progress ) const; //* scrollbar groove void renderScrollBarGroove( QPainter* painter, const QRect& rect, const QColor& color ) const { return renderScrollBarHandle( painter, rect, color ); } //* scrollbar handle void renderScrollBarHandle( QPainter*, const QRect&, const QColor& ) const; //* toolbar handle void renderToolBarHandle( QPainter* painter, const QRect& rect, const QColor& color ) const { return renderProgressBarGroove( painter, rect, color ); } //* separator between scrollbar and contents void renderScrollBarBorder( QPainter*, const QRect&, const QColor& ) const; //* tabbar tab void renderTabBarTab( QPainter*, const QRect&, const QColor& color, const QColor& outline, Corners ) const; //* generic arrow void renderArrow( QPainter*, const QRect&, const QColor&, ArrowOrientation ) const; //* generic button (for mdi decorations, tabs and dock widgets) void renderDecorationButton( QPainter*, const QRect&, const QColor&, ButtonType, bool inverted ) const; //* generic shadow for rounded rectangles void renderRoundedRectShadow ( QPainter*, const QRectF&, const QColor&, qreal radius = Metrics::Frame_FrameRadius - 0.5 ) const; //* generic shadow for ellipses void renderEllipseShadow( QPainter*, const QRectF&, const QColor& ) const; //@} //*@name compositing utilities //@{ //* true if style was compiled for and is running on X11 static bool isX11(); //* true if running on platform Wayland static bool isWayland(); //* returns true if compositing is active bool compositingActive() const; //* returns true if a given widget supports alpha channel bool hasAlphaChannel( const QWidget* ) const; //@} //@name high dpi utility functions //@{ //* return dpi-aware pixmap of given size virtual QPixmap highDpiPixmap( const QSize& size ) const { return highDpiPixmap( size.width(), size.height() ); } //* return dpi-aware pixmap of given size virtual QPixmap highDpiPixmap( int width ) const { return highDpiPixmap( width, width ); } //* return dpi-aware pixmap of given size virtual QPixmap highDpiPixmap( int width, int height ) const; //* return device pixel ratio for a given pixmap virtual qreal devicePixelRatio( const QPixmap& ) const; //@} - //*@name X11 utilities - //@{ - - #if BREEZE_HAVE_X11 - - //* create xcb atom - xcb_atom_t createAtom( const QString& ) const; - - #endif - - //@} - //* frame radius constexpr qreal frameRadius( const int penWidth = PenWidth::NoPen, const qreal bias = 0 ) const { return qMax( Metrics::Frame_FrameRadius - (0.5 * penWidth) + bias, 0.0 ); } //* frame radius with new pen width constexpr qreal frameRadiusForNewPenWidth( const qreal oldRadius, const int penWidth ) const { return qMax( oldRadius - (0.5 * penWidth), 0.0 ); } //* return a QRectF with the appropriate size for a rectangle with a pen stroke QRectF strokedRect( const QRectF &rect, const int penWidth = PenWidth::Frame ) const; //* return a QRectF with the appropriate size for a rectangle with a pen stroke QRectF strokedRect( const QRect &rect, const int penWidth = PenWidth::Frame ) const; protected: - //* initialize - void init(); - //* return rounded path in a given rect, with only selected corners rounded, and for a given radius QPainterPath roundedPath( const QRectF&, Corners, qreal ) const; private: //* configuration KSharedConfig::Ptr _config; //*@name brushes //@{ KStatefulBrush _viewFocusBrush; KStatefulBrush _viewHoverBrush; KStatefulBrush _viewNegativeTextBrush; //@} //*@name windeco colors //@{ QColor _activeTitleBarColor; QColor _activeTitleBarTextColor; QColor _inactiveTitleBarColor; QColor _inactiveTitleBarTextColor; //@} - #if BREEZE_HAVE_X11 - - //* atom used for compositing manager - xcb_atom_t _compositingManagerAtom; - - #endif - }; } #endif