AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

QGtkStyle: use gtk_widget_get_style()

Browse Source 
Do not access GtkWidget::style directly, it doesn't exist in GTK3.

Change-Id: I947776848f5dd64011a40446fcdb9079f295f182
Reviewed-by: J-P Nurmi <jpnurmi@digia.com>
Reviewed-by: Jens Bache-Wiig <jens.bache-wiig@digia.com>
This commit is contained in:
J-P Nurmi 2012-10-08 11:45:23 +02:00 committed by The Qt Project
parent 9f96bf2023
commit c0893962ef
3 changed files with 118 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

201
src/widgets/styles/qgtkstyle.cpp
View File

@ -325,18 +325,19 @@ QPalette QGtkStyle::standardPalette() const
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];
gdkForeground = d->gtk_widget_get_style(gtkButton)->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];
GtkStyle *gtkEntryStyle = d->gtk_widget_get_style(gtkEntry);
gdkBase = gtkEntryStyle->base[GTK_STATE_NORMAL];
gdkText = gtkEntryStyle->text[GTK_STATE_NORMAL];
gdkSbg = gtkEntryStyle->base[GTK_STATE_SELECTED];
gdkSfg = gtkEntryStyle->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];
gdkaSbg = gtkEntryStyle->base[GTK_STATE_ACTIVE];
gdkaSfg = gtkEntryStyle->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);
@ -558,7 +559,7 @@ int QGtkStyle::pixelMetric(PixelMetric metric,
// 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);
int padding = qMax<int>(d->gtk_widget_get_style(gtkMenu)->xthickness, horizontal_padding);
return padding;
}
@ -614,7 +615,7 @@ int QGtkStyle::pixelMetric(PixelMetric metric,
gint val;
d->gtk_widget_style_get(gtkScale, "slider-width", &val, NULL);
if (metric == PM_SliderControlThickness)
return val + 2*gtkScale->style->ythickness;
return val + 2*d->gtk_widget_get_style(gtkScale)->ythickness;
return val;
}
@ -649,7 +650,7 @@ int QGtkStyle::pixelMetric(PixelMetric metric,
case PM_MenuBarVMargin: {
GtkWidget *gtkMenubar = d->gtkWidget("GtkMenuBar");
return qMax(0, gtkMenubar->style->ythickness);
return qMax(0, d->gtk_widget_get_style(gtkMenubar)->ythickness);
}
case PM_ScrollView_ScrollBarSpacing:
{
@ -955,7 +956,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
GtkWidget *gtkStatusbarFrame = d->gtkWidget("GtkStatusbar.GtkFrame");
d->gtk_widget_style_get(d->gtk_widget_get_parent(gtkStatusbarFrame), "shadow-type", &shadow_type, NULL);
gtkPainter.paintShadow(gtkStatusbarFrame, "frame", option->rect, GTK_STATE_NORMAL,
shadow_type, gtkStatusbarFrame->style);
shadow_type, d->gtk_widget_get_style(gtkStatusbarFrame));
}
break;
@ -963,7 +964,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
GtkWidget *gtkTreeHeader = d->gtkWidget("GtkTreeView.GtkButton");
GtkStateType state = gtkPainter.gtkState(option);
style = gtkTreeHeader->style;
style = d->gtk_widget_get_style(gtkTreeHeader);
GtkArrowType type = GTK_ARROW_UP;
// 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
@ -1013,7 +1014,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
state = GTK_STATE_PRELIGHT;
gtkPainter.paintExpander(gtkTreeView, "treeview", rect, state,
option->state & State_Open ? openState : closedState , gtkTreeView->style);
option->state & State_Open ? openState : closedState , d->gtk_widget_get_style(gtkTreeView));
}
break;
@ -1060,7 +1061,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
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);
GTK_SHADOW_OUT, d->gtk_widget_get_style(gtkTreeView), key);
if (isActive )
GTK_WIDGET_UNSET_FLAGS(gtkTreeView, GTK_HAS_FOCUS);
}
@ -1075,14 +1076,14 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
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,
rect, GTK_STATE_NORMAL, d->gtk_widget_get_style(gtkSeparator),
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,
rect, GTK_STATE_NORMAL, d->gtk_widget_get_style(gtkSeparator),
0, rect.width(), 0);
}
}
@ -1096,7 +1097,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
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);
GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL, d->gtk_widget_get_style(gtkToolbar));
}
break;
@ -1141,7 +1142,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
GdkColor color = fromQColor(arrowColor);
d->gtk_widget_modify_fg (gtkArrow, state, &color);
gtkPainter.paintArrow(gtkArrow, "button", arrowRect,
type, state, shadow, false, gtkArrow->style,
type, state, shadow, false, d->gtk_widget_get_style(gtkArrow),
QString::number(arrowColor.rgba(), 16));
// Passing NULL will revert the color change
d->gtk_widget_modify_fg (gtkArrow, state, NULL);
@ -1155,7 +1156,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
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());
gtkPainter.paintBox(gtkMenu, "menu", option->rect, GTK_STATE_NORMAL, GTK_SHADOW_OUT, d->gtk_widget_get_style(gtkMenu), QString());
}
break;
@ -1194,12 +1195,12 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
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,
GTK_SHADOW_IN, d->gtk_widget_get_style(gtkEntry),
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"));
GTK_SHADOW_IN, d->gtk_widget_get_style(gtkEntry), QLS("GtkEntryShadowIn"));
if (option->state & State_HasFocus)
GTK_WIDGET_UNSET_FLAGS(gtkEntry, GTK_HAS_FOCUS);
@ -1212,15 +1213,16 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
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);
GtkStyle *gtkEntryStyle = d->gtk_widget_get_style(gtkEntry);
QRect textRect = option->rect.adjusted(gtkEntryStyle->xthickness, gtkEntryStyle->ythickness,
-gtkEntryStyle->xthickness, -gtkEntryStyle->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);
option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE, GTK_SHADOW_NONE, gtkEntryStyle);
}
break;
@ -1282,7 +1284,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
"focus-padding", &focusPad,
"interior-focus", &interiorFocus, NULL);
style = gtkButton->style;
style = d->gtk_widget_get_style(gtkButton);
QRect buttonRect = option->rect;
@ -1343,7 +1345,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
key += QLatin1Char('f');
GTK_WIDGET_SET_FLAGS(gtkCheckButton, GTK_HAS_FOCUS);
}
gtkPainter.paintOption(gtkCheckButton , buttonRect, state, shadow, gtkRadioButton->style, key);
gtkPainter.paintOption(gtkCheckButton , buttonRect, state, shadow, d->gtk_widget_get_style(gtkRadioButton), key);
if (option->state & State_HasFocus)
GTK_WIDGET_UNSET_FLAGS(gtkCheckButton, GTK_HAS_FOCUS);
}
@ -1379,7 +1381,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
QRect checkRect = option->rect.adjusted(spacing, spacing, -spacing, -spacing);
gtkPainter.paintCheckbox(gtkCheckButton, checkRect, state, shadow, gtkCheckButton->style,
gtkPainter.paintCheckbox(gtkCheckButton, checkRect, state, shadow, d->gtk_widget_get_style(gtkCheckButton),
key);
if (option->state & State_HasFocus)
GTK_WIDGET_UNSET_FLAGS(gtkCheckButton, GTK_HAS_FOCUS);
@ -1768,7 +1770,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
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);
GTK_STATE_PRELIGHT, GTK_SHADOW_ETCHED_OUT, d->gtk_widget_get_style(gtkCheckButton));
}
if (!groupBox->text.isEmpty()) {
@ -1781,7 +1783,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
if (option->state & State_Enabled)
labelState = (option->state & State_MouseOver) ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
GdkColor gdkText = gtkCheckButton->style->fg[labelState];
GdkColor gdkText = d->gtk_widget_get_style(gtkCheckButton)->fg[labelState];
textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
painter->setPen(textColor);
QFont font = painter->font();
@ -1862,9 +1864,9 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
// 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);
GtkStyle *gtkEntryStyle = d->gtk_widget_get_style(gtkEntry);
QRect contentRect = frameRect.adjusted(gtkEntryStyle->xthickness, gtkEntryStyle->ythickness,
-gtkEntryStyle->xthickness, -gtkEntryStyle->ythickness);
// Required for inner blue highlight with clearlooks
if (focus)
GTK_WIDGET_SET_FLAGS(gtkEntry, GTK_HAS_FOCUS);
@ -1875,11 +1877,11 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
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));
GTK_SHADOW_NONE, gtkEntryStyle, entryPath.toString() + QString::number(focus));
}
gtkCachedPainter.paintShadow(gtkEntry, comboBox->editable ? "entry" : "frame", frameRect, frameState,
GTK_SHADOW_IN, gtkEntry->style, entryPath.toString() +
GTK_SHADOW_IN, gtkEntryStyle, entryPath.toString() +
QString::number(focus) + QString::number(comboBox->editable) +
QString::number(option->direction));
if (focus)
@ -1897,19 +1899,20 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
Q_ASSERT(gtkToggleButton);
gtkCachedPainter.paintBox( gtkToggleButton, "button", arrowButtonRect, buttonState,
shadow, gtkToggleButton->style, buttonPath.toString() +
shadow, d->gtk_widget_get_style(gtkToggleButton), 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;
GtkStyle *gtkToggleButtonStyle = d->gtk_widget_get_style(gtkToggleButton);
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,
shadow, gtkToggleButtonStyle,
buttonPath.toString() + QString::number(focus));
if (focus)
GTK_WIDGET_UNSET_FLAGS(gtkToggleButton, GTK_HAS_FOCUS);
@ -1926,19 +1929,20 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
QRect vLineRect(allocation.x, allocation.y, allocation.width, allocation.height);
gtkCachedPainter.paintVline( gtkVSeparator, "vseparator",
vLineRect, state, gtkVSeparator->style,
vLineRect, state, d->gtk_widget_get_style(gtkVSeparator),
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;
GtkStyle *gtkToggleButtonStyle = gtkToggleButtonStyle;
int xt = interiorFocus ? gtkToggleButtonStyle->xthickness : 0;
int yt = interiorFocus ? gtkToggleButtonStyle->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);
gtkToggleButtonStyle);
}
}
@ -1978,12 +1982,12 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
GtkAllocation allocation;
d->gtk_widget_get_allocation(gtkArrow, &allocation);
arrowWidgetRect = QRect(allocation.x, allocation.y, allocation.width, allocation.height);
style = gtkArrow->style;
style = d->gtk_widget_get_style(gtkArrow);
}
// 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),
int arrowSize = qMax(qMin(rect.height() - d->gtk_widget_get_style(gtkCombo)->ythickness * 2, minSize),
qMin(arrowWidgetRect.width(), arrowWidgetRect.height()));
QRect arrowRect(0, 0, static_cast<int>(arrowSize * scale), static_cast<int>(arrowSize * scale));
@ -2072,7 +2076,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
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];
GdkColor gdkText = d->gtk_widget_get_style(gtkButton)->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;
@ -2116,7 +2120,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
QRect grooveRect = proxy()->subControlRect(control, scrollBar, SC_ScrollBarGroove, widget);
bool horizontal = scrollBar->orientation == Qt::Horizontal;
GtkWidget * scrollbarWidget = horizontal ? gtkHScrollBar : gtkVScrollBar;
style = scrollbarWidget->style;
style = d->gtk_widget_get_style(scrollbarWidget);
gboolean trough_under_steppers = true;
gboolean trough_side_details = false;
gboolean activate_slider = false;
@ -2338,7 +2342,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
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);
gtkPainter.paintShadow(gtkSpinButton, "entry", editArea, state, GTK_SHADOW_IN, d->gtk_widget_get_style(gtkSpinButton), key);
if (spinBox->buttonSymbols != QAbstractSpinBox::NoButtons) {
gtkPainter.paintBox(gtkSpinButton, "spinbutton", buttonRect, state, GTK_SHADOW_IN, style, key);
@ -2442,7 +2446,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
QGtkStylePrivate::gtk_widget_set_direction(hScaleWidget, slider->upsideDown ?
GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
GtkWidget *scaleWidget = horizontal ? hScaleWidget : vScaleWidget;
style = scaleWidget->style;
style = d->gtk_widget_get_style(scaleWidget);
if ((option->subControls & SC_SliderGroove) && groove.isValid()) {
@ -2645,9 +2649,10 @@ void QGtkStyle::drawControl(ControlElement element,
QRect leftRect;
QRect rect = bar->rect;
GdkColor gdkText = gtkProgressBar->style->fg[GTK_STATE_NORMAL];
GtkStyle *gtkProgressBarStyle = d->gtk_widget_get_style(gtkProgressBar);
GdkColor gdkText = gtkProgressBarStyle->fg[GTK_STATE_NORMAL];
QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
gdkText = gtkProgressBar->style->fg[GTK_STATE_PRELIGHT];
gdkText = gtkProgressBarStyle->fg[GTK_STATE_PRELIGHT];
QColor alternateTextColor= QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
painter->save();
@ -2749,7 +2754,7 @@ void QGtkStyle::drawControl(ControlElement element,
labelState = (option->state & State_MouseOver && !(option->state & State_Sunken)) ?
GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
GdkColor gdkText = gtkButton->style->fg[labelState];
GdkColor gdkText = d->gtk_widget_get_style(gtkButton)->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),
@ -2767,7 +2772,7 @@ void QGtkStyle::drawControl(ControlElement element,
if (option->state & State_MouseOver) {
gtkPainter.paintFlatBox(gtkRadioButton, "checkbutton", option->rect,
GTK_STATE_PRELIGHT, GTK_SHADOW_ETCHED_OUT, gtkRadioButton->style);
GTK_STATE_PRELIGHT, GTK_SHADOW_ETCHED_OUT, d->gtk_widget_get_style(gtkRadioButton));
}
QStyleOptionButton subopt = *btn;
@ -2783,7 +2788,7 @@ void QGtkStyle::drawControl(ControlElement element,
if (option->state & State_Enabled)
labelState = (option->state & State_MouseOver) ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
GdkColor gdkText = gtkRadioButton->style->fg[labelState];
GdkColor gdkText = d->gtk_widget_get_style(gtkRadioButton)->fg[labelState];
QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
pal.setBrush(QPalette::WindowText, textColor);
subopt.palette = pal;
@ -2838,7 +2843,7 @@ void QGtkStyle::drawControl(ControlElement element,
if (option->state & State_Enabled)
labelState = (option->state & State_MouseOver && !appearsAsList) ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
GdkColor gdkText = gtkCombo->style->fg[labelState];
GdkColor gdkText = d->gtk_widget_get_style(gtkCombo)->fg[labelState];
QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
@ -2920,7 +2925,7 @@ void QGtkStyle::drawControl(ControlElement element,
if (option->state & State_Sunken)
shadow = GTK_SHADOW_IN;
gtkPainter.paintBox(gtkTreeHeader, "button", option->rect.adjusted(-1, 0, 0, 0), state, shadow, gtkTreeHeader->style);
gtkPainter.paintBox(gtkTreeHeader, "button", option->rect.adjusted(-1, 0, 0, 0), state, shadow, d->gtk_widget_get_style(gtkTreeHeader));
}
painter->restore();
@ -2930,11 +2935,12 @@ void QGtkStyle::drawControl(ControlElement element,
case CE_SizeGrip: {
GtkWidget *gtkStatusbar = d->gtkWidget("GtkStatusbar.GtkFrame");
QRect gripRect = option->rect.adjusted(0, 0, -gtkStatusbar->style->xthickness, -gtkStatusbar->style->ythickness);
GtkStyle *gtkStatusbarStyle = d->gtk_widget_get_style(gtkStatusbar);
QRect gripRect = option->rect.adjusted(0, 0, -gtkStatusbarStyle->xthickness, -gtkStatusbarStyle->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);
gtkStatusbarStyle);
}
break;
@ -2942,7 +2948,7 @@ void QGtkStyle::drawControl(ControlElement element,
case CE_MenuBarEmptyArea: {
GtkWidget *gtkMenubar = d->gtkWidget("GtkMenuBar");
GdkColor gdkBg = gtkMenubar->style->bg[GTK_STATE_NORMAL]; // Theme can depend on transparency
GdkColor gdkBg = d->gtk_widget_get_style(gtkMenubar)->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();
@ -2953,7 +2959,7 @@ void QGtkStyle::drawControl(ControlElement element,
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);
GTK_STATE_NORMAL, shadow_type, d->gtk_widget_get_style(gtkMenubar));
pmPainter.end();
painter->drawPixmap(option->rect, pixmap, option->rect);
}
@ -2967,7 +2973,7 @@ void QGtkStyle::drawControl(ControlElement element,
GtkWidget *gtkMenubarItem = d->gtkWidget("GtkMenuBar.GtkMenuItem");
GtkWidget *gtkMenubar = d->gtkWidget("GtkMenuBar");
style = gtkMenubarItem->style;
style = d->gtk_widget_get_style(gtkMenubarItem);
if (widget) {
// Since Qt does not currently allow filling the entire background
@ -2981,10 +2987,10 @@ void QGtkStyle::drawControl(ControlElement element,
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
GdkColor gdkBg = d->gtk_widget_get_style(gtkMenubar)->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);
GTK_STATE_NORMAL, shadow_type, d->gtk_widget_get_style(gtkMenubar));
pmPainter.end();
painter->drawPixmap(option->rect, pixmap, option->rect);
}
@ -2993,8 +2999,8 @@ void QGtkStyle::drawControl(ControlElement element,
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];
GdkColor gdkText = style->fg[dis ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL];
GdkColor gdkHText = 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);
@ -3006,7 +3012,7 @@ void QGtkStyle::drawControl(ControlElement element,
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);
GTK_STATE_PRELIGHT, shadowType, style);
//draw text
QPalette::ColorRole textRole = dis ? QPalette::Text : QPalette::HighlightedText;
uint alignment = Qt::AlignCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
@ -3045,7 +3051,7 @@ void QGtkStyle::drawControl(ControlElement element,
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);
GTK_STATE_NORMAL, shadow_type, d->gtk_widget_get_style(gtkToolbar));
}
break;
@ -3080,15 +3086,16 @@ void QGtkStyle::drawControl(ControlElement element,
"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));
GtkStyle *gtkMenuSeparatorStyle = d->gtk_widget_get_style(gtkMenuSeparator);
separatorRect.setHeight(option->rect.height() - 2 * gtkMenuSeparatorStyle->ythickness);
separatorRect.setWidth(option->rect.width() - 2 * (horizontal_padding + gtkMenuSeparatorStyle->xthickness));
separatorRect.moveCenter(option->rect.center());
if (wide_separators)
gtkPainter.paintBox( gtkMenuSeparator, "hseparator",
separatorRect, GTK_STATE_NORMAL, GTK_SHADOW_NONE, gtkMenuSeparator->style);
separatorRect, GTK_STATE_NORMAL, GTK_SHADOW_NONE, gtkMenuSeparatorStyle);
else
gtkPainter.paintHline( gtkMenuSeparator, "hseparator",
separatorRect, GTK_STATE_NORMAL, gtkMenuSeparator->style,
separatorRect, GTK_STATE_NORMAL, gtkMenuSeparatorStyle,
0, option->rect.right() - 1, 1);
painter->restore();
break;
@ -3142,7 +3149,7 @@ void QGtkStyle::drawControl(ControlElement element,
gtkPainter.setClipRect(checkRect.adjusted(-spacing, -spacing, spacing, spacing));
gtkPainter.paintOption(gtkMenuItem, checkRect.translated(-spacing, -spacing), state, shadow,
gtkMenuItem->style, QLS("option"));
style, QLS("option"));
gtkPainter.setClipRect(QRect());
} else {
@ -3158,7 +3165,7 @@ void QGtkStyle::drawControl(ControlElement element,
gtkPainter.setClipRect(checkRect.adjusted(-spacing, -spacing, -spacing, -spacing));
gtkPainter.paintCheckbox(gtkMenuItem, checkRect.translated(-spacing, -spacing), state, shadow,
gtkMenuItem->style, QLS("check"));
style, QLS("check"));
gtkPainter.setClipRect(QRect());
}
}
@ -3221,9 +3228,9 @@ void QGtkStyle::drawControl(ControlElement element,
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];
GdkColor gdkText = style->fg[GTK_STATE_NORMAL];
GdkColor gdkDText = style->fg[GTK_STATE_INSENSITIVE];
GdkColor gdkHText = 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);
@ -3290,7 +3297,7 @@ void QGtkStyle::drawControl(ControlElement element,
if (menuItem->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow
QFontMetrics fm(menuitem->font);
int arrow_size = fm.ascent() + fm.descent() - 2 * gtkMenuItem->style->ythickness;
int arrow_size = fm.ascent() + fm.descent() - 2 * style->ythickness;
gfloat arrow_scaling = 0.8;
int extra = 0;
if (!d->gtk_check_version(2, 16, 0)) {
@ -3298,7 +3305,7 @@ void QGtkStyle::drawControl(ControlElement element,
// 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;
extra = 2 * style->ythickness;
}
int horizontal_padding;
@ -3326,8 +3333,9 @@ void QGtkStyle::drawControl(ControlElement element,
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;
GtkStyle *gtkButtonStyle = d->gtk_widget_get_style(gtkButton);
int xt = interiorFocus ? gtkButtonStyle->xthickness : 0;
int yt = interiorFocus ? gtkButtonStyle->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
@ -3336,7 +3344,7 @@ void QGtkStyle::drawControl(ControlElement element,
gtkPainter.paintFocus(gtkButton, "button",
option->rect.adjusted(xt, yt, -xt, -yt),
btn->state & State_Sunken ? GTK_STATE_ACTIVE : GTK_STATE_NORMAL,
gtkButton->style);
gtkButtonStyle);
proxy()->drawControl(CE_PushButtonLabel, &subopt, painter, widget);
}
@ -3415,7 +3423,7 @@ void QGtkStyle::drawControl(ControlElement element,
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);
gtkPainter.paintBox( gtkProgressBar, "trough", option->rect, state, GTK_SHADOW_IN, d->gtk_widget_get_style(gtkProgressBar));
}
break;
@ -3424,7 +3432,7 @@ void QGtkStyle::drawControl(ControlElement element,
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;
style = d->gtk_widget_get_style(gtkProgressBar);
gtkPainter.paintBox( gtkProgressBar, "trough", option->rect, state, GTK_SHADOW_IN, style);
int xt = style->xthickness;
int yt = style->ythickness;
@ -3621,8 +3629,9 @@ QRect QGtkStyle::subControlRect(ComplexControl control, const QStyleOptionComple
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;
GtkStyle *gtkSpinButtonStyle = d->gtk_widget_get_style(gtkSpinButton);
int xt = spinbox->frame ? gtkSpinButtonStyle->xthickness : 0;
int yt = spinbox->frame ? gtkSpinButtonStyle->ythickness : 0;
int y = yt;
QSize bs;
@ -3786,10 +3795,11 @@ QRect QGtkStyle::subControlRect(ComplexControl control, const QStyleOptionComple
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));
GtkStyle *gtkComboStyle = d->gtk_widget_get_style(gtkCombo);
rect.setRect(option->rect.left() + gtkComboStyle->xthickness + xMargin,
option->rect.top() + gtkComboStyle->ythickness + yMargin,
option->rect.width() - buttonRect.width() - 2*(gtkComboStyle->xthickness + xMargin),
option->rect.height() - 2*(gtkComboStyle->ythickness + yMargin));
rect = visualRect(option->direction, option->rect, rect);
break;
}
@ -3840,7 +3850,8 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
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);
GtkStyle *gtkButtonStyle = d->gtk_widget_get_style(gtkButton);
newSize = size + QSize(2 * gtkButtonStyle->xthickness, 2 + 2 * gtkButtonStyle->ythickness);
if (widget && qobject_cast<QToolBar *>(widget->parentWidget())) {
QSize minSize(0, 25);
if (toolbutton->toolButtonStyle != Qt::ToolButtonTextOnly)
@ -3865,7 +3876,7 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
}
GtkWidget *gtkMenuItem = d->gtkWidget("GtkMenu.GtkCheckMenuItem");
GtkStyle* style = gtkMenuItem->style;
GtkStyle* style = d->gtk_widget_get_style(gtkMenuItem);
// Note we get the perfect height for the default font since we
// set a fake text label on the gtkMenuItem
@ -3882,7 +3893,7 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
break;
case CT_SpinBox:
// QSpinBox does some nasty things that depends on CT_LineEdit
newSize = size + QSize(0, -d->gtkWidget("GtkSpinButton")->style->ythickness * 2);
newSize = size + QSize(0, -d->gtk_widget_get_style(d->gtkWidget("GtkSpinButton"))->ythickness * 2);
break;
case CT_RadioButton:
case CT_CheckBox:
@ -3898,7 +3909,8 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
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);
GtkStyle *gtkButtonStyle = d->gtk_widget_get_style(gtkButton);
newSize += QSize(2*gtkButtonStyle->xthickness + 4, 2*gtkButtonStyle->ythickness);
newSize += QSize(2*(focusWidth + focusPadding + 2), 2*(focusWidth + focusPadding));
GtkWidget *gtkButtonBox = d->gtkWidget("GtkHButtonBox");
@ -3913,11 +3925,13 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
break;
case CT_Slider: {
GtkWidget *gtkSlider = d->gtkWidget("GtkHScale");
newSize = size + QSize(2*gtkSlider->style->xthickness, 2*gtkSlider->style->ythickness); }
GtkStyle *gtkSliderStyle = d->gtk_widget_get_style(gtkSlider);
newSize = size + QSize(2*gtkSliderStyle->xthickness, 2*gtkSliderStyle->ythickness); }
break;
case CT_LineEdit: {
GtkWidget *gtkEntry = d->gtkWidget("GtkEntry");
newSize = size + QSize(2*gtkEntry->style->xthickness, 2 + 2*gtkEntry->style->ythickness); }
GtkStyle *gtkEntryStyle = d->gtk_widget_get_style(gtkEntry);
newSize = size + QSize(2*gtkEntryStyle->xthickness, 2 + 2*gtkEntryStyle->ythickness); }
break;
case CT_ItemViewItem:
newSize += QSize(0, 2);
@ -3926,7 +3940,8 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
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);
GtkStyle *gtkComboStyle = d->gtk_widget_get_style(gtkCombo);
newSize = size + QSize(12 + arrowButtonRect.width() + 2*gtkComboStyle->xthickness, 4 + 2*gtkComboStyle->ythickness);
if (!(widget && qobject_cast<QToolBar *>(widget->parentWidget())))
newSize += QSize(0, 2);

