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

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

#include "adwaita.h"

#include "adwaitaanimations.h"

#include "adwaitahelper.h"

#include "adwaitamnemonics.h"

#include "adwaitapropertynames.h"

#include "adwaitasplitterproxy.h"

#include "fakeadwaitastyleconfigdata.h"

#include "adwaitawidgetexplorer.h"

#include "adwaitawindowmanager.h"

#include <QApplication>

#include <QCheckBox>

#include <QComboBox>

#include <QDial>

#include <QDialog>

#include <QDBusConnection>

#include <QDockWidget>

#include <QFormLayout>

#include <QGraphicsView>

#include <QGroupBox>

#include <QLineEdit>

#include <QMainWindow>

#include <QMdiSubWindow>

#include <QMenu>

#include <QPainter>

#include <QProxyStyle>

#include <QPushButton>

#include <QRadioButton>

#include <QScrollBar>

#include <QItemDelegate>

#include <QSplitterHandle>

#include <QTextEdit>

#include <QToolBar>

#include <QToolBox>

#include <QToolButton>

#include <QWidgetAction>

namespace AdwaitaPrivate

{

    // needed to keep track of tabbars when being dragged

    class TabBarData: public QObject

    {

        public:

        //* constructor

        explicit TabBarData( QObject* parent ):

            QObject( parent )

        {}

        //* destructor

        virtual ~TabBarData( void )

        {}

        //* assign target tabBar

        void lock( const QWidget* widget )

        { _tabBar = widget; }

        //* true if tabbar is locked

        bool isLocked( const QWidget* widget ) const

        { return _tabBar && _tabBar.data() == widget; }

        //* release

        void release( void )

        { _tabBar.clear(); }

        private:

        //* pointer to target tabBar

        Adwaita::WeakPointer<const QWidget> _tabBar;

    };

    //* needed to have spacing added to items in combobox

    class ComboBoxItemDelegate: public QItemDelegate

    {

        public:

        //* constructor

        ComboBoxItemDelegate( QAbstractItemView* parent ):

            QItemDelegate( parent ),

            _proxy( parent->itemDelegate() ),

            _itemMargin( Adwaita::Metrics::ItemView_ItemMarginWidth )

        {}

        //* destructor

        virtual ~ComboBoxItemDelegate( void )

        {}

        //* paint

        void paint( QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const

        {

            // call either proxy or parent class

            if( _proxy ) _proxy.data()->paint( painter, option, index );

            else QItemDelegate::paint( painter, option, index );

        }

        //* size hint for index

        virtual QSize sizeHint( const QStyleOptionViewItem& option, const QModelIndex& index ) const

        {

            // get size from either proxy or parent class

            QSize size( _proxy ?

                _proxy.data()->sizeHint( option, index ):

                QItemDelegate::sizeHint( option, index ) );

            // adjust and return

            if( size.isValid() ) { size.rheight() += _itemMargin*2; }

            return size;

        }

        private:

        //* proxy

        Adwaita::WeakPointer<QAbstractItemDelegate> _proxy;

        //* margin

        int _itemMargin;

    };

}

void tabLayout(const QStyleOptionTabV3 *opt, const QWidget *widget, QRect *textRect, QRect *iconRect, const QStyle *proxyStyle) {

    Q_ASSERT(textRect);

    Q_ASSERT(iconRect);

    QRect tr = opt->rect;

    bool verticalTabs = opt->shape == QTabBar::RoundedEast

                        || opt->shape == QTabBar::RoundedWest

                        || opt->shape == QTabBar::TriangularEast

                        || opt->shape == QTabBar::TriangularWest;

    if (verticalTabs)

        tr.setRect(0, 0, tr.height(), tr.width()); //0, 0 as we will have a translate transform

    int verticalShift = proxyStyle->pixelMetric(QStyle::PM_TabBarTabShiftVertical, opt, widget);

    int horizontalShift = proxyStyle->pixelMetric(QStyle::PM_TabBarTabShiftHorizontal, opt, widget);

    int hpadding = proxyStyle->pixelMetric(QStyle::PM_TabBarTabHSpace, opt, widget) / 2;

    int vpadding = proxyStyle->pixelMetric(QStyle::PM_TabBarTabVSpace, opt, widget) / 2;

    if (opt->shape == QTabBar::RoundedSouth || opt->shape == QTabBar::TriangularSouth)

        verticalShift = -verticalShift;

    tr.adjust(hpadding, verticalShift - vpadding, horizontalShift - hpadding, vpadding);

    bool selected = opt->state & QStyle::State_Selected;

    if (selected) {

        tr.setTop(tr.top() - verticalShift);

        tr.setRight(tr.right() - horizontalShift);

    }

    // left widget

    if (!opt->leftButtonSize.isEmpty()) {

        tr.setLeft(tr.left() + 4 +

            (verticalTabs ? opt->leftButtonSize.height() : opt->leftButtonSize.width()));

    }

    // right widget

    if (!opt->rightButtonSize.isEmpty()) {

        tr.setRight(tr.right() - 4 -

        (verticalTabs ? opt->rightButtonSize.height() : opt->rightButtonSize.width()));

    }

    // icon

    if (!opt->icon.isNull()) {

        QSize iconSize = opt->iconSize;

        if (!iconSize.isValid()) {

            int iconExtent = proxyStyle->pixelMetric(QStyle::PM_SmallIconSize);

            iconSize = QSize(iconExtent, iconExtent);

        }

        QSize tabIconSize = opt->icon.actualSize(iconSize,

                        (opt->state & QStyle::State_Enabled) ? QIcon::Normal : QIcon::Disabled,

                        (opt->state & QStyle::State_Selected) ? QIcon::On : QIcon::Off  );

        *iconRect = QRect(tr.left(), tr.center().y() - tabIconSize.height() / 2,

                    tabIconSize.width(), tabIconSize .height());

        if (!verticalTabs)

            *iconRect = proxyStyle->visualRect(opt->direction, opt->rect, *iconRect);

        tr.setLeft(tr.left() + tabIconSize.width() + 4);

    }

    if (!verticalTabs)

        tr = proxyStyle->visualRect(opt->direction, opt->rect, tr);

    *textRect = tr;

}

namespace Adwaita

{

