/*************************************************************************

 * Copyright (C) 2014 by Hugo Pereira Da Costa <hugo.pereira@free.fr>    *

 *                                                                       *

 * 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 "adwaitahelper.h"

#include "adwaita.h"

#include "fakeadwaitastyleconfigdata.h"

#include <QApplication>

#include <QPainter>

#include <QLibrary>

#if ADWAITA_HAVE_X11 && QT_VERSION < 0x050000

#include <X11/Xlib-xcb.h>

#endif

namespace Adwaita

{

    //* contrast for arrow and treeline rendering

    static const qreal arrowShade = 0.15;

    //____________________________________________________________________

    Helper::Helper( )

    { init(); }

    //____________________________________________________________________

    #if ADWAITA_USE_KDE4

    Helper::Helper( const QByteArray& name )

    { init(); }

    #endif

    //____________________________________________________________________

    QColor Helper::frameOutlineColor( const QPalette& palette, bool mouseOver, bool hasFocus, qreal opacity, AnimationMode mode ) const

    {

        // I really can't remember why we have differed these two cases. This seems right.

        return inputOutlineColor(palette, mouseOver, hasFocus, opacity, mode);

    }

    QColor Helper::inputOutlineColor(const QPalette &palette, bool mouseOver, bool hasFocus, qreal opacity, AnimationMode mode) const

    {

        QColor outline( buttonOutlineColor( palette, mouseOver, false ) );

        QColor focus( palette.color( QPalette::Active, QPalette::Highlight ) );

        // focus takes precedence over hover

        if( mode == AnimationFocus )

        {

            outline = mix( outline, focus, opacity );

        } else if( hasFocus ) {

            outline = focusColor( palette );

        }

        return outline;

    }

    //____________________________________________________________________

    QColor Helper::focusOutlineColor( const QPalette& palette ) const

    { return mix( focusColor( palette ), palette.color( QPalette::WindowText ), 0.15 ); }

    //____________________________________________________________________

    QColor Helper::hoverOutlineColor( const QPalette& palette ) const

    { return mix( hoverColor( palette ), palette.color( QPalette::WindowText ), 0.15 ); }

    //____________________________________________________________________

    QColor Helper::buttonFocusOutlineColor( const QPalette& palette ) const

    { return mix( focusColor( palette ), palette.color( QPalette::ButtonText ), 0.15 ); }

    //____________________________________________________________________

    QColor Helper::buttonHoverOutlineColor( const QPalette& palette ) const

    { return 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 ) );

        QColor focus( palette.color( QPalette::Active, QPalette::Highlight ) );

        if( mode == AnimationFocus )

        {

            outline = mix( outline, focus, opacity );

        } else if( hasFocus ) {

            outline = focus;

        }

        return outline;

    }

    //____________________________________________________________________

    QColor Helper::frameBackgroundColor( const QPalette& palette, QPalette::ColorGroup group ) const

    { return 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 mix( palette.color( group, QPalette::Text ), palette.color( group, QPalette::Base ), arrowShade );

            case QPalette::WindowText: return mix( palette.color( group, QPalette::WindowText ), palette.color( group, QPalette::Window ), arrowShade );

            case QPalette::ButtonText: return 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

    {

        Q_UNUSED(mouseOver);

        Q_UNUSED(hasFocus);

        Q_UNUSED(opacity);

        Q_UNUSED(mode);

        return palette.text().color();

    }

    //____________________________________________________________________

    QColor Helper::buttonOutlineColor( const QPalette& palette, bool mouseOver, bool hasFocus, qreal opacity, AnimationMode mode ) const

    {

        QColor outline( mix( palette.color( QPalette::Button ), palette.color( QPalette::Shadow ), 0.3 ) );

        return outline;

    }

    //____________________________________________________________________

    QColor Helper::buttonBackgroundColor( const QPalette& palette, bool mouseOver, bool hasFocus, bool sunken, qreal opacity, AnimationMode mode ) const

    {

        QColor background( palette.color( QPalette::Button ) );

        if ( mode == AnimationPressed) {

            background = background.darker(100 + 15.0 * opacity);

        } else if ( sunken ) {

            background = background.darker(115);

        } else if( mode == AnimationHover )

        {

            background = mix(background, background.lighter( 120 ), opacity);

            //if( hasFocus ) background = mix( focus, hover, opacity );

        } else if( mouseOver ) {

            background = background.lighter( 120 );

            //background = hoverColor( palette );

        }

        return background;

    }

    //____________________________________________________________________

    QColor Helper::toolButtonColor( const QPalette& palette, bool mouseOver, bool hasFocus, bool sunken, qreal opacity, AnimationMode mode ) const

    {

        if (sunken || (mode != AnimationNone && mode != AnimationHover) )

            return buttonBackgroundColor(palette, mouseOver, hasFocus, sunken, opacity, mode);

        return Qt::transparent;

    }

    //____________________________________________________________________

    QColor Helper::sliderOutlineColor( const QPalette& palette, bool mouseOver, bool hasFocus, qreal opacity, AnimationMode mode ) const

    {

        QColor outline( mix( palette.color( QPalette::Window ), palette.color( QPalette::Shadow ), 0.5 ) );

        // hover takes precedence over focus

        if( mode == AnimationHover )

        {

            QColor hover( hoverColor( palette ) );

            QColor focus( focusColor( palette ) );

            if( hasFocus ) outline = mix( focus, hover, opacity );

            else outline = mix( outline, hover, opacity );

        } else if( mouseOver ) {

            outline = hoverColor( palette );

        } else if( mode == AnimationFocus ) {

            QColor focus( focusColor( palette ) );

            outline = 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 )

        {

            QColor hover( hoverColor( palette ) );

            QColor focus( focusColor( palette ) );

            if( hasFocus ) color = mix( focus, hover, opacity );

            else color = mix( color, hover, opacity );

        } else if( mouseOver ) {

            color = hoverColor( palette );

        } else if( mode == AnimationFocus ) {

            QColor focus( focusColor( palette ) );

            color = 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

    {

        Q_UNUSED(mouseOver);

        Q_UNUSED(active);

        Q_UNUSED(opacity);

        Q_UNUSED(mode);

        return palette.text().color();

    }

    //______________________________________________________________________________

    QColor Helper::separatorColor( const QPalette& palette ) const

    { return mix( palette.color( QPalette::Window ), palette.color( QPalette::WindowText ), 0.25 ); }

    //____________________________________________________________________

    QColor Helper::headerTextColor( const QPalette& palette, const QStyle::State state ) const

    {

        QColor col(palette.color(QPalette::WindowText));

        if (state & QStyle::State_Enabled)

        {

             if (state & QStyle::State_Sunken)

                return alphaColor( col, 0.9 );

             else if (state & QStyle::State_MouseOver)

                return alphaColor( col, 0.7 );

        }

        return alphaColor( col, 0.5 );

    }

    QColor Helper::tabBarColor(const QPalette &palette, const QStyle::State state) const

    {

        QColor background( mix(palette.window().color(), palette.shadow().color(), 0.15) );

        if (!(state & QStyle::State_Enabled))

            background = background.lighter(115);

        if (!(state & QStyle::State_Active))

            background = background.lighter(115);

        return background;

    }

    //______________________________________________________________________________

    QPalette Helper::disabledPalette( const QPalette& source, qreal ratio ) const

    {

        QPalette copy( source );

        const QList<QPalette::ColorRole> roles = { QPalette::Background, QPalette::Highlight, QPalette::WindowText, QPalette::ButtonText, QPalette::Text, QPalette::Button };

        foreach( const QPalette::ColorRole& role, roles )

        { copy.setColor( role, 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( QRectF( rect ).adjusted( 0.5, 0.5, -0.5, -0.5 ) );

        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( rect );

            copy.adjust( 0.5, 0.5, -0.5, -0.5 );

            qreal radius( frameRadius( -1.0 ) );

            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();

        return;

    }

    //______________________________________________________________________________

    void Helper::renderFocusLine( QPainter* painter, const QRect& rect, const QColor& color ) const

    {

        if( !color.isValid() ) return;

        painter->save();

        QPen pen(color, 1);

        pen.setStyle(Qt::DotLine);

        painter->setRenderHint( QPainter::Antialiasing, false );

        painter->setPen( pen );

        painter->setBrush( Qt::NoBrush );

        painter->drawRoundedRect( rect, 1, 1 );

        painter->restore();

    }

    //______________________________________________________________________________

    void Helper::renderFrame(

        QPainter* painter, const QRect& rect,

        const QColor& color, const QColor& outline, bool hasFocus ) const

    {

        painter->setRenderHint( QPainter::Antialiasing );

        QRectF frameRect( rect.adjusted( 1, 1, -1, -1 ) );

        qreal radius( frameRadius() );

        // set pen

        if( outline.isValid() )

        {

            if (hasFocus) {

                painter->setPen( QPen( outline, 2 ) );

                frameRect.adjust(0.5, 0.5, -0.5, -0.5);

            }

            else {

                painter->setPen( outline );

            }

            frameRect.adjust( 0.5, 0.5, -0.5, -0.5 );

            radius = qMax( radius - 1, qreal( 0.0 ) );

        } 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::renderSquareFrame(

        QPainter* painter, const QRect& rect,

        QColor color, bool hasFocus ) const

    {

        painter->setPen( color );

        painter->drawRect( rect.adjusted(1, 1, -2, -2) );

        if (hasFocus) {

            color.setAlphaF( 0.5 );

            painter->setPen( color );

            painter->drawRect( rect.adjusted(0, 0, -1, -1) );

        }

    }

    //______________________________________________________________________________

    void Helper::renderFlatFrame(

        QPainter* painter, const QRect& rect,

        const QColor& color, const QColor& outline, bool hasFocus ) const

    {

        painter->setRenderHint( QPainter::Antialiasing );

        QRectF frameRect( rect.adjusted( 1, 1, -1, -1 ) );

        qreal radius( frameRadius() );

        // set pen

        if( outline.isValid() )

        {

            if (hasFocus) {

                painter->setPen( QPen( outline, 2 ) );

                frameRect.adjust(0.5, 0.5, -0.5, -0.5);

            }

            else {

                painter->setPen( outline );

            }

            frameRect.adjust( 0.5, 0.5, -0.5, -0.5 );

            radius = qMax( radius - 1, qreal( 0.0 ) );

        } else {

            painter->setPen( Qt::NoPen );

        }

        // set brush

        if( color.isValid() ) painter->setBrush( color );

        else painter->setBrush( Qt::NoBrush );

        QPainterPath path;

        path.setFillRule( Qt::WindingFill );

        path.addRect( frameRect.adjusted(2 * radius, 0, 0, 0) );

        path.addRoundedRect( frameRect.adjusted(0, 0, - 2 *radius, 0), radius, radius);

        painter->drawPath( path.simplified() );

        // 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( rect.adjusted( 1, 1, -1, -1 ) );

        frameRect.adjust( 0.5, 0.5, -0.5, -0.5 );

        // setup painter

        painter->setRenderHint( QPainter::Antialiasing );

        painter->setPen( outline );

        // render

        switch( side )

        {

            default:

            case SideLeft:

            frameRect.adjust( 0, 1, 0, -1 );

            painter->drawLine( frameRect.topRight(), frameRect.bottomRight() );

            break;

            case SideTop:

            frameRect.adjust( 1, 0, -1, 0 );

            painter->drawLine( frameRect.topLeft(), frameRect.topRight() );

            break;

            case SideRight:

            frameRect.adjust( 0, 1, 0, -1 );

            painter->drawLine( frameRect.topLeft(), frameRect.bottomLeft() );

            break;

            case SideBottom:

            frameRect.adjust( 1, 0, -1, 0 );

            painter->drawLine( frameRect.bottomLeft(), frameRect.bottomRight() );

            break;

            case AllSides:

            {

                qreal radius( frameRadius( -1.0 ) );

                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 );

        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, bool mouseOver, bool active ) const

    {

        // setup painter

        painter->setRenderHint( QPainter::Antialiasing, true );

        // copy rect

        QRectF frameRect( rect );

        frameRect.adjust( 1, 1, -1, -1 );

        qreal radius( frameRadius() );

        if( outline.isValid() )

        {

            painter->setPen( QPen( outline, 1.0 ) );

            frameRect.adjust( 0.5, 0.5, -0.5, -0.5 );

            radius = qMax( radius - 1, qreal( 0.0 ) );

        } else painter->setPen( Qt::NoPen );

        // content

        if( color.isValid() )

        {

            QLinearGradient gradient( frameRect.topLeft(), frameRect.bottomLeft() );

            //gradient.setColorAt( 0, color.darker( sunken ? 110 : (hasFocus|mouseOver) ? 85 : 100 ) );

            //gradient.setColorAt( 1, color.darker( sunken ? 130 : (hasFocus|mouseOver) ? 95 : 110 ) );

            if (!active) {

                gradient.setColorAt( 0, color );

            }

            else if (sunken) {

                gradient.setColorAt( 0, color );

            }

            else {

                gradient.setColorAt( 0, mix(color, Qt::white, 0.07) );

                gradient.setColorAt( 1, mix(color, Qt::black, 0.1) );

            }

            painter->setBrush( gradient );

        } else painter->setBrush( Qt::NoBrush );

        // render

        painter->drawRoundedRect( frameRect, radius, radius );

        if (!sunken && active && color.isValid()) {

            painter->setPen(color.lighter(140));

            painter->drawLine(frameRect.topLeft() + QPoint(3, 1), frameRect.topRight() + QPoint(-3, 1));

            painter->setPen(outline.darker(114));

            painter->drawLine(frameRect.bottomLeft() + QPointF(2.7, 0), frameRect.bottomRight() + QPointF(-2.7, 0));

        }

    }

    //______________________________________________________________________________

    void Helper::renderFlatButtonFrame(

        QPainter* painter, const QRect& rect,

        const QColor& color, const QColor& outline, const QColor& shadow,

        bool hasFocus, bool sunken, bool mouseOver, bool active ) const

    {

        // setup painter

        painter->setRenderHint( QPainter::Antialiasing, true );

        // copy rect

        QRectF frameRect( rect );

        frameRect.adjust( 1, 1, -1, -1 );

        qreal radius( frameRadius() );

        if( outline.isValid() )

        {

            painter->setPen( QPen( outline, 1.0 ) );

            frameRect.adjust( 0.5, 0.5, -0.5, -0.5 );

            radius = qMax( radius - 1, qreal( 0.0 ) );

        } else painter->setPen( Qt::NoPen );

        // content

        if( color.isValid() )

        {

            QLinearGradient gradient( frameRect.topLeft(), frameRect.bottomLeft() );

            //gradient.setColorAt( 0, color.darker( sunken ? 110 : (hasFocus|mouseOver) ? 85 : 100 ) );

            //gradient.setColorAt( 1, color.darker( sunken ? 130 : (hasFocus|mouseOver) ? 95 : 110 ) );

            if (!active) {

                gradient.setColorAt( 0, color );

            }

            else if (sunken) {

                gradient.setColorAt( 0, color);

            }

            else {

                gradient.setColorAt( 0, mix(color, Qt::white, 0.07) );

                gradient.setColorAt( 1, mix(color, Qt::black, 0.1) );

            }

            painter->setBrush( gradient );

        } else painter->setBrush( Qt::NoBrush );

        QPainterPath path;

        path.setFillRule( Qt::WindingFill );

        path.addRoundedRect( frameRect.adjusted(2*radius, 0, 0, 0), radius, radius );

        path.addRect( frameRect.adjusted(0, 0, -2*radius, 0) );

        painter->drawPath( path.simplified() );

        if (!sunken && active) {

            painter->setPen(color.lighter(140));

            painter->drawLine(frameRect.topLeft() + QPoint(1, 1), frameRect.topRight() + QPoint(-3, 1));

            painter->setPen(outline.darker(114));

            painter->drawLine(frameRect.bottomLeft() + QPointF(0.7, 0), frameRect.bottomRight() + QPointF(-2.7, 0));

        }

        // 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 );

        QRectF baseRect( rect );

        if( sunken )

        {

            qreal radius( frameRadius() );

            painter->setPen( Qt::NoPen );

            painter->setBrush( color );

            QRectF contentRect( baseRect.adjusted( 1, 1, -1, -1 ) );

            painter->drawRoundedRect( contentRect, radius, radius );

        } else {

            qreal radius( frameRadius(-0.5) );

            painter->setPen( color );

            painter->setBrush( Qt::NoBrush );

            QRectF outlineRect( baseRect.adjusted( 1.5, 1.5, -1.5, -1.5 ) );

            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

        qreal radius( frameRadius() );

        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( rect );

        baseRect.adjust( 0.5, 0.5, -0.5, -0.5 );

        // 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->save();

        painter->setRenderHints( QPainter::Antialiasing );

        painter->setBrush( Qt::NoBrush );

        painter->setPen( outline );

        painter->translate( baseRect.topLeft() );

        painter->drawPath( path );

        painter->restore();

        return;

    }

    //______________________________________________________________________________

    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() );

        // set pen

        if( outline.isValid() )

        {

            painter->setPen( outline );

            frameRect.adjust( 0.5, 0.5, -0.5, -0.5 );

            radius = qMax( radius-1, qreal( 0.0 ) );

        } 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->save();

        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() );

        }

        painter->restore();

        return;

    }

    //______________________________________________________________________________

    void Helper::renderCheckBoxBackground(

        QPainter* painter, const QRect& rect,

        const QColor& color, const QColor &outline, bool sunken ) const

    {

        // setup painter

        painter->setRenderHint( QPainter::Antialiasing, true );

        // copy rect and radius

        QRectF frameRect( rect );

        frameRect.adjust( 3, 3, -3, -3 );

        painter->setPen( outline );

        painter->setBrush( color );

        painter->drawRect( frameRect );

    }

    //______________________________________________________________________________

    void Helper::renderCheckBox(

        QPainter* painter, const QRect& rect,

        const QColor& background, const QColor& outline, const QColor& tickColor,

        bool sunken, CheckBoxState state, qreal animation, bool active ) const

    {

        // setup painter

        painter->save();

        painter->setRenderHint( QPainter::Antialiasing, true );