static VALUE
rg_style_get_property(VALUE self, VALUE prop_name)
{
GParamSpec* pspec = NULL;
const char* name;
if (SYMBOL_P(prop_name)) {
name = rb_id2name(SYM2ID(prop_name));
} else {
name = RVAL2CSTR(prop_name);
}
pspec = gtk_widget_class_find_style_property((GtkWidgetClass*)g_type_class_ref(RVAL2GTYPE(self)), name);
if (!pspec)
rb_raise(rb_eval_string("GLib::NoPropertyError"), "No such property: %s", name);
else {
// FIXME: use rb_ensure to call g_value_unset()
GValue gval = G_VALUE_INIT;
VALUE ret;
g_value_init(&gval, G_PARAM_SPEC_VALUE_TYPE(pspec));
gtk_widget_style_get_property(GTK_WIDGET(RVAL2GOBJ(self)), name, &gval);
ret = GVAL2RVAL(&gval);
g_value_unset(&gval);
return ret;
}
}
static VALUE
rg_s_style_property(VALUE self, VALUE property_name)
{
GtkWidgetClass* oclass;
const char* name;
GParamSpec* prop;
VALUE result;
if (SYMBOL_P(property_name)) {
name = rb_id2name(SYM2ID(property_name));
} else {
name = RVAL2CSTR(property_name);
}
oclass = (GtkWidgetClass*)g_type_class_ref(CLASS2GTYPE(self));
prop = gtk_widget_class_find_style_property(oclass, name);
if (!prop){
g_type_class_unref(oclass);
rb_raise(rb_eval_string("GLib::NoPropertyError"), "no such property: %s", name);
}
result = GOBJ2RVAL(prop);
g_type_class_unref(oclass);
return result;
}
CAMLprim value ml_gtk_widget_style_get_property (value w, value n)
{
CAMLparam2 (w, n);
CAMLlocal1 (ret);
GtkWidget *widget = GtkWidget_val (w);
gchar *name = String_val (n);
GParamSpec * pspec;
pspec = gtk_widget_class_find_style_property
(GTK_WIDGET_GET_CLASS (widget), name);
if (pspec) {
value ret = ml_g_value_new ();
GValue *gv = GValueptr_val (ret);
g_value_init (gv, G_PARAM_SPEC_VALUE_TYPE (pspec));
gtk_widget_style_get_property (widget, name, gv);
} else {
invalid_argument("Gobject.Widget.style_get_property");
}
CAMLreturn (ret);
}
static void
draw_expander (GtkStyle *style,
cairo_t *cr,
GtkStateType state,
GtkWidget *widget,
const gchar *detail,
gint x,
gint y,
GtkExpanderStyle expander_style)
{
#define DEFAULT_EXPANDER_SIZE 12
ThemeMatchData match_data;
gint expander_size;
gint radius;
if (widget &&
gtk_widget_class_find_style_property (GTK_WIDGET_GET_CLASS (widget),
"expander-size"))
{
gtk_widget_style_get (widget,
"expander-size", &expander_size,
NULL);
}
else
expander_size = DEFAULT_EXPANDER_SIZE;
radius = expander_size/2;
match_data.function = TOKEN_D_EXPANDER;
match_data.detail = (gchar *)detail;
match_data.flags = (THEME_MATCH_STATE |
THEME_MATCH_EXPANDER_STYLE);
match_data.state = state;
match_data.expander_style = expander_style;
if (!draw_simple_image (style, cr, widget, &match_data, TRUE, TRUE,
x - radius, y - radius, expander_size, expander_size))
parent_class->draw_expander (style, cr, state, widget, detail,
x, y, expander_style);
}
/*
* Returns a style property if it exists and if it is a long. If not, 0 is returned.
* Its a dirty hack. The proper way would be using gtk_style_get() which is only
* available with Gtk+ >= 2.16
*/
static glong
get_style_property_long (GtkStyle *style,
GType widget_type,
const gchar *property_name)
{
GtkRcProperty *rcprop = NULL;
GtkWidgetClass *klass = g_type_class_ref (widget_type);
GParamSpec *pspec = gtk_widget_class_find_style_property (klass, property_name);
/* Style must be rc style */
g_return_val_if_fail(style->rc_style != NULL, 0);
if (!pspec) {
g_printerr("WARN: get_style_property_long: Property '%s' not found\n", property_name);
return 0;
}
if (style->rc_style->rc_properties) {
GtkRcProperty key;
key.type_name = g_type_qname(widget_type);
key.property_name = g_quark_from_string(pspec->name);
/* Search all properties for given key */
rcprop = bsearch (&key, style->rc_style->rc_properties->data, style->rc_style->rc_properties->len,
sizeof(GtkRcProperty), gtk_rc_properties_cmp);
}
if (rcprop == NULL) {
g_printerr("WARN: get_style_property_long: RcProperty '%s' not found\n", property_name);
return 0;
}
if (G_VALUE_HOLDS_LONG(&(rcprop->value))) {
return g_value_get_long(&(rcprop->value));
} else {
g_printerr("WARN: get_style_property_long: Property '%s' is not a long\n", property_name);
return 0;
}
}
static gboolean
draw_simple_image (GtkStyle *style,
GdkWindow *window,
GdkRectangle *area,
GtkWidget *widget,
ThemeMatchData *match_data,
gboolean draw_center,
gint x,
gint y,
gint width,
gint height)
{
gboolean maemo_position_theming;
ThemeImage *image;
if ((width == -1) && (height == -1))
gdk_drawable_get_size (window, &width, &height);
else if (width == -1)
gdk_drawable_get_size (window, &width, NULL);
else if (height == -1)
gdk_drawable_get_size (window, NULL, &height);
if (!(match_data->flags & THEME_MATCH_ORIENTATION))
{
match_data->flags |= THEME_MATCH_ORIENTATION;
if (height > width)
match_data->orientation = GTK_ORIENTATION_VERTICAL;
else
match_data->orientation = GTK_ORIENTATION_HORIZONTAL;
}
/* Check for maemo-position-theming to update the position data */
if (widget && widget->parent &&
gtk_widget_class_find_style_property (GTK_WIDGET_GET_CLASS (widget->parent),
"maemo-position-theming"))
{
gtk_widget_style_get (widget->parent,
"maemo-position-theming", &maemo_position_theming,
NULL);
if (maemo_position_theming)
{
if (GTK_IS_BUTTON_BOX (widget->parent))
check_buttonbox_child_position (widget, match_data);
else
{
/* Generic code for other kinds of containers */
GList *children;
children = gtk_container_get_children (GTK_CONTAINER (widget->parent));
check_child_position (widget, children, match_data);
g_list_free (children);
}
}
}
image = match_theme_image (style, match_data);
if (image)
{
if (image->background)
{
GdkWindow *maskwin;
GdkBitmap *mask = NULL;
gboolean valid;
maskwin = get_window_for_shape (image, window, widget, x, y, width, height);
if (maskwin)
mask = gdk_pixmap_new (maskwin, width, height, 1);
valid = theme_pixbuf_render (image->background, G_OBJECT_TYPE (widget),
window, mask, area,
draw_center ? COMPONENT_ALL : COMPONENT_ALL | COMPONENT_CENTER,
FALSE,
x, y, width, height);
if (mask)
{
if (valid)
gdk_window_shape_combine_mask (maskwin, mask, 0, 0);
g_object_unref (mask);
}
}
if (image->overlay && draw_center)
theme_pixbuf_render (image->overlay, G_OBJECT_TYPE (widget),
window, NULL, area, COMPONENT_ALL,
TRUE,
x, y, width, height);
return TRUE;
}
else
return FALSE;
}
void
nsLookAndFeel::InitLookAndFeel()
{
GtkStyle *style;
// tooltip foreground and background
style = gtk_rc_get_style_by_paths(gtk_settings_get_default(),
"gtk-tooltips", "GtkWindow",
GTK_TYPE_WINDOW);
if (style) {
sInfoBackground = GDK_COLOR_TO_NS_RGB(style->bg[GTK_STATE_NORMAL]);
sInfoText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_NORMAL]);
}
// menu foreground & menu background
GtkWidget *accel_label = gtk_accel_label_new("M");
GtkWidget *menuitem = gtk_menu_item_new();
GtkWidget *menu = gtk_menu_new();
g_object_ref_sink(menu);
gtk_container_add(GTK_CONTAINER(menuitem), accel_label);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_set_style(accel_label, NULL);
gtk_widget_set_style(menu, NULL);
gtk_widget_realize(menu);
gtk_widget_realize(accel_label);
style = gtk_widget_get_style(accel_label);
if (style) {
sMenuText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_NORMAL]);
}
style = gtk_widget_get_style(menu);
if (style) {
sMenuBackground = GDK_COLOR_TO_NS_RGB(style->bg[GTK_STATE_NORMAL]);
}
style = gtk_widget_get_style(menuitem);
if (style) {
sMenuHover = GDK_COLOR_TO_NS_RGB(style->bg[GTK_STATE_PRELIGHT]);
sMenuHoverText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_PRELIGHT]);
}
g_object_unref(menu);
// button styles
GtkWidget *parent = gtk_fixed_new();
GtkWidget *button = gtk_button_new();
GtkWidget *label = gtk_label_new("M");
GtkWidget *combobox = gtk_combo_box_new();
GtkWidget *comboboxLabel = gtk_label_new("M");
GtkWidget *window = gtk_window_new(GTK_WINDOW_POPUP);
GtkWidget *treeView = gtk_tree_view_new();
GtkWidget *linkButton = gtk_link_button_new("http://example.com/");
GtkWidget *menuBar = gtk_menu_bar_new();
GtkWidget *entry = gtk_entry_new();
gtk_container_add(GTK_CONTAINER(button), label);
gtk_container_add(GTK_CONTAINER(combobox), comboboxLabel);
gtk_container_add(GTK_CONTAINER(parent), button);
gtk_container_add(GTK_CONTAINER(parent), treeView);
gtk_container_add(GTK_CONTAINER(parent), linkButton);
gtk_container_add(GTK_CONTAINER(parent), combobox);
gtk_container_add(GTK_CONTAINER(parent), menuBar);
gtk_container_add(GTK_CONTAINER(window), parent);
gtk_container_add(GTK_CONTAINER(parent), entry);
gtk_widget_set_style(button, NULL);
gtk_widget_set_style(label, NULL);
gtk_widget_set_style(treeView, NULL);
gtk_widget_set_style(linkButton, NULL);
gtk_widget_set_style(combobox, NULL);
gtk_widget_set_style(comboboxLabel, NULL);
gtk_widget_set_style(menuBar, NULL);
gtk_widget_set_style(entry, NULL);
gtk_widget_realize(button);
gtk_widget_realize(label);
gtk_widget_realize(treeView);
gtk_widget_realize(linkButton);
gtk_widget_realize(combobox);
gtk_widget_realize(comboboxLabel);
gtk_widget_realize(menuBar);
gtk_widget_realize(entry);
style = gtk_widget_get_style(label);
if (style) {
sButtonText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_NORMAL]);
}
style = gtk_widget_get_style(comboboxLabel);
if (style) {
sComboBoxText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_NORMAL]);
}
style = gtk_widget_get_style(combobox);
if (style) {
sComboBoxBackground = GDK_COLOR_TO_NS_RGB(style->bg[GTK_STATE_NORMAL]);
}
style = gtk_widget_get_style(menuBar);
if (style) {
sMenuBarText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_NORMAL]);
sMenuBarHoverText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_SELECTED]);
}
// Some themes have a unified menu bar, and support window dragging on it
gboolean supports_menubar_drag = FALSE;
GParamSpec *param_spec =
gtk_widget_class_find_style_property(GTK_WIDGET_GET_CLASS(menuBar),
"window-dragging");
if (param_spec) {
if (g_type_is_a(G_PARAM_SPEC_VALUE_TYPE(param_spec), G_TYPE_BOOLEAN)) {
gtk_widget_style_get(menuBar,
"window-dragging", &supports_menubar_drag,
NULL);
}
}
sMenuSupportsDrag = supports_menubar_drag;
// GTK's guide to fancy odd row background colors:
// 1) Check if a theme explicitly defines an odd row color
// 2) If not, check if it defines an even row color, and darken it
// slightly by a hardcoded value (gtkstyle.c)
// 3) If neither are defined, take the base background color and
// darken that by a hardcoded value
GdkColor colorValue;
GdkColor *colorValuePtr = NULL;
gtk_widget_style_get(treeView,
"odd-row-color", &colorValuePtr,
NULL);
if (colorValuePtr) {
colorValue = *colorValuePtr;
} else {
gtk_widget_style_get(treeView,
"even-row-color", &colorValuePtr,
NULL);
if (colorValuePtr)
darken_gdk_color(colorValuePtr, &colorValue);
else
darken_gdk_color(&treeView->style->base[GTK_STATE_NORMAL], &colorValue);
}
sOddCellBackground = GDK_COLOR_TO_NS_RGB(colorValue);
if (colorValuePtr)
gdk_color_free(colorValuePtr);
style = gtk_widget_get_style(button);
if (style) {
sButtonBackground = GDK_COLOR_TO_NS_RGB(style->bg[GTK_STATE_NORMAL]);
sButtonOuterLightBorder =
GDK_COLOR_TO_NS_RGB(style->light[GTK_STATE_NORMAL]);
sButtonInnerDarkBorder =
GDK_COLOR_TO_NS_RGB(style->dark[GTK_STATE_NORMAL]);
}
colorValuePtr = NULL;
gtk_widget_style_get(linkButton, "link-color", &colorValuePtr, NULL);
if (colorValuePtr) {
colorValue = *colorValuePtr; // we can't pass deref pointers to GDK_COLOR_TO_NS_RGB
sNativeHyperLinkText = GDK_COLOR_TO_NS_RGB(colorValue);
gdk_color_free(colorValuePtr);
} else {
sNativeHyperLinkText = NS_RGB(0x00,0x00,0xEE);
}
// invisible character styles
guint value;
g_object_get (entry, "invisible-char", &value, NULL);
sInvisibleCharacter = PRUnichar(value);
// caret styles
gtk_widget_style_get(entry,
"cursor-aspect-ratio", &sCaretRatio,
NULL);
gtk_widget_destroy(window);
}