    //______________________________________________________________

    Style::Style( bool dark ):

        _addLineButtons( SingleButton )

        , _subLineButtons( SingleButton )

        #if ADWAITA_USE_KDE4

        , _helper( new Helper( "adwaita" ) )

        #else

        , _helper( new Helper( ) )

        #endif

        , _animations( new Animations( this ) )

        , _mnemonics( new Mnemonics( this ) )

        , _windowManager( new WindowManager( this ) )

        , _splitterFactory( new SplitterFactory( this ) )

        , _widgetExplorer( new WidgetExplorer( this ) )

        , _tabBarData( new AdwaitaPrivate::TabBarData( this ) )

        #if ADWAITA_USE_KDE4

        , SH_ArgbDndWindow( newStyleHint( QStringLiteral( "SH_ArgbDndWindow" ) ) )

        , CE_CapacityBar( newControlElement( QStringLiteral( "CE_CapacityBar" ) ) )

        #endif

        , _dark(dark)

    {

        // use DBus connection to update on adwaita configuration change

        QDBusConnection dbus = QDBusConnection::sessionBus();

        dbus.connect( QString(),

            QStringLiteral( "/AdwaitaStyle" ),

            QStringLiteral( "org.kde.Adwaita.Style" ),

            QStringLiteral( "reparseConfiguration" ), this, SLOT(configurationChanged()) );

        dbus.connect( QString(),

            QStringLiteral( "/AdwaitaDecoration" ),

            QStringLiteral( "org.kde.Adwaita.Style" ),

            QStringLiteral( "reparseConfiguration" ), this, SLOT(configurationChanged()) );

        // Detect if running under KDE, if so set menus, etc, to have translucent background.

        // For GNOME desktop, dont want translucent backgrounds otherwise no menu shadow is drawn.

        _isKDE = qgetenv("XDG_CURRENT_DESKTOP").toLower()=="kde";

        _isGNOME = qgetenv("XDG_CURRENT_DESKTOP").toLower()=="gnome";

        // call the slot directly; this initial call will set up things that also

        // need to be reset when the system palette changes

        loadConfiguration();

    }

    //______________________________________________________________

    Style::~Style( void )

    {

        delete _helper;

    }

    //______________________________________________________________

    void Style::polish( QWidget* widget )

