static void
gtk_finalize_color_instance (struct Lisp_Color_Instance *c)
{
if (c->data)
{
if (DEVICE_LIVE_P (XDEVICE (c->device)))
{
if (COLOR_INSTANCE_GTK_DEALLOC (c))
{
gdk_colormap_free_colors (DEVICE_GTK_COLORMAP (XDEVICE (c->device)),
COLOR_INSTANCE_GTK_COLOR (c), 1);
}
gdk_color_free (COLOR_INSTANCE_GTK_COLOR (c));
}
xfree (c->data);
c->data = 0;
}
}
wxColour wxHyperlinkCtrl::GetVisitedColour() const
{
wxColour ret;
if ( UseNative() )
{
GdkColor *link_color = NULL;
// convert GdkColor in wxColour
gtk_widget_style_get(m_widget, "visited-link-color", &link_color, NULL);
if (link_color)
ret = wxColour(*link_color);
gdk_color_free (link_color);
}
else
return wxGenericHyperlinkCtrl::GetVisitedColour();
return ret;
}
static void
on_color_button_color_set (WarlockColorButton *widget, gpointer user_data)
{
GdkColor *color;
char *key;
Preference pref;
debug ("color button color set\n");
color = warlock_color_button_get_color (widget);
pref = GPOINTER_TO_INT (user_data);
key = preferences_get_key (pref);
preferences_set_color (key, color);
g_free (key);
if (color != NULL) {
gdk_color_free (color);
}
}
void
prefs_set_color_gdk (Prefs *p, Color which, GdkColor *color)
{
gboolean changed = FALSE;
if (p->color[which]) {
changed = !gdk_color_equal (color, p->color[which]);
gdk_color_free (p->color[which]);
}
p->color[which] = gdk_color_copy (color);
if (changed) {
gchar *spec;
spec = prefs_colors_to_csvstr (p);
gconf_client_set_string (p->gconf_client, PREF_CARD_COLORS, spec, NULL);
g_free (spec);
}
}
/**
* gtk_text_attributes_unref:
* @values: a #GtkTextAttributes
*
* Decrements the reference count on @values, freeing the structure
* if the reference count reaches 0.
**/
void
gtk_text_attributes_unref (GtkTextAttributes *values)
{
g_return_if_fail (values != NULL);
g_return_if_fail (values->refcount > 0);
values->refcount -= 1;
if (values->refcount == 0)
{
if (values->tabs)
pango_tab_array_free (values->tabs);
if (values->font)
pango_font_description_free (values->font);
if (values->pg_bg_color)
gdk_color_free (values->pg_bg_color);
g_free (values);
}
}
/**
* gtk_text_attributes_unref:
* @values: a #GtkTextAttributes
*
* Decrements the reference count on @values, freeing the structure
* if the reference count reaches 0.
**/
void
gtk_text_attributes_unref (GtkTextAttributes *values)
{
g_return_if_fail (values != NULL);
g_return_if_fail (values->refcount > 0);
values->refcount -= 1;
if (values->refcount == 0)
{
if (values->tabs)
pango_tab_array_free (values->tabs);
if (values->font)
pango_font_description_free (values->font);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (values->pg_bg_color)
gdk_color_free (values->pg_bg_color);
G_GNUC_END_IGNORE_DEPRECATIONS
if (values->pg_bg_rgba)
gdk_rgba_free (values->pg_bg_rgba);
if (values->appearance.rgba[0])
gdk_rgba_free (values->appearance.rgba[0]);
if (values->appearance.rgba[1])
gdk_rgba_free (values->appearance.rgba[1]);
if (values->font_features)
g_free (values->font_features);
g_slice_free (GtkTextAttributes, values);
}
}
static PurpleTheme *
pidgin_blist_loader_build(const gchar *dir)
{
xmlnode *root_node = NULL, *sub_node, *sub_sub_node;
gchar *filename_full, *data = NULL;
const gchar *temp, *name;
gboolean success = TRUE;
GdkColor *bgcolor, *expanded_bgcolor, *collapsed_bgcolor, *contact_color;
PidginThemeFont *expanded, *collapsed, *contact, *online, *away, *offline, *idle, *message, *message_nick_said, *status;
PidginBlistLayout layout;
PidginBlistTheme *theme;
int i;
struct {
const char *tag;
PidginThemeFont **font;
} lookups[] = {
{"contact_text", &contact},
{"online_text", &online},
{"away_text", &away},
{"offline_text", &offline},
{"idle_text", &idle},
{"message_text", &message},
{"message_nick_said_text", &message_nick_said},
{"status_text", &status},
{NULL, NULL}
};
bgcolor = expanded_bgcolor = collapsed_bgcolor = contact_color = NULL;
expanded = NULL;
collapsed = NULL;
contact = NULL;
online = NULL;
away = NULL;
offline = NULL;
idle = NULL;
message = NULL;
message_nick_said = NULL;
status = NULL;
/* Find the theme file */
g_return_val_if_fail(dir != NULL, NULL);
filename_full = g_build_filename(dir, "theme.xml", NULL);
if (g_file_test(filename_full, G_FILE_TEST_IS_REGULAR))
root_node = xmlnode_from_file(dir, "theme.xml", "buddy list themes", "blist-loader");
g_free(filename_full);
if (root_node == NULL)
return NULL;
sub_node = xmlnode_get_child(root_node, "description");
data = xmlnode_get_data(sub_node);
name = xmlnode_get_attrib(root_node, "name");
/* <blist> */
success = name && purple_strequal(xmlnode_get_attrib(root_node, "type"), "pidgin buddy list");
if (!success)
purple_debug_warning("gtkblist-theme-loader", "Missing attribute or problem with the root element\n");
if (success) {
if ((success = (sub_node = xmlnode_get_child(root_node, "blist")) != NULL))
bgcolor = parse_color(sub_node, "color");
else
purple_debug_warning("gtkblist-theme-loader", "Missing or problem with tags: <blist>.\n");
}
/* <groups> */
if (success) {
if ((success = (sub_node = xmlnode_get_child(root_node, "groups")) != NULL
&& (sub_sub_node = xmlnode_get_child(sub_node, "expanded")) != NULL)) {
expanded = pidgin_theme_font_parse(sub_sub_node);
expanded_bgcolor = parse_color(sub_sub_node, "background");
} else
purple_debug_warning("gtkblist-theme-loader", "Missing or problem with tags: <groups> <expanded>.\n");
}
if (success) {
if ((success = sub_node != NULL && (sub_sub_node = xmlnode_get_child(sub_node, "collapsed")) != NULL)) {
collapsed = pidgin_theme_font_parse(sub_sub_node);
collapsed_bgcolor = parse_color(sub_sub_node, "background");
} else
purple_debug_warning("gtkblist-theme-loader", "Missing or problem with tags: <groups> <collapsed>.\n");
}
/* <buddys> */
if (success) {
if ((success = (sub_node = xmlnode_get_child(root_node, "buddys")) != NULL &&
(sub_sub_node = xmlnode_get_child(sub_node, "placement")) != NULL)) {
layout.status_icon = (temp = xmlnode_get_attrib(sub_sub_node, "status_icon")) != NULL ? atoi(temp) : 0;
layout.text = (temp = xmlnode_get_attrib(sub_sub_node, "name")) != NULL ? atoi(temp) : 1;
layout.emblem = (temp = xmlnode_get_attrib(sub_sub_node, "emblem")) != NULL ? atoi(temp) : 2;
layout.protocol_icon = (temp = xmlnode_get_attrib(sub_sub_node, "protocol_icon")) != NULL ? atoi(temp) : 3;
layout.buddy_icon = (temp = xmlnode_get_attrib(sub_sub_node, "buddy_icon")) != NULL ? atoi(temp) : 4;
layout.show_status = (temp = xmlnode_get_attrib(sub_sub_node, "status_icon")) != NULL ? atoi(temp) != 0 : 1;
} else purple_debug_warning("gtkblist-theme-loader", "Missing or problem with tags: <buddys> <placement>.\n");
}
if (success) {
if ((success = (sub_node != NULL && (sub_sub_node = xmlnode_get_child(sub_node, "background")) != NULL)))
contact_color = parse_color(sub_sub_node, "color");
else
purple_debug_warning("gtkblist-theme-loader", "Missing or problem with tags: <buddys> <background>.\n");
}
for (i = 0; success && lookups[i].tag; i++) {
if ((success = (sub_node != NULL &&
(sub_sub_node = xmlnode_get_child(sub_node, lookups[i].tag)) != NULL))) {
*(lookups[i].font) = pidgin_theme_font_parse(sub_sub_node);
} else {
*(lookups[i].font) = NULL;
}
}
/* name is required for theme manager */
success = (success && xmlnode_get_attrib(root_node, "name") != NULL);
/* the new theme */
theme = g_object_new(PIDGIN_TYPE_BLIST_THEME,
"type", "blist",
"name", name,
"author", xmlnode_get_attrib(root_node, "author"),
"image", xmlnode_get_attrib(root_node, "image"),
"directory", dir,
"description", data,
"background-color", bgcolor,
"layout", &layout,
"expanded-color", expanded_bgcolor,
"expanded-text", expanded,
"collapsed-color", collapsed_bgcolor,
"collapsed-text", collapsed,
"contact-color", contact_color,
"contact", contact,
"online", online,
"away", away,
"offline", offline,
"idle", idle,
"message", message,
"message_nick_said", message_nick_said,
"status", status, NULL);
for (i = 0; lookups[i].tag; i++) {
if (*lookups[i].font) {
pidgin_theme_font_free(*lookups[i].font);
}
}
pidgin_theme_font_free(expanded);
pidgin_theme_font_free(collapsed);
xmlnode_free(root_node);
g_free(data);
/* malformed xml file - also frees all partial data*/
if (!success) {
g_object_unref(theme);
theme = NULL;
}
if (bgcolor)
gdk_color_free(bgcolor);
if (expanded_bgcolor)
gdk_color_free(expanded_bgcolor);
if (collapsed_bgcolor)
gdk_color_free(collapsed_bgcolor);
if (contact_color)
gdk_color_free(contact_color);
return PURPLE_THEME(theme);
}
static void
run_add_edit_dialog (LogviewFilterManager *manager, LogviewFilter *filter)
{
GError *error;
gchar *name, *regex;
const gchar *title;
GtkWidget *dialog, *entry_name, *entry_regex, *radio_color;
GtkWidget *radio_visible, *check_foreground, *check_background;
GtkWidget *color_foreground, *color_background, *vbox_color;
gboolean foreground_set, background_set, invisible;
GtkTextTag *tag;
GtkBuilder* builder;
builder = manager->priv->builder;
error = NULL;
name = NULL;
gtk_builder_add_from_file (builder, UI_FILE, &error);
if (error) {
g_warning ("Could not load filter ui: %s", error->message);
g_error_free (error);
return;
}
title = (filter != NULL ? _("Edit filter") : _("Add new filter"));
dialog = GTK_WIDGET (gtk_builder_get_object (builder,
"dialog_filter"));
entry_name = GTK_WIDGET (gtk_builder_get_object (builder,
"entry_name"));
entry_regex = GTK_WIDGET (gtk_builder_get_object (builder,
"entry_regex"));
radio_color = GTK_WIDGET (gtk_builder_get_object (builder,
"radio_color"));
radio_visible = GTK_WIDGET (gtk_builder_get_object (builder,
"radio_visible"));
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio_color),
gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_visible)));
check_foreground = GTK_WIDGET (gtk_builder_get_object (builder,
"check_foreground"));
check_background = GTK_WIDGET (gtk_builder_get_object (builder,
"check_background"));
color_foreground = GTK_WIDGET (gtk_builder_get_object (builder,
"color_foreground"));
color_background = GTK_WIDGET (gtk_builder_get_object (builder,
"color_background"));
g_signal_connect (check_foreground, "toggled", G_CALLBACK (on_check_toggled),
color_foreground);
g_signal_connect (check_background, "toggled", G_CALLBACK (on_check_toggled),
color_background);
on_check_toggled (GTK_TOGGLE_BUTTON (check_foreground),
color_foreground);
on_check_toggled (GTK_TOGGLE_BUTTON (check_background),
color_background);
vbox_color = GTK_WIDGET (gtk_builder_get_object (builder, "vbox_color"));
g_signal_connect (radio_color, "toggled", G_CALLBACK (on_check_toggled),
vbox_color);
on_check_toggled (GTK_TOGGLE_BUTTON (radio_color),
vbox_color);
if (filter) {
g_object_get (filter,
"name", &name,
"regex", ®ex,
"texttag", &tag,
NULL);
g_object_get (tag,
"foreground-set", &foreground_set,
"paragraph-background-set", &background_set,
"invisible", &invisible, NULL);
gtk_entry_set_text (GTK_ENTRY(entry_name), name);
gtk_entry_set_text (GTK_ENTRY(entry_regex), regex);
if (foreground_set) {
GdkColor *foreground;
g_object_get (tag, "foreground-gdk", &foreground, NULL);
gtk_color_button_set_color (GTK_COLOR_BUTTON (color_foreground),
foreground);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_foreground),
TRUE);
gdk_color_free (foreground);
}
if (background_set) {
GdkColor *background;
g_object_get (tag, "paragraph-background-gdk", &background, NULL);
gtk_color_button_set_color (GTK_COLOR_BUTTON (color_background),
background);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_background),
TRUE);
gdk_color_free (background);
}
if (background_set || foreground_set) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_color), TRUE);
} else if (invisible) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_visible), TRUE);
}
g_free (regex);
g_object_unref (tag);
}
g_object_set_data_full (G_OBJECT (manager), "old_name", name, g_free);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (on_dialog_add_edit_reponse), manager);
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (manager));
gtk_window_set_modal (GTK_WINDOW (dialog),
TRUE);
gtk_widget_show (GTK_WIDGET (dialog));
}
static void
save_filter_foreach_func (gpointer key, gpointer value, gpointer user_data)
{
GPtrArray *filters;
const gchar *name;
LogviewFilter *filter;
GdkColor *foreground;
gboolean foreground_set;
GdkColor *background;
gboolean background_set;
gchar *regex, *color;
gboolean invisible;
GtkTextTag *tag;
GString *prefs_string;
filters = user_data;
filter = LOGVIEW_FILTER (value);
name = key;
color = NULL;
prefs_string = g_string_new (name);
g_string_append (prefs_string, DELIMITER);
g_object_get (filter,
"regex", ®ex,
"texttag", &tag,
NULL);
g_object_get (tag,
"foreground-gdk", &foreground,
"paragraph-background-gdk", &background,
"foreground-set", &foreground_set,
"paragraph-background-set", &background_set,
"invisible", &invisible, NULL);
if (invisible) {
g_string_append (prefs_string, "1" DELIMITER);
} else {
g_string_append (prefs_string, "0" DELIMITER);
}
if (foreground_set) {
color = gdk_color_to_string (foreground);
g_string_append (prefs_string, color);
g_free (color);
}
if (foreground) {
gdk_color_free (foreground);
}
g_string_append (prefs_string, DELIMITER);
if (background_set) {
color = gdk_color_to_string (background);
g_string_append (prefs_string, color);
g_free (color);
}
if (background) {
gdk_color_free (background);
}
g_string_append (prefs_string, DELIMITER);
g_string_append (prefs_string, regex);
g_free (regex);
g_object_unref (tag);
g_ptr_array_add (filters, g_string_free (prefs_string, FALSE));
}
static void
nemo_cell_renderer_disk_render (GtkCellRenderer *cell,
cairo_t *cr,
GtkWidget *widget,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
NemoCellRendererDisk *cellprogress = NEMO_CELL_RENDERER_DISK (cell);
gint x, y, w;
gint xpad, ypad;
gint full;
gboolean show = cellprogress->show_disk_full_percent;
GtkStyleContext *context;
if (show) {
context = gtk_widget_get_style_context (widget);
GdkColor *gdk_bg_color, *gdk_fg_color;
GdkRGBA bg_color, fg_color;
gint bar_width, bar_radius, bottom_padding, max_length;
gtk_style_context_get_style (context,
"disk-full-bg-color", &gdk_bg_color,
"disk-full-fg-color", &gdk_fg_color,
"disk-full-bar-width", &bar_width,
"disk-full-bar-radius", &bar_radius,
"disk-full-bottom-padding", &bottom_padding,
"disk-full-max-length", &max_length,
NULL);
if (gdk_bg_color) {
convert_color (gdk_bg_color, &bg_color);
gdk_color_free (gdk_bg_color);
} else {
use_default_color (&bg_color);
}
if (gdk_fg_color) {
convert_color (gdk_fg_color, &fg_color);
gdk_color_free (gdk_fg_color);
} else {
use_default_color (&fg_color);
}
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
x = cell_area->x + xpad;
y = cell_area->y + cell_area->height - bar_width - bottom_padding;
w = cell_area->width - xpad * 2;
w = w < max_length ? w : max_length;
full = (int) (((float) cellprogress->disk_full_percent / 100.0) * (float) w);
gtk_style_context_save (context);
cairo_save (cr);
gdk_cairo_set_source_rgba (cr, &bg_color);
cairo_rectangle_with_radius_corners (cr, x, y, w, bar_width, bar_radius);
cairo_fill (cr);
cairo_restore (cr);
cairo_save (cr);
gdk_cairo_set_source_rgba (cr, &fg_color);
cairo_rectangle_with_radius_corners (cr, x, y, full, bar_width, bar_radius);
cairo_fill (cr);
cairo_restore (cr);
gtk_style_context_restore (context);
}
GTK_CELL_RENDERER_CLASS (parent_class)->render (cell,
cr,
widget,
background_area,
cell_area,
flags);
}
void
_gtk_text_attributes_fill_from_tags (GtkTextAttributes *dest,
GtkTextTag** tags,
guint n_tags)
{
guint n = 0;
guint left_margin_accumulative = 0;
guint right_margin_accumulative = 0;
while (n < n_tags)
{
GtkTextTag *tag = tags[n];
GtkTextAttributes *vals = tag->priv->values;
g_assert (tag->priv->table != NULL);
if (n > 0)
g_assert (tags[n]->priv->priority > tags[n-1]->priv->priority);
if (tag->priv->bg_color_set)
{
if (dest->appearance.rgba[0])
{
gdk_rgba_free (dest->appearance.rgba[0]);
dest->appearance.rgba[0] = NULL;
}
if (vals->appearance.rgba[0])
dest->appearance.rgba[0] = gdk_rgba_copy (vals->appearance.rgba[0]);
dest->appearance.draw_bg = TRUE;
}
if (tag->priv->fg_color_set)
{
if (dest->appearance.rgba[1])
{
gdk_rgba_free (dest->appearance.rgba[1]);
dest->appearance.rgba[1] = NULL;
}
if (vals->appearance.rgba[1])
dest->appearance.rgba[1] = gdk_rgba_copy (vals->appearance.rgba[1]);
}
if (tag->priv->pg_bg_color_set)
{
if (dest->pg_bg_rgba)
{
gdk_rgba_free (dest->pg_bg_rgba);
dest->pg_bg_rgba = NULL;
}
if (dest->pg_bg_color)
{
gdk_color_free (dest->pg_bg_color);
dest->pg_bg_color = NULL;
}
if (vals->pg_bg_rgba)
dest->pg_bg_rgba = gdk_rgba_copy (vals->pg_bg_rgba);
if (vals->pg_bg_color)
dest->pg_bg_color = gdk_color_copy (vals->pg_bg_color);
}
if (vals->font)
{
if (dest->font)
pango_font_description_merge (dest->font, vals->font, TRUE);
else
dest->font = pango_font_description_copy (vals->font);
}
/* multiply all the scales together to get a composite */
if (tag->priv->scale_set)
dest->font_scale *= vals->font_scale;
if (tag->priv->justification_set)
dest->justification = vals->justification;
if (vals->direction != GTK_TEXT_DIR_NONE)
dest->direction = vals->direction;
if (tag->priv->left_margin_set)
{
if (tag->priv->accumulative_margin)
left_margin_accumulative += vals->left_margin;
else
dest->left_margin = vals->left_margin;
}
if (tag->priv->indent_set)
dest->indent = vals->indent;
if (tag->priv->rise_set)
dest->appearance.rise = vals->appearance.rise;
if (tag->priv->right_margin_set)
{
if (tag->priv->accumulative_margin)
right_margin_accumulative += vals->right_margin;
else
dest->right_margin = vals->right_margin;
}
if (tag->priv->pixels_above_lines_set)
dest->pixels_above_lines = vals->pixels_above_lines;
if (tag->priv->pixels_below_lines_set)
dest->pixels_below_lines = vals->pixels_below_lines;
if (tag->priv->pixels_inside_wrap_set)
dest->pixels_inside_wrap = vals->pixels_inside_wrap;
if (tag->priv->tabs_set)
{
if (dest->tabs)
pango_tab_array_free (dest->tabs);
dest->tabs = pango_tab_array_copy (vals->tabs);
}
if (tag->priv->wrap_mode_set)
dest->wrap_mode = vals->wrap_mode;
if (tag->priv->underline_set)
dest->appearance.underline = vals->appearance.underline;
if (tag->priv->strikethrough_set)
dest->appearance.strikethrough = vals->appearance.strikethrough;
if (tag->priv->invisible_set)
dest->invisible = vals->invisible;
if (tag->priv->editable_set)
dest->editable = vals->editable;
if (tag->priv->bg_full_height_set)
dest->bg_full_height = vals->bg_full_height;
if (tag->priv->language_set)
dest->language = vals->language;
++n;
}
dest->left_margin += left_margin_accumulative;
dest->right_margin += right_margin_accumulative;
}
static PangoAttrList*
hildon_font_selection_dialog_create_attrlist (HildonFontSelectionDialog *fontsel,
guint start_index,
guint len)
{
PangoAttrList *list;
PangoAttribute *attr;
gint size, position;
gboolean family_set, size_set, color_set, bold, bold_set,
italic, italic_set, underline, underline_set,
strikethrough, strikethrough_set, position_set;
GdkColor *color = NULL;
gchar *family = NULL;
gdouble font_scaling = 1.0;
list = pango_attr_list_new ();
g_object_get (G_OBJECT (fontsel),
"family", &family, "family-set", &family_set,
"size", &size, "size-set", &size_set,
"color", &color, "color-set", &color_set,
"bold", &bold, "bold-set", &bold_set,
"italic", &italic, "italic-set", &italic_set,
"underline", &underline, "underline-set", &underline_set,
"strikethrough", &strikethrough, "strikethrough-set",
&strikethrough_set, "position", &position,
"position-set", &position_set,
"font-scaling", &font_scaling,
NULL);
/* family */
if (family_set)
{
attr = pango_attr_family_new (family);
add_preview_text_attr (list, attr, start_index, len);
}
g_free (family);
/* size */
if (size_set)
{
attr = pango_attr_size_new (size * PANGO_SCALE);
add_preview_text_attr (list, attr, start_index, len);
}
/*color*/
if (color_set)
{
attr = pango_attr_foreground_new (color->red, color->green, color->blue);
add_preview_text_attr (list, attr, start_index, len);
}
if (color != NULL)
gdk_color_free (color);
/*weight*/
if (bold_set)
{
if (bold)
attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
else
attr = pango_attr_weight_new (PANGO_WEIGHT_NORMAL);
add_preview_text_attr(list, attr, start_index, len);
}
/* style */
if (italic_set)
{
if (italic)
attr = pango_attr_style_new (PANGO_STYLE_ITALIC);
else
attr = pango_attr_style_new (PANGO_STYLE_NORMAL);
add_preview_text_attr(list, attr, start_index, len);
}
/* underline */
if (underline_set)
{
if (underline)
attr = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE);
else
attr = pango_attr_underline_new (PANGO_UNDERLINE_NONE);
add_preview_text_attr(list, attr, start_index, len);
}
/* strikethrough */
if (strikethrough_set)
{
if (strikethrough)
attr = pango_attr_strikethrough_new (TRUE);
else
attr = pango_attr_strikethrough_new (FALSE);
add_preview_text_attr(list, attr, start_index, len);
}
/* position */
if (position_set)
{
switch (position)
{
case 1: /*super*/
attr = pango_attr_rise_new (SUPERSCRIPT_RISE);
break;
case -1: /*sub*/
attr = pango_attr_rise_new (SUBSCRIPT_LOW);
break;
default: /*normal*/
attr = pango_attr_rise_new (0);
break;
}
add_preview_text_attr (list, attr, start_index, len);
}
/* font scaling for preview */
if (font_scaling)
{
attr = pango_attr_scale_new(font_scaling);
add_preview_text_attr(list, attr, 0, len + start_index);
}
return list;
}
void
_gtk_text_attributes_fill_from_tags (GtkTextAttributes *dest,
GtkTextTag** tags,
guint n_tags)
{
guint n = 0;
guint left_margin_accumulative = 0;
guint right_margin_accumulative = 0;
while (n < n_tags)
{
GtkTextTag *tag = tags[n];
GtkTextAttributes *vals = tag->priv->values;
g_assert (tag->priv->table != NULL);
if (n > 0)
g_assert (tags[n]->priv->priority > tags[n-1]->priv->priority);
if (tag->priv->bg_color_set)
{
if (dest->appearance.rgba[0])
{
gdk_rgba_free (dest->appearance.rgba[0]);
dest->appearance.rgba[0] = NULL;
}
if (vals->appearance.rgba[0])
dest->appearance.rgba[0] = gdk_rgba_copy (vals->appearance.rgba[0]);
dest->appearance.draw_bg = TRUE;
}
if (tag->priv->fg_color_set)
{
if (dest->appearance.rgba[1])
{
gdk_rgba_free (dest->appearance.rgba[1]);
dest->appearance.rgba[1] = NULL;
}
if (vals->appearance.rgba[1])
dest->appearance.rgba[1] = gdk_rgba_copy (vals->appearance.rgba[1]);
}
if (tag->priv->pg_bg_color_set)
{
if (dest->pg_bg_rgba)
{
gdk_rgba_free (dest->pg_bg_rgba);
dest->pg_bg_rgba = NULL;
}
if (dest->pg_bg_color)
{
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gdk_color_free (dest->pg_bg_color);
dest->pg_bg_color = NULL;
G_GNUC_END_IGNORE_DEPRECATIONS
}
if (vals->pg_bg_rgba)
dest->pg_bg_rgba = gdk_rgba_copy (vals->pg_bg_rgba);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (vals->pg_bg_color)
dest->pg_bg_color = gdk_color_copy (vals->pg_bg_color);
G_GNUC_END_IGNORE_DEPRECATIONS
}
if (vals->font)
{
if (dest->font)
pango_font_description_merge (dest->font, vals->font, TRUE);
else
dest->font = pango_font_description_copy (vals->font);
}
/* multiply all the scales together to get a composite */
if (tag->priv->scale_set)
dest->font_scale *= vals->font_scale;
if (tag->priv->justification_set)
dest->justification = vals->justification;
if (vals->direction != GTK_TEXT_DIR_NONE)
dest->direction = vals->direction;
if (tag->priv->left_margin_set)
{
if (tag->priv->accumulative_margin)
left_margin_accumulative += vals->left_margin;
else
dest->left_margin = vals->left_margin;
}
if (tag->priv->indent_set)
dest->indent = vals->indent;
if (tag->priv->rise_set)
dest->appearance.rise = vals->appearance.rise;
if (tag->priv->right_margin_set)
{
if (tag->priv->accumulative_margin)
right_margin_accumulative += vals->right_margin;
else
dest->right_margin = vals->right_margin;
}
if (tag->priv->pixels_above_lines_set)
dest->pixels_above_lines = vals->pixels_above_lines;
if (tag->priv->pixels_below_lines_set)
dest->pixels_below_lines = vals->pixels_below_lines;
if (tag->priv->pixels_inside_wrap_set)
dest->pixels_inside_wrap = vals->pixels_inside_wrap;
if (tag->priv->tabs_set)
{
if (dest->tabs)
pango_tab_array_free (dest->tabs);
dest->tabs = pango_tab_array_copy (vals->tabs);
}
if (tag->priv->wrap_mode_set)
dest->wrap_mode = vals->wrap_mode;
if (tag->priv->underline_set)
dest->appearance.underline = vals->appearance.underline;
if (GTK_TEXT_APPEARANCE_GET_UNDERLINE_RGBA_SET (&vals->appearance))
{
GdkRGBA rgba;
GTK_TEXT_APPEARANCE_GET_UNDERLINE_RGBA (&vals->appearance, &rgba);
GTK_TEXT_APPEARANCE_SET_UNDERLINE_RGBA (&dest->appearance, &rgba);
GTK_TEXT_APPEARANCE_SET_UNDERLINE_RGBA_SET (&dest->appearance, TRUE);
}
if (tag->priv->strikethrough_set)
dest->appearance.strikethrough = vals->appearance.strikethrough;
if (GTK_TEXT_APPEARANCE_GET_STRIKETHROUGH_RGBA_SET (&vals->appearance))
{
GdkRGBA rgba;
GTK_TEXT_APPEARANCE_GET_STRIKETHROUGH_RGBA (&vals->appearance, &rgba);
GTK_TEXT_APPEARANCE_SET_STRIKETHROUGH_RGBA (&dest->appearance, &rgba);
GTK_TEXT_APPEARANCE_SET_STRIKETHROUGH_RGBA_SET (&dest->appearance, TRUE);
}
if (tag->priv->invisible_set)
dest->invisible = vals->invisible;
if (tag->priv->editable_set)
dest->editable = vals->editable;
if (tag->priv->bg_full_height_set)
dest->bg_full_height = vals->bg_full_height;
if (tag->priv->language_set)
dest->language = vals->language;
if (tag->priv->fallback_set)
dest->no_fallback = vals->no_fallback;
if (tag->priv->letter_spacing_set)
dest->letter_spacing = vals->letter_spacing;
if (tag->priv->font_features_set)
dest->font_features = g_strdup (vals->font_features);
++n;
}
/**
* gtk_text_attributes_copy_values:
* @src: a #GtkTextAttributes
* @dest: another #GtkTextAttributes
*
* Copies the values from @src to @dest so that @dest has
* the same values as @src. Frees existing values in @dest.
*/
void
gtk_text_attributes_copy_values (GtkTextAttributes *src,
GtkTextAttributes *dest)
{
guint orig_refcount;
if (src == dest)
return;
/* Remove refs */
if (dest->tabs)
pango_tab_array_free (dest->tabs);
if (dest->font)
pango_font_description_free (dest->font);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (dest->pg_bg_color)
gdk_color_free (dest->pg_bg_color);
G_GNUC_END_IGNORE_DEPRECATIONS
if (dest->pg_bg_rgba)
gdk_rgba_free (dest->pg_bg_rgba);
if (dest->appearance.rgba[0])
gdk_rgba_free (dest->appearance.rgba[0]);
if (dest->appearance.rgba[1])
gdk_rgba_free (dest->appearance.rgba[1]);
if (dest->font_features)
g_free (dest->font_features);
/* Copy */
orig_refcount = dest->refcount;
*dest = *src;
if (src->tabs)
dest->tabs = pango_tab_array_copy (src->tabs);
dest->language = src->language;
if (src->font)
dest->font = pango_font_description_copy (src->font);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (src->pg_bg_color)
dest->pg_bg_color = gdk_color_copy (src->pg_bg_color);
G_GNUC_END_IGNORE_DEPRECATIONS
if (src->pg_bg_rgba)
dest->pg_bg_rgba = gdk_rgba_copy (src->pg_bg_rgba);
if (src->appearance.rgba[0])
dest->appearance.rgba[0] = gdk_rgba_copy (src->appearance.rgba[0]);
if (src->appearance.rgba[1])
dest->appearance.rgba[1] = gdk_rgba_copy (src->appearance.rgba[1]);
if (src->font_features)
dest->font_features = g_strdup (src->font_features);
dest->refcount = orig_refcount;
}
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);
}
static void
theme_boxes_maybe_append_header (EmpathyThemeBoxes *theme,
EmpathyMessage *msg)
{
EmpathyChatTextView *view = EMPATHY_CHAT_TEXT_VIEW (theme);
EmpathyThemeBoxesPriv*priv = GET_PRIV (theme);
EmpathyContact *contact;
EmpathyContact *last_contact;
GdkPixbuf *avatar = NULL;
GtkTextBuffer *buffer;
const gchar *name;
GtkTextIter iter;
GtkWidget *label1, *label2;
GtkTextChildAnchor *anchor;
GtkWidget *box;
gchar *str;
time_t time_;
gchar *tmp;
GtkTextIter start;
gboolean color_set;
GtkTextTagTable *table;
GtkTextTag *tag;
GString *str_obj;
gboolean consecutive;
contact = empathy_message_get_sender (msg);
name = empathy_contact_get_alias (contact);
last_contact = empathy_chat_text_view_get_last_contact (view);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (theme));
time_ = empathy_message_get_timestamp (msg);
consecutive = (time_ - empathy_chat_text_view_get_last_timestamp (view)
< MESSAGE_JOIN_PERIOD);
DEBUG ("Maybe add fancy header");
/* Only insert a header if
* - the previously inserted block is not the same as this one.
* - the delay between two messages is lower then MESSAGE_JOIN_PERIOD
*/
if (empathy_contact_equal (last_contact, contact) && consecutive) {
return;
}
empathy_chat_text_view_append_spacing (view);
/* Insert header line */
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name (buffer,
&iter,
"\n",
-1,
EMPATHY_THEME_BOXES_TAG_HEADER_LINE,
NULL);
gtk_text_buffer_get_end_iter (buffer, &iter);
anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);
/* Create a hbox for the header and resize it when the view allocation
* changes */
box = gtk_hbox_new (FALSE, 0);
g_signal_connect_object (view, "size-allocate",
G_CALLBACK (table_size_allocate_cb),
box, 0);
/* Add avatar to the box if needed */
if (priv->show_avatars) {
avatar = theme_boxes_get_avatar_pixbuf_with_cache (contact);
if (avatar) {
GtkWidget *image;
image = gtk_image_new_from_pixbuf (avatar);
gtk_box_pack_start (GTK_BOX (box), image,
FALSE, TRUE, 2);
}
}
/* Add contact alias */
str = g_markup_printf_escaped ("<b>%s</b>", name);
label1 = g_object_new (GTK_TYPE_LABEL,
"label", str,
"use-markup", TRUE,
"xalign", 0.0,
NULL);
g_free (str);
/* Add the message receive time */
tmp = empathy_time_to_string_local (time_,
EMPATHY_TIME_FORMAT_DISPLAY_SHORT);
str = g_strdup_printf ("<i>%s</i>", tmp);
label2 = g_object_new (GTK_TYPE_LABEL,
"label", str,
"use-markup", TRUE,
"xalign", 1.0,
NULL);
str_obj = g_string_new ("\n- ");
g_string_append (str_obj, name);
g_string_append (str_obj, ", ");
g_string_append (str_obj, tmp);
g_string_append (str_obj, " -");
g_free (tmp);
g_free (str);
/* Set foreground color of labels to the same color than the header tag. */
table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (table, EMPATHY_THEME_BOXES_TAG_HEADER);
g_object_get (tag, "foreground-set", &color_set, NULL);
if (color_set) {
GdkColor *color;
g_object_get (tag, "foreground-gdk", &color, NULL);
gtk_widget_modify_fg (label1, GTK_STATE_NORMAL, color);
gtk_widget_modify_fg (label2, GTK_STATE_NORMAL, color);
gdk_color_free (color);
}
/* Pack labels into the box */
gtk_misc_set_alignment (GTK_MISC (label1), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label2), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (box), label1, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), label2, TRUE, TRUE, 0);
/* Add the header box to the text view */
g_object_set_data_full (G_OBJECT (box),
"str_obj",
g_string_free (str_obj, FALSE),
g_free);
gtk_text_view_add_child_at_anchor (GTK_TEXT_VIEW (view),
box,
anchor);
gtk_widget_show_all (box);
/* Insert a header line */
gtk_text_buffer_get_end_iter (buffer, &iter);
start = iter;
gtk_text_iter_backward_char (&start);
gtk_text_buffer_apply_tag_by_name (buffer,
EMPATHY_THEME_BOXES_TAG_HEADER,
&start, &iter);
gtk_text_buffer_insert_with_tags_by_name (buffer,
&iter,
"\n",
-1,
EMPATHY_THEME_BOXES_TAG_HEADER,
NULL);
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name (buffer,
&iter,
"\n",
-1,
EMPATHY_THEME_BOXES_TAG_HEADER_LINE,
NULL);
}
/**
* gtk_ellipsis_set_label_widget:
* @ellipsis: a #GtkEllipsis
* @label: the new label widget
*
* Set the label widget for the ellipsis. This is the widget
* that will appear embedded alongside the ellipsis arrow.
*
* Since: 2.4
**/
void
gtk_ellipsis_set_label_widget (GtkEllipsis *ellipsis,
GtkWidget *label)
{
GtkEllipsisPrivate *priv;
g_return_if_fail (GTK_IS_ELLIPSIS (ellipsis));
g_return_if_fail (label == NULL || GTK_IS_WIDGET (label));
g_return_if_fail (label == NULL || label->parent == NULL);
priv = ellipsis->priv;
if (priv->label == label)
return;
if (priv->label)
{
gtk_widget_set_state (priv->label, GTK_STATE_NORMAL);
gtk_widget_unparent (priv->label);
}
priv->label = label;
if (label)
{
gfloat xalign, yalign;
gtk_misc_get_alignment (>K_LABEL (label)->misc, &xalign, &yalign);
gtk_misc_set_alignment (>K_LABEL (label)->misc, 0.0, yalign);
gtk_widget_set_parent (label, GTK_WIDGET (ellipsis));
if (!priv->ellipsis_label)
{
GdkColor *link_color, active_bg_color;
GtkWidget *child;
PangoAttrList *attrs;
PangoAttribute *uline;
child = gtk_label_new ("...");
/* Change the foreground color for all states but selected. */
gtk_widget_style_get (GTK_WIDGET (child),
"link-color", &link_color, NULL);
if (!link_color)
{
GtkStyle *style = gtk_widget_get_style (child);
active_bg_color = style->bg[GTK_STATE_SELECTED];
link_color = &active_bg_color;
}
gtk_widget_modify_fg (child, GTK_STATE_NORMAL, link_color);
gtk_widget_modify_fg (child, GTK_STATE_ACTIVE, link_color);
gtk_widget_modify_fg (child, GTK_STATE_PRELIGHT, link_color);
if (link_color != &active_bg_color)
gdk_color_free (link_color);
/* Add an underline. */
attrs = gtk_label_get_attributes (GTK_LABEL (label));
attrs = attrs ? pango_attr_list_copy (attrs) : pango_attr_list_new ();
uline = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE);
uline->start_index = 0;
uline->end_index = G_MAXUINT;
pango_attr_list_insert (attrs, uline);
gtk_label_set_attributes (GTK_LABEL (child), attrs);
pango_attr_list_unref (attrs);
gtk_widget_show (child);
gtk_widget_set_parent (child, GTK_WIDGET (ellipsis));
priv->ellipsis_label = child;
}
if (priv->prelight)
{
gtk_widget_set_state (label, GTK_STATE_PRELIGHT);
gtk_widget_set_state (priv->ellipsis_label, GTK_STATE_PRELIGHT);
}
}
else
{
if (priv->ellipsis_label)
{
gtk_widget_destroy (priv->ellipsis_label);
priv->ellipsis_label = NULL;
}
}
if (GTK_WIDGET_VISIBLE (ellipsis))
gtk_widget_queue_resize (GTK_WIDGET (ellipsis));
g_object_freeze_notify (G_OBJECT (ellipsis));
g_object_notify (G_OBJECT (ellipsis), "label-widget");
g_object_notify (G_OBJECT (ellipsis), "label");
g_object_thaw_notify (G_OBJECT (ellipsis));
}
