MCL/sf/mw/qt: comparison src/gui/styles/qgtkstyle.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 #include <QtGui/QRadioButton>
 #include <QtGui/QCheckBox>
 #include <QtGui/QTreeView>
 #include <qpixmapcache.h>
 #undef signals // Collides with GTK stymbols
-#include "qgtkpainter_p.h"
+#include <private/qgtkpainter_p.h>
-#include "qstylehelper_p.h"
+#include <private/qstylehelper_p.h>
+#include <private/qgtkstyle_p.h>
 #include <private/qcleanlooksstyle_p.h>
 QT_BEGIN_NAMESPACE
-typedef QStringList (*_qt_filedialog_open_filenames_hook)(QWidget * parent, const QString &caption, const QString &dir,
-const QString &filter, QString *selectedFilter, QFileDialog::Options options);
-typedef QString (*_qt_filedialog_open_filename_hook)     (QWidget * parent, const QString &caption, const QString &dir,
-const QString &filter, QString *selectedFilter, QFileDialog::Options options);
-typedef QString (*_qt_filedialog_save_filename_hook)     (QWidget * parent, const QString &caption, const QString &dir,
-const QString &filter, QString *selectedFilter, QFileDialog::Options options);
-typedef QString (*_qt_filedialog_existing_directory_hook)(QWidget *parent, const QString &caption, const QString &dir,
-QFileDialog::Options options);
-extern Q_GUI_EXPORT _qt_filedialog_open_filename_hook qt_filedialog_open_filename_hook;
-extern Q_GUI_EXPORT _qt_filedialog_open_filenames_hook qt_filedialog_open_filenames_hook;
-extern Q_GUI_EXPORT _qt_filedialog_save_filename_hook qt_filedialog_save_filename_hook;
-extern Q_GUI_EXPORT _qt_filedialog_existing_directory_hook qt_filedialog_existing_directory_hook;
 static const char * const dock_widget_close_xpm[] =
 {
 "11 13 5 1",
 "  c None",
 "@+       +@",
 " @@@@@@@@@ ",
 "           "
 };
-class QGtkStyleFilter : public QObject
-{
-public:
-QGtkStyleFilter() {}
-private:
-bool eventFilter(QObject *obj, QEvent *e);
-};
-bool QGtkStyleFilter::eventFilter(QObject *obj, QEvent *e)
-{
-if (e->type() == QEvent::ApplicationPaletteChange) {
-// Only do this the first time since this will also
-// generate applicationPaletteChange events
-if (!qt_app_palettes_hash() ||  qt_app_palettes_hash()->isEmpty()) {
-QGtk::applyCustomPaletteHash();
-}
-}
-return QObject::eventFilter(obj, e);
-}
-class QGtkStylePrivate : public QCleanlooksStylePrivate
-{
-Q_DECLARE_PUBLIC(QGtkStyle)
-public:
-QGtkStylePrivate()
-: QCleanlooksStylePrivate()
-{
-QGtk::initGtkWidgets();
-if (QGtk::isThemeAvailable())
-qApp->installEventFilter(&filter);
-}
-QGtkStyleFilter filter;
-};
 static const int groupBoxBottomMargin    =  2;  // space below the groupbox
 static const int groupBoxTitleMargin     =  6;  // space between contents and title
 static const int groupBoxTopMargin       =  2;