    {

        if( !widget ) return;

        // register widget to animations

        _animations->registerWidget( widget );

        _windowManager->registerWidget( widget );

        _splitterFactory->registerWidget( widget );

        // enable mouse over effects for all necessary widgets

        if(

            qobject_cast<QAbstractItemView*>( widget )

            || qobject_cast<QAbstractSpinBox*>( widget )

            || qobject_cast<QCheckBox*>( widget )

            || qobject_cast<QComboBox*>( widget )

            || qobject_cast<QDial*>( widget )

            || qobject_cast<QLineEdit*>( widget )

            || qobject_cast<QPushButton*>( widget )

            || qobject_cast<QRadioButton*>( widget )

            || qobject_cast<QScrollBar*>( widget )

            || qobject_cast<QSlider*>( widget )

            || qobject_cast<QSplitterHandle*>( widget )

            || qobject_cast<QTabBar*>( widget )

            || qobject_cast<QTextEdit*>( widget )

            || qobject_cast<QToolButton*>( widget )

            #if QT_VERSION >= 0x050000

            || qobject_cast<QHeaderView*>( widget )

            #endif

            || widget->inherits( "KTextEditor::View" )

            )

        { widget->setAttribute( Qt::WA_Hover ); }

        if (qobject_cast<QTabBar*>(widget)) {

            qobject_cast<QTabBar*>(widget)->setDrawBase(true);

        }

        // enforce translucency for drag and drop window

        if( widget->testAttribute( Qt::WA_X11NetWmWindowTypeDND ) && _helper->compositingActive() )

        {

            widget->setAttribute( Qt::WA_TranslucentBackground );

            widget->clearMask();

        }

        // scrollarea polishing is somewhat complex. It is moved to a dedicated method

        polishScrollArea( qobject_cast<QAbstractScrollArea*>( widget ) );

        if( QAbstractItemView *itemView = qobject_cast<QAbstractItemView*>( widget ) )

        {

            // enable mouse over effects in itemviews' viewport

            itemView->viewport()->setAttribute( Qt::WA_Hover );

        } else if( QGroupBox* groupBox = qobject_cast<QGroupBox*>( widget ) )  {

            // checkable group boxes

            if( groupBox->isCheckable() )

            { groupBox->setAttribute( Qt::WA_Hover ); }

        } else if( qobject_cast<QAbstractButton*>( widget ) && qobject_cast<QDockWidget*>( widget->parent() ) ) {

            widget->setAttribute( Qt::WA_Hover );

        } else if( qobject_cast<QAbstractButton*>( widget ) && qobject_cast<QToolBox*>( widget->parent() ) ) {

            widget->setAttribute( Qt::WA_Hover );

        } else if( qobject_cast<QFrame*>( widget ) && widget->parent() && widget->parent()->inherits( "KTitleWidget" ) ) {

            widget->setAutoFillBackground( false );

            if( !StyleConfigData::titleWidgetDrawFrame() )

            { widget->setBackgroundRole( QPalette::Window ); }

        }

        if( qobject_cast<QScrollBar*>( widget ) )

        {

            // remove opaque painting for scrollbars

            widget->setAttribute( Qt::WA_OpaquePaintEvent, false );

        } else if( widget->inherits( "KTextEditor::View" ) ) {

            addEventFilter( widget );

        } else if( QToolButton* toolButton = qobject_cast<QToolButton*>( widget ) ) {

            if( toolButton->autoRaise() )

            {

                // for flat toolbuttons, adjust foreground and background role accordingly

                widget->setBackgroundRole( QPalette::NoRole );

                widget->setForegroundRole( QPalette::WindowText );

            }

            if( widget->parentWidget() &&

                widget->parentWidget()->parentWidget() &&

                widget->parentWidget()->parentWidget()->inherits( "Gwenview::SideBarGroup" ) )

            { widget->setProperty( PropertyNames::toolButtonAlignment, Qt::AlignLeft ); }

        } else if( qobject_cast<QDockWidget*>( widget ) ) {

            // add event filter on dock widgets

            // and alter palette

            widget->setAutoFillBackground( false );

            widget->setContentsMargins( Metrics::Frame_FrameWidth, Metrics::Frame_FrameWidth, Metrics::Frame_FrameWidth, Metrics::Frame_FrameWidth );

            addEventFilter( widget );

        } else if( qobject_cast<QMdiSubWindow*>( widget ) ) {

            widget->setAutoFillBackground( false );

            addEventFilter( widget );

        } else if( qobject_cast<QToolBox*>( widget ) ) {

            widget->setBackgroundRole( QPalette::NoRole );

            widget->setAutoFillBackground( false );

        } else if( widget->parentWidget() && widget->parentWidget()->parentWidget() && qobject_cast<QToolBox*>( widget->parentWidget()->parentWidget()->parentWidget() ) ) {

            widget->setBackgroundRole( QPalette::NoRole );

            widget->setAutoFillBackground( false );

            widget->parentWidget()->setAutoFillBackground( false );

        } else if( qobject_cast<QMenu*>( widget ) ) {

            setTranslucentBackground( widget );

        #if QT_VERSION >= 0x050000

        } else if( qobject_cast<QCommandLinkButton*>( widget ) ) {

            addEventFilter( widget );

        #endif

        } else if( QComboBox *comboBox = qobject_cast<QComboBox*>( widget ) ) {

            if( !hasParent( widget, "QWebView" ) )

            {

                QAbstractItemView *itemView( comboBox->view() );

                if( itemView && itemView->itemDelegate() && itemView->itemDelegate()->inherits( "QComboBoxDelegate" ) )

                { itemView->setItemDelegate( new AdwaitaPrivate::ComboBoxItemDelegate( itemView ) ); }

            }

        } else if( widget->inherits( "QComboBoxPrivateContainer" ) ) {

            addEventFilter( widget );

            setTranslucentBackground( widget );

        } else if( widget->inherits( "QTipLabel" ) ) {

            setTranslucentBackground( widget );

        }

        if (!widget->parent() || !qobject_cast<QWidget *>(widget->parent())) {

            addEventFilter( widget );

        }

        // base class polishing

        ParentStyleClass::polish( widget );

    }

