/**************************************************************************** | |
** | |
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). | |
** All rights reserved. | |
** Contact: Nokia Corporation (qt-info@nokia.com) | |
** | |
** This file is part of the QtGui module of the Qt Toolkit. | |
** | |
** $QT_BEGIN_LICENSE:LGPL$ | |
** GNU Lesser General Public License Usage | |
** This file may be used under the terms of the GNU Lesser General Public | |
** License version 2.1 as published by the Free Software Foundation and | |
** appearing in the file LICENSE.LGPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU Lesser | |
** General Public License version 2.1 requirements will be met: | |
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. | |
** | |
** In addition, as a special exception, Nokia gives you certain additional | |
** rights. These rights are described in the Nokia Qt LGPL Exception | |
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. | |
** | |
** GNU General Public License Usage | |
** Alternatively, this file may be used under the terms of the GNU General | |
** Public License version 3.0 as published by the Free Software Foundation | |
** and appearing in the file LICENSE.GPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU General | |
** Public License version 3.0 requirements will be met: | |
** http://www.gnu.org/copyleft/gpl.html. | |
** | |
** Other Usage | |
** Alternatively, this file may be used in accordance with the terms and | |
** conditions contained in a signed written agreement between you and Nokia. | |
** | |
** | |
** | |
** | |
** | |
** $QT_END_LICENSE$ | |
** | |
****************************************************************************/ | |
#include "qgtkstyle.h" | |
#if !defined(QT_NO_STYLE_GTK) | |
#include <private/qapplication_p.h> | |
#include <QtCore/QLibrary> | |
#include <QtCore/QSettings> | |
#include <QtGui/QDialogButtonBox> | |
#include <QtGui/QStatusBar> | |
#include <QtGui/QLineEdit> | |
#include <QtGui/QWidget> | |
#include <QtGui/QListView> | |
#include <QtGui/QApplication> | |
#include <QtGui/QStyleOption> | |
#include <QtGui/QPushButton> | |
#include <QtGui/QPainter> | |
#include <QtGui/QMainWindow> | |
#include <QtGui/QToolBar> | |
#include <QtGui/QHeaderView> | |
#include <QtGui/QMenuBar> | |
#include <QtGui/QComboBox> | |
#include <QtGui/QSpinBox> | |
#include <QtGui/QScrollBar> | |
#include <QtGui/QAbstractButton> | |
#include <QtGui/QToolButton> | |
#include <QtGui/QGroupBox> | |
#include <QtGui/QRadioButton> | |
#include <QtGui/QCheckBox> | |
#include <QtGui/QTreeView> | |
#include <QtGui/QStyledItemDelegate> | |
#include <qpixmapcache.h> | |
#undef signals // Collides with GTK stymbols | |
#include <private/qgtkpainter_p.h> | |
#include <private/qstylehelper_p.h> | |
#include <private/qgtkstyle_p.h> | |
#include <private/qcleanlooksstyle_p.h> | |
QT_BEGIN_NAMESPACE | |
static const char * const dock_widget_close_xpm[] = | |
{ | |
"11 13 5 1", | |
" c None", | |
". c #D5CFCB", | |
"+ c #6C6A67", | |
"@ c #6C6A67", | |
"$ c #B5B0AC", | |
" ", | |
" @@@@@@@@@ ", | |
"@+ +@", | |
"@ +@ @+ @", | |
"@ @@@ @@@ @", | |
"@ @@@@@ @", | |
"@ @@@ @", | |
"@ @@@@@ @", | |
"@ @@@ @@@ @", | |
"@ +@ @+ @", | |
"@+ +@", | |
" @@@@@@@@@ ", | |
" " | |
}; | |
static const char * const dock_widget_restore_xpm[] = | |
{ | |
"11 13 5 1", | |
" c None", | |
". c #D5CFCB", | |
"+ c #6C6A67", | |
"@ c #6C6A67", | |
"# c #6C6A67", | |
" ", | |
" @@@@@@@@@ ", | |
"@+ +@", | |
"@ #@@@# @", | |
"@ @ @ @", | |
"@ #@@@# @ @", | |
"@ @ @ @ @", | |
"@ @ @@@ @", | |
"@ @ @ @", | |
"@ #@@@@ @", | |
"@+ +@", | |
" @@@@@@@@@ ", | |
" " | |
}; | |
static const int groupBoxBottomMargin = 2; // space below the groupbox | |
static const int groupBoxTitleMargin = 6; // space between contents and title | |
static const int groupBoxTopMargin = 2; | |
/*! | |
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) | |
{ | |
return QGtkStylePrivate::getGConfString(value, fallback); | |
} | |
/*! | |
Returns the configuration boolean for \a key. | |
Returns \a fallback if \a key is not found. | |
*/ | |
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; | |
QColor tmp = colorA; | |
tmp.setRed((tmp.red() * factor) / maxFactor + (colorB.red() * (maxFactor - factor)) / maxFactor); | |
tmp.setGreen((tmp.green() * factor) / maxFactor + (colorB.green() * (maxFactor - factor)) / maxFactor); | |
tmp.setBlue((tmp.blue() * factor) / maxFactor + (colorB.blue() * (maxFactor - factor)) / maxFactor); | |
return tmp; | |
} | |
static GdkColor fromQColor(const QColor &color) | |
{ | |
GdkColor retval; | |
retval.red = color.red() * 255; | |
retval.green = color.green() * 255; | |
retval.blue = color.blue() * 255; | |
return retval; | |
} | |
/*! | |
\class QGtkStyle | |
\brief The QGtkStyle class provides a widget style rendered by GTK+ | |
\since 4.5 | |
The QGtkStyle style provides a look and feel that integrates well | |
into GTK-based desktop environments such as the XFCe and GNOME. | |
It does this by making use of the GTK+ theme engine, ensuring | |
that Qt applications look and feel native on these platforms. | |
Note: The style requires GTK+ version 2.10 or later. | |
The Qt3-based "Qt" GTK+ theme engine will not work with QGtkStyle. | |
\sa {Cleanlooks Style Widget Gallery}, QWindowsXPStyle, QMacStyle, QWindowsStyle, | |
QCDEStyle, QMotifStyle, QPlastiqueStyle, QCleanlooksStyle | |
*/ | |
/*! | |
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 (d->isThemeAvailable()) { | |
GtkStyle *style = d->gtkStyle(); | |
GtkWidget *gtkButton = d->gtkWidget("GtkButton"); | |
GtkWidget *gtkEntry = d->getTextColorWidget(); | |
GdkColor gdkBg, gdkBase, gdkText, gdkForeground, gdkSbg, gdkSfg, gdkaSbg, gdkaSfg; | |
QColor bg, base, text, fg, highlight, highlightText, inactiveHighlight, inactiveHighlightedTExt; | |
gdkBg = style->bg[GTK_STATE_NORMAL]; | |
gdkForeground = gtkButton->style->fg[GTK_STATE_NORMAL]; | |
// Our base and selected color is primarily used for text | |
// so we assume a gtkEntry will have the most correct value | |
gdkBase = gtkEntry->style->base[GTK_STATE_NORMAL]; | |
gdkText = gtkEntry->style->text[GTK_STATE_NORMAL]; | |
gdkSbg = gtkEntry->style->base[GTK_STATE_SELECTED]; | |
gdkSfg = gtkEntry->style->text[GTK_STATE_SELECTED]; | |
// The ACTIVE base color is really used for inactive windows | |
gdkaSbg = gtkEntry->style->base[GTK_STATE_ACTIVE]; | |
gdkaSfg = gtkEntry->style->text[GTK_STATE_ACTIVE]; | |
bg = QColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8); | |
text = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8); | |
fg = QColor(gdkForeground.red>>8, gdkForeground.green>>8, gdkForeground.blue>>8); | |
base = QColor(gdkBase.red>>8, gdkBase.green>>8, gdkBase.blue>>8); | |
highlight = QColor(gdkSbg.red>>8, gdkSbg.green>>8, gdkSbg.blue>>8); | |
highlightText = QColor(gdkSfg.red>>8, gdkSfg.green>>8, gdkSfg.blue>>8); | |
inactiveHighlight = QColor(gdkaSbg.red>>8, gdkaSbg.green>>8, gdkaSbg.blue>>8); | |
inactiveHighlightedTExt = QColor(gdkaSfg.red>>8, gdkaSfg.green>>8, gdkaSfg.blue>>8); | |
palette.setColor(QPalette::HighlightedText, highlightText); | |
palette.setColor(QPalette::Light, bg.lighter(125)); | |
palette.setColor(QPalette::Shadow, bg.darker(130)); | |
palette.setColor(QPalette::Dark, bg.darker(120)); | |
palette.setColor(QPalette::Text, text); | |
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 = d->gtkWidget("GtkTreeView"); | |
GdkColor *gtkAltBase = NULL; | |
d->gtk_widget_style_get(gtkTreeView, "odd-row-color", >kAltBase, NULL); | |
if (gtkAltBase) { | |
alternateRowColor = QColor(gtkAltBase->red>>8, gtkAltBase->green>>8, gtkAltBase->blue>>8); | |
d->gdk_color_free(gtkAltBase); | |
} | |
palette.setColor(QPalette::AlternateBase, alternateRowColor); | |
palette.setColor(QPalette::Window, bg); | |
palette.setColor(QPalette::Button, bg); | |
palette.setColor(QPalette::Background, bg); | |
QColor disabled((fg.red() + bg.red()) / 2, | |
(fg.green() + bg.green())/ 2, | |
(fg.blue() + bg.blue()) / 2); | |
palette.setColor(QPalette::Disabled, QPalette::Text, disabled); | |
palette.setColor(QPalette::Disabled, QPalette::WindowText, disabled); | |
palette.setColor(QPalette::Disabled, QPalette::Foreground, disabled); | |
palette.setColor(QPalette::Disabled, QPalette::ButtonText, disabled); | |
palette.setColor(QPalette::Highlight, highlight); | |
// 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); | |
palette.setColor(QPalette::Inactive, QPalette::HighlightedText, inactiveHighlightedTExt); | |
palette.setColor(QPalette::Inactive, QPalette::Highlight, inactiveHighlight); | |
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); | |
} | |
} | |
return palette; | |
} | |
/*! | |
\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 (!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() && d->isThemeAvailable()) { | |
QApplicationPrivate::setSystemPalette(standardPalette()); | |
QApplicationPrivate::setSystemFont(d->getThemeFont()); | |
d->applyCustomPaletteHash(); | |
if (!d->isKDE4Session()) { | |
qt_filedialog_open_filename_hook = &QGtkStylePrivate::openFilename; | |
qt_filedialog_save_filename_hook = &QGtkStylePrivate::saveFilename; | |
qt_filedialog_open_filenames_hook = &QGtkStylePrivate::openFilenames; | |
qt_filedialog_existing_directory_hook = &QGtkStylePrivate::openDirectory; | |
qApp->installEventFilter(&d->filter); | |
} | |
} | |
} | |
/*! | |
\reimp | |
*/ | |
void QGtkStyle::unpolish(QApplication *app) | |
{ | |
Q_D(QGtkStyle); | |
QCleanlooksStyle::unpolish(app); | |
QPixmapCache::clear(); | |
if (app->desktopSettingsAware() && d->isThemeAvailable() | |
&& !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; | |
qApp->removeEventFilter(&d->filter); | |
} | |
} | |
/*! | |
\reimp | |
*/ | |
void QGtkStyle::polish(QWidget *widget) | |
{ | |
Q_D(QGtkStyle); | |
QCleanlooksStyle::polish(widget); | |
if (!d->isThemeAvailable()) | |
return; | |
if (qobject_cast<QAbstractButton*>(widget) | |
|| qobject_cast<QToolButton*>(widget) | |
|| qobject_cast<QComboBox*>(widget) | |
|| qobject_cast<QGroupBox*>(widget) | |
|| qobject_cast<QScrollBar*>(widget) | |
|| qobject_cast<QSlider*>(widget) | |
|| qobject_cast<QAbstractSpinBox*>(widget) | |
|| qobject_cast<QSpinBox*>(widget) | |
|| qobject_cast<QHeaderView*>(widget)) | |
widget->setAttribute(Qt::WA_Hover); | |
else if (QTreeView *tree = qobject_cast<QTreeView *> (widget)) | |
tree->viewport()->setAttribute(Qt::WA_Hover); | |
} | |
/*! | |
\reimp | |
*/ | |
void QGtkStyle::unpolish(QWidget *widget) | |
{ | |
QCleanlooksStyle::unpolish(widget); | |
} | |
/*! | |
\reimp | |
*/ | |
int QGtkStyle::pixelMetric(PixelMetric metric, | |
const QStyleOption *option, | |
const QWidget *widget) const | |
{ | |
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 = | |
d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(), | |
"*.GtkScrolledWindow", | |
"*.GtkScrolledWindow", | |
d->gtk_window_get_type())) | |
return qMax(style->xthickness, style->ythickness); | |
} | |
return 2; | |
case PM_MenuButtonIndicator: | |
return 20; | |
case PM_TabBarBaseOverlap: | |
return 1; | |
case PM_ToolBarSeparatorExtent: | |
return 11; | |
case PM_ToolBarFrameWidth: | |
return 1; | |
case PM_ToolBarItemSpacing: | |
return 0; | |
case PM_ButtonShiftHorizontal: { | |
GtkWidget *gtkButton = d->gtkWidget("GtkButton"); | |
guint horizontal_shift; | |
d->gtk_widget_style_get(gtkButton, "child-displacement-x", &horizontal_shift, NULL); | |
return horizontal_shift; | |
} | |
case PM_ButtonShiftVertical: { | |
GtkWidget *gtkButton = d->gtkWidget("GtkButton"); | |
guint vertical_shift; | |
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 = d->gtkWidget("GtkMenu"); | |
guint horizontal_padding = 0; | |
// horizontal-padding is used by Maemo to get thicker borders | |
if (!d->gtk_check_version(2, 10, 0)) | |
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 = 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(',')); | |
foreach (const QString &value, values) { | |
if (value.startsWith(QLS("gtk-button="))) { | |
QString iconSize = value.right(value.size() - 11); | |
if (iconSize.contains(splitChar)) | |
retVal = iconSize.split(splitChar)[0].toInt(); | |
break; | |
} | |
} | |
return retVal; | |
} | |
case PM_MenuVMargin: | |
case PM_MenuHMargin: | |
return 0; | |
case PM_DockWidgetTitleMargin: | |
return 0; | |
case PM_DockWidgetTitleBarButtonMargin: | |
return 5; | |
case PM_TabBarTabVSpace: | |
return 12; | |
case PM_TabBarTabHSpace: | |
return 14; | |
case PM_TabBarTabShiftVertical: | |
return 2; | |
case PM_ToolBarHandleExtent: | |
return 9; | |
case PM_SplitterWidth: | |
return 6; | |
case PM_SliderThickness: | |
case PM_SliderControlThickness: { | |
GtkWidget *gtkScale = d->gtkWidget("GtkHScale"); | |
gint val; | |
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 = d->gtkWidget("GtkHScrollbar"); | |
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; | |
d->gtk_widget_style_get(d->gtkWidget("GtkHScale"), "slider-length", &val, NULL); | |
return val; | |
case PM_ExclusiveIndicatorWidth: | |
case PM_ExclusiveIndicatorHeight: | |
case PM_IndicatorWidth: | |
case PM_IndicatorHeight: { | |
GtkWidget *gtkCheckButton = d->gtkWidget("GtkCheckButton"); | |
gint size, spacing; | |
d->gtk_widget_style_get(gtkCheckButton, "indicator-spacing", &spacing, "indicator-size", &size, NULL); | |
return size + 2 * spacing; | |
} | |
case PM_MenuBarVMargin: { | |
GtkWidget *gtkMenubar = d->gtkWidget("GtkMenuBar"); | |
return qMax(0, gtkMenubar->style->ythickness); | |
} | |
case PM_ScrollView_ScrollBarSpacing: | |
{ | |
gint spacing = 3; | |
GtkWidget *gtkScrollWindow = d->gtkWidget("GtkScrolledWindow"); | |
Q_ASSERT(gtkScrollWindow); | |
d->gtk_widget_style_get(gtkScrollWindow, "scrollbar-spacing", &spacing, NULL); | |
return spacing; | |
} | |
case PM_SubMenuOverlap: { | |
gint offset = 0; | |
GtkWidget *gtkMenu = d->gtkWidget("GtkMenu"); | |
d->gtk_widget_style_get(gtkMenu, "horizontal-offset", &offset, NULL); | |
return offset; | |
} | |
default: | |
return QCleanlooksStyle::pixelMetric(metric, option, widget); | |
} | |
} | |
/*! | |
\reimp | |
*/ | |
int QGtkStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget, | |
QStyleHintReturn *returnData = 0) const | |
{ | |
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 = d->gtk_settings_get_default(); | |
g_object_get(settings, "gtk-alternative-button-order", &alternateOrder, NULL); | |
if (alternateOrder) | |
ret = QDialogButtonBox::WinLayout; | |
return ret; | |
} | |
break; | |
case SH_ToolButtonStyle: | |
{ | |
if (d->isKDE4Session()) | |
return QCleanlooksStyle::styleHint(hint, option, widget, returnData); | |
GtkWidget *gtkToolbar = d->gtkWidget("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 GTK_TOOLBAR_BOTH: | |
return Qt::ToolButtonTextUnderIcon; | |
case GTK_TOOLBAR_BOTH_HORIZ: | |
return Qt::ToolButtonTextBesideIcon; | |
case GTK_TOOLBAR_ICONS: | |
default: | |
return Qt::ToolButtonIconOnly; | |
} | |
} | |
break; | |
case SH_SpinControls_DisableOnBounds: | |
return int(true); | |
case SH_DitherDisabledText: | |
return int(false); | |
case SH_ComboBox_Popup: { | |
GtkWidget *gtkComboBox = d->gtkWidget("GtkComboBox"); | |
gboolean appears_as_list; | |
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 = 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 (!d->gtk_check_version(2, 12, 0)) { | |
GtkWidget *gtkScrollWindow = d->gtkWidget("GtkScrolledWindow"); | |
d->gtk_widget_style_get(gtkScrollWindow, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL); | |
} | |
return !scrollbars_within_bevel; | |
} | |
case SH_DialogButtonBox_ButtonsHaveIcons: { | |
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 | |
{ | |
Q_D(const QGtkStyle); | |
if (!d->isThemeAvailable()) { | |
QCleanlooksStyle::drawPrimitive(element, option, painter, widget); | |
return; | |
} | |
GtkStyle* style = d->gtkStyle(); | |
QGtkPainter gtkPainter(painter); | |
switch (element) { | |
case PE_Frame: { | |
if (widget && widget->inherits("QComboBoxPrivateContainer")){ | |
QStyleOption copy = *option; | |
copy.state |= State_Raised; | |
proxy()->drawPrimitive(PE_PanelMenu, ©, painter, widget); | |
break; | |
} | |
// Drawing the entire itemview frame is very expensive, especially on the native X11 engine | |
// Instead we cheat a bit and draw a border image without the center part, hence only scaling | |
// thin rectangular images | |
const int pmSize = 64; | |
const int border = proxy()->pixelMetric(PM_DefaultFrameWidth, option, widget); | |
const QString pmKey = QLatin1Literal("windowframe") % HexString<uint>(option->state); | |
QPixmap pixmap; | |
QRect pmRect(QPoint(0,0), QSize(pmSize, pmSize)); | |
// Only draw through style once | |
if (!QPixmapCache::find(pmKey, pixmap)) { | |
pixmap = QPixmap(pmSize, pmSize); | |
pixmap.fill(Qt::transparent); | |
QPainter pmPainter(&pixmap); | |
QGtkPainter gtkFramePainter(&pmPainter); | |
gtkFramePainter.setUsePixmapCache(false); // Don't cache twice | |
GtkShadowType shadow_type = GTK_SHADOW_NONE; | |
if (option->state & State_Sunken) | |
shadow_type = GTK_SHADOW_IN; | |
else if (option->state & State_Raised) | |
shadow_type = GTK_SHADOW_OUT; | |
GtkStyle *style = d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(), | |
"*.GtkScrolledWindow", "*.GtkScrolledWindow", d->gtk_window_get_type()); | |
if (style) | |
gtkFramePainter.paintShadow(d->gtkWidget("GtkFrame"), "viewport", pmRect, | |
option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE, | |
shadow_type, style); | |
QPixmapCache::insert(pmKey, pixmap); | |
} | |
QRect rect = option->rect; | |
const int rw = rect.width() - border; | |
const int rh = rect.height() - border; | |
const int pw = pmRect.width() - border; | |
const int ph = pmRect.height() - border; | |
// Sidelines | |
painter->drawPixmap(rect.adjusted(border, 0, -border, -rh), pixmap, pmRect.adjusted(border, 0, -border,-ph)); | |
painter->drawPixmap(rect.adjusted(border, rh, -border, 0), pixmap, pmRect.adjusted(border, ph,-border,0)); | |
painter->drawPixmap(rect.adjusted(0, border, -rw, -border), pixmap, pmRect.adjusted(0, border, -pw, -border)); | |
painter->drawPixmap(rect.adjusted(rw, border, 0, -border), pixmap, pmRect.adjusted(pw, border, 0, -border)); | |
// Corners | |
painter->drawPixmap(rect.adjusted(0, 0, -rw, -rh), pixmap, pmRect.adjusted(0, 0, -pw,-ph)); | |
painter->drawPixmap(rect.adjusted(rw, 0, 0, -rh), pixmap, pmRect.adjusted(pw, 0, 0,-ph)); | |
painter->drawPixmap(rect.adjusted(0, rh, -rw, 0), pixmap, pmRect.adjusted(0, ph, -pw,0)); | |
painter->drawPixmap(rect.adjusted(rw, rh, 0, 0), pixmap, pmRect.adjusted(pw, ph, 0,0)); | |
} | |
break; | |
case PE_PanelTipLabel: { | |
GtkWidget *gtkWindow = d->gtkWidget("GtkWindow"); // The Murrine Engine currently assumes a widget is passed | |
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: { | |
if (widget && widget->testAttribute(Qt::WA_SetPalette) && | |
option->palette.resolve() & (1 << QPalette::Window)) { | |
// Respect custom palette | |
painter->fillRect(option->rect, option->palette.window()); | |
break; | |
} | |
GtkShadowType shadow_type; | |
GtkWidget *gtkStatusbarFrame = d->gtkWidget("GtkStatusbar.GtkFrame"); | |
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 = d->gtkWidget("GtkTreeView.GtkButton"); | |
GtkStateType state = gtkPainter.gtkState(option); | |
style = gtkTreeHeader->style; | |
GtkArrowType type = GTK_ARROW_UP; | |
QRect r = header->rect; | |
QImage arrow; | |
// This sorting indicator inversion is intentional, and follows the GNOME HIG. | |
// See http://library.gnome.org/devel/hig-book/stable/controls-lists.html.en#controls-lists-sortable | |
if (header->sortIndicator & QStyleOptionHeader::SortUp) | |
type = GTK_ARROW_UP; | |
else if (header->sortIndicator & QStyleOptionHeader::SortDown) | |
type = GTK_ARROW_DOWN; | |
gtkPainter.paintArrow(gtkTreeHeader, "button", option->rect.adjusted(1, 1, -1, -1), type, state, | |
GTK_SHADOW_NONE, FALSE, style); | |
} | |
break; | |
case PE_FrameFocusRect: | |
if (!widget || qobject_cast<const QAbstractItemView*>(widget)) | |
QCleanlooksStyle::drawPrimitive(element, option, painter, widget); | |
else { | |
// ### this mess should move to subcontrolrect | |
QRect frameRect = option->rect.adjusted(1, 1, -1, -2); | |
if (qobject_cast<const QTabBar*>(widget)) { | |
GtkWidget *gtkNotebook = d->gtkWidget("GtkNotebook"); | |
style = gtkPainter.getStyle(gtkNotebook); | |
gtkPainter.paintFocus(gtkNotebook, "tab", frameRect.adjusted(-1, 1, 1, 1), GTK_STATE_ACTIVE, style); | |
} else { | |
gtkPainter.paintFocus(NULL, "tab", frameRect, GTK_STATE_ACTIVE, style); | |
} | |
} | |
break; | |
case PE_IndicatorBranch: | |
if (option->state & State_Children) { | |
QRect rect = option->rect; | |
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 = d->gtkWidget("GtkTreeView"); | |
GtkStateType state = GTK_STATE_NORMAL; | |
if (!(option->state & State_Enabled)) | |
state = GTK_STATE_INSENSITIVE; | |
else if (option->state & State_MouseOver) | |
state = GTK_STATE_PRELIGHT; | |
gtkPainter.paintExpander(gtkTreeView, "treeview", rect, state, | |
option->state & State_Open ? openState : closedState , gtkTreeView->style); | |
} | |
break; | |
case PE_PanelItemViewRow: | |
// This primitive is only used to draw selection behind selected expander arrows. | |
// We try not to decorate the tree branch background unless you inherit from StyledItemDelegate | |
// The reason for this is that a lot of code that relies on custom item delegates will look odd having | |
// a gradient on the branch but a flat shaded color on the item itself. | |
QCommonStyle::drawPrimitive(element, option, painter, widget); | |
if (!option->state & State_Selected) { | |
break; | |
} else { | |
if (const QAbstractItemView *view = qobject_cast<const QAbstractItemView*>(widget)) { | |
if (!qobject_cast<QStyledItemDelegate*>(view->itemDelegate())) | |
break; | |
} | |
} // fall through | |
case PE_PanelItemViewItem: | |
if (const QStyleOptionViewItemV4 *vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) { | |
uint resolve_mask = vopt->palette.resolve(); | |
if (vopt->backgroundBrush.style() != Qt::NoBrush | |
|| (resolve_mask & (1 << QPalette::Base))) | |
{ | |
QPointF oldBO = painter->brushOrigin(); | |
painter->setBrushOrigin(vopt->rect.topLeft()); | |
painter->fillRect(vopt->rect, vopt->backgroundBrush); | |
painter->setBrushOrigin(oldBO); | |
if (!(option->state & State_Selected)) | |
break; | |
} | |
if (GtkWidget *gtkTreeView = d->gtkWidget("GtkTreeView")) { | |
const char *detail = "cell_even_ruled"; | |
if (vopt && vopt->features & QStyleOptionViewItemV2::Alternate) | |
detail = "cell_odd_ruled"; | |
bool isActive = option->state & State_Active; | |
QString key; | |
if (isActive ) { | |
// Required for active/non-active window appearance | |
key = QLS("a"); | |
GTK_WIDGET_SET_FLAGS(gtkTreeView, GTK_HAS_FOCUS); | |
} | |
bool isEnabled = (widget ? widget->isEnabled() : (vopt->state & QStyle::State_Enabled)); | |
gtkPainter.paintFlatBox(gtkTreeView, detail, option->rect, | |
option->state & State_Selected ? GTK_STATE_SELECTED : | |
isEnabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE, | |
GTK_SHADOW_OUT, gtkTreeView->style, key); | |
if (isActive ) | |
GTK_WIDGET_UNSET_FLAGS(gtkTreeView, GTK_HAS_FOCUS); | |
} | |
} | |
break; | |
case PE_IndicatorToolBarSeparator: | |
{ | |
const int margin = 6; | |
GtkWidget *gtkSeparator = d->gtkWidget("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", | |
rect, GTK_STATE_NORMAL, gtkSeparator->style, | |
0, rect.height(), 0); | |
} else { //Draw vertical separator | |
const int offset = option->rect.height()/2; | |
QRect rect = option->rect.adjusted(margin, offset, -margin, 0); | |
painter->setPen(QPen(option->palette.background().color().darker(110))); | |
gtkPainter.paintHline( gtkSeparator, "hseparator", | |
rect, GTK_STATE_NORMAL, gtkSeparator->style, | |
0, rect.width(), 0); | |
} | |
} | |
break; | |
case PE_IndicatorToolBarHandle: { | |
GtkWidget *gtkToolbar = d->gtkWidget("GtkToolbar"); | |
GtkShadowType shadow_type; | |
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); | |
} | |
break; | |
case PE_IndicatorArrowUp: | |
case PE_IndicatorArrowDown: | |
case PE_IndicatorArrowLeft: | |
case PE_IndicatorArrowRight: { | |
GtkArrowType type = GTK_ARROW_UP; | |
switch (element) { | |
case PE_IndicatorArrowDown: | |
type = GTK_ARROW_DOWN; | |
break; | |
case PE_IndicatorArrowLeft: | |
type = GTK_ARROW_LEFT; | |
break; | |
case PE_IndicatorArrowRight: | |
type = GTK_ARROW_RIGHT; | |
break; | |
default: | |
break; | |
} | |
int size = qMin(option->rect.height(), option->rect.width()); | |
int border = (size > 9) ? (size/4) : 0; //Allow small arrows to have exact dimensions | |
int bsx = 0, bsy = 0; | |
if (option->state & State_Sunken) { | |
bsx = proxy()->pixelMetric(PM_ButtonShiftHorizontal); | |
bsy = proxy()->pixelMetric(PM_ButtonShiftVertical); | |
} | |
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 = d->gtkWidget("GtkArrow"); | |
GdkColor color = fromQColor(arrowColor); | |
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 | |
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 = d->gtkWidget("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; | |
case PE_FrameMenu: | |
//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 = d->gtkWidget("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 = d->gtkWidget("GtkEntry"); | |
gboolean interior_focus; | |
gint focus_line_width; | |
QRect rect = option->rect; | |
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)); | |
if (!interior_focus && option->state & State_HasFocus) | |
rect.adjust(focus_line_width, focus_line_width, -focus_line_width, -focus_line_width); | |
if (option->state & State_HasFocus) | |
GTK_WIDGET_SET_FLAGS(gtkEntry, GTK_HAS_FOCUS); | |
gtkPainter.paintShadow(gtkEntry, "entry", rect, option->state & State_Enabled ? | |
GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE, | |
GTK_SHADOW_IN, gtkEntry->style, | |
option->state & State_HasFocus ? QLS("focus") : QString()); | |
if (!interior_focus && option->state & State_HasFocus) | |
gtkPainter.paintShadow(gtkEntry, "entry", option->rect, option->state & State_Enabled ? | |
GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE, | |
GTK_SHADOW_IN, gtkEntry->style, QLS("GtkEntryShadowIn")); | |
if (option->state & State_HasFocus) | |
GTK_WIDGET_UNSET_FLAGS(gtkEntry, GTK_HAS_FOCUS); | |
} | |
break; | |
case PE_PanelLineEdit: | |
if (const QStyleOptionFrame *panel = qstyleoption_cast<const QStyleOptionFrame *>(option)) { | |
GtkWidget *gtkEntry = d->gtkWidget("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); | |
if (widget && widget->testAttribute(Qt::WA_SetPalette) && | |
resolve_mask & (1 << QPalette::Base)) // Palette overridden by user | |
painter->fillRect(textRect, option->palette.base()); | |
else | |
gtkPainter.paintFlatBox( gtkEntry, "entry_bg", textRect, | |
option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE, GTK_SHADOW_NONE, gtkEntry->style); | |
} | |
break; | |
case PE_FrameTabWidget: | |
if (const QStyleOptionTabWidgetFrame *frame = qstyleoption_cast<const QStyleOptionTabWidgetFrame*>(option)) { | |
GtkWidget *gtkNotebook = d->gtkWidget("GtkNotebook"); | |
style = gtkPainter.getStyle(gtkNotebook); | |
gtkPainter.setAlphaSupport(false); | |
GtkShadowType shadow = GTK_SHADOW_OUT; | |
GtkStateType state = GTK_STATE_NORMAL; // Only state supported by gtknotebook | |
bool reverse = (option->direction == Qt::RightToLeft); | |
QGtkStylePrivate::gtk_widget_set_direction(gtkNotebook, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR); | |
if (const QStyleOptionTabWidgetFrameV2 *tabframe = qstyleoption_cast<const QStyleOptionTabWidgetFrameV2*>(option)) { | |
GtkPositionType frameType = GTK_POS_TOP; | |
QTabBar::Shape shape = frame->shape; | |
int gapStart = 0; | |
int gapSize = 0; | |
if (shape == QTabBar::RoundedNorth || shape == QTabBar::RoundedSouth) { | |
frameType = (shape == QTabBar::RoundedNorth) ? GTK_POS_TOP : GTK_POS_BOTTOM; | |
gapStart = tabframe->selectedTabRect.left(); | |
gapSize = tabframe->selectedTabRect.width(); | |
} else { | |
frameType = (shape == QTabBar::RoundedWest) ? GTK_POS_LEFT : GTK_POS_RIGHT; | |
gapStart = tabframe->selectedTabRect.y(); | |
gapSize = tabframe->selectedTabRect.height(); | |
} | |
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_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 = isTool ? d->gtkWidget("GtkToolButton.GtkButton") : d->gtkWidget("GtkButton"); | |
gint focusWidth, focusPad; | |
gboolean interiorFocus = false; | |
d->gtk_widget_style_get (gtkButton, | |
"focus-line-width", &focusWidth, | |
"focus-padding", &focusPad, | |
"interior-focus", &interiorFocus, NULL); | |
style = gtkButton->style; | |
QRect buttonRect = option->rect; | |
QString key; | |
if (isDefault) { | |
key += QLS("def"); | |
GTK_WIDGET_SET_FLAGS(gtkButton, GTK_HAS_DEFAULT); | |
gtkPainter.paintBox(gtkButton, "buttondefault", buttonRect, state, GTK_SHADOW_IN, | |
style, isDefault ? QLS("d") : QString()); | |
} | |
bool hasFocus = option->state & State_HasFocus; | |
if (hasFocus) { | |
key += QLS("def"); | |
GTK_WIDGET_SET_FLAGS(gtkButton, GTK_HAS_FOCUS); | |
} | |
if (!interiorFocus) | |
buttonRect = buttonRect.adjusted(focusWidth, focusWidth, -focusWidth, -focusWidth); | |
GtkShadowType shadow = (option->state & State_Sunken || option->state & State_On ) ? | |
GTK_SHADOW_IN : GTK_SHADOW_OUT; | |
gtkPainter.paintBox(gtkButton, "button", buttonRect, state, shadow, | |
style, key); | |
if (isDefault) | |
GTK_WIDGET_UNSET_FLAGS(gtkButton, GTK_HAS_DEFAULT); | |
if (hasFocus) | |
GTK_WIDGET_UNSET_FLAGS(gtkButton, GTK_HAS_FOCUS); | |
} | |
break; | |
case PE_IndicatorRadioButton: { | |
GtkShadowType shadow = GTK_SHADOW_OUT; | |
GtkStateType state = gtkPainter.gtkState(option); | |
if (option->state & State_Sunken) | |
state = GTK_STATE_ACTIVE; | |
if (option->state & State_NoChange) | |
shadow = GTK_SHADOW_ETCHED_IN; | |
else if (option->state & State_On) | |
shadow = GTK_SHADOW_IN; | |
else | |
shadow = GTK_SHADOW_OUT; | |
GtkWidget *gtkRadioButton = d->gtkWidget("GtkRadioButton"); | |
gint spacing; | |
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 = d->gtkWidget("GtkCheckButton"); | |
QString key(QLS("radiobutton")); | |
if (option->state & State_HasFocus) { // Themes such as Nodoka check this flag | |
key += QLatin1Char('f'); | |
GTK_WIDGET_SET_FLAGS(gtkCheckButton, GTK_HAS_FOCUS); | |
} | |
gtkPainter.paintOption(gtkCheckButton , buttonRect, state, shadow, gtkRadioButton->style, key); | |
if (option->state & State_HasFocus) | |
GTK_WIDGET_UNSET_FLAGS(gtkCheckButton, GTK_HAS_FOCUS); | |
} | |
break; | |
case PE_IndicatorCheckBox: { | |
GtkShadowType shadow = GTK_SHADOW_OUT; | |
GtkStateType state = gtkPainter.gtkState(option); | |
if (option->state & State_Sunken) | |
state = GTK_STATE_ACTIVE; | |
if (option->state & State_NoChange) | |
shadow = GTK_SHADOW_ETCHED_IN; | |
else if (option->state & State_On) | |
shadow = GTK_SHADOW_IN; | |
else | |
shadow = GTK_SHADOW_OUT; | |
int spacing; | |
GtkWidget *gtkCheckButton = d->gtkWidget("GtkCheckButton"); | |
QString key(QLS("checkbutton")); | |
if (option->state & State_HasFocus) { // Themes such as Nodoka checks this flag | |
key += QLatin1Char('f'); | |
GTK_WIDGET_SET_FLAGS(gtkCheckButton, GTK_HAS_FOCUS); | |
} | |
// Some styles such as aero-clone assume they can paint in the spacing area | |
gtkPainter.setClipRect(option->rect); | |
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, | |
key); | |
if (option->state & State_HasFocus) | |
GTK_WIDGET_UNSET_FLAGS(gtkCheckButton, GTK_HAS_FOCUS); | |
} | |
break; | |
#ifndef QT_NO_TABBAR | |
case PE_FrameTabBarBase: | |
if (const QStyleOptionTabBarBase *tbb | |
= qstyleoption_cast<const QStyleOptionTabBarBase *>(option)) { | |
QRect tabRect = tbb->rect; | |
painter->save(); | |
painter->setPen(QPen(option->palette.dark().color().dark(110), 0)); | |
switch (tbb->shape) { | |
case QTabBar::RoundedNorth: | |
painter->drawLine(tabRect.topLeft(), tabRect.topRight()); | |
break; | |
case QTabBar::RoundedWest: | |
painter->drawLine(tabRect.left(), tabRect.top(), tabRect.left(), tabRect.bottom()); | |
break; | |
case QTabBar::RoundedSouth: | |
painter->drawLine(tbb->rect.left(), tbb->rect.bottom(), | |
tabRect.right(), tabRect.bottom()); | |
break; | |
case QTabBar::RoundedEast: | |
painter->drawLine(tabRect.topRight(), tabRect.bottomRight()); | |
break; | |
case QTabBar::TriangularNorth: | |
case QTabBar::TriangularEast: | |
case QTabBar::TriangularWest: | |
case QTabBar::TriangularSouth: | |
painter->restore(); | |
QWindowsStyle::drawPrimitive(element, option, painter, widget); | |
return; | |
} | |
painter->restore(); | |
} | |
return; | |
#endif // QT_NO_TABBAR | |
case PE_Widget: | |
break; | |
default: | |
QCleanlooksStyle::drawPrimitive(element, option, painter, widget); | |
} | |
} | |
/*! | |
\reimp | |
*/ | |
void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionComplex *option, | |
QPainter *painter, const QWidget *widget) const | |
{ | |
Q_D(const QGtkStyle); | |
if (!d->isThemeAvailable()) { | |
QCleanlooksStyle::drawComplexControl(control, option, painter, widget); | |
return; | |
} | |
GtkStyle* style = d->gtkStyle(); | |
QGtkPainter gtkPainter(painter); | |
QColor button = option->palette.button().color(); | |
QColor dark; | |
QColor grooveColor; | |
QColor darkOutline; | |
dark.setHsv(button.hue(), | |
qMin(255, (int)(button.saturation()*1.9)), | |
qMin(255, (int)(button.value()*0.7))); | |
grooveColor.setHsv(button.hue(), | |
qMin(255, (int)(button.saturation()*2.6)), | |
qMin(255, (int)(button.value()*0.9))); | |
darkOutline.setHsv(button.hue(), | |
qMin(255, (int)(button.saturation()*3.0)), | |
qMin(255, (int)(button.value()*0.6))); | |
QColor alphaCornerColor; | |
if (widget) | |
alphaCornerColor = mergedColors(option->palette.color(widget->backgroundRole()), darkOutline); | |
else | |
alphaCornerColor = mergedColors(option->palette.background().color(), darkOutline); | |
switch (control) { | |
case CC_TitleBar: | |
if (const QStyleOptionTitleBar *tb = qstyleoption_cast<const QStyleOptionTitleBar *>(option)) { | |
// Since this is drawn by metacity and not Gtk we | |
// have to rely on Cleanlooks for a fallback | |
QStyleOptionTitleBar copyOpt = *tb; | |
QPalette pal = copyOpt.palette; | |
// Bg color is closer to the window selection than | |
// the base selection color | |
GdkColor gdkBg = style->bg[GTK_STATE_SELECTED]; | |
QColor bgColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8); | |
pal.setBrush(QPalette::Active, QPalette::Highlight, bgColor); | |
copyOpt.palette = pal; | |
QCleanlooksStyle::drawComplexControl(control, ©Opt, painter, widget); | |
} | |
break; | |
#ifndef QT_NO_GROUPBOX | |
case CC_GroupBox: | |
painter->save(); | |
if (const QStyleOptionGroupBox *groupBox = qstyleoption_cast<const QStyleOptionGroupBox *>(option)) { | |
QRect textRect = proxy()->subControlRect(CC_GroupBox, groupBox, SC_GroupBoxLabel, widget); | |
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 = d->gtkWidget("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); | |
} | |
if (!groupBox->text.isEmpty()) { | |
int alignment = int(groupBox->textAlignment); | |
if (!proxy()->styleHint(QStyle::SH_UnderlineShortcut, option, widget)) | |
alignment |= Qt::TextHideMnemonic; | |
QColor textColor = groupBox->textColor; // Note: custom textColor is currently ignored | |
int labelState = GTK_STATE_INSENSITIVE; | |
if (option->state & State_Enabled) | |
labelState = (option->state & State_MouseOver) ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL; | |
GdkColor gdkText = gtkCheckButton->style->fg[labelState]; | |
textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8); | |
painter->setPen(textColor); | |
QFont font = painter->font(); | |
font.setBold(true); | |
painter->setFont(font); | |
painter->drawText(textRect, Qt::TextShowMnemonic | Qt::AlignLeft| alignment, groupBox->text); | |
if (option->state & State_HasFocus) | |
gtkPainter.paintFocus( NULL, "tab", textRect.adjusted(-4, -1, 0, -3), GTK_STATE_ACTIVE, style); | |
} | |
} | |
if (groupBox->subControls & SC_GroupBoxCheckBox) { | |
QStyleOptionButton box; | |
box.QStyleOption::operator=(*groupBox); | |
box.rect = checkBoxRect; | |
proxy()->drawPrimitive(PE_IndicatorCheckBox, &box, painter, widget); | |
} | |
} | |
painter->restore(); | |
break; | |
#endif // QT_NO_GROUPBOX | |
#ifndef QT_NO_COMBOBOX | |
case CC_ComboBox: | |
// See: http://live.gnome.org/GnomeArt/Tutorials/GtkThemes/GtkComboBox | |
// and http://live.gnome.org/GnomeArt/Tutorials/GtkThemes/GtkComboBoxEntry | |
if (const QStyleOptionComboBox *comboBox = qstyleoption_cast<const QStyleOptionComboBox *>(option)) { | |
bool sunken = comboBox->state & State_On; // play dead, if combobox has no items | |
BEGIN_STYLE_PIXMAPCACHE(QString::fromLatin1("cb-%0-%1").arg(sunken).arg(comboBox->editable)); | |
QGtkPainter gtkCachedPainter(p); | |
gtkCachedPainter.setUsePixmapCache(false); // cached externally | |
bool isEnabled = (comboBox->state & State_Enabled); | |
bool focus = isEnabled && (comboBox->state & State_HasFocus); | |
GtkStateType state = gtkPainter.gtkState(option); | |
int appears_as_list = !proxy()->styleHint(QStyle::SH_ComboBox_Popup, comboBox, widget); | |
QStyleOptionComboBox comboBoxCopy = *comboBox; | |
comboBoxCopy.rect = option->rect; | |
bool reverse = (option->direction == Qt::RightToLeft); | |
QRect rect = option->rect; | |
QRect arrowButtonRect = proxy()->subControlRect(CC_ComboBox, &comboBoxCopy, | |
SC_ComboBoxArrow, widget); | |
GtkShadowType shadow = (option->state & State_Sunken || option->state & State_On ) ? | |
GTK_SHADOW_IN : GTK_SHADOW_OUT; | |
const QHashableLatin1Literal comboBoxPath = comboBox->editable ? QHashableLatin1Literal("GtkComboBoxEntry") : QHashableLatin1Literal("GtkComboBox"); | |
// We use the gtk widget to position arrows and separators for us | |
GtkWidget *gtkCombo = d->gtkWidget(comboBoxPath); | |
GtkAllocation geometry = {0, 0, option->rect.width(), option->rect.height()}; | |
d->gtk_widget_set_direction(gtkCombo, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR); | |
d->gtk_widget_size_allocate(gtkCombo, &geometry); | |
QHashableLatin1Literal buttonPath = comboBox->editable ? QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton") | |
: QHashableLatin1Literal("GtkComboBox.GtkToggleButton"); | |
GtkWidget *gtkToggleButton = d->gtkWidget(buttonPath); | |
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; | |
QHashableLatin1Literal entryPath = comboBox->editable ? QHashableLatin1Literal("GtkComboBoxEntry.GtkEntry") : QHashableLatin1Literal("GtkComboBox.GtkFrame"); | |
GtkWidget *gtkEntry = d->gtkWidget(entryPath); | |
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 | |
frameRect.setRight(arrowButtonRect.left()); | |
// Fill the line edit background | |
// We could have used flat_box with "entry_bg" but that is probably not worth the overhead | |
uint resolve_mask = option->palette.resolve(); | |
int xt = gtkEntry->style->xthickness; | |
int yt = gtkEntry->style->ythickness; | |
QRect contentRect = frameRect.adjusted(xt, yt, -xt, -yt); | |
// Required for inner blue highlight with clearlooks | |
if (focus) | |
GTK_WIDGET_SET_FLAGS(gtkEntry, GTK_HAS_FOCUS); | |
if (widget && widget->testAttribute(Qt::WA_SetPalette) && | |
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, gtkEntry->style, entryPath.toString() + QString::number(focus)); | |
} | |
gtkCachedPainter.paintShadow(gtkEntry, comboBox->editable ? "entry" : "frame", frameRect, frameState, | |
GTK_SHADOW_IN, gtkEntry->style, entryPath.toString() + | |
QString::number(focus) + QString::number(comboBox->editable) + | |
QString::number(option->direction)); | |
if (focus) | |
GTK_WIDGET_UNSET_FLAGS(gtkEntry, GTK_HAS_FOCUS); | |
} | |
GtkStateType buttonState = GTK_STATE_NORMAL; | |
if (!(option->state & State_Enabled)) | |
buttonState = GTK_STATE_INSENSITIVE; | |
else if (option->state & State_Sunken || option->state & State_On) | |
buttonState = GTK_STATE_ACTIVE; | |
else if (option->state & State_MouseOver && comboBox->activeSubControls & SC_ComboBoxArrow) | |
buttonState = GTK_STATE_PRELIGHT; | |
Q_ASSERT(gtkToggleButton); | |
gtkCachedPainter.paintBox( gtkToggleButton, "button", arrowButtonRect, buttonState, | |
shadow, gtkToggleButton->style, buttonPath.toString() + | |
QString::number(focus) + QString::number(option->direction)); | |
if (focus) | |
GTK_WIDGET_UNSET_FLAGS(gtkToggleButton, GTK_HAS_FOCUS); | |
} else { | |
// Draw combo box as a button | |
QRect buttonRect = option->rect; | |
if (focus) // Clearlooks actually check the widget for the default state | |
GTK_WIDGET_SET_FLAGS(gtkToggleButton, GTK_HAS_FOCUS); | |
gtkCachedPainter.paintBox(gtkToggleButton, "button", | |
buttonRect, state, | |
shadow, gtkToggleButton->style, | |
buttonPath.toString() + QString::number(focus)); | |
if (focus) | |
GTK_WIDGET_UNSET_FLAGS(gtkToggleButton, GTK_HAS_FOCUS); | |
// Draw the separator between label and arrows | |
QHashableLatin1Literal vSeparatorPath = comboBox->editable | |
? QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton.GtkHBox.GtkVSeparator") | |
: QHashableLatin1Literal("GtkComboBox.GtkToggleButton.GtkHBox.GtkVSeparator"); | |
if (GtkWidget *gtkVSeparator = d->gtkWidget(vSeparatorPath)) { | |
QRect vLineRect(gtkVSeparator->allocation.x, | |
gtkVSeparator->allocation.y, | |
gtkVSeparator->allocation.width, | |
gtkVSeparator->allocation.height); | |
gtkCachedPainter.paintVline( gtkVSeparator, "vseparator", | |
vLineRect, state, gtkVSeparator->style, | |
0, vLineRect.height(), 0, vSeparatorPath.toString()); | |
gint interiorFocus = true; | |
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), | |
option->state & State_Sunken ? GTK_STATE_ACTIVE : GTK_STATE_NORMAL, | |
gtkToggleButton->style); | |
} | |
} | |
if (comboBox->subControls & SC_ComboBoxArrow) { | |
if (!isEnabled) | |
state = GTK_STATE_INSENSITIVE; | |
else if (sunken) | |
state = GTK_STATE_ACTIVE; | |
else if (option->state & State_MouseOver) | |
state = GTK_STATE_PRELIGHT; | |
else | |
state = GTK_STATE_NORMAL; | |
QHashableLatin1Literal arrowPath(""); | |
if (comboBox->editable) { | |
if (appears_as_list) | |
arrowPath = QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton.GtkArrow"); | |
else | |
arrowPath = QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton.GtkHBox.GtkArrow"); | |
} else { | |
if (appears_as_list) | |
arrowPath = QHashableLatin1Literal("GtkComboBox.GtkToggleButton.GtkArrow"); | |
else | |
arrowPath = QHashableLatin1Literal("GtkComboBox.GtkToggleButton.GtkHBox.GtkArrow"); | |
} | |
GtkWidget *gtkArrow = d->gtkWidget(arrowPath); | |
gfloat scale = 0.7; | |
gint minSize = 15; | |
QRect arrowWidgetRect; | |
if (gtkArrow && !d->gtk_check_version(2, 12, 0)) { | |
d->gtk_widget_style_get(gtkArrow, "arrow-scaling", &scale, 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; | |
} | |
// Note that for some reason the arrow-size is not properly respected with Hildon | |
// Hence we enforce the minimum "arrow-size" ourselves | |
int arrowSize = qMax(qMin(rect.height() - gtkCombo->style->ythickness * 2, minSize), | |
qMin(arrowWidgetRect.width(), arrowWidgetRect.height())); | |
QRect arrowRect(0, 0, static_cast<int>(arrowSize * scale), static_cast<int>(arrowSize * scale)); | |
arrowRect.moveCenter(arrowWidgetRect.center()); | |
if (sunken) { | |
int xoff, yoff; | |
const QHashableLatin1Literal toggleButtonPath = comboBox->editable | |
? QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton") | |
: QHashableLatin1Literal("GtkComboBox.GtkToggleButton"); | |
GtkWidget *gtkButton = d->gtkWidget(toggleButtonPath); | |
d->gtk_widget_style_get(gtkButton, "child-displacement-x", &xoff, 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 | |
if (gtkArrow) { | |
gtkCachedPainter.setClipRect(option->rect); | |
gtkCachedPainter.paintArrow( gtkArrow, "arrow", arrowRect, | |
GTK_ARROW_DOWN, state, GTK_SHADOW_NONE, TRUE, | |
style, arrowPath.toString() + QString::number(option->direction)); | |
} | |
} | |
END_STYLE_PIXMAPCACHE; | |
} | |
break; | |
#endif // QT_NO_COMBOBOX | |
#ifndef QT_NO_TOOLBUTTON | |
case CC_ToolButton: | |
if (const QStyleOptionToolButton *toolbutton | |
= qstyleoption_cast<const QStyleOptionToolButton *>(option)) { | |
QRect button, menuarea; | |
button = proxy()->subControlRect(control, toolbutton, SC_ToolButton, widget); | |
menuarea = proxy()->subControlRect(control, toolbutton, SC_ToolButtonMenu, widget); | |
State bflags = toolbutton->state & ~(State_Sunken | State_MouseOver); | |
if (bflags & State_AutoRaise) | |
if (!(bflags & State_MouseOver)) | |
bflags &= ~State_Raised; | |
State mflags = bflags; | |
if (toolbutton->state & State_Sunken) { | |
if (toolbutton->activeSubControls & SC_ToolButton) | |
bflags |= State_Sunken; | |
if (toolbutton->activeSubControls & SC_ToolButtonMenu) | |
mflags |= State_Sunken; | |
} else if (toolbutton->state & State_MouseOver) { | |
if (toolbutton->activeSubControls & SC_ToolButton) | |
bflags |= State_MouseOver; | |
if (toolbutton->activeSubControls & SC_ToolButtonMenu) | |
mflags |= State_MouseOver; | |
} | |
QStyleOption tool(0); | |
tool.palette = toolbutton->palette; | |
if (toolbutton->subControls & SC_ToolButton) { | |
if (bflags & (State_Sunken | State_On | State_Raised | State_MouseOver)) { | |
tool.rect = button; | |
tool.state = bflags; | |
proxy()->drawPrimitive(PE_PanelButtonTool, &tool, painter, widget); | |
} | |
} | |
bool drawMenuArrow = toolbutton->features & QStyleOptionToolButton::HasMenu && | |
!(toolbutton->features & QStyleOptionToolButton::MenuButtonPopup); | |
int popupArrowSize = drawMenuArrow ? 7 : 0; | |
if (toolbutton->state & State_HasFocus) { | |
QStyleOptionFocusRect fr; | |
fr.QStyleOption::operator=(*toolbutton); | |
fr.rect = proxy()->subControlRect(CC_ToolButton, toolbutton, SC_ToolButton, widget); | |
fr.rect.adjust(1, 1, -1, -1); | |
proxy()->drawPrimitive(PE_FrameFocusRect, &fr, painter, widget); | |
} | |
QStyleOptionToolButton label = *toolbutton; | |
label.state = bflags; | |
GtkWidget *gtkButton = d->gtkWidget("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); | |
pal.setBrush(QPalette::All, QPalette::ButtonText, textColor); | |
label.palette = pal; | |
} | |
label.rect = button.adjusted(style->xthickness, style->ythickness, | |
-style->xthickness - popupArrowSize, -style->ythickness); | |
proxy()->drawControl(CE_ToolButtonLabel, &label, painter, widget); | |
if (toolbutton->subControls & SC_ToolButtonMenu) { | |
tool.rect = menuarea; | |
tool.state = mflags; | |
if ((mflags & State_Enabled && (mflags & (State_Sunken | State_Raised | State_MouseOver))) || !(mflags & State_AutoRaise)) | |
proxy()->drawPrimitive(PE_IndicatorButtonDropDown, &tool, painter, widget); | |
proxy()->drawPrimitive(PE_IndicatorArrowDown, &tool, painter, widget); | |
} else if (drawMenuArrow) { | |
QRect ir = toolbutton->rect; | |
QStyleOptionToolButton newBtn = *toolbutton; | |
newBtn.rect = QRect(ir.right() - popupArrowSize - style->xthickness - 3, ir.height()/2 - 1, popupArrowSize, popupArrowSize); | |
proxy()->drawPrimitive(PE_IndicatorArrowDown, &newBtn, painter, widget); | |
} | |
} | |
break; | |
#endif // QT_NO_TOOLBUTTON | |
#ifndef QT_NO_SCROLLBAR | |
case CC_ScrollBar: | |
if (const QStyleOptionSlider *scrollBar = qstyleoption_cast<const QStyleOptionSlider *>(option)) { | |
GtkWidget *gtkHScrollBar = d->gtkWidget("GtkHScrollbar"); | |
GtkWidget *gtkVScrollBar = d->gtkWidget("GtkVScrollbar"); | |
// Fill background in case the scrollbar is partially transparent | |
painter->fillRect(option->rect, option->palette.background()); | |
QRect rect = scrollBar->rect; | |
QRect scrollBarSubLine = proxy()->subControlRect(control, scrollBar, SC_ScrollBarSubLine, widget); | |
QRect scrollBarAddLine = proxy()->subControlRect(control, scrollBar, SC_ScrollBarAddLine, widget); | |
QRect scrollBarSlider = proxy()->subControlRect(control, scrollBar, SC_ScrollBarSlider, widget); | |
QRect grooveRect = proxy()->subControlRect(control, scrollBar, SC_ScrollBarGroove, widget); | |
bool horizontal = scrollBar->orientation == Qt::Horizontal; | |
GtkWidget * scrollbarWidget = horizontal ? gtkHScrollBar : gtkVScrollBar; | |
style = scrollbarWidget->style; | |
gboolean trough_under_steppers = true; | |
gboolean trough_side_details = false; | |
gboolean activate_slider = false; | |
gboolean stepper_size = 14; | |
gint trough_border = 1; | |
if (!d->gtk_check_version(2, 10, 0)) { | |
d->gtk_widget_style_get((GtkWidget*)(scrollbarWidget), | |
"trough-border", &trough_border, | |
"trough-side-details", &trough_side_details, | |
"trough-under-steppers", &trough_under_steppers, | |
"activate-slider", &activate_slider, | |
"stepper-size", &stepper_size, NULL); | |
} | |
if (trough_under_steppers) { | |
scrollBarAddLine.adjust(trough_border, trough_border, -trough_border, -trough_border); | |
scrollBarSubLine.adjust(trough_border, trough_border, -trough_border, -trough_border); | |
scrollBarSlider.adjust(horizontal ? -trough_border : 0, horizontal ? 0 : -trough_border, | |
horizontal ? trough_border : 0, horizontal ? 0 : trough_border); | |
} | |
// Some styles check the position of scrollbars in order to determine | |
// if lines should be painted when the scrollbar is in max or min positions. | |
int maximum = 2; | |
int fakePos = 0; | |
bool reverse = (option->direction == Qt::RightToLeft); | |
if (scrollBar->minimum == scrollBar->maximum) | |
maximum = 0; | |
if (scrollBar->sliderPosition == scrollBar->maximum) | |
fakePos = maximum; | |
else if (scrollBar->sliderPosition > scrollBar->minimum) | |
fakePos = maximum - 1; | |
GtkObject *adjustment = d->gtk_adjustment_new(fakePos, 0, maximum, 0, 0, 0); | |
if (horizontal) | |
d->gtk_range_set_adjustment((GtkRange*)(gtkHScrollBar), (GtkAdjustment*)(adjustment)); | |
else | |
d->gtk_range_set_adjustment((GtkRange*)(gtkVScrollBar), (GtkAdjustment*)(adjustment)); | |
if (scrollBar->subControls & SC_ScrollBarGroove) { | |
GtkStateType state = GTK_STATE_ACTIVE; | |
if (!(option->state & State_Enabled)) | |
state = GTK_STATE_INSENSITIVE; | |
if (trough_under_steppers) | |
grooveRect = option->rect; | |
gtkPainter.paintBox( scrollbarWidget, "trough", grooveRect, state, GTK_SHADOW_IN, style); | |
} | |
//paint slider | |
if (scrollBar->subControls & SC_ScrollBarSlider) { | |
GtkStateType state = GTK_STATE_NORMAL; | |
if (!(option->state & State_Enabled)) | |
state = GTK_STATE_INSENSITIVE; | |
else if (activate_slider && | |
option->state & State_Sunken && (scrollBar->activeSubControls & SC_ScrollBarSlider)) | |
state = GTK_STATE_ACTIVE; | |
else if (option->state & State_MouseOver && (scrollBar->activeSubControls & SC_ScrollBarSlider)) | |
state = GTK_STATE_PRELIGHT; | |
GtkShadowType shadow = GTK_SHADOW_OUT; | |
if (trough_under_steppers) { | |
if (!horizontal) | |
scrollBarSlider.adjust(trough_border, 0, -trough_border, 0); | |
else | |
scrollBarSlider.adjust(0, trough_border, 0, -trough_border); | |
} | |
gtkPainter.paintSlider( scrollbarWidget, "slider", scrollBarSlider, state, shadow, style, | |
horizontal ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL, QString(QLS("%0%1")).arg(fakePos).arg(maximum)); | |
} | |
if (scrollBar->subControls & SC_ScrollBarAddLine) { | |
gtkVScrollBar->allocation.y = scrollBarAddLine.top(); | |
gtkVScrollBar->allocation.height = scrollBarAddLine.height() - rect.height() + 6; | |
gtkHScrollBar->allocation.x = scrollBarAddLine.right(); | |
gtkHScrollBar->allocation.width = scrollBarAddLine.width() - rect.width(); | |
GtkShadowType shadow = GTK_SHADOW_OUT; | |
GtkStateType state = GTK_STATE_NORMAL; | |
if (!(option->state & State_Enabled) || (fakePos == maximum)) | |
state = GTK_STATE_INSENSITIVE; | |
else if (option->state & State_Sunken && (scrollBar->activeSubControls & SC_ScrollBarAddLine)) { | |
state = GTK_STATE_ACTIVE; | |
shadow = GTK_SHADOW_IN; | |
} else if (option->state & State_MouseOver && (scrollBar->activeSubControls & SC_ScrollBarAddLine)) | |
state = GTK_STATE_PRELIGHT; | |
gtkPainter.paintBox( scrollbarWidget, | |
horizontal ? "hscrollbar" : "vscrollbar", scrollBarAddLine, | |
state, shadow, style, QLS("add")); | |
gtkPainter.paintArrow( scrollbarWidget, horizontal ? "hscrollbar" : "vscrollbar", scrollBarAddLine.adjusted(4, 4, -4, -4), | |
horizontal ? (reverse ? GTK_ARROW_LEFT : GTK_ARROW_RIGHT) : | |
GTK_ARROW_DOWN, state, GTK_SHADOW_NONE, FALSE, style); | |
} | |
if (scrollBar->subControls & SC_ScrollBarSubLine) { | |
gtkVScrollBar->allocation.y = 0; | |
gtkVScrollBar->allocation.height = scrollBarSubLine.height(); | |
gtkHScrollBar->allocation.x = 0; | |
gtkHScrollBar->allocation.width = scrollBarSubLine.width(); | |
GtkShadowType shadow = GTK_SHADOW_OUT; | |
GtkStateType state = GTK_STATE_NORMAL; | |
if (!(option->state & State_Enabled) || (fakePos == 0)) | |
state = GTK_STATE_INSENSITIVE; | |
else if (option->state & State_Sunken && (scrollBar->activeSubControls & SC_ScrollBarSubLine)) { | |
shadow = GTK_SHADOW_IN; | |
state = GTK_STATE_ACTIVE; | |
} else if (option->state & State_MouseOver && (scrollBar->activeSubControls & SC_ScrollBarSubLine)) | |
state = GTK_STATE_PRELIGHT; | |
gtkPainter.paintBox(scrollbarWidget, horizontal ? "hscrollbar" : "vscrollbar", scrollBarSubLine, | |
state, shadow, style, QLS("sub")); | |
gtkPainter.paintArrow(scrollbarWidget, horizontal ? "hscrollbar" : "vscrollbar", scrollBarSubLine.adjusted(4, 4, -4, -4), | |
horizontal ? (reverse ? GTK_ARROW_RIGHT : GTK_ARROW_LEFT) : | |
GTK_ARROW_UP, state, GTK_SHADOW_NONE, FALSE, style); | |
} | |
} | |
break; | |
#endif //QT_NO_SCROLLBAR | |
#ifndef QT_NO_SPINBOX | |
case CC_SpinBox: | |
if (const QStyleOptionSpinBox *spinBox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) { | |
GtkWidget *gtkSpinButton = spinBox->buttonSymbols == QAbstractSpinBox::NoButtons | |
? d->gtkWidget("GtkEntry") | |
: d->gtkWidget("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); | |
bool reverse = (spinBox->direction == Qt::RightToLeft); | |
QRect editArea = option->rect; | |
QRect editRect = proxy()->subControlRect(CC_SpinBox, option, SC_SpinBoxEditField, widget); | |
QRect upRect, downRect, buttonRect; | |
if (spinBox->buttonSymbols != QAbstractSpinBox::NoButtons) { | |
upRect = proxy()->subControlRect(CC_SpinBox, option, SC_SpinBoxUp, widget); | |
downRect = proxy()->subControlRect(CC_SpinBox, option, SC_SpinBoxDown, widget); | |
//### Move this to subControlRect | |
upRect.setTop(option->rect.top()); | |
if (reverse) | |
upRect.setLeft(option->rect.left()); | |
else | |
upRect.setRight(option->rect.right()); | |
downRect.setBottom(option->rect.bottom()); | |
if (reverse) | |
downRect.setLeft(option->rect.left()); | |
else | |
downRect.setRight(option->rect.right()); | |
buttonRect = upRect | downRect; | |
if (reverse) | |
editArea.setLeft(upRect.right()); | |
else | |
editArea.setRight(upRect.left()); | |
} | |
if (spinBox->frame) { | |
GtkShadowType shadow = GTK_SHADOW_OUT; | |
GtkStateType state = gtkPainter.gtkState(option); | |
if (!(option->state & State_Enabled)) | |
state = GTK_STATE_INSENSITIVE; | |
else if (option->state & State_HasFocus) | |
state = GTK_STATE_NORMAL; | |
else if (state == GTK_STATE_PRELIGHT) | |
state = GTK_STATE_NORMAL; | |
shadow = GTK_SHADOW_IN; | |
style = gtkPainter.getStyle(gtkSpinButton); | |
QString key; | |
if (option->state & State_HasFocus) { | |
key += QLatin1Char('f'); | |
GTK_WIDGET_SET_FLAGS(gtkSpinButton, GTK_HAS_FOCUS); | |
} | |
uint resolve_mask = option->palette.resolve(); | |
if (resolve_mask & (1 << QPalette::Base)) // Palette overridden by user | |
painter->fillRect(editRect, option->palette.base().color()); | |
else | |
gtkPainter.paintFlatBox(gtkSpinButton, "entry_bg", editArea.adjusted(style->xthickness, style->ythickness, | |
-style->xthickness, -style->ythickness), | |
option->state & State_Enabled ? | |
GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE, GTK_SHADOW_NONE, style, key); | |
gtkPainter.paintShadow(gtkSpinButton, "entry", editArea, state, GTK_SHADOW_IN, gtkSpinButton->style, key); | |
if (spinBox->buttonSymbols != QAbstractSpinBox::NoButtons) { | |
gtkPainter.paintBox(gtkSpinButton, "spinbutton", buttonRect, state, GTK_SHADOW_IN, style, key); | |
upRect.setSize(downRect.size()); | |
if (!(option->state & State_Enabled)) | |
gtkPainter.paintBox( gtkSpinButton, "spinbutton_up", upRect, GTK_STATE_INSENSITIVE, GTK_SHADOW_IN, style, key); | |
else if (upIsActive && sunken) | |
gtkPainter.paintBox( gtkSpinButton, "spinbutton_up", upRect, GTK_STATE_ACTIVE, GTK_SHADOW_IN, style, key); | |
else if (upIsActive && hover) | |
gtkPainter.paintBox( gtkSpinButton, "spinbutton_up", upRect, GTK_STATE_PRELIGHT, GTK_SHADOW_OUT, style, key); | |
else | |
gtkPainter.paintBox( gtkSpinButton, "spinbutton_up", upRect, GTK_STATE_NORMAL, GTK_SHADOW_OUT, style, key); | |
if (!(option->state & State_Enabled)) | |
gtkPainter.paintBox( gtkSpinButton, "spinbutton_down", downRect, GTK_STATE_INSENSITIVE, GTK_SHADOW_IN, style, key); | |
else if (downIsActive && sunken) | |
gtkPainter.paintBox( gtkSpinButton, "spinbutton_down", downRect, GTK_STATE_ACTIVE, GTK_SHADOW_IN, style, key); | |
else if (downIsActive && hover) | |
gtkPainter.paintBox( gtkSpinButton, "spinbutton_down", downRect, GTK_STATE_PRELIGHT, GTK_SHADOW_OUT, style, key); | |
else | |
gtkPainter.paintBox( gtkSpinButton, "spinbutton_down", downRect, GTK_STATE_NORMAL, GTK_SHADOW_OUT, style, key); | |
if (option->state & State_HasFocus) | |
GTK_WIDGET_UNSET_FLAGS(gtkSpinButton, GTK_HAS_FOCUS); | |
} | |
} | |
if (spinBox->buttonSymbols == QAbstractSpinBox::PlusMinus) { | |
int centerX = upRect.center().x(); | |
int centerY = upRect.center().y(); | |
// plus/minus | |
if (spinBox->activeSubControls == SC_SpinBoxUp && sunken) { | |
painter->drawLine(1 + centerX - 2, 1 + centerY, 1 + centerX + 2, 1 + centerY); | |
painter->drawLine(1 + centerX, 1 + centerY - 2, 1 + centerX, 1 + centerY + 2); | |
} else { | |
painter->drawLine(centerX - 2, centerY, centerX + 2, centerY); | |
painter->drawLine(centerX, centerY - 2, centerX, centerY + 2); | |
} | |
centerX = downRect.center().x(); | |
centerY = downRect.center().y(); | |
if (spinBox->activeSubControls == SC_SpinBoxDown && sunken) { | |
painter->drawLine(1 + centerX - 2, 1 + centerY, 1 + centerX + 2, 1 + centerY); | |
} else { | |
painter->drawLine(centerX - 2, centerY, centerX + 2, centerY); | |
} | |
} else if (spinBox->buttonSymbols == QAbstractSpinBox::UpDownArrows) { | |
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()); | |
// arrows | |
GtkStateType state = GTK_STATE_NORMAL; | |
if (!(option->state & State_Enabled) || !(spinBox->stepEnabled & QAbstractSpinBox::StepUpEnabled)) | |
state = GTK_STATE_INSENSITIVE; | |
gtkPainter.paintArrow( gtkSpinButton, "spinbutton", arrowRect, GTK_ARROW_UP, state, | |
GTK_SHADOW_NONE, FALSE, style); | |
arrowRect.moveCenter(downRect.center()); | |
if (!(option->state & State_Enabled) || !(spinBox->stepEnabled & QAbstractSpinBox::StepDownEnabled)) | |
state = GTK_STATE_INSENSITIVE; | |
gtkPainter.paintArrow( gtkSpinButton, "spinbutton", arrowRect, GTK_ARROW_DOWN, state, | |
GTK_SHADOW_NONE, FALSE, style); | |
} | |
} | |
break; | |
#endif // QT_NO_SPINBOX | |
#ifndef QT_NO_SLIDER | |
case CC_Slider: | |
if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) { | |
GtkWidget *hScaleWidget = d->gtkWidget("GtkHScale"); | |
GtkWidget *vScaleWidget = d->gtkWidget("GtkVScale"); | |
QRect groove = proxy()->subControlRect(CC_Slider, option, SC_SliderGroove, widget); | |
QRect handle = proxy()->subControlRect(CC_Slider, option, SC_SliderHandle, widget); | |
bool horizontal = slider->orientation == Qt::Horizontal; | |
bool ticksAbove = slider->tickPosition & QSlider::TicksAbove; | |
bool ticksBelow = slider->tickPosition & QSlider::TicksBelow; | |
QBrush oldBrush = painter->brush(); | |
QPen oldPen = painter->pen(); | |
QColor shadowAlpha(Qt::black); | |
shadowAlpha.setAlpha(10); | |
QColor highlightAlpha(Qt::white); | |
highlightAlpha.setAlpha(80); | |
QGtkStylePrivate::gtk_widget_set_direction(hScaleWidget, slider->upsideDown ? | |
GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR); | |
GtkWidget *scaleWidget = horizontal ? hScaleWidget : vScaleWidget; | |
style = scaleWidget->style; | |
if ((option->subControls & SC_SliderGroove) && groove.isValid()) { | |
GtkObject *adjustment = d->gtk_adjustment_new(slider->sliderPosition, | |
slider->minimum, | |
slider->maximum, | |
slider->singleStep, | |
slider->singleStep, | |
slider->pageStep); | |
int outerSize; | |
d->gtk_range_set_adjustment ((GtkRange*)(scaleWidget), (GtkAdjustment*)(adjustment)); | |
d->gtk_range_set_inverted((GtkRange*)(scaleWidget), !horizontal); | |
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); | |
gboolean trough_side_details = false; // Indicates if the upper or lower scale background differs | |
if (!d->gtk_check_version(2, 10, 0)) | |
d->gtk_widget_style_get((GtkWidget*)(scaleWidget), "trough-side-details", &trough_side_details, NULL); | |
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; | |
if (horizontal) { | |
if (slider->upsideDown) { | |
lowerGroove.setLeft(handle.center().x()); | |
upperGroove.setRight(handle.center().x()); | |
} else { | |
upperGroove.setLeft(handle.center().x()); | |
lowerGroove.setRight(handle.center().x()); | |
} | |
} else { | |
if (!slider->upsideDown) { | |
lowerGroove.setBottom(handle.center().y()); | |
upperGroove.setTop(handle.center().y()); | |
} 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); | |
int available = proxy()->pixelMetric(PM_SliderSpaceAvailable, slider, widget); | |
int interval = slider->tickInterval; | |
if (interval <= 0) { | |
interval = slider->singleStep; | |
if (QStyle::sliderPositionFromValue(slider->minimum, slider->maximum, interval, | |
available) | |
- QStyle::sliderPositionFromValue(slider->minimum, slider->maximum, | |
0, available) < 3) | |
interval = slider->pageStep; | |
} | |
if (interval <= 0) | |
interval = 1; | |
int v = slider->minimum; | |
int len = proxy()->pixelMetric(PM_SliderLength, slider, widget); | |
while (v <= slider->maximum + 1) { | |
if (v == slider->maximum + 1 && interval == 1) | |
break; | |
const int v_ = qMin(v, slider->maximum); | |
int pos = sliderPositionFromValue(slider->minimum, slider->maximum, | |
v_, (horizontal | |
? slider->rect.width() | |
: slider->rect.height()) - len, | |
slider->upsideDown) + len / 2; | |
int extra = 2 - ((v_ == slider->minimum || v_ == slider->maximum) ? 1 : 0); | |
if (horizontal) { | |
if (ticksAbove) | |
painter->drawLine(pos, slider->rect.top() + extra, | |
pos, slider->rect.top() + tickSize); | |
if (ticksBelow) | |
painter->drawLine(pos, slider->rect.bottom() - extra, | |
pos, slider->rect.bottom() - tickSize); | |
} else { | |
if (ticksAbove) | |
painter->drawLine(slider->rect.left() + extra, pos, | |
slider->rect.left() + tickSize, pos); | |
if (ticksBelow) | |
painter->drawLine(slider->rect.right() - extra, pos, | |
slider->rect.right() - tickSize, pos); | |
} | |
// In the case where maximum is max int | |
int nextInterval = v + interval; | |
if (nextInterval < v) | |
break; | |
v = nextInterval; | |
} | |
} | |
// Draw slider handle | |
if (option->subControls & SC_SliderHandle) { | |
GtkShadowType shadow = GTK_SHADOW_OUT; | |
GtkStateType state = GTK_STATE_NORMAL; | |
if (!(option->state & State_Enabled)) | |
state = GTK_STATE_INSENSITIVE; | |
else if (option->state & State_MouseOver && option->activeSubControls & SC_SliderHandle) | |
state = GTK_STATE_PRELIGHT; | |
bool horizontal = option->state & State_Horizontal; | |
if (slider->state & State_HasFocus) { | |
QStyleOptionFocusRect fropt; | |
fropt.QStyleOption::operator=(*slider); | |
fropt.rect = slider->rect.adjusted(-1, -1 ,1, 1); | |
if (horizontal) { | |
fropt.rect.setTop(handle.top() - 3); | |
fropt.rect.setBottom(handle.bottom() + 4); | |
} else { | |
fropt.rect.setLeft(handle.left() - 3); | |
fropt.rect.setRight(handle.right() + 3); | |
} | |
proxy()->drawPrimitive(PE_FrameFocusRect, &fropt, painter, widget); | |
} | |
gtkPainter.paintSlider( scaleWidget, horizontal ? "hscale" : "vscale", handle, state, shadow, style, | |
horizontal ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL); | |
} | |
painter->setBrush(oldBrush); | |
painter->setPen(oldPen); | |
} | |
break; | |
#endif // QT_NO_SLIDER | |
default: | |
QCleanlooksStyle::drawComplexControl(control, option, painter, widget); | |
break; | |
} | |
} | |
/*! | |
\reimp | |
*/ | |
void QGtkStyle::drawControl(ControlElement element, | |
const QStyleOption *option, | |
QPainter *painter, | |
const QWidget *widget) const | |
{ | |
Q_D(const QGtkStyle); | |
if (!d->isThemeAvailable()) { | |
QCleanlooksStyle::drawControl(element, option, painter, widget); | |
return; | |
} | |
GtkStyle* style = d->gtkStyle(); | |
QGtkPainter gtkPainter(painter); | |
switch (element) { | |
case CE_ProgressBarLabel: | |
if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) { | |
GtkWidget *gtkProgressBar = d->gtkWidget("GtkProgressBar"); | |
if (!gtkProgressBar) | |
return; | |
QRect leftRect; | |
QRect rect = bar->rect; | |
GdkColor gdkText = gtkProgressBar->style->fg[GTK_STATE_NORMAL]; | |
QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8); | |
gdkText = gtkProgressBar->style->fg[GTK_STATE_PRELIGHT]; | |
QColor alternateTextColor= QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8); | |
painter->save(); | |
bool vertical = false, inverted = false; | |
if (const QStyleOptionProgressBarV2 *bar2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) { | |
vertical = (bar2->orientation == Qt::Vertical); | |
inverted = bar2->invertedAppearance; | |
} | |
if (vertical) | |
rect = QRect(rect.left(), rect.top(), rect.height(), rect.width()); // flip width and height | |
const int progressIndicatorPos = (bar->progress - qreal(bar->minimum)) * rect.width() / | |
qMax(qreal(1.0), qreal(bar->maximum) - bar->minimum); | |
if (progressIndicatorPos >= 0 && progressIndicatorPos <= rect.width()) | |
leftRect = QRect(rect.left(), rect.top(), progressIndicatorPos, rect.height()); | |
if (vertical) | |
leftRect.translate(rect.width() - progressIndicatorPos, 0); | |
bool flip = (!vertical && (((bar->direction == Qt::RightToLeft) && !inverted) || | |
((bar->direction == Qt::LeftToRight) && inverted))); | |
QRegion rightRect = rect; | |
rightRect = rightRect.subtracted(leftRect); | |
painter->setClipRegion(rightRect); | |
painter->setPen(flip ? alternateTextColor : textColor); | |
painter->drawText(rect, bar->text, QTextOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter)); | |
if (!leftRect.isNull()) { | |
painter->setPen(flip ? textColor : alternateTextColor); | |
painter->setClipRect(leftRect); | |
painter->drawText(rect, bar->text, QTextOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter)); | |
} | |
painter->restore(); | |
} | |
break; | |
case CE_PushButtonLabel: | |
if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton *>(option)) { | |
QRect ir = button->rect; | |
uint tf = Qt::AlignVCenter | Qt::TextShowMnemonic; | |
QPoint buttonShift; | |
if (option->state & State_Sunken) | |
buttonShift = QPoint(pixelMetric(PM_ButtonShiftHorizontal, option, widget), | |
proxy()->pixelMetric(PM_ButtonShiftVertical, option, widget)); | |
if (proxy()->styleHint(SH_UnderlineShortcut, button, widget)) | |
tf |= Qt::TextShowMnemonic; | |
else | |
tf |= Qt::TextHideMnemonic; | |
if (!button->icon.isNull()) { | |
//Center both icon and text | |
QPoint point; | |
QIcon::Mode mode = button->state & State_Enabled ? QIcon::Normal : QIcon::Disabled; | |
if (mode == QIcon::Normal && button->state & State_HasFocus) | |
mode = QIcon::Active; | |
QIcon::State state = QIcon::Off; | |
if (button->state & State_On) | |
state = QIcon::On; | |
QPixmap pixmap = button->icon.pixmap(button->iconSize, mode, state); | |
int w = pixmap.width(); | |
int h = pixmap.height(); | |
if (!button->text.isEmpty()) | |
w += button->fontMetrics.boundingRect(option->rect, tf, button->text).width() + 4; | |
point = QPoint(ir.x() + ir.width() / 2 - w / 2, | |
ir.y() + ir.height() / 2 - h / 2); | |
if (button->direction == Qt::RightToLeft) | |
point.rx() += pixmap.width(); | |
painter->drawPixmap(visualPos(button->direction, button->rect, point + buttonShift), pixmap); | |
if (button->direction == Qt::RightToLeft) | |
ir.translate(-point.x() - 2, 0); | |
else | |
ir.translate(point.x() + pixmap.width() + 2, 0); | |
// left-align text if there is | |
if (!button->text.isEmpty()) | |
tf |= Qt::AlignLeft; | |
} else { | |
tf |= Qt::AlignHCenter; | |
} | |
ir.translate(buttonShift); | |
if (button->features & QStyleOptionButton::HasMenu) | |
ir = ir.adjusted(0, 0, -pixelMetric(PM_MenuButtonIndicator, button, widget), 0); | |
GtkWidget *gtkButton = d->gtkWidget("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; | |
GdkColor gdkText = gtkButton->style->fg[labelState]; | |
QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8); | |
pal.setBrush(QPalette::ButtonText, textColor); | |
proxy()->drawItemText(painter, ir, tf, pal, (button->state & State_Enabled), | |
button->text, QPalette::ButtonText); | |
} | |
break; | |
case CE_RadioButton: // Fall through | |
case CE_CheckBox: | |
if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) { | |
bool isRadio = (element == CE_RadioButton); | |
// Draw prelight background | |
GtkWidget *gtkRadioButton = d->gtkWidget("GtkRadioButton"); | |
if (option->state & State_MouseOver) { | |
gtkPainter.paintFlatBox(gtkRadioButton, "checkbutton", option->rect, | |
GTK_STATE_PRELIGHT, GTK_SHADOW_ETCHED_OUT, gtkRadioButton->style); | |
} | |
QStyleOptionButton subopt = *btn; | |
subopt.rect = subElementRect(isRadio ? SE_RadioButtonIndicator | |
: SE_CheckBoxIndicator, btn, widget); | |
proxy()->drawPrimitive(isRadio ? PE_IndicatorRadioButton : PE_IndicatorCheckBox, | |
&subopt, painter, widget); | |
subopt.rect = subElementRect(isRadio ? SE_RadioButtonContents | |
: SE_CheckBoxContents, btn, widget); | |
// Get label text color | |
QPalette pal = subopt.palette; | |
int labelState = GTK_STATE_INSENSITIVE; | |
if (option->state & State_Enabled) | |
labelState = (option->state & State_MouseOver) ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL; | |
GdkColor gdkText = gtkRadioButton->style->fg[labelState]; | |
QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8); | |
pal.setBrush(QPalette::WindowText, textColor); | |
subopt.palette = pal; | |
proxy()->drawControl(isRadio ? CE_RadioButtonLabel : CE_CheckBoxLabel, &subopt, painter, widget); | |
if (btn->state & State_HasFocus) { | |
QStyleOptionFocusRect fropt; | |
fropt.QStyleOption::operator=(*btn); | |
fropt.rect = subElementRect(isRadio ? SE_RadioButtonFocusRect | |
: SE_CheckBoxFocusRect, btn, widget); | |
proxy()->drawPrimitive(PE_FrameFocusRect, &fropt, painter, widget); | |
} | |
} | |
break; | |
#ifndef QT_NO_COMBOBOX | |
case CE_ComboBoxLabel: | |
if (const QStyleOptionComboBox *cb = qstyleoption_cast<const QStyleOptionComboBox *>(option)) { | |
QRect editRect = proxy()->subControlRect(CC_ComboBox, cb, SC_ComboBoxEditField, widget); | |
bool appearsAsList = !proxy()->styleHint(QStyle::SH_ComboBox_Popup, cb, widget); | |
painter->save(); | |
painter->setClipRect(editRect); | |
if (!cb->currentIcon.isNull()) { | |
QIcon::Mode mode = cb->state & State_Enabled ? QIcon::Normal | |
: QIcon::Disabled; | |
QPixmap pixmap = cb->currentIcon.pixmap(cb->iconSize, mode); | |
QRect iconRect(editRect); | |
iconRect.setWidth(cb->iconSize.width() + 4); | |
iconRect = alignedRect(cb->direction, | |
Qt::AlignLeft | Qt::AlignVCenter, | |
iconRect.size(), editRect); | |
if (cb->editable) | |
painter->fillRect(iconRect, option->palette.brush(QPalette::Base)); | |
proxy()->drawItemPixmap(painter, iconRect, Qt::AlignCenter, pixmap); | |
if (cb->direction == Qt::RightToLeft) | |
editRect.translate(-4 - cb->iconSize.width(), 0); | |
else | |
editRect.translate(cb->iconSize.width() + 4, 0); | |
} | |
if (!cb->currentText.isEmpty() && !cb->editable) { | |
GtkWidget *gtkCombo = d->gtkWidget("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; | |
GdkColor gdkText = gtkCombo->style->fg[labelState]; | |
QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8); | |
pal.setBrush(QPalette::ButtonText, textColor); | |
proxy()->drawItemText(painter, editRect.adjusted(1, 0, -1, 0), | |
visualAlignment(cb->direction, Qt::AlignLeft | Qt::AlignVCenter), | |
pal, cb->state & State_Enabled, cb->currentText, QPalette::ButtonText); | |
} | |
painter->restore(); | |
} | |
break; | |
#endif // QT_NO_COMBOBOX | |
case CE_DockWidgetTitle: | |
painter->save(); | |
if (const QStyleOptionDockWidget *dwOpt = qstyleoption_cast<const QStyleOptionDockWidget *>(option)) { | |
const QStyleOptionDockWidgetV2 *v2 | |
= qstyleoption_cast<const QStyleOptionDockWidgetV2*>(dwOpt); | |
bool verticalTitleBar = v2 == 0 ? false : v2->verticalTitleBar; | |
QRect rect = dwOpt->rect; | |
QRect titleRect = subElementRect(SE_DockWidgetTitleBarText, option, widget).adjusted(-2, 0, -2, 0); | |
QRect r = rect.adjusted(0, 0, -1, -1); | |
if (verticalTitleBar) | |
r.adjust(0, 0, 0, -1); | |
if (verticalTitleBar) { | |
QRect r = rect; | |
QSize s = r.size(); | |
s.transpose(); | |
r.setSize(s); | |
titleRect = QRect(r.left() + rect.bottom() | |
- titleRect.bottom(), | |
r.top() + titleRect.left() - rect.left(), | |
titleRect.height(), titleRect.width()); | |
painter->translate(r.left(), r.top() + r.width()); | |
painter->rotate(-90); | |
painter->translate(-r.left(), -r.top()); | |
rect = r; | |
} | |
if (!dwOpt->title.isEmpty()) { | |
QString titleText | |
= painter->fontMetrics().elidedText(dwOpt->title, | |
Qt::ElideRight, titleRect.width()); | |
proxy()->drawItemText(painter, | |
titleRect, | |
Qt::AlignLeft | Qt::AlignVCenter | Qt::TextShowMnemonic, dwOpt->palette, | |
dwOpt->state & State_Enabled, titleText, | |
QPalette::WindowText); | |
} | |
} | |
painter->restore(); | |
break; | |
case CE_HeaderSection: | |
painter->save(); | |
// Draws the header in tables. | |
if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) { | |
Q_UNUSED(header); | |
GtkWidget *gtkTreeView = d->gtkWidget("GtkTreeView"); | |
// Get the middle column | |
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; | |
if (option->state & State_Sunken) | |
shadow = GTK_SHADOW_IN; | |
gtkPainter.paintBox(gtkTreeHeader, "button", option->rect.adjusted(-1, 0, 0, 0), state, shadow, gtkTreeHeader->style); | |
} | |
painter->restore(); | |
break; | |
#ifndef QT_NO_SIZEGRIP | |
case CE_SizeGrip: { | |
GtkWidget *gtkStatusbar = d->gtkWidget("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 = d->gtkWidget("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; | |
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); | |
} | |
} | |
break; | |
case CE_MenuBarItem: | |
painter->save(); | |
if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) { | |
GtkWidget *gtkMenubarItem = d->gtkWidget("GtkMenuBar.GtkMenuItem"); | |
GtkWidget *gtkMenubar = d->gtkWidget("GtkMenuBar"); | |
style = gtkMenubarItem->style; | |
if (widget) { | |
// Since Qt does not currently allow filling the entire background | |
// we use a hack for this by making a complete menubar each time and | |
// paint with the correct offset inside it. Pixmap caching should resolve | |
// most of the performance penalty. | |
QRect menuBarRect = widget->rect(); | |
QPixmap pixmap(menuBarRect.size()); | |
pixmap.fill(Qt::transparent); | |
QPainter pmPainter(&pixmap); | |
QGtkPainter menubarPainter(&pmPainter); | |
GtkShadowType shadow_type; | |
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(); | |
painter->drawPixmap(option->rect, pixmap, option->rect); | |
} | |
QStyleOptionMenuItem item = *mbi; | |
bool act = mbi->state & State_Selected && mbi->state & State_Sunken; | |
bool dis = !(mbi->state & State_Enabled); | |
item.rect = mbi->rect; | |
GdkColor gdkText = gtkMenubarItem->style->fg[dis ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL]; | |
GdkColor gdkHText = gtkMenubarItem->style->fg[GTK_STATE_PRELIGHT]; | |
QColor normalTextColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8); | |
QColor highlightedTextColor = QColor(gdkHText.red>>8, gdkHText.green>>8, gdkHText.blue>>8); | |
item.palette.setBrush(QPalette::HighlightedText, highlightedTextColor); | |
item.palette.setBrush(QPalette::Text, normalTextColor); | |
item.palette.setBrush(QPalette::ButtonText, normalTextColor); | |
QCommonStyle::drawControl(element, &item, painter, widget); | |
if (act) { | |
GtkShadowType shadowType = GTK_SHADOW_NONE; | |
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; | |
if (!proxy()->styleHint(SH_UnderlineShortcut, mbi, widget)) | |
alignment |= Qt::TextHideMnemonic; | |
proxy()->drawItemText(painter, item.rect, alignment, item.palette, mbi->state & State_Enabled, mbi->text, textRole); | |
} | |
} | |
painter->restore(); | |
break; | |
case CE_Splitter: { | |
GtkWidget *gtkWindow = d->gtkWidget("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; | |
#ifndef QT_NO_TOOLBAR | |
case CE_ToolBar: | |
if (const QStyleOptionToolBar *toolbar = qstyleoption_cast<const QStyleOptionToolBar *>(option)) { | |
// Reserve the beveled appearance only for mainwindow toolbars | |
if (!(widget && qobject_cast<const QMainWindow*> (widget->parentWidget()))) | |
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 = d->gtkWidget("GtkToolbar"); | |
GtkShadowType shadow_type = GTK_SHADOW_NONE; | |
d->gtk_widget_style_get(gtkToolbar, "shadow-type", &shadow_type, NULL); | |
gtkPainter.paintBox( gtkToolbar, "toolbar", rect, | |
GTK_STATE_NORMAL, shadow_type, gtkToolbar->style); | |
} | |
break; | |
#endif // QT_NO_TOOLBAR | |
case CE_MenuItem: | |
painter->save(); | |
// Draws one item in a popup menu. | |
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 *gtkMenuItem = menuItem->checked ? d->gtkWidget("GtkMenu.GtkCheckMenuItem") : | |
d->gtkWidget("GtkMenu.GtkMenuItem"); | |
style = gtkPainter.getStyle(gtkMenuItem); | |
QColor shadow = option->palette.dark().color(); | |
if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) { | |
GtkWidget *gtkMenuSeparator = d->gtkWidget("GtkMenu.GtkSeparatorMenuItem"); | |
painter->setPen(shadow.lighter(106)); | |
gboolean wide_separators = 0; | |
gint separator_height = 0; | |
guint horizontal_padding = 3; | |
QRect separatorRect = option->rect; | |
if (!d->gtk_check_version(2, 10, 0)) { | |
d->gtk_widget_style_get(gtkMenuSeparator, | |
"wide-separators", &wide_separators, | |
"separator-height", &separator_height, | |
"horizontal-padding", &horizontal_padding, | |
NULL); | |
} | |
separatorRect.setHeight(option->rect.height() - 2 * gtkMenuSeparator->style->ythickness); | |
separatorRect.setWidth(option->rect.width() - 2 * (horizontal_padding + gtkMenuSeparator->style->xthickness)); | |
separatorRect.moveCenter(option->rect.center()); | |
if (wide_separators) | |
gtkPainter.paintBox( gtkMenuSeparator, "hseparator", | |
separatorRect, GTK_STATE_NORMAL, GTK_SHADOW_NONE, gtkMenuSeparator->style); | |
else | |
gtkPainter.paintHline( gtkMenuSeparator, "hseparator", | |
separatorRect, GTK_STATE_NORMAL, gtkMenuSeparator->style, | |
0, option->rect.right() - 1, 1); | |
painter->restore(); | |
break; | |
} | |
bool selected = menuItem->state & State_Selected && menuItem->state & State_Enabled; | |
if (selected) { | |
QRect rect = option->rect; | |
#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 checkable = menuItem->checkType != QStyleOptionMenuItem::NotCheckable; | |
bool checked = menuItem->checked; | |
bool enabled = menuItem->state & State_Enabled; | |
bool ignoreCheckMark = false; | |
gint checkSize; | |
d->gtk_widget_style_get(d->gtkWidget("GtkMenu.GtkCheckMenuItem"), "indicator-size", &checkSize, NULL); | |
int checkcol = qMax(menuItem->maxIconWidth, qMax(20, checkSize)); | |
#ifndef QT_NO_COMBOBOX | |
if (qobject_cast<const QComboBox*>(widget)) | |
ignoreCheckMark = true; // Ignore the checkmarks provided by the QComboMenuDelegate | |
#endif | |
if (!ignoreCheckMark) { | |
// Check | |
QRect checkRect(option->rect.left() + 7, option->rect.center().y() - checkSize/2 + 1, checkSize, checkSize); | |
checkRect = visualRect(menuItem->direction, menuItem->rect, checkRect); | |
if (checkable && menuItem->icon.isNull()) { | |
// Some themes such as aero-clone draw slightly outside the paint rect | |
int spacing = 1; // ### Consider using gtkCheckBox : "indicator-spacing" instead | |
if (menuItem->checkType & QStyleOptionMenuItem::Exclusive) { | |
// Radio button | |
GtkShadowType shadow = GTK_SHADOW_OUT; | |
GtkStateType state = gtkPainter.gtkState(option); | |
if (selected) | |
state = GTK_STATE_PRELIGHT; | |
if (checked) | |
shadow = GTK_SHADOW_IN; | |
gtkPainter.setClipRect(checkRect.adjusted(-spacing, -spacing, spacing, spacing)); | |
gtkPainter.paintOption(gtkMenuItem, checkRect.translated(-spacing, -spacing), state, shadow, | |
gtkMenuItem->style, QLS("option")); | |
gtkPainter.setClipRect(QRect()); | |
} else { | |
// Check box | |
if (menuItem->icon.isNull()) { | |
GtkShadowType shadow = GTK_SHADOW_OUT; | |
GtkStateType state = gtkPainter.gtkState(option); | |
if (selected) | |
state = GTK_STATE_PRELIGHT; | |
if (checked) | |
shadow = GTK_SHADOW_IN; | |
gtkPainter.setClipRect(checkRect.adjusted(-spacing, -spacing, -spacing, -spacing)); | |
gtkPainter.paintCheckbox(gtkMenuItem, checkRect.translated(-spacing, -spacing), state, shadow, | |
gtkMenuItem->style, QLS("check")); | |
gtkPainter.setClipRect(QRect()); | |
} | |
} | |
} | |
} else { | |
// Ignore checkmark | |
if (menuItem->icon.isNull()) | |
checkcol = 0; | |
else | |
checkcol = menuItem->maxIconWidth; | |
} | |
bool dis = !(menuItem->state & State_Enabled); | |
bool act = menuItem->state & State_Selected; | |
const QStyleOption *opt = option; | |
const QStyleOptionMenuItem *menuitem = menuItem; | |
QPainter *p = painter; | |
QRect vCheckRect = visualRect(opt->direction, menuitem->rect, | |
QRect(menuitem->rect.x() + 3, menuitem->rect.y(), | |
checkcol, menuitem->rect.height())); | |
if (!menuItem->icon.isNull()) { | |
QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal; | |
if (act && !dis) | |
mode = QIcon::Active; | |
QPixmap pixmap; | |
int smallIconSize = proxy()->pixelMetric(PM_SmallIconSize, option, widget); | |
QSize iconSize(smallIconSize, smallIconSize); | |
#ifndef QT_NO_COMBOBOX | |
if (const QComboBox *combo = qobject_cast<const QComboBox*>(widget)) | |
iconSize = combo->iconSize(); | |
#endif // QT_NO_COMBOBOX | |
if (checked) | |
pixmap = menuItem->icon.pixmap(iconSize, mode, QIcon::On); | |
else | |
pixmap = menuItem->icon.pixmap(iconSize, mode); | |
int pixw = pixmap.width(); | |
int pixh = pixmap.height(); | |
QRect pmr(0, 0, pixw, pixh); | |
pmr.moveCenter(vCheckRect.center() - QPoint(0, 1)); | |
painter->setPen(menuItem->palette.text().color()); | |
if (!ignoreCheckMark && checkable && checked) { | |
QStyleOption opt = *option; | |
if (act) { | |
QColor activeColor = mergedColors(option->palette.background().color(), | |
option->palette.highlight().color()); | |
opt.palette.setBrush(QPalette::Button, activeColor); | |
} | |
opt.state |= State_Sunken; | |
opt.rect = vCheckRect; | |
proxy()->drawPrimitive(PE_PanelButtonCommand, &opt, painter, widget); | |
} | |
painter->drawPixmap(pmr.topLeft(), pixmap); | |
} | |
GdkColor gdkText = gtkMenuItem->style->fg[GTK_STATE_NORMAL]; | |
GdkColor gdkDText = gtkMenuItem->style->fg[GTK_STATE_INSENSITIVE]; | |
GdkColor gdkHText = gtkMenuItem->style->fg[GTK_STATE_PRELIGHT]; | |
uint resolve_mask = option->palette.resolve(); | |
QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8); | |
QColor disabledTextColor = QColor(gdkDText.red>>8, gdkDText.green>>8, gdkDText.blue>>8); | |
if (resolve_mask & (1 << QPalette::ButtonText)) { | |
textColor = option->palette.buttonText().color(); | |
disabledTextColor = option->palette.brush(QPalette::Disabled, QPalette::ButtonText).color(); | |
} | |
QColor highlightedTextColor = QColor(gdkHText.red>>8, gdkHText.green>>8, gdkHText.blue>>8); | |
if (resolve_mask & (1 << QPalette::HighlightedText)) { | |
highlightedTextColor = option->palette.highlightedText().color(); | |
} | |
if (selected) | |
painter->setPen(highlightedTextColor); | |
else | |
painter->setPen(textColor); | |
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 + 1; | |
QRect textRect(xpos, y + windowsItemVMargin, 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(); | |
int t = s.indexOf(QLatin1Char('\t')); | |
int text_flags = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine; | |
if (!proxy()->styleHint(SH_UnderlineShortcut, menuitem, widget)) | |
text_flags |= Qt::TextHideMnemonic; | |
// Draw shortcut right aligned | |
text_flags |= Qt::AlignRight; | |
if (t >= 0) { | |
int rightMargin = 12; // Hardcode for now | |
QRect vShortcutRect = visualRect(opt->direction, menuitem->rect, | |
QRect(textRect.topRight(), QPoint(menuitem->rect.right() - rightMargin, textRect.bottom()))); | |
if (dis) | |
p->setPen(disabledTextColor); | |
p->drawText(vShortcutRect, text_flags , s.mid(t + 1)); | |
s = s.left(t); | |
} | |
text_flags &= ~Qt::AlignRight; | |
text_flags |= Qt::AlignLeft; | |
QFont font = menuitem->font; | |
if (menuitem->menuItemType == QStyleOptionMenuItem::DefaultItem) | |
font.setBold(true); | |
p->setFont(font); | |
if (dis) | |
p->setPen(disabledTextColor); | |
p->drawText(vTextRect, text_flags, s.left(t)); | |
p->restore(); | |
} | |
// Arrow | |
if (menuItem->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow | |
QFontMetrics fm(menuitem->font); | |
int arrow_size = fm.ascent() + fm.descent() - 2 * gtkMenuItem->style->ythickness; | |
gfloat arrow_scaling = 0.8; | |
int extra = 0; | |
if (!d->gtk_check_version(2, 16, 0)) { | |
// "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; | |
d->gtk_widget_style_get(gtkMenuItem, "horizontal-padding", &horizontal_padding, NULL); | |
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; | |
GtkShadowType shadowType = (state == GTK_STATE_PRELIGHT) ? GTK_SHADOW_OUT : GTK_SHADOW_IN; | |
gtkPainter.paintArrow(gtkMenuItem, "menuitem", vSubMenuRect, QApplication::isRightToLeft() ? GTK_ARROW_LEFT : GTK_ARROW_RIGHT, state, | |
shadowType, FALSE, style); | |
} | |
} | |
painter->restore(); | |
break; | |
case CE_PushButton: | |
if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) { | |
GtkWidget *gtkButton = d->gtkWidget("GtkButton"); | |
proxy()->drawControl(CE_PushButtonBevel, btn, painter, widget); | |
QStyleOptionButton subopt = *btn; | |
subopt.rect = subElementRect(SE_PushButtonContents, btn, widget); | |
gint interiorFocus = true; | |
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 | |
proxy()->drawPrimitive(PE_FrameFocusRect, option, painter, widget); | |
else if (btn->state & State_HasFocus) | |
gtkPainter.paintFocus(gtkButton, "button", | |
option->rect.adjusted(xt, yt, -xt, -yt), | |
btn->state & State_Sunken ? GTK_STATE_ACTIVE : GTK_STATE_NORMAL, | |
gtkButton->style); | |
proxy()->drawControl(CE_PushButtonLabel, &subopt, painter, widget); | |
} | |
break; | |
#ifndef QT_NO_TABBAR | |
case CE_TabBarTabShape: | |
if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) { | |
GtkWidget *gtkNotebook = d->gtkWidget("GtkNotebook"); | |
style = gtkPainter.getStyle(gtkNotebook); | |
QRect rect = option->rect; | |
GtkShadowType shadow = GTK_SHADOW_OUT; | |
GtkStateType state = GTK_STATE_ACTIVE; | |
if (tab->state & State_Selected) | |
state = GTK_STATE_NORMAL; | |
bool selected = (tab->state & State_Selected); | |
bool first = false, last = false; | |
if (widget) { | |
// This is most accurate and avoids resizing tabs while moving | |
first = tab->rect.left() == widget->rect().left(); | |
last = tab->rect.right() == widget->rect().right(); | |
} else if (option->direction == Qt::RightToLeft) { | |
bool tmp = first; | |
first = last; | |
last = tmp; | |
} | |
int topIndent = 3; | |
int bottomIndent = 1; | |
int tabOverlap = 1; | |
painter->save(); | |
switch (tab->shape) { | |
case QTabBar::RoundedNorth: | |
if (!selected) | |
rect.adjust(first ? 0 : -tabOverlap, topIndent, last ? 0 : tabOverlap, -bottomIndent); | |
gtkPainter.paintExtention( gtkNotebook, "tab", rect, | |
state, shadow, GTK_POS_BOTTOM, style); | |
break; | |
case QTabBar::RoundedSouth: | |
if (!selected) | |
rect.adjust(first ? 0 : -tabOverlap, 0, last ? 0 : tabOverlap, -topIndent); | |
gtkPainter.paintExtention( gtkNotebook, "tab", rect.adjusted(0, 1, 0, 0), | |
state, shadow, GTK_POS_TOP, style); | |
break; | |
case QTabBar::RoundedWest: | |
if (!selected) | |
rect.adjust(topIndent, 0, -bottomIndent, 0); | |
gtkPainter.paintExtention( gtkNotebook, "tab", rect, state, shadow, GTK_POS_RIGHT, style); | |
break; | |
case QTabBar::RoundedEast: | |
if (!selected) | |
rect.adjust(bottomIndent, 0, -topIndent, 0); | |
gtkPainter.paintExtention( gtkNotebook, "tab", rect, state, shadow, GTK_POS_LEFT, style); | |
break; | |
default: | |
QCleanlooksStyle::drawControl(element, option, painter, widget); | |
break; | |
} | |
painter->restore(); | |
} | |
break; | |
#endif //QT_NO_TABBAR | |
case CE_ProgressBarGroove: | |
if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) { | |
Q_UNUSED(bar); | |
GtkWidget *gtkProgressBar = d->gtkWidget("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 = d->gtkWidget("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); | |
bool vertical = false; | |
bool inverted = false; | |
bool indeterminate = (bar->minimum == 0 && bar->maximum == 0); | |
// Get extra style options if version 2 | |
if (const QStyleOptionProgressBarV2 *bar2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) { | |
vertical = (bar2->orientation == Qt::Vertical); | |
inverted = bar2->invertedAppearance; | |
} | |
// If the orientation is vertical, we use a transform to rotate | |
// the progress bar 90 degrees clockwise. This way we can use the | |
// same rendering code for both orientations. | |
if (vertical) { | |
rect.translate(xt, -yt * 2); | |
rect = QRect(rect.left(), rect.top(), rect.height(), rect.width()); // Flip width and height | |
QTransform m = QTransform::fromTranslate(rect.height(), 0); | |
m.rotate(90.0); | |
painter->setTransform(m); | |
} | |
int maxWidth = rect.width(); | |
int minWidth = 4; | |
qint64 progress = (qint64)qMax(bar->progress, bar->minimum); // Workaround for bug in QProgressBar | |
double vc6_workaround = ((progress - qint64(bar->minimum)) / double(qint64(bar->maximum) - qint64(bar->minimum))) * maxWidth; | |
int progressBarWidth = (int(vc6_workaround) > minWidth ) ? int(vc6_workaround) : minWidth; | |
int width = indeterminate ? maxWidth : progressBarWidth; | |
bool reverse = (!vertical && (bar->direction == Qt::RightToLeft)) || vertical; | |
if (inverted) | |
reverse = !reverse; | |
int maximum = 2; | |
int fakePos = 0; | |
if (bar->minimum == bar->maximum) | |
maximum = 0; | |
if (bar->progress == bar->maximum) | |
fakePos = maximum; | |
else if (bar->progress > bar->minimum) | |
fakePos = maximum - 1; | |
GtkObject *adjustment = d->gtk_adjustment_new(fakePos, 0, maximum, 0, 0, 0); | |
d->gtk_progress_set_adjustment((GtkProgress*)(gtkProgressBar), (GtkAdjustment*)(adjustment)); | |
QRect progressBar; | |
if (!indeterminate) { | |
if (!reverse) | |
progressBar.setRect(rect.left(), rect.top(), width, rect.height()); | |
else | |
progressBar.setRect(rect.right() - width, rect.top(), width, rect.height()); | |
} else { | |
Q_D(const QGtkStyle); | |
int slideWidth = ((rect.width() - 4) * 2) / 3; | |
int step = ((d->animateStep * slideWidth) / d->animationFps) % slideWidth; | |
if ((((d->animateStep * slideWidth) / d->animationFps) % (2 * slideWidth)) >= slideWidth) | |
step = slideWidth - step; | |
progressBar.setRect(rect.left() + step, rect.top(), slideWidth / 2, rect.height()); | |
} | |
QString key = QString(QLS("%0")).arg(fakePos); | |
if (inverted) { | |
key += QLatin1String("inv"); | |
gtkPainter.setFlipHorizontal(true); | |
} | |
gtkPainter.paintBox( gtkProgressBar, "bar", progressBar, GTK_STATE_SELECTED, GTK_SHADOW_OUT, style, key); | |
} | |
break; | |
default: | |
QCleanlooksStyle::drawControl(element, option, painter, widget); | |
} | |
} | |
/*! | |
\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 (!d->isThemeAvailable()) | |
return QCleanlooksStyle::subControlRect(control, option, subControl, widget); | |
switch (control) { | |
case CC_TitleBar: | |
return QCleanlooksStyle::subControlRect(control, option, subControl, widget); | |
case CC_Slider: | |
if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) { | |
// Reserve space for outside focus rect | |
QStyleOptionSlider sliderCopy = *slider; | |
sliderCopy.rect = option->rect.adjusted(2, 2, -2, -2); | |
return QCleanlooksStyle::subControlRect(control, &sliderCopy, subControl, widget); | |
} | |
break; | |
#ifndef QT_NO_GROUPBOX | |
case CC_GroupBox: | |
if (qstyleoption_cast<const QStyleOptionGroupBox *>(option)) { | |
rect = option->rect.adjusted(0, groupBoxTopMargin, 0, -groupBoxBottomMargin); | |
int topMargin = 0; | |
int topHeight = 0; | |
topHeight = 10; | |
QRect frameRect = rect; | |
frameRect.setTop(topMargin); | |
if (subControl == SC_GroupBoxFrame) | |
return rect; | |
else if (subControl == SC_GroupBoxContents) { | |
int margin = 0; | |
int leftMarginExtension = 8; | |
return frameRect.adjusted(leftMarginExtension + margin, margin + topHeight + groupBoxTitleMargin, -margin, -margin); | |
} | |
if (const QGroupBox *groupBoxWidget = qobject_cast<const QGroupBox *>(widget)) { | |
//Prepare metrics for a bold font | |
QFont font = widget->font(); | |
font.setBold(true); | |
QFontMetrics fontMetrics(font); | |
QSize textRect = fontMetrics.boundingRect(groupBoxWidget->title()).size() + QSize(4, 4); | |
int indicatorWidth = proxy()->pixelMetric(PM_IndicatorWidth, option, widget); | |
int indicatorHeight = proxy()->pixelMetric(PM_IndicatorHeight, option, widget); | |
if (subControl == SC_GroupBoxCheckBox) { | |
rect.setWidth(indicatorWidth); | |
rect.setHeight(indicatorHeight); | |
rect.moveTop((textRect.height() - indicatorHeight) / 2); | |
} else if (subControl == SC_GroupBoxLabel) { | |
if (groupBoxWidget->isCheckable()) | |
rect.adjust(indicatorWidth + 4, 0, 0, 0); | |
rect.setSize(textRect); | |
} | |
rect = visualRect(option->direction, option->rect, rect); | |
} | |
} | |
return rect; | |
#endif | |
#ifndef QT_NO_SPINBOX | |
case CC_SpinBox: | |
if (const QStyleOptionSpinBox *spinbox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) { | |
GtkWidget *gtkSpinButton = d->gtkWidget("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(d->getSpinboxArrowSize()); | |
int x, lx, rx; | |
x = spinbox->rect.width() - y - bs.width() + 2; | |
lx = xt; | |
rx = x - xt; | |
switch (subControl) { | |
case SC_SpinBoxUp: | |
if (spinbox->buttonSymbols == QAbstractSpinBox::NoButtons) | |
return QRect(); | |
rect = QRect(x, xt, bs.width(), center - yt); | |
break; | |
case SC_SpinBoxDown: | |
if (spinbox->buttonSymbols == QAbstractSpinBox::NoButtons) | |
return QRect(); | |
rect = QRect(x, center, bs.width(), spinbox->rect.bottom() - center - yt + 1); | |
break; | |
case SC_SpinBoxEditField: | |
if (spinbox->buttonSymbols == QAbstractSpinBox::NoButtons) | |
rect = QRect(lx, yt, spinbox->rect.width() - 2*xt, spinbox->rect.height() - 2*yt); | |
else | |
rect = QRect(lx, yt, rx - qMax(xt - 1, 0), spinbox->rect.height() - 2*yt); | |
break; | |
case SC_SpinBoxFrame: | |
rect = spinbox->rect; | |
default: | |
break; | |
} | |
rect = visualRect(spinbox->direction, spinbox->rect, rect); | |
} | |
break; | |
#endif // Qt_NO_SPINBOX | |
#ifndef QT_NO_COMBOBOX | |
case CC_ComboBox: | |
if (const QStyleOptionComboBox *box = qstyleoption_cast<const QStyleOptionComboBox *>(option)) { | |
// We employ the gtk widget to position arrows and separators for us | |
GtkWidget *gtkCombo = box->editable ? d->gtkWidget("GtkComboBoxEntry") | |
: d->gtkWidget("GtkComboBox"); | |
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())}; | |
d->gtk_widget_size_allocate(gtkCombo, &geometry); | |
int appears_as_list = !proxy()->styleHint(QStyle::SH_ComboBox_Popup, option, widget); | |
QHashableLatin1Literal arrowPath("GtkComboBoxEntry.GtkToggleButton"); | |
if (!box->editable) { | |
if (appears_as_list) | |
arrowPath = "GtkComboBox.GtkToggleButton"; | |
else | |
arrowPath = "GtkComboBox.GtkToggleButton.GtkHBox.GtkArrow"; | |
} | |
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, | |
arrowWidget->allocation.width, arrowWidget->allocation.height); | |
switch (subControl) { | |
case SC_ComboBoxArrow: // Note: this indicates the arrowbutton for editable combos | |
rect = buttonRect; | |
break; | |
case SC_ComboBoxEditField: { | |
rect = visualRect(option->direction, option->rect, rect); | |
int xMargin = box->editable ? 1 : 4, yMargin = 2; | |
rect.setRect(option->rect.left() + gtkCombo->style->xthickness + xMargin, | |
option->rect.top() + gtkCombo->style->ythickness + yMargin, | |
option->rect.width() - buttonRect.width() - 2*(gtkCombo->style->xthickness + xMargin), | |
option->rect.height() - 2*(gtkCombo->style->ythickness + yMargin)); | |
rect = visualRect(option->direction, option->rect, rect); | |
break; | |
} | |
default: | |
break; | |
} | |
} | |
break; | |
#endif // QT_NO_COMBOBOX | |
default: | |
break; | |
} | |
return rect; | |
} | |
/*! | |
\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 (!d->isThemeAvailable()) | |
return newSize; | |
switch (type) { | |
case CT_ToolButton: | |
if (const QStyleOptionToolButton *toolbutton = qstyleoption_cast<const QStyleOptionToolButton *>(option)) { | |
GtkWidget *gtkButton = d->gtkWidget("GtkToolButton.GtkButton"); | |
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 = d->gtkWidget("GtkMenu.GtkSeparatorMenuItem"); | |
GtkRequisition sizeReq = {0, 0}; | |
d->gtk_widget_size_request(gtkMenuSeparator, &sizeReq); | |
newSize = QSize(size.width(), sizeReq.height); | |
break; | |
} | |
GtkWidget *gtkMenuItem = d->gtkWidget("GtkMenu.GtkCheckMenuItem"); | |
GtkStyle* style = gtkMenuItem->style; | |
// Note we get the perfect height for the default font since we | |
// set a fake text label on the gtkMenuItem | |
// But if custom fonts are used on the widget we need a minimum size | |
GtkRequisition sizeReq = {0, 0}; | |
d->gtk_widget_size_request(gtkMenuItem, &sizeReq); | |
newSize.setHeight(qMax(newSize.height() - 4, sizeReq.height)); | |
newSize += QSize(textMargin + style->xthickness - 1, 0); | |
// Cleanlooks assumes a check column of 20 pixels so we need to | |
// expand it a bit | |
gint checkSize; | |
d->gtk_widget_style_get(gtkMenuItem, "indicator-size", &checkSize, NULL); | |
newSize.setWidth(newSize.width() + qMax(0, checkSize - 20)); | |
} | |
break; | |
case CT_SpinBox: | |
// QSpinBox does some nasty things that depends on CT_LineEdit | |
newSize = size + QSize(0, -d->gtkWidget("GtkSpinButton")->style->ythickness * 2); | |
break; | |
case CT_PushButton: | |
if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) { | |
GtkWidget *gtkButton = d->gtkWidget("GtkButton"); | |
gint focusPadding, focusWidth; | |
d->gtk_widget_style_get(gtkButton, "focus-padding", &focusPadding, 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 = d->gtkWidget("GtkHButtonBox"); | |
gint minWidth = 85, minHeight = 0; | |
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 = d->gtkWidget("GtkHScale"); | |
newSize = size + QSize(2*gtkSlider->style->xthickness, 2*gtkSlider->style->ythickness); | |
} | |
break; | |
case CT_LineEdit: { | |
GtkWidget *gtkEntry = d->gtkWidget("GtkEntry"); | |
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 = d->gtkWidget("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, 2); | |
} | |
break; | |
case CT_GroupBox: | |
newSize += QSize(4, groupBoxBottomMargin + groupBoxTopMargin + groupBoxTitleMargin); // Add some space below the groupbox | |
break; | |
case CT_TabBarTab: | |
if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) { | |
if (!tab->icon.isNull()) | |
newSize += QSize(6, 0); | |
} | |
newSize += QSize(1, 1); | |
break; | |
default: | |
break; | |
} | |
return newSize; | |
} | |
/*! \reimp */ | |
QPixmap QGtkStyle::standardPixmap(StandardPixmap sp, const QStyleOption *option, | |
const QWidget *widget) const | |
{ | |
Q_D(const QGtkStyle); | |
if (!d->isThemeAvailable()) | |
return QCleanlooksStyle::standardPixmap(sp, option, widget); | |
QPixmap pixmap; | |
switch (sp) { | |
case SP_TitleBarNormalButton: { | |
QImage restoreButton((const char **)dock_widget_restore_xpm); | |
QColor alphaCorner = restoreButton.color(2); | |
alphaCorner.setAlpha(80); | |
restoreButton.setColor(2, alphaCorner.rgba()); | |
alphaCorner.setAlpha(180); | |
restoreButton.setColor(4, alphaCorner.rgba()); | |
return QPixmap::fromImage(restoreButton); | |
} | |
break; | |
case SP_TitleBarCloseButton: // Fall through | |
case SP_DockWidgetCloseButton: { | |
QImage closeButton((const char **)dock_widget_close_xpm); | |
QColor alphaCorner = closeButton.color(2); | |
alphaCorner.setAlpha(80); | |
closeButton.setColor(2, alphaCorner.rgba()); | |
return QPixmap::fromImage(closeButton); | |
} | |
break; | |
case SP_DialogDiscardButton: | |
return QGtkPainter::getIcon(GTK_STOCK_DELETE); | |
case SP_DialogOkButton: | |
return QGtkPainter::getIcon(GTK_STOCK_OK); | |
case SP_DialogCancelButton: | |
return QGtkPainter::getIcon(GTK_STOCK_CANCEL); | |
case SP_DialogYesButton: | |
return QGtkPainter::getIcon(GTK_STOCK_YES); | |
case SP_DialogNoButton: | |
return QGtkPainter::getIcon(GTK_STOCK_NO); | |
case SP_DialogOpenButton: | |
return QGtkPainter::getIcon(GTK_STOCK_OPEN); | |
case SP_DialogCloseButton: | |
return QGtkPainter::getIcon(GTK_STOCK_CLOSE); | |
case SP_DialogApplyButton: | |
return QGtkPainter::getIcon(GTK_STOCK_APPLY); | |
case SP_DialogSaveButton: | |
return QGtkPainter::getIcon(GTK_STOCK_SAVE); | |
case SP_MessageBoxWarning: | |
return QGtkPainter::getIcon(GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); | |
case SP_MessageBoxQuestion: | |
return QGtkPainter::getIcon(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); | |
case SP_MessageBoxInformation: | |
return QGtkPainter::getIcon(GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); | |
case SP_MessageBoxCritical: | |
return QGtkPainter::getIcon(GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG); | |
default: | |
return QCleanlooksStyle::standardPixmap(sp, option, widget); | |
} | |
return pixmap; | |
} | |
/*! | |
\internal | |
*/ | |
QIcon QGtkStyle::standardIconImplementation(StandardPixmap standardIcon, | |
const QStyleOption *option, | |
const QWidget *widget) const | |
{ | |
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: | |
return QGtkPainter::getIcon(GTK_STOCK_OK); | |
case SP_DialogCancelButton: | |
return QGtkPainter::getIcon(GTK_STOCK_CANCEL); | |
case SP_DialogYesButton: | |
return QGtkPainter::getIcon(GTK_STOCK_YES); | |
case SP_DialogNoButton: | |
return QGtkPainter::getIcon(GTK_STOCK_NO); | |
case SP_DialogOpenButton: | |
return QGtkPainter::getIcon(GTK_STOCK_OPEN); | |
case SP_DialogCloseButton: | |
return QGtkPainter::getIcon(GTK_STOCK_CLOSE); | |
case SP_DialogApplyButton: | |
return QGtkPainter::getIcon(GTK_STOCK_APPLY); | |
case SP_DialogSaveButton: | |
return QGtkPainter::getIcon(GTK_STOCK_SAVE); | |
case SP_MessageBoxWarning: | |
return QGtkPainter::getIcon(GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); | |
case SP_MessageBoxQuestion: | |
return QGtkPainter::getIcon(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); | |
case SP_MessageBoxInformation: | |
return QGtkPainter::getIcon(GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); | |
case SP_MessageBoxCritical: | |
return QGtkPainter::getIcon(GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG); | |
default: | |
return QCleanlooksStyle::standardIconImplementation(standardIcon, option, widget); | |
} | |
} | |
/*! \reimp */ | |
QRect QGtkStyle::subElementRect(SubElement element, const QStyleOption *option, const QWidget *widget) const | |
{ | |
Q_D(const QGtkStyle); | |
QRect r = QCleanlooksStyle::subElementRect(element, option, widget); | |
if (!d->isThemeAvailable()) | |
return r; | |
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("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; | |
} | |
/*! | |
\reimp | |
*/ | |
QRect QGtkStyle::itemPixmapRect(const QRect &r, int flags, const QPixmap &pixmap) const | |
{ | |
return QCleanlooksStyle::itemPixmapRect(r, flags, pixmap); | |
} | |
/*! | |
\reimp | |
*/ | |
void QGtkStyle::drawItemPixmap(QPainter *painter, const QRect &rect, | |
int alignment, const QPixmap &pixmap) const | |
{ | |
QCleanlooksStyle::drawItemPixmap(painter, rect, alignment, pixmap); | |
} | |
/*! | |
\reimp | |
*/ | |
QStyle::SubControl QGtkStyle::hitTestComplexControl(ComplexControl cc, const QStyleOptionComplex *opt, | |
const QPoint &pt, const QWidget *w) const | |
{ | |
return QCleanlooksStyle::hitTestComplexControl(cc, opt, pt, w); | |
} | |
/*! | |
\reimp | |
*/ | |
QPixmap QGtkStyle::generatedIconPixmap(QIcon::Mode iconMode, const QPixmap &pixmap, | |
const QStyleOption *opt) const | |
{ | |
return QCleanlooksStyle::generatedIconPixmap(iconMode, pixmap, opt); | |
} | |
/*! | |
\reimp | |
*/ | |
void QGtkStyle::drawItemText(QPainter *painter, const QRect &rect, int alignment, const QPalette &pal, | |
bool enabled, const QString& text, QPalette::ColorRole textRole) const | |
{ | |
return QCleanlooksStyle::drawItemText(painter, rect, alignment, pal, enabled, text, textRole); | |
} | |
QT_END_NAMESPACE | |
#endif //!defined(QT_NO_STYLE_QGTK) |