-// Get size of the arrow controls in a GtkSpinButton
+/*!
-static int spinboxArrowSize()
+Returns the configuration string for \a value.
+Returns \a fallback if \a value is not found.
+*/
+QString QGtkStyle::getGConfString(const QString &value, const QString &fallback)
 {
-const int MIN_ARROW_WIDTH = 6;
+return QGtkStylePrivate::getGConfString(value, fallback);
-GtkWidget *spinButton = QGtk::gtkWidget(QLS("GtkSpinButton"));
+}
-GtkStyle *style = spinButton->style;
-gint size = QGtk::pango_font_description_get_size (style->font_desc);
+/*!
-gint arrow_size;
+Returns the configuration boolean for \a key.
-arrow_size = qMax(PANGO_PIXELS (size), MIN_ARROW_WIDTH) + style->xthickness;
+Returns \a fallback if \a key is not found.
-arrow_size += arrow_size%2 + 1;
+*/
-return arrow_size;
+bool QGtkStyle::getGConfBool(const QString &key, bool fallback)
+{
+return QGtkStylePrivate::getGConfBool(key, fallback);
 }
 static QColor mergedColors(const QColor &colorA, const QColor &colorB, int factor = 50)
 {
 const int maxFactor = 100;
 Constructs a QGtkStyle object.
 */
 QGtkStyle::QGtkStyle()
 : QCleanlooksStyle(*new QGtkStylePrivate)
 {
+Q_D(QGtkStyle);
+d->init();
 }
+/*!
+\internal
+Constructs a QGtkStyle object.
+*/
+QGtkStyle::QGtkStyle(QGtkStylePrivate &dd)
+: QCleanlooksStyle(dd)
+{
+Q_D(QGtkStyle);
+d->init();
+}
 /*!
 Destroys the QGtkStyle object.
 */
 QGtkStyle::~QGtkStyle()
 /*!
 \reimp
 */
 QPalette QGtkStyle::standardPalette() const
 {
+Q_D(const QGtkStyle);
 QPalette palette = QCleanlooksStyle::standardPalette();
-if (QGtk::isThemeAvailable()) {
+if (d->isThemeAvailable()) {
-GtkStyle *style = QGtk::gtkStyle();
+GtkStyle *style = d->gtkStyle();
-GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
-GtkWidget *gtkEntry = QGtk::gtkWidget(QLS("GtkEntry"));
+GtkWidget *gtkEntry = d->getTextColorWidget();
 GdkColor gdkBg, gdkBase, gdkText, gdkForeground, gdkSbg, gdkSfg;
 QColor bg, base, text, fg, highlight, highlightText;
 gdkBg = style->bg[GTK_STATE_NORMAL];
 gdkForeground = gtkButton->style->fg[GTK_STATE_NORMAL];
 palette.setColor(QPalette::WindowText, fg);
 palette.setColor(QPalette::ButtonText, fg);
 palette.setColor(QPalette::Base, base);
 QColor alternateRowColor = palette.base().color().lighter(93); // ref gtkstyle.c draw_flat_box
-GtkWidget *gtkTreeView = QGtk::gtkWidget(QLS("GtkTreeView"));
+GtkWidget *gtkTreeView = d->gtkWidget(QLS("GtkTreeView"));
 GdkColor *gtkAltBase = NULL;
-QGtk::gtk_widget_style_get(gtkTreeView, "odd-row-color", &gtkAltBase, NULL);
+d->gtk_widget_style_get(gtkTreeView, "odd-row-color", &gtkAltBase, NULL);
 if (gtkAltBase) {
 alternateRowColor = QColor(gtkAltBase->red>>8, gtkAltBase->green>>8, gtkAltBase->blue>>8);
-QGtk::gdk_color_free(gtkAltBase);
+d->gdk_color_free(gtkAltBase);
 }
 palette.setColor(QPalette::AlternateBase, alternateRowColor);
 palette.setColor(QPalette::Window, bg);
 palette.setColor(QPalette::Button, bg);
 // calculate disabled colors by removing saturation
 highlight.setHsv(highlight.hue(), 0, highlight.value(), highlight.alpha());
 highlightText.setHsv(highlightText.hue(), 0, highlightText.value(), highlightText.alpha());
 palette.setColor(QPalette::Disabled, QPalette::Highlight, highlight);
 palette.setColor(QPalette::Disabled, QPalette::HighlightedText, highlightText);
-style = QGtk::gtk_rc_get_style_by_paths(QGtk::gtk_settings_get_default(), "gtk-tooltips", "GtkWindow", Q_GTK_TYPE_WINDOW);
+style = d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(), "gtk-tooltips", "GtkWindow",
+d->gtk_window_get_type());
 if (style) {
 gdkText = style->fg[GTK_STATE_NORMAL];
 text = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
 palette.setColor(QPalette::ToolTipText, text);
 }
 /*!
 \reimp
 */
 void QGtkStyle::polish(QPalette &palette)
 {
+Q_D(QGtkStyle);
 // QCleanlooksStyle will alter the palette, hence we do
 // not want to polish the palette unless we are using it as
 // the fallback
-if (!QGtk::isThemeAvailable())
+if (!d->isThemeAvailable())
 QCleanlooksStyle::polish(palette);
 else
 palette = palette.resolve(standardPalette());
 }
 /*!
 \reimp
 */
 void QGtkStyle::polish(QApplication *app)
 {
+Q_D(QGtkStyle);
 QCleanlooksStyle::polish(app);
 // Custom fonts and palettes with QtConfig are intentionally
 // not supported as these should be entirely determined by
 // current Gtk settings
-if (app->desktopSettingsAware() && QGtk::isThemeAvailable()) {
+if (app->desktopSettingsAware() && d->isThemeAvailable()) {
 QApplicationPrivate::setSystemPalette(standardPalette());
-QApplicationPrivate::setSystemFont(QGtk::getThemeFont());
+QApplicationPrivate::setSystemFont(d->getThemeFont());
-QGtk::applyCustomPaletteHash();
+d->applyCustomPaletteHash();
-if (!QGtk::isKDE4Session()) {
+if (!d->isKDE4Session()) {
-qt_filedialog_open_filename_hook = &QGtk::openFilename;
+qt_filedialog_open_filename_hook = &QGtkStylePrivate::openFilename;
-qt_filedialog_save_filename_hook = &QGtk::saveFilename;
+qt_filedialog_save_filename_hook = &QGtkStylePrivate::saveFilename;
-qt_filedialog_open_filenames_hook = &QGtk::openFilenames;
+qt_filedialog_open_filenames_hook = &QGtkStylePrivate::openFilenames;
-qt_filedialog_existing_directory_hook = &QGtk::openDirectory;
+qt_filedialog_existing_directory_hook = &QGtkStylePrivate::openDirectory;
 }
 }
 }
 /*!
 \reimp
 */
 void QGtkStyle::unpolish(QApplication *app)
 {
+Q_D(QGtkStyle);
 QCleanlooksStyle::unpolish(app);
 QPixmapCache::clear();
-if (app->desktopSettingsAware() && QGtk::isThemeAvailable()
+if (app->desktopSettingsAware() && d->isThemeAvailable()
-&& !QGtk::isKDE4Session()) {
+&& !d->isKDE4Session()) {
 qt_filedialog_open_filename_hook = 0;
 qt_filedialog_save_filename_hook = 0;
 qt_filedialog_open_filenames_hook = 0;
 qt_filedialog_existing_directory_hook = 0;
 }
 \reimp
 */
 void QGtkStyle::polish(QWidget *widget)
 {
+Q_D(QGtkStyle);
 QCleanlooksStyle::polish(widget);
-if (!QGtk::isThemeAvailable())
+if (!d->isThemeAvailable())
 return;
 if (qobject_cast<QAbstractButton*>(widget)
 || qobject_cast<QToolButton*>(widget)
 || qobject_cast<QComboBox*>(widget)
 || qobject_cast<QGroupBox*>(widget)
 /*!
 \reimp
 */
 int QGtkStyle::pixelMetric(PixelMetric metric,
 const QStyleOption *option,
 const QWidget *widget) const
 {
-if (!QGtk::isThemeAvailable())
+Q_D(const QGtkStyle);
+if (!d->isThemeAvailable())
 return QCleanlooksStyle::pixelMetric(metric, option, widget);
 switch (metric) {
 case PM_DefaultFrameWidth:
 if (qobject_cast<const QFrame*>(widget)) {
 if (GtkStyle *style =
-QGtk::gtk_rc_get_style_by_paths(QGtk::gtk_settings_get_default(),
+d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(),
 "*.GtkScrolledWindow",
 "*.GtkScrolledWindow",
-Q_GTK_TYPE_WINDOW))
+d->gtk_window_get_type()))
 return qMax(style->xthickness, style->ythickness);
 }
 return 2;
 case PM_MenuButtonIndicator:
 case PM_ToolBarItemSpacing:
 return 0;
 case PM_ButtonShiftHorizontal: {
-GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
 guint horizontal_shift;
-QGtk::gtk_widget_style_get(gtkButton, "child-displacement-x", &horizontal_shift, NULL);
+d->gtk_widget_style_get(gtkButton, "child-displacement-x", &horizontal_shift, NULL);
 return horizontal_shift;
 }
 case PM_ButtonShiftVertical: {
-GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
 guint vertical_shift;
-QGtk::gtk_widget_style_get(gtkButton, "child-displacement-y", &vertical_shift, NULL);
+d->gtk_widget_style_get(gtkButton, "child-displacement-y", &vertical_shift, NULL);
 return vertical_shift;
 }
 case PM_MenuBarPanelWidth:
 return 0;
 case PM_MenuPanelWidth: {
-GtkWidget *gtkMenu = QGtk::gtkWidget(QLS("GtkMenu"));
+GtkWidget *gtkMenu = d->gtkWidget(QLS("GtkMenu"));
 guint horizontal_padding = 0;
 // horizontal-padding is used by Maemo to get thicker borders
-if (!QGtk::gtk_check_version(2, 10, 0))
+if (!d->gtk_check_version(2, 10, 0))
-QGtk::gtk_widget_style_get(gtkMenu, "horizontal-padding", &horizontal_padding, NULL);
+d->gtk_widget_style_get(gtkMenu, "horizontal-padding", &horizontal_padding, NULL);
 int padding = qMax<int>(gtkMenu->style->xthickness, horizontal_padding);
 return padding;
 }
 case PM_ButtonIconSize: {
 int retVal = 24;
-GtkSettings *settings = QGtk::gtk_settings_get_default();
+GtkSettings *settings = d->gtk_settings_get_default();
 gchararray icon_sizes;
 g_object_get(settings, "gtk-icon-sizes", &icon_sizes, NULL);
 QStringList values = QString(QLS(icon_sizes)).split(QLatin1Char(':'));
 g_free(icon_sizes);
 QChar splitChar(QLatin1Char(','));
 case PM_SplitterWidth:
 return 6;
 case PM_SliderThickness:
 case PM_SliderControlThickness: {
-GtkWidget *gtkScale = QGtk::gtkWidget(QLS("GtkHScale"));
+GtkWidget *gtkScale = d->gtkWidget(QLS("GtkHScale"));
 gint val;
-QGtk::gtk_widget_style_get(gtkScale, "slider-width", &val, NULL);
+d->gtk_widget_style_get(gtkScale, "slider-width", &val, NULL);
 if (metric == PM_SliderControlThickness)
 return val + 2*gtkScale->style->ythickness;
 return val;
 }
 case PM_ScrollBarExtent: {
 gint sliderLength;
 gint trough_border;
-GtkWidget *hScrollbar = QGtk::gtkWidget(QLS("GtkHScrollbar"));
+GtkWidget *hScrollbar = d->gtkWidget(QLS("GtkHScrollbar"));
-QGtk::gtk_widget_style_get(hScrollbar,
+d->gtk_widget_style_get(hScrollbar,
 "trough-border",   &trough_border,
 "slider-width",    &sliderLength,
 NULL);
 return sliderLength + trough_border*2;
 }
 case PM_ScrollBarSliderMin:
 return 34;
 case PM_SliderLength:
 gint val;
-QGtk::gtk_widget_style_get(QGtk::gtkWidget(QLS("GtkHScale")), "slider-length", &val, NULL);
+d->gtk_widget_style_get(d->gtkWidget(QLS("GtkHScale")), "slider-length", &val, NULL);
 return val;
 case PM_ExclusiveIndicatorWidth:
 case PM_ExclusiveIndicatorHeight:
 case PM_IndicatorWidth:
 case PM_IndicatorHeight: {
-GtkWidget *gtkCheckButton = QGtk::gtkWidget(QLS("GtkCheckButton"));
+GtkWidget *gtkCheckButton = d->gtkWidget(QLS("GtkCheckButton"));
 gint size, spacing;
-QGtk::gtk_widget_style_get(gtkCheckButton, "indicator-spacing", &spacing, "indicator-size", &size, NULL);
+d->gtk_widget_style_get(gtkCheckButton, "indicator-spacing", &spacing, "indicator-size", &size, NULL);
 return size + 2 * spacing;
 }
 case PM_MenuBarVMargin: {
-GtkWidget *gtkMenubar = QGtk::gtkWidget(QLS("GtkMenuBar"));
+GtkWidget *gtkMenubar = d->gtkWidget(QLS("GtkMenuBar"));
 return  qMax(0, gtkMenubar->style->ythickness);
 }
 case PM_ScrollView_ScrollBarSpacing:
 {
 gint spacing = 3;
-GtkWidget *gtkScrollWindow = QGtk::gtkWidget(QLS("GtkScrolledWindow"));
+GtkWidget *gtkScrollWindow = d->gtkWidget(QLS("GtkScrolledWindow"));
 Q_ASSERT(gtkScrollWindow);
-QGtk::gtk_widget_style_get(gtkScrollWindow, "scrollbar-spacing", &spacing, NULL);
+d->gtk_widget_style_get(gtkScrollWindow, "scrollbar-spacing", &spacing, NULL);
 return spacing;
 }
 case PM_SubMenuOverlap: {
 gint offset = 0;
-GtkWidget *gtkMenu = QGtk::gtkWidget(QLS("GtkMenu"));
+GtkWidget *gtkMenu = d->gtkWidget(QLS("GtkMenu"));
-QGtk::gtk_widget_style_get(gtkMenu, "horizontal-offset", &offset, NULL);
+d->gtk_widget_style_get(gtkMenu, "horizontal-offset", &offset, NULL);
 return offset;
 }
 default:
 return QCleanlooksStyle::pixelMetric(metric, option, widget);
 }
 */
 int QGtkStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget,
 QStyleHintReturn *returnData = 0) const
 {
-if (!QGtk::isThemeAvailable())
+Q_D(const QGtkStyle);
+if (!d->isThemeAvailable())
 return QCleanlooksStyle::styleHint(hint, option, widget, returnData);
 switch (hint) {
 case SH_DialogButtonLayout: {
 int ret = QDialogButtonBox::GnomeLayout;
 gboolean alternateOrder = 0;
-GtkSettings *settings = QGtk::gtk_settings_get_default();
+GtkSettings *settings = d->gtk_settings_get_default();
 g_object_get(settings, "gtk-alternative-button-order", &alternateOrder, NULL);
 if (alternateOrder)
 ret = QDialogButtonBox::WinLayout;
 break;
 case SH_ToolButtonStyle:
 {
-if (QGtk::isKDE4Session())
+if (d->isKDE4Session())
 return QCleanlooksStyle::styleHint(hint, option, widget, returnData);
-GtkWidget *gtkToolbar = QGtk::gtkWidget(QLS("GtkToolbar"));
+GtkWidget *gtkToolbar = d->gtkWidget(QLS("GtkToolbar"));
 GtkToolbarStyle toolbar_style = GTK_TOOLBAR_ICONS;
 g_object_get(gtkToolbar, "toolbar-style", &toolbar_style, NULL);
 switch (toolbar_style) {
 case GTK_TOOLBAR_TEXT:
 return Qt::ToolButtonTextOnly;
 case SH_DitherDisabledText:
 return int(false);
 case SH_ComboBox_Popup: {
-GtkWidget *gtkComboBox = QGtk::gtkWidget(QLS("GtkComboBox"));
+GtkWidget *gtkComboBox = d->gtkWidget(QLS("GtkComboBox"));
 gboolean appears_as_list;
-QGtk::gtk_widget_style_get((GtkWidget*)gtkComboBox, "appears-as-list", &appears_as_list, NULL);
+d->gtk_widget_style_get((GtkWidget*)gtkComboBox, "appears-as-list", &appears_as_list, NULL);
 return appears_as_list ? 0 : 1;
 }
 case SH_MenuBar_AltKeyNavigation:
 return int(false);
 case SH_EtchDisabledText:
 return int(false);
 case SH_Menu_SubMenuPopupDelay: {
 gint delay = 225;
-GtkSettings *settings = QGtk::gtk_settings_get_default();
+GtkSettings *settings = d->gtk_settings_get_default();
 g_object_get(settings, "gtk-menu-popup-delay", &delay, NULL);
 return delay;
 }
 case SH_ScrollView_FrameOnlyAroundContents: {
 gboolean scrollbars_within_bevel = false;
 if (widget && widget->isWindow())
 scrollbars_within_bevel = true;
-else if (!QGtk::gtk_check_version(2, 12, 0)) {
+else if (!d->gtk_check_version(2, 12, 0)) {
-GtkWidget *gtkScrollWindow = QGtk::gtkWidget(QLS("GtkScrolledWindow"));
+GtkWidget *gtkScrollWindow = d->gtkWidget(QLS("GtkScrolledWindow"));
-QGtk::gtk_widget_style_get(gtkScrollWindow, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
+d->gtk_widget_style_get(gtkScrollWindow, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
 }
 return !scrollbars_within_bevel;
 }
 case SH_DialogButtonBox_ButtonsHaveIcons: {
-static bool buttonsHaveIcons = QGtk::getGConfBool(QLS("/desktop/gnome/interface/buttons_have_icons"));
+static bool buttonsHaveIcons = d->getGConfBool(QLS("/desktop/gnome/interface/buttons_have_icons"));
 return buttonsHaveIcons;
+}
+case SH_UnderlineShortcut: {
+gboolean underlineShortcut = true;
+if (!d->gtk_check_version(2, 12, 0)) {
+GtkSettings *settings = d->gtk_settings_get_default();
+g_object_get(settings, "gtk-enable-mnemonics", &underlineShortcut, NULL);
+}
+return underlineShortcut;
 }
 default:
 return QCleanlooksStyle::styleHint(hint, option, widget, returnData);
 }
 /*!
 \reimp
 */
 void QGtkStyle::drawPrimitive(PrimitiveElement element,
 const QStyleOption *option,
 QPainter *painter,
 const QWidget *widget) const
 {
-if (!QGtk::isThemeAvailable()) {
+Q_D(const QGtkStyle);
+if (!d->isThemeAvailable()) {
 QCleanlooksStyle::drawPrimitive(element, option, painter, widget);
 return;
 }
-GtkStyle* style = QGtk::gtkStyle();
+GtkStyle* style = d->gtkStyle();
 QGtkPainter gtkPainter(painter);
 switch (element) {
 case PE_Frame: {
 if (widget && widget->inherits("QComboBoxPrivateContainer")){
 if (option->state & State_Sunken)
 shadow_type = GTK_SHADOW_IN;
 else if (option->state & State_Raised)
 shadow_type = GTK_SHADOW_OUT;
-GtkStyle *style = QGtk::gtk_rc_get_style_by_paths(QGtk::gtk_settings_get_default(),
+GtkStyle *style = d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(),
-"*.GtkScrolledWindow", "*.GtkScrolledWindow", Q_GTK_TYPE_WINDOW);
+"*.GtkScrolledWindow", "*.GtkScrolledWindow", d->gtk_window_get_type());
 if (style)
-gtkFramePainter.paintShadow(QGtk::gtkWidget(QLS("GtkFrame")), "viewport", pmRect,
+gtkFramePainter.paintShadow(d->gtkWidget(QLS("GtkFrame")), "viewport", pmRect,
 option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE,
 shadow_type, style);
 QPixmapCache::insert(pmKey, pixmap);
 }
 painter->drawPixmap(rect.adjusted(rw, rh, 0, 0), pixmap, pmRect.adjusted(pw, ph, 0,0));
 }
 break;
 case PE_PanelTipLabel: {
-GtkWidget *gtkWindow = QGtk::gtkWidget(QLS("GtkWindow")); // The Murrine Engine currently assumes a widget is passed
+GtkWidget *gtkWindow = d->gtkWidget(QLS("GtkWindow")); // The Murrine Engine currently assumes a widget is passed
-style = QGtk::gtk_rc_get_style_by_paths(QGtk::gtk_settings_get_default(), "gtk-tooltips", "GtkWindow", Q_GTK_TYPE_WINDOW);
+style = d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(), "gtk-tooltips", "GtkWindow",
+d->gtk_window_get_type());
 gtkPainter.paintFlatBox(gtkWindow, "tooltip", option->rect, GTK_STATE_NORMAL, GTK_SHADOW_NONE, style);
 }
 break;
 case PE_PanelStatusBar: {
 // Respect custom palette
 painter->fillRect(option->rect, option->palette.window());
 break;
 }
 GtkShadowType shadow_type;
-GtkWidget *gtkStatusbarFrame = QGtk::gtkWidget(QLS("GtkStatusbar.GtkFrame"));
+GtkWidget *gtkStatusbarFrame = d->gtkWidget(QLS("GtkStatusbar.GtkFrame"));
-QGtk::gtk_widget_style_get(gtkStatusbarFrame->parent, "shadow-type", &shadow_type, NULL);
+d->gtk_widget_style_get(gtkStatusbarFrame->parent, "shadow-type", &shadow_type, NULL);
 gtkPainter.paintShadow(gtkStatusbarFrame, "frame", option->rect, GTK_STATE_NORMAL,
 shadow_type, gtkStatusbarFrame->style);
 }
 break;
 case PE_IndicatorHeaderArrow:
 if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
-GtkWidget *gtkTreeHeader = QGtk::gtkWidget(QLS("GtkTreeView.GtkButton"));
+GtkWidget *gtkTreeHeader = d->gtkWidget(QLS("GtkTreeView.GtkButton"));
 GtkStateType state = gtkPainter.gtkState(option);
 style = gtkTreeHeader->style;
 GtkArrowType type = GTK_ARROW_UP;
 QRect r = header->rect;
 QImage arrow;
 rect = QRect(0, 0, 12, 12);
 rect.moveCenter(option->rect.center());
 rect.translate(2, 0);
 GtkExpanderStyle openState = GTK_EXPANDER_EXPANDED;
 GtkExpanderStyle closedState = GTK_EXPANDER_COLLAPSED;
-GtkWidget *gtkTreeView = QGtk::gtkWidget(QLS("GtkTreeView"));
+GtkWidget *gtkTreeView = d->gtkWidget(QLS("GtkTreeView"));
 GtkStateType state = GTK_STATE_NORMAL;
 if (!(option->state & State_Enabled))
 state = GTK_STATE_INSENSITIVE;
 else if (option->state & State_MouseOver)
 }
 break;
 case PE_IndicatorToolBarSeparator:
 {
 const int margin = 6;
-GtkWidget *gtkSeparator = QGtk::gtkWidget(QLS("GtkToolbar.GtkSeparatorToolItem"));
+GtkWidget *gtkSeparator = d->gtkWidget(QLS("GtkToolbar.GtkSeparatorToolItem"));
 if (option->state & State_Horizontal) {
 const int offset = option->rect.width()/2;
 QRect rect = option->rect.adjusted(offset, margin, 0, -margin);
 painter->setPen(QPen(option->palette.background().color().darker(110)));
 gtkPainter.paintVline( gtkSeparator, "vseparator",
 }
 }
 break;
 case PE_IndicatorToolBarHandle: {
-GtkWidget *gtkToolbar = QGtk::gtkWidget(QLS("GtkToolbar"));
+GtkWidget *gtkToolbar = d->gtkWidget(QLS("GtkToolbar"));
 GtkShadowType shadow_type;
-QGtk::gtk_widget_style_get(gtkToolbar, "shadow-type", &shadow_type, NULL);
+d->gtk_widget_style_get(gtkToolbar, "shadow-type", &shadow_type, NULL);
 //Note when the toolbar is horizontal, the handle is vertical
 painter->setClipRect(option->rect);
 gtkPainter.paintHandle(gtkToolbar, "toolbar", option->rect.adjusted(-1, -1 ,0 ,1),
 GTK_STATE_NORMAL, shadow_type, !(option->state & State_Horizontal) ?
 GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL, gtkToolbar->style);
 QRect arrowRect = option->rect.adjusted(border + bsx, border + bsy, -border + bsx, -border + bsy);
 GtkShadowType shadow = option->state & State_Sunken ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
 GtkStateType state = gtkPainter.gtkState(option);
 QColor arrowColor = option->palette.buttonText().color();
-GtkWidget *gtkArrow = QGtk::gtkWidget(QLS("GtkArrow"));
+GtkWidget *gtkArrow = d->gtkWidget(QLS("GtkArrow"));
 GdkColor color = fromQColor(arrowColor);
-QGtk::gtk_widget_modify_fg (gtkArrow, state, &color);
+d->gtk_widget_modify_fg (gtkArrow, state, &color);
 gtkPainter.paintArrow(gtkArrow, "button", arrowRect,
 type, state, shadow, FALSE, gtkArrow->style,
 QString::number(arrowColor.rgba(), 16));
 // Passing NULL will revert the color change
-QGtk::gtk_widget_modify_fg (gtkArrow, state, NULL);
+d->gtk_widget_modify_fg (gtkArrow, state, NULL);
 }
 break;
 case PE_FrameGroupBox:
 // Do nothing here, the GNOME groupboxes are flat
 break;
 case PE_PanelMenu: {
-GtkWidget *gtkMenu = QGtk::gtkWidget(QLS("GtkMenu"));
+GtkWidget *gtkMenu = d->gtkWidget(QLS("GtkMenu"));
 gtkPainter.setAlphaSupport(false); // Note, alpha disabled for performance reasons
 gtkPainter.paintBox(gtkMenu, "menu", option->rect, GTK_STATE_NORMAL, GTK_SHADOW_OUT, gtkMenu->style, QString());
 }
 break;
 //This is actually done by PE_Widget due to a clipping issue
 //Otherwise Menu items will not be able to span the entire menu width
 // This is only used by floating tool bars
 if (qobject_cast<const QToolBar *>(widget)) {
-GtkWidget *gtkMenubar = QGtk::gtkWidget(QLS("GtkMenuBar"));
+GtkWidget *gtkMenubar = d->gtkWidget(QLS("GtkMenuBar"));
 gtkPainter.paintBox( gtkMenubar, "toolbar",  option->rect,
 GTK_STATE_NORMAL, GTK_SHADOW_OUT, style);
 gtkPainter.paintBox( gtkMenubar, "menu",  option->rect,
 GTK_STATE_NORMAL, GTK_SHADOW_OUT, style);
 }
 break;
 case PE_FrameLineEdit: {
-GtkWidget *gtkEntry = QGtk::gtkWidget(QLS("GtkEntry"));
+GtkWidget *gtkEntry = d->gtkWidget(QLS("GtkEntry"));
 gboolean interior_focus;
 gint focus_line_width;
 QRect rect = option->rect;
-QGtk::gtk_widget_style_get(gtkEntry,
+d->gtk_widget_style_get(gtkEntry,
 "interior-focus", &interior_focus,
 "focus-line-width", &focus_line_width, NULL);
 // See https://bugzilla.mozilla.org/show_bug.cgi?id=405421 for info about this hack
 g_object_set_data(G_OBJECT(gtkEntry), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
 }
 break;
 case PE_PanelLineEdit:
 if (const QStyleOptionFrame *panel = qstyleoption_cast<const QStyleOptionFrame *>(option)) {
-GtkWidget *gtkEntry = QGtk::gtkWidget(QLS("GtkEntry"));
+GtkWidget *gtkEntry = d->gtkWidget(QLS("GtkEntry"));
 if (panel->lineWidth > 0)
 proxy()->drawPrimitive(PE_FrameLineEdit, option, painter, widget);
 uint resolve_mask = option->palette.resolve();
 QRect textRect = option->rect.adjusted(gtkEntry->style->xthickness, gtkEntry->style->ythickness,
 -gtkEntry->style->xthickness, -gtkEntry->style->ythickness);
 }
 break;
 case PE_FrameTabWidget:
 if (const QStyleOptionTabWidgetFrame *frame = qstyleoption_cast<const QStyleOptionTabWidgetFrame*>(option)) {
-GtkWidget *gtkNotebook = QGtk::gtkWidget(QLS("GtkNotebook"));
+GtkWidget *gtkNotebook = d->gtkWidget(QLS("GtkNotebook"));
 style = gtkPainter.getStyle(gtkNotebook);
 gtkPainter.setAlphaSupport(false);
 GtkShadowType shadow = GTK_SHADOW_OUT;
 GtkStateType state = GTK_STATE_NORMAL; // Only state supported by gtknotebook
-if (const QTabWidget *tabwidget = qobject_cast<const QTabWidget*>(widget)) {
+bool reverse = (option->direction == Qt::RightToLeft);
-// We should introduce QStyleOptionTabWidgetFrameV2 to obtain this information
+QGtkStylePrivate::gtk_widget_set_direction(gtkNotebook, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
-// No gap if we do not show the actual tabs
+if (const QStyleOptionTabWidgetFrameV2 *tabframe = qstyleoption_cast<const QStyleOptionTabWidgetFrameV2*>(option)) {
-QTabBar *tabBar = tabwidget->findChild<QTabBar*>();
+GtkPositionType frameType = GTK_POS_TOP;
-if (tabwidget->count() > 0 && tabBar->isVisible()) {
+QTabBar::Shape shape = frame->shape;
-QRect tabRect = tabBar->tabRect(tabBar->currentIndex());
+int gapStart = 0;
-int begin = 0, size = 0;
+int gapSize = 0;
-GtkPositionType frameType = GTK_POS_TOP;
+if (shape == QTabBar::RoundedNorth || shape == QTabBar::RoundedSouth) {
-QTabBar::Shape shape = frame->shape;
+frameType = (shape == QTabBar::RoundedNorth) ? GTK_POS_TOP : GTK_POS_BOTTOM;
-if (shape == QTabBar::RoundedNorth || shape == QTabBar::RoundedSouth) {
+gapStart = tabframe->selectedTabRect.left();
-begin = option->direction == Qt::LeftToRight ?
+gapSize = tabframe->selectedTabRect.width();
-frame->leftCornerWidgetSize.width() + tabRect.left() :
+} else {
-frame->rect.width() - frame->tabBarSize.width() + tabRect.left()
+frameType = (shape == QTabBar::RoundedWest) ? GTK_POS_LEFT : GTK_POS_RIGHT;
-- frame->rightCornerWidgetSize.width();
+gapStart = tabframe->selectedTabRect.y();
-size = tabRect.width();
+gapSize = tabframe->selectedTabRect.height();
-frameType = (shape == QTabBar::RoundedNorth) ? GTK_POS_TOP : GTK_POS_BOTTOM;
-} else {
-begin = frame->leftCornerWidgetSize.height() + tabRect.top();
-size = tabRect.height();
-frameType = (shape == QTabBar::RoundedWest) ? GTK_POS_LEFT : GTK_POS_RIGHT;
-}
-gtkPainter.paintBoxGap(gtkNotebook, "notebook",  option->rect, state, shadow, frameType,
-begin, size, style);
-break; // done
 }
-}
+gtkPainter.paintBoxGap(gtkNotebook, "notebook",  option->rect, state, shadow, frameType,
+gapStart, gapSize, style);
+break; // done
+}
 // Note this is only the fallback option
 gtkPainter.paintBox(gtkNotebook, "notebook",  option->rect, state, shadow, style);
 }
 break;
-case PE_PanelButtonCommand: {
+case PE_PanelButtonCommand:
+case PE_PanelButtonTool: {
 bool isDefault = false;
+bool isTool = (element == PE_PanelButtonTool);
 if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton*>(option))
 isDefault = btn->features & QStyleOptionButton::DefaultButton;
+// don't draw a frame for tool buttons that have the autoRaise flag and are not enabled or on
+if (isTool && !(option->state & State_Enabled || option->state & State_On) && (option->state & State_AutoRaise))
+break;
+// don't draw a frame for dock widget buttons, unless we are hovering
+if (widget && widget->inherits("QDockWidgetTitleButton") && !(option->state & State_MouseOver))
+break;
 GtkStateType state = gtkPainter.gtkState(option);
 if (option->state & State_On || option->state & State_Sunken)
 state = GTK_STATE_ACTIVE;
-GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+GtkWidget *gtkButton = d->gtkWidget(isTool ? QLS("GtkToolButton.GtkButton") : QLS("GtkButton"));
 gint focusWidth, focusPad;
 gboolean interiorFocus = false;
-QGtk::gtk_widget_style_get (gtkButton,
+d->gtk_widget_style_get (gtkButton,
 "focus-line-width", &focusWidth,
 "focus-padding", &focusPad,
 "interior-focus", &interiorFocus, NULL);
 style = gtkButton->style;
 else if (option->state & State_On)
 shadow = GTK_SHADOW_IN;
 else
 shadow = GTK_SHADOW_OUT;
-GtkWidget *gtkRadioButton = QGtk::gtkWidget(QLS("GtkRadioButton"));
+GtkWidget *gtkRadioButton = d->gtkWidget(QLS("GtkRadioButton"));
 gint spacing;
-QGtk::gtk_widget_style_get(gtkRadioButton, "indicator-spacing", &spacing, NULL);
+d->gtk_widget_style_get(gtkRadioButton, "indicator-spacing", &spacing, NULL);
 QRect buttonRect = option->rect.adjusted(spacing, spacing, -spacing, -spacing);
 gtkPainter.setClipRect(option->rect);
 // ### Note: Ubuntulooks breaks when the proper widget is passed
 //           Murrine engine requires a widget not to get RGBA check - warnings
-GtkWidget *gtkCheckButton = QGtk::gtkWidget(QLS("GtkCheckButton"));
+GtkWidget *gtkCheckButton = d->gtkWidget(QLS("GtkCheckButton"));
 gtkPainter.paintOption(gtkCheckButton , buttonRect, state, shadow, gtkRadioButton->style, QLS("radiobutton"));
 }
 break;
 else
 shadow = GTK_SHADOW_OUT;
 int spacing;
-GtkWidget *gtkCheckButton = QGtk::gtkWidget(QLS("GtkCheckButton"));
+GtkWidget *gtkCheckButton = d->gtkWidget(QLS("GtkCheckButton"));
 // Some styles such as aero-clone assume they can paint in the spacing area
 gtkPainter.setClipRect(option->rect);
-QGtk::gtk_widget_style_get(gtkCheckButton, "indicator-spacing", &spacing, NULL);
+d->gtk_widget_style_get(gtkCheckButton, "indicator-spacing", &spacing, NULL);
 QRect checkRect = option->rect.adjusted(spacing, spacing, -spacing, -spacing);
 gtkPainter.paintCheckbox(gtkCheckButton, checkRect, state, shadow, gtkCheckButton->style,
 QLS("checkbutton"));
 */
 void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionComplex *option,
 QPainter *painter, const QWidget *widget) const
 {
-if (!QGtk::isThemeAvailable()) {
+Q_D(const QGtkStyle);
+if (!d->isThemeAvailable()) {
 QCleanlooksStyle::drawComplexControl(control, option, painter, widget);
 return;
 }
-GtkStyle* style = QGtk::gtkStyle();
+GtkStyle* style = d->gtkStyle();
 QGtkPainter gtkPainter(painter);
 QColor button = option->palette.button().color();
 QColor dark;
 QColor grooveColor;
 QColor darkOutline;
 QRect checkBoxRect = proxy()->subControlRect(CC_GroupBox, groupBox, SC_GroupBoxCheckBox, widget);
 // Draw title
 if ((groupBox->subControls & QStyle::SC_GroupBoxLabel) && !groupBox->text.isEmpty()) {
 // Draw prelight background
-GtkWidget *gtkCheckButton = QGtk::gtkWidget(QLS("GtkCheckButton"));
+GtkWidget *gtkCheckButton = d->gtkWidget(QLS("GtkCheckButton"));
 if (option->state & State_MouseOver) {
 QRect bgRect = textRect | checkBoxRect;
 gtkPainter.paintFlatBox(gtkCheckButton, "checkbutton", bgRect.adjusted(0, 0, 0, -2),
 GTK_STATE_PRELIGHT, GTK_SHADOW_ETCHED_OUT, gtkCheckButton->style);
 GtkShadowType shadow = (option->state & State_Sunken || option->state & State_On ) ?
 GTK_SHADOW_IN : GTK_SHADOW_OUT;
 QString comboBoxPath = QLS(comboBox->editable ? "GtkComboBoxEntry" : "GtkComboBox");
 // We use the gtk widget to position arrows and separators for us
-GtkWidget *gtkCombo = QGtk::gtkWidget(comboBoxPath);
+GtkWidget *gtkCombo = d->gtkWidget(comboBoxPath);
 GtkAllocation geometry = {0, 0, option->rect.width(), option->rect.height()};
-QGtk::gtk_widget_set_direction(gtkCombo, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
+d->gtk_widget_set_direction(gtkCombo, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
-QGtk::gtk_widget_size_allocate(gtkCombo, &geometry);
+d->gtk_widget_size_allocate(gtkCombo, &geometry);
 QString buttonPath = comboBoxPath + QLS(".GtkToggleButton");
-GtkWidget *gtkToggleButton = QGtk::gtkWidget(buttonPath);
+GtkWidget *gtkToggleButton = d->gtkWidget(buttonPath);
-QGtk::gtk_widget_set_direction(gtkToggleButton, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
+d->gtk_widget_set_direction(gtkToggleButton, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
 if (gtkToggleButton && (appears_as_list || comboBox->editable)) {
 if (focus)
 GTK_WIDGET_SET_FLAGS(gtkToggleButton, GTK_HAS_FOCUS);
 // Draw the combo box as a line edit with a button next to it
 if (comboBox->editable || appears_as_list) {
 GtkStateType frameState = (state == GTK_STATE_PRELIGHT) ? GTK_STATE_NORMAL : state;
 QString entryPath = QLS(comboBox->editable ? "GtkComboBoxEntry.GtkEntry" : "GtkComboBox.GtkFrame");
-GtkWidget *gtkEntry = QGtk::gtkWidget(entryPath);
+GtkWidget *gtkEntry = d->gtkWidget(entryPath);
-QGtk::gtk_widget_set_direction(gtkEntry, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
+d->gtk_widget_set_direction(gtkEntry, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
 QRect frameRect = option->rect;
 if (reverse)
 frameRect.setLeft(arrowButtonRect.right());
 else
 resolve_mask & (1 << QPalette::Base)) // Palette overridden by user
 p->fillRect(contentRect, option->palette.base().color());
 else {
 gtkCachedPainter.paintFlatBox(gtkEntry, "entry_bg", contentRect,
 option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE,
-GTK_SHADOW_NONE, style, entryPath + QString::number(focus));
+GTK_SHADOW_NONE, gtkCombo->style, entryPath + QString::number(focus));
 }
 gtkCachedPainter.paintShadow(gtkEntry, comboBox->editable ? "entry" : "frame", frameRect, frameState,
 GTK_SHADOW_IN, gtkEntry->style, entryPath +
 QString::number(focus) + QString::number(comboBox->editable) +
 GTK_WIDGET_UNSET_FLAGS(gtkToggleButton, GTK_HAS_FOCUS);
 // Draw the separator between label and arrows
 QString vSeparatorPath = buttonPath + QLS(".GtkHBox.GtkVSeparator");
-if (GtkWidget *gtkVSeparator = QGtk::gtkWidget(vSeparatorPath)) {
+if (GtkWidget *gtkVSeparator = d->gtkWidget(vSeparatorPath)) {
 QRect vLineRect(gtkVSeparator->allocation.x,
 gtkVSeparator->allocation.y,
 gtkVSeparator->allocation.width,
 gtkVSeparator->allocation.height);
 vLineRect, state, gtkVSeparator->style,
 0, vLineRect.height(), 0,  vSeparatorPath);
 gint interiorFocus = true;
-QGtk::gtk_widget_style_get(gtkToggleButton, "interior-focus", &interiorFocus, NULL);
+d->gtk_widget_style_get(gtkToggleButton, "interior-focus", &interiorFocus, NULL);
 int xt = interiorFocus ? gtkToggleButton->style->xthickness : 0;
 int yt = interiorFocus ? gtkToggleButton->style->ythickness : 0;
 if (focus && ((option->state & State_KeyboardFocusChange) || styleHint(SH_UnderlineShortcut, option, widget)))
 gtkCachedPainter.paintFocus(gtkToggleButton, "button",
 option->rect.adjusted(xt, yt, -xt, -yt),
 state = GTK_STATE_NORMAL;
 QString arrowPath = comboBoxPath + QLS(appears_as_list ? ".GtkToggleButton.GtkArrow"
 : ".GtkToggleButton.GtkHBox.GtkArrow");
-GtkWidget *gtkArrow = QGtk::gtkWidget(arrowPath);
+GtkWidget *gtkArrow = d->gtkWidget(arrowPath);
 gfloat scale = 0.7;
 gint minSize = 15;
 QRect arrowWidgetRect;
-if (gtkArrow && !QGtk::gtk_check_version(2, 12, 0)) {
+if (gtkArrow && !d->gtk_check_version(2, 12, 0)) {
-QGtk::gtk_widget_style_get(gtkArrow, "arrow-scaling", &scale, NULL);
+d->gtk_widget_style_get(gtkArrow, "arrow-scaling", &scale, NULL);
-QGtk::gtk_widget_style_get(gtkCombo, "arrow-size", &minSize, NULL);
+d->gtk_widget_style_get(gtkCombo, "arrow-size", &minSize, NULL);
 }
 if (gtkArrow) {
 arrowWidgetRect = QRect(gtkArrow->allocation.x, gtkArrow->allocation.y,
 gtkArrow->allocation.width, gtkArrow->allocation.height);
 style = gtkArrow->style;
 arrowRect.moveCenter(arrowWidgetRect.center());
 if (sunken) {
 int xoff, yoff;
-GtkWidget *gtkButton = QGtk::gtkWidget(comboBoxPath + QLS(".GtkToggleButton"));
+GtkWidget *gtkButton = d->gtkWidget(comboBoxPath + QLS(".GtkToggleButton"));
-QGtk::gtk_widget_style_get(gtkButton, "child-displacement-x", &xoff, NULL);
+d->gtk_widget_style_get(gtkButton, "child-displacement-x", &xoff, NULL);
-QGtk::gtk_widget_style_get(gtkButton, "child-displacement-y", &yoff, NULL);
+d->gtk_widget_style_get(gtkButton, "child-displacement-y", &yoff, NULL);
 arrowRect = arrowRect.adjusted(xoff, yoff, xoff, yoff);
 }
 // Some styles such as Nimbus paint outside the arrowRect
 // hence we have provide the whole widget as the cliprect
 proxy()->drawPrimitive(PE_FrameFocusRect, &fr, painter, widget);
 }
 QStyleOptionToolButton label = *toolbutton;
 label.state = bflags;
-GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+GtkWidget *gtkButton = d->gtkWidget(QLS("GtkToolButton.GtkButton"));
 QPalette pal = toolbutton->palette;
 if (option->state & State_Enabled &&
 option->state & State_MouseOver && !(widget && widget->testAttribute(Qt::WA_SetPalette))) {
 GdkColor gdkText = gtkButton->style->fg[GTK_STATE_PRELIGHT];
 QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
 #endif // QT_NO_TOOLBUTTON
 #ifndef QT_NO_SCROLLBAR
 case CC_ScrollBar:
 if (const QStyleOptionSlider *scrollBar = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
-GtkWidget *gtkHScrollBar = QGtk::gtkWidget(QLS("GtkHScrollbar"));
+GtkWidget *gtkHScrollBar = d->gtkWidget(QLS("GtkHScrollbar"));
-GtkWidget *gtkVScrollBar = QGtk::gtkWidget(QLS("GtkVScrollbar"));
+GtkWidget *gtkVScrollBar = d->gtkWidget(QLS("GtkVScrollbar"));
 // Fill background in case the scrollbar is partially transparent
 painter->fillRect(option->rect, option->palette.background());
 QRect rect = scrollBar->rect;
 style = scrollbarWidget->style;
 gboolean trough_under_steppers = true;
 gboolean trough_side_details = false;
 gboolean stepper_size = 14;
 gint trough_border = 1;
-if (!QGtk::gtk_check_version(2, 10, 0)) {
+if (!d->gtk_check_version(2, 10, 0)) {
-QGtk::gtk_widget_style_get((GtkWidget*)(scrollbarWidget),
+d->gtk_widget_style_get((GtkWidget*)(scrollbarWidget),
 "trough-border",   &trough_border,
 "trough-side-details",   &trough_side_details,
 "trough-under-steppers", &trough_under_steppers,
 "stepper-size",          &stepper_size, NULL);
 }
 maximum = 0;
 if (scrollBar->sliderPosition == scrollBar->maximum)
 fakePos = maximum;
 else if (scrollBar->sliderPosition > scrollBar->minimum)
 fakePos = maximum - 1;
-GtkObject *adjustment =  QGtk::gtk_adjustment_new(fakePos, 0, maximum, 0, 0, 0);
+GtkObject *adjustment =  d->gtk_adjustment_new(fakePos, 0, maximum, 0, 0, 0);
 if (horizontal)
-QGtk::gtk_range_set_adjustment((GtkRange*)(gtkHScrollBar), (GtkAdjustment*)(adjustment));
+d->gtk_range_set_adjustment((GtkRange*)(gtkHScrollBar), (GtkAdjustment*)(adjustment));
 else
-QGtk::gtk_range_set_adjustment((GtkRange*)(gtkVScrollBar), (GtkAdjustment*)(adjustment));
+d->gtk_range_set_adjustment((GtkRange*)(gtkVScrollBar), (GtkAdjustment*)(adjustment));
 if (scrollBar->subControls & SC_ScrollBarGroove) {
 GtkStateType state = GTK_STATE_ACTIVE;
 if (!(option->state & State_Enabled))
 #endif //QT_NO_SCROLLBAR
 #ifndef QT_NO_SPINBOX
 case CC_SpinBox:
 if (const QStyleOptionSpinBox *spinBox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) {
-GtkWidget *gtkSpinButton = QGtk::gtkWidget(QLS("GtkSpinButton"));
+GtkWidget *gtkSpinButton = d->gtkWidget(QLS("GtkSpinButton"));
 bool isEnabled = (spinBox->state & State_Enabled);
 bool hover = isEnabled && (spinBox->state & State_MouseOver);
 bool sunken = (spinBox->state & State_Sunken);
 bool upIsActive = (spinBox->activeSubControls == SC_SpinBoxUp);
 bool downIsActive = (spinBox->activeSubControls == SC_SpinBoxDown);
 } else {
 painter->drawLine(centerX - 2, centerY, centerX + 2, centerY);
 }
 } else {
-int size = spinboxArrowSize();
+int size = d->getSpinboxArrowSize();
 int w = size / 2 - 1;
 w -= w % 2 - 1; // force odd
 int h = (w + 1)/2;
 QRect arrowRect(0, 0, w, h);
 arrowRect.moveCenter(upRect.center());
 #ifndef QT_NO_SLIDER
 case CC_Slider:
 if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
-GtkWidget *hScaleWidget = QGtk::gtkWidget(QLS("GtkHScale"));
+GtkWidget *hScaleWidget = d->gtkWidget(QLS("GtkHScale"));
-GtkWidget *vScaleWidget = QGtk::gtkWidget(QLS("GtkVScale"));
+GtkWidget *vScaleWidget = d->gtkWidget(QLS("GtkVScale"));
 QRect groove = proxy()->subControlRect(CC_Slider, option, SC_SliderGroove, widget);
 QRect handle = proxy()->subControlRect(CC_Slider, option, SC_SliderHandle, widget);
 QRect ticks = proxy()->subControlRect(CC_Slider, option, SC_SliderTickmarks, widget);
 GtkWidget *scaleWidget = horizontal ? hScaleWidget : vScaleWidget;
 style = scaleWidget->style;
 if ((option->subControls & SC_SliderGroove) && groove.isValid()) {
-GtkObject *adjustment =  QGtk::gtk_adjustment_new(slider->sliderPosition,
+GtkObject *adjustment =  d->gtk_adjustment_new(slider->sliderPosition,
 slider->minimum,
 slider->maximum,
 slider->singleStep,
 slider->singleStep,
 slider->pageStep);
 int outerSize;
-QGtk::gtk_range_set_adjustment ((GtkRange*)(scaleWidget), (GtkAdjustment*)(adjustment));
+d->gtk_range_set_adjustment ((GtkRange*)(scaleWidget), (GtkAdjustment*)(adjustment));
-QGtk::gtk_range_set_inverted((GtkRange*)(scaleWidget), !horizontal);
+d->gtk_range_set_inverted((GtkRange*)(scaleWidget), !horizontal);
-QGtk::gtk_widget_style_get(scaleWidget, "trough-border", &outerSize, NULL);
+d->gtk_widget_style_get(scaleWidget, "trough-border", &outerSize, NULL);
 outerSize++;
 GtkStateType state = gtkPainter.gtkState(option);
 int focusFrameMargin = 2;
 QRect grooveRect = option->rect.adjusted(focusFrameMargin, outerSize + focusFrameMargin,
 -focusFrameMargin, -outerSize - focusFrameMargin);
-gtkPainter.paintBox( scaleWidget, "trough", grooveRect, state,
-GTK_SHADOW_IN, style, QString(QLS("p%0")).arg(slider->sliderPosition));
 gboolean trough_side_details = false; // Indicates if the upper or lower scale background differs
-if (!QGtk::gtk_check_version(2, 10, 0))
+if (!d->gtk_check_version(2, 10, 0))
-QGtk::gtk_widget_style_get((GtkWidget*)(scaleWidget), "trough-side-details",   &trough_side_details, NULL);
+d->gtk_widget_style_get((GtkWidget*)(scaleWidget), "trough-side-details",   &trough_side_details, NULL);
-if (trough_side_details && horizontal) { //### Vertical sliders look broken with this for some reason
+if (!trough_side_details) {
+gtkPainter.paintBox( scaleWidget, "trough", grooveRect, state,
+GTK_SHADOW_IN, style, QString(QLS("p%0")).arg(slider->sliderPosition));
+} else {
+QRect upperGroove = grooveRect;
 QRect lowerGroove = grooveRect;
-lowerGroove.setRight(handle.center().x());
+if (horizontal) {
+upperGroove.setLeft(handle.center().x());
+lowerGroove.setRight(handle.center().x());
+} else {
+upperGroove.setBottom(handle.center().y());
+lowerGroove.setTop(handle.center().y());
+}
+gtkPainter.paintBox( scaleWidget, "trough-upper", upperGroove, state,
+GTK_SHADOW_IN, style, QString(QLS("p%0")).arg(slider->sliderPosition));
 gtkPainter.paintBox( scaleWidget, "trough-lower", lowerGroove, state,
 GTK_SHADOW_IN, style, QString(QLS("p%0")).arg(slider->sliderPosition));
 }
 }
 if (option->subControls & SC_SliderTickmarks) {
 painter->setPen(darkOutline);
 int tickSize = proxy()->pixelMetric(PM_SliderTickmarkOffset, option, widget);
 void QGtkStyle::drawControl(ControlElement element,
 const QStyleOption *option,
 QPainter *painter,
 const QWidget *widget) const
 {
-if (!QGtk::isThemeAvailable()) {
+Q_D(const QGtkStyle);
+if (!d->isThemeAvailable()) {
 QCleanlooksStyle::drawControl(element, option, painter, widget);
 return;
 }
-GtkStyle* style = QGtk::gtkStyle();
+GtkStyle* style = d->gtkStyle();
 QGtkPainter gtkPainter(painter);
 switch (element) {
 case CE_ProgressBarLabel:
 if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
-GtkWidget *gtkProgressBar = QGtk::gtkWidget(QLS("GtkProgressBar"));
+GtkWidget *gtkProgressBar = d->gtkWidget(QLS("GtkProgressBar"));
 if (!gtkProgressBar)
 return;
 QRect leftRect;
 QRect rect = bar->rect;
 ir.translate(buttonShift);
 if (button->features & QStyleOptionButton::HasMenu)
 ir = ir.adjusted(0, 0, -pixelMetric(PM_MenuButtonIndicator, button, widget), 0);
-GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
 QPalette pal = button->palette;
 int labelState = GTK_STATE_INSENSITIVE;
 if (option->state & State_Enabled)
 labelState = (option->state & State_MouseOver && !(option->state & State_Sunken)) ?
 GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
 case CE_CheckBox:
 if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {
 bool isRadio = (element == CE_RadioButton);
 // Draw prelight background
-GtkWidget *gtkRadioButton = QGtk::gtkWidget(QLS("GtkRadioButton"));
+GtkWidget *gtkRadioButton = d->gtkWidget(QLS("GtkRadioButton"));
 if (option->state & State_MouseOver) {
 gtkPainter.paintFlatBox(gtkRadioButton, "checkbutton", option->rect,
 GTK_STATE_PRELIGHT, GTK_SHADOW_ETCHED_OUT, gtkRadioButton->style);
 }
 else
 editRect.translate(cb->iconSize.width() + 4, 0);
 }
 if (!cb->currentText.isEmpty() && !cb->editable) {
-GtkWidget *gtkCombo = QGtk::gtkWidget(QLS("GtkComboBox"));
+GtkWidget *gtkCombo = d->gtkWidget(QLS("GtkComboBox"));
 QPalette pal = cb->palette;
 int labelState = GTK_STATE_INSENSITIVE;
 if (option->state & State_Enabled)
 labelState = (option->state & State_MouseOver && !appearsAsList) ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
 painter->save();
 // Draws the header in tables.
 if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
 Q_UNUSED(header);
-GtkWidget *gtkTreeView = QGtk::gtkWidget(QLS("GtkTreeView"));
+GtkWidget *gtkTreeView = d->gtkWidget(QLS("GtkTreeView"));
 // Get the middle column
-GtkTreeViewColumn *column = QGtk::gtk_tree_view_get_column((GtkTreeView*)gtkTreeView, 1);
+GtkTreeViewColumn *column = d->gtk_tree_view_get_column((GtkTreeView*)gtkTreeView, 1);
 Q_ASSERT(column);
 GtkWidget *gtkTreeHeader = column->button;
 GtkStateType state = gtkPainter.gtkState(option);
 GtkShadowType shadow = GTK_SHADOW_OUT;
 break;
 #ifndef QT_NO_SIZEGRIP
 case CE_SizeGrip: {
-GtkWidget *gtkStatusbar = QGtk::gtkWidget(QLS("GtkStatusbar.GtkFrame"));
+GtkWidget *gtkStatusbar = d->gtkWidget(QLS("GtkStatusbar.GtkFrame"));
 QRect gripRect = option->rect.adjusted(0, 0, -gtkStatusbar->style->xthickness, -gtkStatusbar->style->ythickness);
 gtkPainter.paintResizeGrip( gtkStatusbar, "statusbar", gripRect, GTK_STATE_NORMAL,
 GTK_SHADOW_OUT, QApplication::isRightToLeft() ?
 GDK_WINDOW_EDGE_SOUTH_WEST : GDK_WINDOW_EDGE_SOUTH_EAST,
 gtkStatusbar->style);
 break;
 #endif // QT_NO_SIZEGRIP
 case CE_MenuBarEmptyArea: {
-GtkWidget *gtkMenubar = QGtk::gtkWidget(QLS("GtkMenuBar"));
+GtkWidget *gtkMenubar = d->gtkWidget(QLS("GtkMenuBar"));
 GdkColor gdkBg = gtkMenubar->style->bg[GTK_STATE_NORMAL]; // Theme can depend on transparency
 painter->fillRect(option->rect, QColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8));
 if (widget) { // See CE_MenuBarItem
 QRect menuBarRect = widget->rect();
 QPixmap pixmap(menuBarRect.size());
 pixmap.fill(Qt::transparent);
 QPainter pmPainter(&pixmap);
 QGtkPainter gtkMenuBarPainter(&pmPainter);
 GtkShadowType shadow_type;
-QGtk::gtk_widget_style_get(gtkMenubar, "shadow-type", &shadow_type, NULL);
+d->gtk_widget_style_get(gtkMenubar, "shadow-type", &shadow_type, NULL);
 gtkMenuBarPainter.paintBox( gtkMenubar, "menubar",  menuBarRect,
 GTK_STATE_NORMAL, shadow_type, gtkMenubar->style);
 pmPainter.end();
 painter->drawPixmap(option->rect, pixmap, option->rect);
 }
 case CE_MenuBarItem:
 painter->save();
 if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
-GtkWidget *gtkMenubarItem = QGtk::gtkWidget(QLS("GtkMenuBar.GtkMenuItem"));
+GtkWidget *gtkMenubarItem = d->gtkWidget(QLS("GtkMenuBar.GtkMenuItem"));
-GtkWidget *gtkMenubar = QGtk::gtkWidget(QLS("GtkMenuBar"));
+GtkWidget *gtkMenubar = d->gtkWidget(QLS("GtkMenuBar"));
 style = gtkMenubarItem->style;
 if (widget) {
 // Since Qt does not currently allow filling the entire background
 QPixmap pixmap(menuBarRect.size());
 pixmap.fill(Qt::transparent);
 QPainter pmPainter(&pixmap);
 QGtkPainter menubarPainter(&pmPainter);
 GtkShadowType shadow_type;
-QGtk::gtk_widget_style_get(gtkMenubar, "shadow-type", &shadow_type, NULL);
+d->gtk_widget_style_get(gtkMenubar, "shadow-type", &shadow_type, NULL);
 GdkColor gdkBg = gtkMenubar->style->bg[GTK_STATE_NORMAL]; // Theme can depend on transparency
 painter->fillRect(option->rect, QColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8));
 menubarPainter.paintBox(gtkMenubar, "menubar",  menuBarRect,
 GTK_STATE_NORMAL, shadow_type, gtkMenubar->style);
 pmPainter.end();
 item.palette.setBrush(QPalette::ButtonText, normalTextColor);
 QCommonStyle::drawControl(element, &item, painter, widget);
 if (act) {
 GtkShadowType shadowType = GTK_SHADOW_NONE;
-QGtk::gtk_widget_style_get (gtkMenubarItem, "selected-shadow-type", &shadowType, NULL);
+d->gtk_widget_style_get (gtkMenubarItem, "selected-shadow-type", &shadowType, NULL);
 gtkPainter.paintBox(gtkMenubarItem, "menuitem",  option->rect.adjusted(0, 0, 0, 3),
 GTK_STATE_PRELIGHT, shadowType, gtkMenubarItem->style);
 //draw text
 QPalette::ColorRole textRole = dis ? QPalette::Text : QPalette::HighlightedText;
 uint alignment = Qt::AlignCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
 }
 painter->restore();
 break;
 case CE_Splitter: {
-GtkWidget *gtkWindow = QGtk::gtkWidget(QLS("GtkWindow")); // The Murrine Engine currently assumes a widget is passed
+GtkWidget *gtkWindow = d->gtkWidget(QLS("GtkWindow")); // The Murrine Engine currently assumes a widget is passed
 gtkPainter.paintHandle(gtkWindow, "splitter", option->rect, gtkPainter.gtkState(option), GTK_SHADOW_NONE,
 !(option->state & State_Horizontal) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL,
 style);
 }
 break;
 QRect rect = option->rect;
 // There is a 1 pixel gap between toolbar lines in some styles (i.e Human)
 if (toolbar->positionWithinLine != QStyleOptionToolBar::End)
 rect.adjust(0, 0, 1, 0);
-GtkWidget *gtkToolbar = QGtk::gtkWidget(QLS("GtkToolbar"));
+GtkWidget *gtkToolbar = d->gtkWidget(QLS("GtkToolbar"));
 GtkShadowType shadow_type = GTK_SHADOW_NONE;
-QGtk::gtk_widget_style_get(gtkToolbar, "shadow-type", &shadow_type, NULL);
+d->gtk_widget_style_get(gtkToolbar, "shadow-type", &shadow_type, NULL);
 gtkPainter.paintBox( gtkToolbar, "toolbar",  rect,
 GTK_STATE_NORMAL, shadow_type, gtkToolbar->style);
 }
 break;
 if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
 const int windowsItemFrame        =  2; // menu item frame width
 const int windowsItemHMargin      =  3; // menu item hor text margin
 const int windowsItemVMargin      = 26; // menu item ver text margin
 const int windowsRightBorder      = 15; // right border on windows
-GtkWidget *gtkMenu = QGtk::gtkWidget(QLS("GtkMenu"));
+GtkWidget *gtkMenu = d->gtkWidget(QLS("GtkMenu"));
-GtkWidget *gtkMenuItem = menuItem->checked ? QGtk::gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")) :
+GtkWidget *gtkMenuItem = menuItem->checked ? d->gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")) :
-QGtk::gtkWidget(QLS("GtkMenu.GtkMenuItem"));
+d->gtkWidget(QLS("GtkMenu.GtkMenuItem"));
 style = gtkPainter.getStyle(gtkMenuItem);
 QColor borderColor = option->palette.background().color().darker(160);
 QColor shadow = option->palette.dark().color();
 if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) {
-GtkWidget *gtkMenuSeparator = QGtk::gtkWidget(QLS("GtkMenu.GtkSeparatorMenuItem"));
+GtkWidget *gtkMenuSeparator = d->gtkWidget(QLS("GtkMenu.GtkSeparatorMenuItem"));
 painter->setPen(shadow.lighter(106));
 gboolean wide_separators = 0;
 gint     separator_height = 0;
 guint    horizontal_padding = 3;
-if (!QGtk::gtk_check_version(2, 10, 0)) {
+if (!d->gtk_check_version(2, 10, 0)) {
-QGtk::gtk_widget_style_get(gtkMenuSeparator,
+d->gtk_widget_style_get(gtkMenuSeparator,
 "wide-separators",    &wide_separators,
 "separator-height",   &separator_height,
 "horizontal-padding", &horizontal_padding,
 NULL);
 }
 }
 bool selected = menuItem->state & State_Selected && menuItem->state & State_Enabled;
 if (selected) {
-QRect rect = option->rect.adjusted(0, 0, -1, -1);
+QRect rect = option->rect.adjusted(0, 0, 0, -1);
 #ifndef QT_NO_COMBOBOX
 if (qobject_cast<const QComboBox*>(widget))
 rect = option->rect;
 #endif
 gtkPainter.paintBox( gtkMenuItem, "menuitem", rect, GTK_STATE_PRELIGHT, GTK_SHADOW_OUT, style);
 bool checked = menuItem->checked;
 bool enabled = menuItem->state & State_Enabled;
 bool ignoreCheckMark = false;
 gint checkSize;
-QGtk::gtk_widget_style_get(QGtk::gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")), "indicator-size", &checkSize, NULL);
+d->gtk_widget_style_get(d->gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")), "indicator-size", &checkSize, NULL);
 int checkcol = qMax(menuItem->maxIconWidth, qMax(20, checkSize));
 #ifndef QT_NO_COMBOBOX
 pixmap = menuItem->icon.pixmap(iconSize, mode);
 int pixw = pixmap.width();
 int pixh = pixmap.height();
 QRect pmr(0, 0, pixw, pixh);
-pmr.moveCenter(vCheckRect.center());
+pmr.moveCenter(vCheckRect.center() - QPoint(0, 1));
 painter->setPen(menuItem->palette.text().color());
 if (!ignoreCheckMark && checkable && checked) {
 QStyleOption opt = *option;
 if (act) {
 int x, y, w, h;
 menuitem->rect.getRect(&x, &y, &w, &h);
 int tab = menuitem->tabWidth;
 int xm = windowsItemFrame + checkcol + windowsItemHMargin;
-int xpos = menuitem->rect.x() + xm;
+int xpos = menuitem->rect.x() + xm + 1;
-QRect textRect(xpos, y + windowsItemVMargin, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin);
+QRect textRect(xpos, y + windowsItemVMargin - 1, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin);
 QRect vTextRect = visualRect(opt->direction, menuitem->rect, textRect);
 QString s = menuitem->text;
 if (!s.isEmpty()) { // Draw text
 p->save();
 proxy()->pixelMetric(PM_ButtonShiftVertical, option, widget));
 QFontMetrics fm(menuitem->font);
 int arrow_size = fm.ascent() + fm.descent() - 2 * gtkMenuItem->style->ythickness;
 gfloat arrow_scaling = 0.8;
+int extra = 0;
-// "arrow-scaling" is actually hardcoded and fails on hardy (see gtk+-2.12/gtkmenuitem.c)
+if (!d->gtk_check_version(2, 16, 0)) {
-// though the current documentation states otherwise
+// "arrow-scaling" is actually hardcoded and fails on hardy (see gtk+-2.12/gtkmenuitem.c)
+// though the current documentation states otherwise
+d->gtk_widget_style_get(gtkMenuItem, "arrow-scaling", &arrow_scaling, NULL);
+// in versions < 2.16 ythickness was previously subtracted from the arrow_size
+extra = 2 * gtkMenuItem->style->ythickness;
+}
 int horizontal_padding;
-QGtk::gtk_widget_style_get(gtkMenuItem, "horizontal-padding", &horizontal_padding, NULL);
+d->gtk_widget_style_get(gtkMenuItem, "horizontal-padding", &horizontal_padding, NULL);
-const int dim = static_cast<int>(arrow_size * arrow_scaling);
+const int dim = static_cast<int>(arrow_size * arrow_scaling) + extra;
 int xpos = menuItem->rect.left() + menuItem->rect.width() - horizontal_padding - dim;
 QRect  vSubMenuRect = visualRect(option->direction, menuItem->rect,
 QRect(xpos, menuItem->rect.top() +
 menuItem->rect.height() / 2 - dim / 2, dim, dim));
 GtkStateType state = enabled ? (act ? GTK_STATE_PRELIGHT: GTK_STATE_NORMAL) : GTK_STATE_INSENSITIVE;
 painter->restore();
 break;
 case CE_PushButton:
 if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {
-GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
 proxy()->drawControl(CE_PushButtonBevel, btn, painter, widget);
 QStyleOptionButton subopt = *btn;
 subopt.rect = subElementRect(SE_PushButtonContents, btn, widget);
 gint interiorFocus = true;
-QGtk::gtk_widget_style_get(gtkButton, "interior-focus", &interiorFocus, NULL);
+d->gtk_widget_style_get(gtkButton, "interior-focus", &interiorFocus, NULL);
 int xt = interiorFocus ? gtkButton->style->xthickness : 0;
 int yt = interiorFocus ? gtkButton->style->ythickness : 0;
 if (btn->features & QStyleOptionButton::Flat && btn->state & State_HasFocus)
 // The normal button focus rect does not work well for flat buttons in Clearlooks
 #ifndef QT_NO_TABBAR
 case CE_TabBarTabShape:
 if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {
-GtkWidget *gtkNotebook = QGtk::gtkWidget(QLS("GtkNotebook"));
+GtkWidget *gtkNotebook = d->gtkWidget(QLS("GtkNotebook"));
 style = gtkPainter.getStyle(gtkNotebook);
 QRect rect = option->rect;
 GtkShadowType shadow = GTK_SHADOW_OUT;
 GtkStateType state = GTK_STATE_ACTIVE;
 #endif //QT_NO_TABBAR
 case CE_ProgressBarGroove:
 if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
 Q_UNUSED(bar);
-GtkWidget *gtkProgressBar = QGtk::gtkWidget(QLS("GtkProgressBar"));
+GtkWidget *gtkProgressBar = d->gtkWidget(QLS("GtkProgressBar"));
 GtkStateType state = gtkPainter.gtkState(option);
 gtkPainter.paintBox( gtkProgressBar, "trough",  option->rect, state, GTK_SHADOW_IN, gtkProgressBar->style);
 }
 break;
 case CE_ProgressBarContents:
 if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
 GtkStateType state = option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE;
-GtkWidget *gtkProgressBar = QGtk::gtkWidget(QLS("GtkProgressBar"));
+GtkWidget *gtkProgressBar = d->gtkWidget(QLS("GtkProgressBar"));
 style = gtkProgressBar->style;
 gtkPainter.paintBox( gtkProgressBar, "trough",  option->rect, state, GTK_SHADOW_IN, style);
 int xt = style->xthickness;
 int yt = style->ythickness;
 QRect rect = bar->rect.adjusted(xt, yt, -xt, -yt);
 if (bar->progress == bar->maximum)
 fakePos = maximum;
 else if (bar->progress > bar->minimum)
 fakePos = maximum - 1;
-GtkObject *adjustment =  QGtk::gtk_adjustment_new(fakePos, 0, maximum, 0, 0, 0);
+GtkObject *adjustment =  d->gtk_adjustment_new(fakePos, 0, maximum, 0, 0, 0);
-QGtk::gtk_progress_set_adjustment((GtkProgress*)(gtkProgressBar), (GtkAdjustment*)(adjustment));
+d->gtk_progress_set_adjustment((GtkProgress*)(gtkProgressBar), (GtkAdjustment*)(adjustment));
 QRect progressBar;
 if (!indeterminate) {
 if (!reverse)
 \reimp
 */
 QRect QGtkStyle::subControlRect(ComplexControl control, const QStyleOptionComplex *option,
 SubControl subControl, const QWidget *widget) const
 {
+Q_D(const QGtkStyle);
 QRect rect = QWindowsStyle::subControlRect(control, option, subControl, widget);
-if (!QGtk::isThemeAvailable())
+if (!d->isThemeAvailable())
 return QCleanlooksStyle::subControlRect(control, option, subControl, widget);
 switch (control) {
 case CC_TitleBar:
 return QCleanlooksStyle::subControlRect(control, option, subControl, widget);
 #endif
 #ifndef QT_NO_SPINBOX
 case CC_SpinBox:
 if (const QStyleOptionSpinBox *spinbox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) {
-GtkWidget *gtkSpinButton = QGtk::gtkWidget(QLS("GtkSpinButton"));
+GtkWidget *gtkSpinButton = d->gtkWidget(QLS("GtkSpinButton"));
 int center = spinbox->rect.height() / 2;
 int xt = spinbox->frame ? gtkSpinButton->style->xthickness : 0;
 int yt = spinbox->frame ? gtkSpinButton->style->ythickness : 0;
 int y = yt;
 QSize bs;
 bs.setHeight(qMax(8, spinbox->rect.height()/2 - y));
-bs.setWidth(spinboxArrowSize());
+bs.setWidth(d->getSpinboxArrowSize());
 int x, lx, rx;
 x = spinbox->rect.width() - y - bs.width() + 2;
 lx = xt;
 rx = x - xt;
 case CC_ComboBox:
 if (const QStyleOptionComboBox *box = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
 // We employ the gtk widget to position arrows and separators for us
 QString comboBoxPath = box->editable ? QLS("GtkComboBoxEntry") : QLS("GtkComboBox");
-GtkWidget *gtkCombo = QGtk::gtkWidget(comboBoxPath);
+GtkWidget *gtkCombo = d->gtkWidget(comboBoxPath);
-QGtk::gtk_widget_set_direction(gtkCombo, (option->direction == Qt::RightToLeft) ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
+d->gtk_widget_set_direction(gtkCombo, (option->direction == Qt::RightToLeft) ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
 GtkAllocation geometry = {0, 0, qMax(0, option->rect.width()), qMax(0, option->rect.height())};
-QGtk::gtk_widget_size_allocate(gtkCombo, &geometry);
+d->gtk_widget_size_allocate(gtkCombo, &geometry);
 int appears_as_list = !proxy()->styleHint(QStyle::SH_ComboBox_Popup, option, widget);
 QString arrowPath = comboBoxPath + QLS(".GtkToggleButton");
 if (!box->editable && !appears_as_list)
 arrowPath += QLS(".GtkHBox.GtkArrow");
-GtkWidget *arrowWidget = QGtk::gtkWidget(arrowPath);
+GtkWidget *arrowWidget = d->gtkWidget(arrowPath);
 if (!arrowWidget)
 return QCleanlooksStyle::subControlRect(control, option, subControl, widget);
 QRect buttonRect(option->rect.left() + arrowWidget->allocation.x,
 option->rect.top() + arrowWidget->allocation.y,
 /*!
 \reimp
 */
 QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
 const QSize &size, const QWidget *widget) const
 {
+Q_D(const QGtkStyle);
 QSize newSize = QCleanlooksStyle::sizeFromContents(type, option, size, widget);
-if (!QGtk::isThemeAvailable())
+if (!d->isThemeAvailable())
 return newSize;
 switch (type) {
 case CT_ToolButton:
 if (const QStyleOptionToolButton *toolbutton = qstyleoption_cast<const QStyleOptionToolButton *>(option)) {
-GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+GtkWidget *gtkButton = d->gtkWidget(QLS("GtkToolButton.GtkButton"));
-newSize = size + QSize(2 * gtkButton->style->xthickness, 1 + 2 * gtkButton->style->ythickness);
+newSize = size + QSize(2 * gtkButton->style->xthickness, 2 + 2 * gtkButton->style->ythickness);
 if (widget && qobject_cast<QToolBar *>(widget->parentWidget())) {
 QSize minSize(0, 25);
 if (toolbutton->toolButtonStyle != Qt::ToolButtonTextOnly)
 minSize = toolbutton->iconSize + QSize(12, 12);
 newSize = newSize.expandedTo(minSize);
 }
 if (toolbutton->features & QStyleOptionToolButton::HasMenu)
 newSize += QSize(6, 0);
 }
 break;
 case CT_MenuItem:
 if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
 int textMargin = 8;
 if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) {
-GtkWidget *gtkMenuSeparator = QGtk::gtkWidget(QLS("GtkMenu.GtkSeparatorMenuItem"));
+GtkWidget *gtkMenuSeparator = d->gtkWidget(QLS("GtkMenu.GtkSeparatorMenuItem"));
 gboolean wide_separators;
 gint     separator_height;
-QGtk::gtk_widget_style_get(gtkMenuSeparator,
+d->gtk_widget_style_get(gtkMenuSeparator,
 "wide-separators",    &wide_separators,
 "separator-height",   &separator_height,
 NULL);
 newSize = QSize(size.width(), wide_separators ? separator_height - 1 : 7 );
 break;
 }
-GtkWidget *gtkMenuItem = QGtk::gtkWidget(QLS("GtkMenu.GtkMenuItem"));
+GtkWidget *gtkMenuItem = d->gtkWidget(QLS("GtkMenu.GtkMenuItem"));
 GtkStyle* style = gtkMenuItem->style;
-newSize += QSize(textMargin + style->xthickness - 2, style->ythickness - 4);
+newSize += QSize(textMargin + style->xthickness - 1, style->ythickness - 3);
 // Cleanlooks assumes a check column of 20 pixels so we need to
 // expand it a bit
 gint checkSize;
-QGtk::gtk_widget_style_get(QGtk::gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")), "indicator-size", &checkSize, NULL);
+d->gtk_widget_style_get(d->gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")), "indicator-size", &checkSize, NULL);
 newSize.setHeight(qMax(newSize.height(), checkSize + 2));
 newSize.setWidth(newSize.width() + qMax(0, checkSize - 20));
 }
 break;
 break;
 case CT_SpinBox:
 // QSpinBox does some nasty things that depends on CT_LineEdit
-newSize = size + QSize(0, -QGtk::gtkWidget(QLS("GtkSpinButton"))->style->ythickness * 2 + 2);
+newSize = size + QSize(0, -d->gtkWidget(QLS("GtkSpinButton"))->style->ythickness * 2);
 break;
 case CT_PushButton:
 if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {
-GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
 gint focusPadding, focusWidth;
-QGtk::gtk_widget_style_get(gtkButton, "focus-padding", &focusPadding, NULL);
+d->gtk_widget_style_get(gtkButton, "focus-padding", &focusPadding, NULL);
-QGtk::gtk_widget_style_get(gtkButton, "focus-line-width", &focusWidth, NULL);
+d->gtk_widget_style_get(gtkButton, "focus-line-width", &focusWidth, NULL);
 newSize = size;
 newSize += QSize(2*gtkButton->style->xthickness + 4, 2*gtkButton->style->ythickness);
 newSize += QSize(2*(focusWidth + focusPadding + 2), 2*(focusWidth + focusPadding));
-GtkWidget *gtkButtonBox = QGtk::gtkWidget(QLS("GtkHButtonBox"));
+GtkWidget *gtkButtonBox = d->gtkWidget(QLS("GtkHButtonBox"));
 gint minWidth = 85, minHeight = 0;
-QGtk::gtk_widget_style_get(gtkButtonBox, "child-min-width", &minWidth,
+d->gtk_widget_style_get(gtkButtonBox, "child-min-width", &minWidth,
 "child-min-height", &minHeight, NULL);
 if (!btn->text.isEmpty() && newSize.width() < minWidth)
 newSize.setWidth(minWidth);
 if (newSize.height() < minHeight)
 newSize.setHeight(minHeight);
 }
 break;
 case CT_Slider: {
-GtkWidget *gtkSlider = QGtk::gtkWidget(QLS("GtkHScale"));
+GtkWidget *gtkSlider = d->gtkWidget(QLS("GtkHScale"));
 newSize = size + QSize(2*gtkSlider->style->xthickness, 2*gtkSlider->style->ythickness);
 }
 break;
-case CT_MenuBarItem://cleanlooks adds 2 pixels
-newSize = QWindowsStyle::sizeFromContents(type, option, size, widget) + QSize(0, 1);
-break;
 case CT_LineEdit: {
-GtkWidget *gtkEntry = QGtk::gtkWidget(QLS("GtkEntry"));
+GtkWidget *gtkEntry = d->gtkWidget(QLS("GtkEntry"));
-newSize = size + QSize(2*gtkEntry->style->xthickness, 2*gtkEntry->style->ythickness);
+newSize = size + QSize(2*gtkEntry->style->xthickness, 2 + 2*gtkEntry->style->ythickness);
 }
 break;
 case CT_ItemViewItem:
 newSize += QSize(0, 2);
 break;
 case CT_ComboBox:
 if (const QStyleOptionComboBox *combo = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
-GtkWidget *gtkCombo = QGtk::gtkWidget(QLS("GtkComboBox"));
+GtkWidget *gtkCombo = d->gtkWidget(QLS("GtkComboBox"));
 QRect arrowButtonRect = proxy()->subControlRect(CC_ComboBox, combo, SC_ComboBoxArrow, widget);
 newSize = size + QSize(12 + arrowButtonRect.width() + 2*gtkCombo->style->xthickness, 4 + 2*gtkCombo->style->ythickness);
 if (!(widget && qobject_cast<QToolBar *>(widget->parentWidget())))
-newSize += QSize(0, 3);
+newSize += QSize(0, 2);
 }
 break;
 case CT_GroupBox:
 newSize += QSize(4, groupBoxBottomMargin + groupBoxTopMargin + groupBoxTitleMargin); // Add some space below the groupbox
 case CT_TabBarTab:
 if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {
 if (!tab->icon.isNull())
 newSize += QSize(6, 0);
 }
-newSize += QSize(1, 0);
+newSize += QSize(1, 1);
 break;
 default:
 break;
 }
 /*! \reimp */
 QPixmap QGtkStyle::standardPixmap(StandardPixmap sp, const QStyleOption *option,
 const QWidget *widget) const
 {
-if (!QGtk::isThemeAvailable())
+Q_D(const QGtkStyle);
+if (!d->isThemeAvailable())
 return QCleanlooksStyle::standardPixmap(sp, option, widget);
 QPixmap pixmap;
 switch (sp) {
 */
 QIcon QGtkStyle::standardIconImplementation(StandardPixmap standardIcon,
 const QStyleOption *option,
 const QWidget *widget) const
 {
-if (!QGtk::isThemeAvailable())
+Q_D(const QGtkStyle);
+if (!d->isThemeAvailable())
 return QCleanlooksStyle::standardIconImplementation(standardIcon, option, widget);
 switch (standardIcon) {
 case SP_DialogDiscardButton:
 return QGtkPainter::getIcon(GTK_STOCK_DELETE);
 case SP_DialogOkButton:
 /*! \reimp */
 QRect QGtkStyle::subElementRect(SubElement element, const QStyleOption *option, const QWidget *widget) const
 {
+Q_D(const QGtkStyle);
 QRect r = QCleanlooksStyle::subElementRect(element, option, widget);
 switch (element) {
 case SE_ProgressBarLabel:
 case SE_ProgressBarContents:
 case SE_ProgressBarGroove:
 return option->rect;
+case SE_PushButtonContents:
+if (!d->gtk_check_version(2, 10, 0)) {
+GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
+GtkBorder *border = 0;
+d->gtk_widget_style_get(gtkButton, "inner-border", &border, NULL);
+if (border) {
+r = option->rect.adjusted(border->left, border->top, -border->right, -border->bottom);
+d->gtk_border_free(border);
+} else {
+r = option->rect.adjusted(1, 1, -1, -1);
+}
+r = visualRect(option->direction, option->rect, r);
+}
+break;
 default:
 break;
 }
 return r;

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7