    //______________________________________________________________

    void Style::polishScrollArea( QAbstractScrollArea* scrollArea )

    {

        // check argument

        if( !scrollArea ) return;

        // enable mouse over effect in sunken scrollareas that support focus

        if( scrollArea->frameShadow() == QFrame::Sunken && scrollArea->focusPolicy()&Qt::StrongFocus )

        { scrollArea->setAttribute( Qt::WA_Hover ); }

        if( scrollArea->viewport() && scrollArea->inherits( "KItemListContainer" ) && scrollArea->frameShape() == QFrame::NoFrame )

        {

            scrollArea->viewport()->setBackgroundRole( QPalette::Window );

            scrollArea->viewport()->setForegroundRole( QPalette::WindowText );

        }

        // add event filter, to make sure proper background is rendered behind scrollbars

        addEventFilter( scrollArea );

        // force side panels as flat, on option

        if( scrollArea->inherits( "KDEPrivate::KPageListView" ) || scrollArea->inherits( "KDEPrivate::KPageTreeView" ) )

        { scrollArea->setProperty( PropertyNames::sidePanelView, true ); }

        // for all side view panels, unbold font (design choice)

        if( scrollArea->property( PropertyNames::sidePanelView ).toBool() )

        {

            // upbold list font

            QFont font( scrollArea->font() );

            font.setBold( false );

            scrollArea->setFont( font );

            // adjust background role

            if( !StyleConfigData::sidePanelDrawFrame() )

            {

                scrollArea->setBackgroundRole( QPalette::Window );

                scrollArea->setForegroundRole( QPalette::WindowText );

                if( scrollArea->viewport() )

                {

                    scrollArea->viewport()->setBackgroundRole( QPalette::Window );

                    scrollArea->viewport()->setForegroundRole( QPalette::WindowText );

                }

            }

        }

        // disable autofill background for flat (== NoFrame) scrollareas, with QPalette::Window as a background

        // this fixes flat scrollareas placed in a tinted widget, such as groupboxes, tabwidgets or framed dock-widgets

        if( !(scrollArea->frameShape() == QFrame::NoFrame || scrollArea->backgroundRole() == QPalette::Window ) )

        { return; }

        // get viewport and check background role

        QWidget* viewport( scrollArea->viewport() );

        if( !( viewport && viewport->backgroundRole() == QPalette::Window ) ) return;

        // change viewport autoFill background.

        // do the same for all children if the background role is QPalette::Window

        viewport->setAutoFillBackground( false );

        QList<QWidget*> children( viewport->findChildren<QWidget*>() );

        foreach( QWidget* child, children )

        {

            if( child->parent() == viewport && child->backgroundRole() == QPalette::Window )

            { child->setAutoFillBackground( false ); }

        }

    }

    //_______________________________________________________________

    void Style::unpolish( QWidget* widget )

    {

        // register widget to animations

        _animations->unregisterWidget( widget );

        _windowManager->unregisterWidget( widget );

        _splitterFactory->unregisterWidget( widget );

        // remove event filter

        if( qobject_cast<QAbstractScrollArea*>( widget ) ||

            qobject_cast<QDockWidget*>( widget ) ||

            qobject_cast<QMdiSubWindow*>( widget ) ||

            widget->inherits( "QComboBoxPrivateContainer" ) ||

            qobject_cast<QDialog *>(widget) ||

            qobject_cast<QMainWindow *>(widget))

            { widget->removeEventFilter( this ); }

        ParentStyleClass::unpolish( widget );

    }

    void Style::polish(QPalette &palette)