14
src/widgets/styles/qgtkstyle_p.cpp
View File

@ -139,6 +139,7 @@ Ptr_gtk_range_set_adjustment QGtkStylePrivate::gtk_range_set_adjustment = 0;
Ptr_gtk_range_set_inverted QGtkStylePrivate::gtk_range_set_inverted = 0;
Ptr_gtk_icon_factory_lookup_default QGtkStylePrivate::gtk_icon_factory_lookup_default = 0;
Ptr_gtk_icon_theme_get_default QGtkStylePrivate::gtk_icon_theme_get_default = 0;
Ptr_gtk_widget_get_style QGtkStylePrivate::gtk_widget_get_style = 0;
Ptr_gtk_widget_style_get QGtkStylePrivate::gtk_widget_style_get = 0;
Ptr_gtk_icon_set_render_icon QGtkStylePrivate::gtk_icon_set_render_icon = 0;
Ptr_gtk_fixed_new QGtkStylePrivate::gtk_fixed_new = 0;
@ -318,7 +319,7 @@ GtkWidget* QGtkStylePrivate::gtkWidget(const QHashableLatin1Literal &path)
GtkStyle* QGtkStylePrivate::gtkStyle(const QHashableLatin1Literal &path)
{
if (GtkWidget *w = gtkWidgetMap()->value(path))
return w->style;
return QGtkStylePrivate::gtk_widget_get_style(w);
return 0;
}
@ -400,6 +401,7 @@ void QGtkStylePrivate::resolveGtk() const
gtk_container_add = (Ptr_gtk_container_add)libgtk.resolve("gtk_container_add");
gtk_icon_factory_lookup_default = (Ptr_gtk_icon_factory_lookup_default)libgtk.resolve("gtk_icon_factory_lookup_default");
gtk_icon_theme_get_default = (Ptr_gtk_icon_theme_get_default)libgtk.resolve("gtk_icon_theme_get_default");
gtk_widget_get_style = (Ptr_gtk_widget_get_style)libgtk.resolve("gtk_widget_get_style");
gtk_widget_style_get = (Ptr_gtk_widget_style_get)libgtk.resolve("gtk_widget_style_get");
gtk_icon_set_render_icon = (Ptr_gtk_icon_set_render_icon)libgtk.resolve("gtk_icon_set_render_icon");
gtk_fixed_new = (Ptr_gtk_fixed_new)libgtk.resolve("gtk_fixed_new");
@ -708,7 +710,7 @@ int QGtkStylePrivate::getSpinboxArrowSize() const
{
const int MIN_ARROW_WIDTH = 6;
GtkWidget *spinButton = gtkWidget("GtkSpinButton");
GtkStyle *style = spinButton->style;
GtkStyle *style = QGtkStylePrivate::gtk_widget_get_style(spinButton);
gint size = pango_font_description_get_size (style->font_desc);
gint arrow_size;
arrow_size = qMax(PANGO_PIXELS (size), MIN_ARROW_WIDTH) + style->xthickness;
@ -728,7 +730,7 @@ bool QGtkStylePrivate::isKDE4Session()
void QGtkStylePrivate::applyCustomPaletteHash()
{
QPalette menuPal = gtkWidgetPalette("GtkMenu");
GdkColor gdkBg = gtkWidget("GtkMenu")->style->bg[GTK_STATE_NORMAL];
GdkColor gdkBg = QGtkStylePrivate::gtk_widget_get_style(gtkWidget("GtkMenu"))->bg[GTK_STATE_NORMAL];
QColor bgColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8);
menuPal.setBrush(QPalette::Base, bgColor);
menuPal.setBrush(QPalette::Window, bgColor);
@ -803,9 +805,9 @@ QPalette QGtkStylePrivate::gtkWidgetPalette(const QHashableLatin1Literal &gtkWid
GtkWidget *gtkWidget = QGtkStylePrivate::gtkWidget(gtkWidgetName);
Q_ASSERT(gtkWidget);
QPalette pal = QApplication::palette();
GdkColor gdkBg = gtkWidget->style->bg[GTK_STATE_NORMAL];
GdkColor gdkText = gtkWidget->style->fg[GTK_STATE_NORMAL];
GdkColor gdkDisabledText = gtkWidget->style->fg[GTK_STATE_INSENSITIVE];
GdkColor gdkBg = gtk_widget_get_style(gtkWidget)->bg[GTK_STATE_NORMAL];
GdkColor gdkText = gtk_widget_get_style(gtkWidget)->fg[GTK_STATE_NORMAL];
GdkColor gdkDisabledText = gtk_widget_get_style(gtkWidget)->fg[GTK_STATE_INSENSITIVE];
QColor bgColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8);
QColor textColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
QColor disabledTextColor(gdkDisabledText.red>>8, gdkDisabledText.green>>8, gdkDisabledText.blue>>8);

2
src/widgets/styles/qgtkstyle_p.h
View File

@ -181,6 +181,7 @@ typedef void (*Ptr_gtk_range_set_inverted)(GtkRange*, bool);
typedef void (*Ptr_gtk_container_add)(GtkContainer *container, GtkWidget *widget);
typedef GtkIconSet* (*Ptr_gtk_icon_factory_lookup_default) (const gchar*);
typedef GtkIconTheme* (*Ptr_gtk_icon_theme_get_default) (void);
typedef GtkStyle* (*Ptr_gtk_widget_get_style)(GtkWidget *);
typedef void (*Ptr_gtk_widget_style_get)(GtkWidget *, const gchar *first_property_name, ...);
typedef GtkTreeViewColumn* (*Ptr_gtk_tree_view_column_new)(void);
typedef GtkWidget* (*Ptr_gtk_fixed_new)(void);
@ -408,6 +409,7 @@ public:
static Ptr_gtk_range_set_inverted gtk_range_set_inverted;
static Ptr_gtk_icon_factory_lookup_default gtk_icon_factory_lookup_default;
static Ptr_gtk_icon_theme_get_default gtk_icon_theme_get_default;
static Ptr_gtk_widget_get_style gtk_widget_get_style;
static Ptr_gtk_widget_style_get gtk_widget_style_get;
static Ptr_gtk_icon_set_render_icon gtk_icon_set_render_icon;
static Ptr_gtk_fixed_new gtk_fixed_new;