    {

        if (_dark) {

            palette.setColor(QPalette::All,      QPalette::Window,          QColor("#33393b"));

            palette.setColor(QPalette::All,      QPalette::WindowText,      QColor("white"));

            palette.setColor(QPalette::All,      QPalette::Base,            QColor("#232729"));

            palette.setColor(QPalette::All,      QPalette::AlternateBase,   QColor("#1c1f20"));

            palette.setColor(QPalette::All,      QPalette::ToolTipBase,     QColor("#1c1f20"));

            palette.setColor(QPalette::All,      QPalette::ToolTipText,     QColor("white"));

            palette.setColor(QPalette::All,      QPalette::Text,            QColor("white"));

            palette.setColor(QPalette::All,      QPalette::Button,          QColor("#25292b"));

            palette.setColor(QPalette::All,      QPalette::ButtonText,      QColor("white"));

            palette.setColor(QPalette::All,      QPalette::BrightText,      QColor("black"));

            palette.setColor(QPalette::All,      QPalette::Light,           QColor("white"));

            palette.setColor(QPalette::All,      QPalette::Midlight,        QColor("#d7d7d7"));

            palette.setColor(QPalette::All,      QPalette::Mid,             QColor("#b4b4b4"));

            palette.setColor(QPalette::All,      QPalette::Dark,            QColor("#1a1a1a"));

            palette.setColor(QPalette::All,      QPalette::Shadow,          QColor("black"));

            palette.setColor(QPalette::All,      QPalette::Highlight,       QColor("#4a90d9"));

            palette.setColor(QPalette::All,      QPalette::HighlightedText, QColor("white"));

            palette.setColor(QPalette::All,      QPalette::Link,            QColor("#2a76c6"));

            palette.setColor(QPalette::All,      QPalette::LinkVisited,     QColor("#2a76c6"));

            palette.setColor(QPalette::Disabled, QPalette::Window,          QColor("#2e3436"));

            palette.setColor(QPalette::Disabled, QPalette::WindowText,      QColor("#8d9091"));

            palette.setColor(QPalette::Disabled, QPalette::Base,            QColor("#3d4244"));

            palette.setColor(QPalette::Disabled, QPalette::AlternateBase,   QColor("#3a3d3e"));

            palette.setColor(QPalette::Disabled, QPalette::Text,            QColor("#8d9091"));

            palette.setColor(QPalette::Disabled, QPalette::Button,          QColor("#33393b"));

            palette.setColor(QPalette::Disabled, QPalette::ButtonText,      QColor("#8d9091"));

            palette.setColor(QPalette::Disabled, QPalette::BrightText,      QColor("#ededed"));

            palette.setColor(QPalette::Disabled, QPalette::Light,           QColor("#f4f4f4"));

            palette.setColor(QPalette::Disabled, QPalette::Midlight,        QColor("#f4f4f4"));

            palette.setColor(QPalette::Disabled, QPalette::Dark,            QColor("#f4f4f4"));

            palette.setColor(QPalette::Disabled, QPalette::Mid,             QColor("#c3c3c3"));

            palette.setColor(QPalette::Disabled, QPalette::Shadow,          QColor("black"));

            palette.setColor(QPalette::Disabled, QPalette::Highlight,       QColor("#4a90d9"));

            palette.setColor(QPalette::Disabled, QPalette::HighlightedText, QColor("white"));

            palette.setColor(QPalette::Disabled, QPalette::Link,            QColor("#4a90d9"));

            palette.setColor(QPalette::Disabled, QPalette::LinkVisited,     QColor("#4a90d9"));

            palette.setColor(QPalette::Inactive, QPalette::Window,          QColor("#33393b"));

            palette.setColor(QPalette::Inactive, QPalette::WindowText,      QColor("#d3d4d5"));

            palette.setColor(QPalette::Inactive, QPalette::Base,            QColor("#252a2c"));

            palette.setColor(QPalette::Inactive, QPalette::AlternateBase,   QColor("#1d2021"));

            palette.setColor(QPalette::Inactive, QPalette::Text,            QColor("#d3d4d5"));

            palette.setColor(QPalette::Inactive, QPalette::Button,          QColor("#33393b"));

            palette.setColor(QPalette::Inactive, QPalette::ButtonText,      QColor("#eeeeec"));

            palette.setColor(QPalette::Inactive, QPalette::BrightText,      QColor("#d3d4d5"));

            palette.setColor(QPalette::Inactive, QPalette::Light,           QColor("white"));

            palette.setColor(QPalette::Inactive, QPalette::Midlight,        QColor("#d7d7d7"));

            palette.setColor(QPalette::Inactive, QPalette::Mid,             QColor("#b4b4b4"));

            palette.setColor(QPalette::Inactive, QPalette::Dark,            QColor("#33393b"));

            palette.setColor(QPalette::Inactive, QPalette::Shadow,          QColor("black"));

            palette.setColor(QPalette::Inactive, QPalette::Highlight,       QColor("#4a90d9"));

            palette.setColor(QPalette::Inactive, QPalette::HighlightedText, QColor("white"));

            palette.setColor(QPalette::Inactive, QPalette::Link,            QColor("#4a90d9"));

            palette.setColor(QPalette::Inactive, QPalette::LinkVisited,     QColor("#4a90d9"));

        }

        else {

            palette.setColor(QPalette::All,      QPalette::Window,          QColor("#ededed"));

            palette.setColor(QPalette::All,      QPalette::WindowText,      QColor("#2e3436"));

            palette.setColor(QPalette::All,      QPalette::Base,            QColor("white"));

            palette.setColor(QPalette::All,      QPalette::AlternateBase,   QColor("#ededed"));

            palette.setColor(QPalette::All,      QPalette::ToolTipBase,     QColor("#060606"));

            palette.setColor(QPalette::All,      QPalette::ToolTipText,     QColor("white"));

            palette.setColor(QPalette::All,      QPalette::Text,            QColor("#2e3436"));

            palette.setColor(QPalette::All,      QPalette::Button,          QColor("#eeeeee"));

            palette.setColor(QPalette::All,      QPalette::ButtonText,      QColor("#2e3436"));

            palette.setColor(QPalette::All,      QPalette::BrightText,      QColor("white"));

            palette.setColor(QPalette::All,      QPalette::Light,           QColor("#fafafa"));

            palette.setColor(QPalette::All,      QPalette::Midlight,        QColor("#f3f3f3"));

            palette.setColor(QPalette::All,      QPalette::Dark,            QColor("#d3d3d3"));

            palette.setColor(QPalette::All,      QPalette::Mid,             QColor("#b4b4b4"));

            palette.setColor(QPalette::All,      QPalette::Shadow,          QColor("black"));

            palette.setColor(QPalette::All,      QPalette::Highlight,       QColor("#4a90d9"));

            palette.setColor(QPalette::All,      QPalette::HighlightedText, QColor("white"));

            palette.setColor(QPalette::All,      QPalette::Link,            QColor("#2a76c6"));

            palette.setColor(QPalette::All,      QPalette::LinkVisited,     QColor("#2a76c6"));

            palette.setColor(QPalette::Disabled, QPalette::Window,          QColor("#f4f4f4"));

            palette.setColor(QPalette::Disabled, QPalette::WindowText,      QColor("#8d9091"));

            palette.setColor(QPalette::Disabled, QPalette::Base,            QColor("white"));

            palette.setColor(QPalette::Disabled, QPalette::AlternateBase,   QColor("#ededed"));

            palette.setColor(QPalette::Disabled, QPalette::Text,            QColor("#8d9091"));

            palette.setColor(QPalette::Disabled, QPalette::Button,          QColor("#f4f4f4"));

            palette.setColor(QPalette::Disabled, QPalette::ButtonText,      QColor("#8d9091"));

            palette.setColor(QPalette::Disabled, QPalette::BrightText,      QColor("#ededed"));

            palette.setColor(QPalette::Disabled, QPalette::Light,           QColor("#f4f4f4"));

            palette.setColor(QPalette::Disabled, QPalette::Midlight,        QColor("#f4f4f4"));

            palette.setColor(QPalette::Disabled, QPalette::Dark,            QColor("#f4f4f4"));

            palette.setColor(QPalette::Disabled, QPalette::Mid,             QColor("#c3c3c3"));

            palette.setColor(QPalette::Disabled, QPalette::Shadow,          QColor("black"));

            palette.setColor(QPalette::Disabled, QPalette::Highlight,       QColor("#4a90d9"));

            palette.setColor(QPalette::Disabled, QPalette::HighlightedText, QColor("white"));

            palette.setColor(QPalette::Disabled, QPalette::Link,            QColor("#4a90d9"));

            palette.setColor(QPalette::Disabled, QPalette::LinkVisited,     QColor("#4a90d9"));

            palette.setColor(QPalette::Inactive, QPalette::Window,          QColor("#ededed"));

            palette.setColor(QPalette::Inactive, QPalette::WindowText,      QColor("#54595a"));

            palette.setColor(QPalette::Inactive, QPalette::Base,            QColor("#fcfcfc"));

            palette.setColor(QPalette::Inactive, QPalette::AlternateBase,   QColor("#ededed"));

            palette.setColor(QPalette::Inactive, QPalette::Text,            QColor("#54595a"));

            palette.setColor(QPalette::Inactive, QPalette::Button,          QColor("#ededed"));

            palette.setColor(QPalette::Inactive, QPalette::ButtonText,      QColor("#54595a"));

            palette.setColor(QPalette::Inactive, QPalette::BrightText,      QColor("#ededed"));

            palette.setColor(QPalette::Inactive, QPalette::Light,           QColor("#ededed"));

            palette.setColor(QPalette::Inactive, QPalette::Midlight,        QColor("#ededed"));

            palette.setColor(QPalette::Inactive, QPalette::Dark,            QColor("#ededed"));

            palette.setColor(QPalette::Inactive, QPalette::Mid,             QColor("#c3c3c3"));

            palette.setColor(QPalette::Inactive, QPalette::Shadow,          QColor("black"));

            palette.setColor(QPalette::Inactive, QPalette::Highlight,       QColor("#4a90d9"));

            palette.setColor(QPalette::Inactive, QPalette::HighlightedText, QColor("white"));

            palette.setColor(QPalette::Inactive, QPalette::Link,            QColor("#4a90d9"));

            palette.setColor(QPalette::Inactive, QPalette::LinkVisited,     QColor("#4a90d9"));

        }

    }

    //______________________________________________________________

    int Style::pixelMetric( PixelMetric metric, const QStyleOption* option, const QWidget* widget ) const

    {

        // handle special cases

        switch( metric )

        {

            // frame width

            case PM_DefaultFrameWidth:

            if ( widget && widget->inherits("QComboBoxPrivateContainer") ) return 1;

            if( qobject_cast<const QMenu*>( widget ) ) return Metrics::Menu_FrameWidth;

            if( qobject_cast<const QLineEdit*>( widget ) ) return Metrics::LineEdit_FrameWidth;

            if( qobject_cast<const QAbstractScrollArea*>( widget ) ) return Metrics::ScrollArea_FrameWidth;

            #if QT_VERSION >= 0x050000

            else if( isQtQuickControl( option, widget ) )

            {

                const QString &elementType = option->styleObject->property( "elementType" ).toString();

                if( elementType == QLatin1String( "edit" ) || elementType == QLatin1String( "spinbox" ) )

                {

                    return Metrics::LineEdit_FrameWidth;

                } else if( elementType == QLatin1String( "combobox" ) ) {

                    return Metrics::ComboBox_FrameWidth;

                }

            }

            #endif

            // fallback

            return Metrics::Frame_FrameWidth;

            case PM_ComboBoxFrameWidth:

            {

                const QStyleOptionComboBox* comboBoxOption( qstyleoption_cast< const QStyleOptionComboBox*>( option ) );

                return comboBoxOption && comboBoxOption->editable ? Metrics::LineEdit_FrameWidth : Metrics::ComboBox_FrameWidth;

            }

            case PM_SpinBoxFrameWidth: return Metrics::SpinBox_FrameWidth;

            case PM_ToolBarFrameWidth: return Metrics::ToolBar_FrameWidth;

            case PM_ToolTipLabelFrameWidth: return Metrics::ToolTip_FrameWidth;

            // layout

            case PM_LayoutLeftMargin:

            case PM_LayoutTopMargin:

            case PM_LayoutRightMargin:

            case PM_LayoutBottomMargin:

            {

                /*

                 * use either Child margin or TopLevel margin,

                 * depending on  widget type

                 */

                if( ( option && ( option->state & QStyle::State_Window ) ) || ( widget && widget->isWindow() ) )

                {

                    return Metrics::Layout_TopLevelMarginWidth;

                } else if( widget && widget->inherits( "KPageView" ) ) {

                    return 0;

                } else {

                    return Metrics::Layout_ChildMarginWidth;

                }

            }

            case PM_LayoutHorizontalSpacing: return Metrics::Layout_DefaultSpacing;

            case PM_LayoutVerticalSpacing: return Metrics::Layout_DefaultSpacing;

            // buttons

            case PM_ButtonMargin:

            {

                // needs special case for kcalc buttons, to prevent the application to set too small margins

                if( widget && widget->inherits( "KCalcButton" ) ) return Metrics::Button_MarginWidth + 4;

                else return Metrics::Button_MarginWidth;

            }

            case PM_ButtonDefaultIndicator: return 0;

            case PM_ButtonShiftHorizontal: return 0;

            case PM_ButtonShiftVertical: return 0;

            // menubars

            case PM_MenuBarPanelWidth: return 0;

            case PM_MenuBarHMargin: return 0;

            case PM_MenuBarVMargin: return 0;

            case PM_MenuBarItemSpacing: return 0;

            case PM_MenuDesktopFrameWidth: return 0;

            // menu buttons

            case PM_MenuButtonIndicator: return Metrics::MenuButton_IndicatorWidth;

            case PM_MenuVMargin: return 2;

            case PM_MenuHMargin: return _isGNOME ? 0 : 1;

            // toolbars

            case PM_ToolBarHandleExtent: return Metrics::ToolBar_HandleExtent;

            case PM_ToolBarSeparatorExtent: return Metrics::ToolBar_SeparatorWidth;

            case PM_ToolBarExtensionExtent:

            return pixelMetric( PM_SmallIconSize, option, widget ) + 2*Metrics::ToolButton_MarginWidth;

            case PM_ToolBarItemMargin: return 0;

            case PM_ToolBarItemSpacing: return Metrics::ToolBar_ItemSpacing;

            // tabbars

            case PM_TabBarTabShiftVertical: return 0;

            case PM_TabBarTabShiftHorizontal: return 0;

            case PM_TabBarTabOverlap: return Metrics::TabBar_TabOverlap;

            case PM_TabBarBaseOverlap: return Metrics::TabBar_BaseOverlap;

            case PM_TabBarTabHSpace: return 2*Metrics::TabBar_TabMarginWidth;

            case PM_TabBarTabVSpace: return 2*Metrics::TabBar_TabMarginHeight;

            case PM_TabCloseIndicatorWidth:

            case PM_TabCloseIndicatorHeight:

            return pixelMetric( PM_SmallIconSize, option, widget );

            // scrollbars

            case PM_ScrollBarExtent: return Metrics::ScrollBar_Extend;

            case PM_ScrollBarSliderMin: return Metrics::ScrollBar_MinSliderHeight;

            // title bar

            case PM_TitleBarHeight: return 2*Metrics::TitleBar_MarginWidth + pixelMetric( PM_SmallIconSize, option, widget );

            // sliders

            case PM_SliderThickness: return Metrics::Slider_ControlThickness;

            case PM_SliderControlThickness: return Metrics::Slider_ControlThickness;

            case PM_SliderLength: return Metrics::Slider_ControlThickness;

            // checkboxes and radio buttons

            case PM_IndicatorWidth: return Metrics::CheckBox_Size;

            case PM_IndicatorHeight: return Metrics::CheckBox_Size;

            case PM_ExclusiveIndicatorWidth: return Metrics::CheckBox_Size;

            case PM_ExclusiveIndicatorHeight: return Metrics::CheckBox_Size;

            // list heaaders

            case PM_HeaderMarkSize: return Metrics::Header_ArrowSize;

            case PM_HeaderMargin: return Metrics::Header_MarginWidth;

            // dock widget

            // return 0 here, since frame is handled directly in polish

            case PM_DockWidgetFrameWidth: return 0;

            case PM_DockWidgetTitleMargin: return Metrics::Frame_FrameWidth;

            case PM_DockWidgetTitleBarButtonMargin: return Metrics::ToolButton_MarginWidth;

            case PM_SplitterWidth: return Metrics::Splitter_SplitterWidth;

            case PM_DockWidgetSeparatorExtent: return Metrics::Splitter_SplitterWidth;

            // fallback

            default: return ParentStyleClass::pixelMetric( metric, option, widget );

        }

    }

    //______________________________________________________________

    int Style::styleHint( StyleHint hint, const QStyleOption* option, const QWidget* widget, QStyleHintReturn* returnData ) const

    {

        switch( hint )

        {

            case SH_RubberBand_Mask:

            {

                if( QStyleHintReturnMask *mask = qstyleoption_cast<QStyleHintReturnMask*>( returnData ) )

                {

                    mask->region = option->rect;

                    /*

                     * need to check on widget before removing inner region

                     * in order to still preserve rubberband in MainWindow and QGraphicsView

                     * in QMainWindow because it looks better

                     * in QGraphicsView because the painting fails completely otherwise

                     */

                    if( widget && (

                        qobject_cast<const QAbstractItemView*>( widget->parent() ) ||

                        qobject_cast<const QGraphicsView*>( widget->parent() ) ||

                        qobject_cast<const QMainWindow*>( widget->parent() ) ) )

                    { return true; }

                    // also check if widget's parent is some itemView viewport

                    if( widget && widget->parent() &&

                        qobject_cast<const QAbstractItemView*>( widget->parent()->parent() ) &&

                        static_cast<const QAbstractItemView*>( widget->parent()->parent() )->viewport() == widget->parent() )

                    { return true; }

                    // mask out center

                    mask->region -= insideMargin( option->rect, 1 );

                    return true;

                }

                return false;

            }

            case SH_ComboBox_ListMouseTracking: return true;

            case SH_MenuBar_MouseTracking: return true;

            case SH_Menu_MouseTracking: return true;

            case SH_Menu_SubMenuPopupDelay: return 150;

            case SH_Menu_SloppySubMenus: return true;

            #if QT_VERSION >= 0x050000

            case SH_Widget_Animate: return StyleConfigData::animationsEnabled();

            case SH_Menu_SupportsSections: return true;

            #endif

            case SH_DialogButtonBox_ButtonsHaveIcons: return false;

            case SH_GroupBox_TextLabelVerticalAlignment: return Qt::AlignVCenter;

            case SH_TabBar_Alignment: return StyleConfigData::tabBarDrawCenteredTabs() ? Qt::AlignCenter:Qt::AlignLeft;

            case SH_ToolBox_SelectedPageTitleBold: return false;

            case SH_ScrollBar_MiddleClickAbsolutePosition: return true;

            case SH_ScrollView_FrameOnlyAroundContents: return false;

            case SH_FormLayoutFormAlignment: return Qt::AlignLeft | Qt::AlignTop;

            case SH_FormLayoutLabelAlignment: return Qt::AlignRight;

            case SH_FormLayoutFieldGrowthPolicy: return QFormLayout::ExpandingFieldsGrow;

            case SH_FormLayoutWrapPolicy: return QFormLayout::DontWrapRows;

            case SH_MessageBox_TextInteractionFlags: return Qt::TextSelectableByMouse | Qt::LinksAccessibleByMouse;

            case SH_ProgressDialog_CenterCancelButton: return false;

            case SH_MessageBox_CenterButtons: return false;

            case SH_RequestSoftwareInputPanel: return RSIP_OnMouseClick;

            case SH_TitleBar_NoBorder: return true;