/**
* thunar_pango_attr_list_italic:
*
* Returns a #PangoAttrList for rendering italic text.
* The returned list is owned by the callee and must
* not be freed or modified by the caller.
*
* Return value: a #PangoAttrList for rendering italic text.
**/
PangoAttrList*
thunar_pango_attr_list_italic (void)
{
static PangoAttrList *attr_list = NULL;
if (G_UNLIKELY (attr_list == NULL))
attr_list = thunar_pango_attr_list_wrap (pango_attr_style_new (PANGO_STYLE_ITALIC), NULL);
return attr_list;
}
static gboolean
i_parse_func (MarkupData *md,
OpenTag *tag,
const gchar **names,
const gchar **values,
GMarkupParseContext *context,
GError **error)
{
CHECK_NO_ATTRS("i");
add_attribute (tag, pango_attr_style_new (PANGO_STYLE_ITALIC));
return TRUE;
}
/* This function is used by gtk_text_cell_accessible_get_offset_at_point()
* and gtk_text_cell_accessible_get_character_extents(). There is no
* cached PangoLayout so we must create a temporary one using this function.
*/
static PangoLayout *
create_pango_layout (GtkTextCellAccessible *text)
{
GdkRGBA *foreground_rgba;
PangoAttrList *attr_list, *attributes;
PangoLayout *layout;
PangoUnderline uline, underline;
PangoFontMask mask;
PangoFontDescription *font_desc;
gboolean foreground_set, strikethrough_set, strikethrough;
gboolean scale_set, underline_set, rise_set;
gchar *renderer_text;
gdouble scale;
gint rise;
GtkRendererCellAccessible *gail_renderer;
GtkCellRendererText *gtk_renderer;
gail_renderer = GTK_RENDERER_CELL_ACCESSIBLE (text);
gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);
g_object_get (gtk_renderer,
"text", &renderer_text,
"attributes", &attributes,
"foreground-set", &foreground_set,
"foreground-rgba", &foreground_rgba,
"strikethrough-set", &strikethrough_set,
"strikethrough", &strikethrough,
"font-desc", &font_desc,
"scale-set", &scale_set,
"scale", &scale,
"underline-set", &underline_set,
"underline", &underline,
"rise-set", &rise_set,
"rise", &rise,
NULL);
layout = gtk_widget_create_pango_layout (get_widget (text), renderer_text);
if (attributes)
attr_list = pango_attr_list_copy (attributes);
else
attr_list = pango_attr_list_new ();
if (foreground_set)
{
add_attr (attr_list, pango_attr_foreground_new (foreground_rgba->red * 65535,
foreground_rgba->green * 65535,
foreground_rgba->blue * 65535));
}
if (strikethrough_set)
add_attr (attr_list,
pango_attr_strikethrough_new (strikethrough));
mask = pango_font_description_get_set_fields (font_desc);
if (mask & PANGO_FONT_MASK_FAMILY)
add_attr (attr_list,
pango_attr_family_new (pango_font_description_get_family (font_desc)));
if (mask & PANGO_FONT_MASK_STYLE)
add_attr (attr_list, pango_attr_style_new (pango_font_description_get_style (font_desc)));
if (mask & PANGO_FONT_MASK_VARIANT)
add_attr (attr_list, pango_attr_variant_new (pango_font_description_get_variant (font_desc)));
if (mask & PANGO_FONT_MASK_WEIGHT)
add_attr (attr_list, pango_attr_weight_new (pango_font_description_get_weight (font_desc)));
if (mask & PANGO_FONT_MASK_STRETCH)
add_attr (attr_list, pango_attr_stretch_new (pango_font_description_get_stretch (font_desc)));
if (mask & PANGO_FONT_MASK_SIZE)
add_attr (attr_list, pango_attr_size_new (pango_font_description_get_size (font_desc)));
if (scale_set && scale != 1.0)
add_attr (attr_list, pango_attr_scale_new (scale));
if (underline_set)
uline = underline;
else
uline = PANGO_UNDERLINE_NONE;
if (uline != PANGO_UNDERLINE_NONE)
add_attr (attr_list,
pango_attr_underline_new (underline));
if (rise_set)
add_attr (attr_list, pango_attr_rise_new (rise));
pango_layout_set_attributes (layout, attr_list);
pango_layout_set_width (layout, -1);
pango_attr_list_unref (attr_list);
pango_font_description_free (font_desc);
pango_attr_list_unref (attributes);
g_free (renderer_text);
gdk_rgba_free (foreground_rgba);
return layout;
}
static void
mail_config_sendmail_backend_insert_widgets (EMailConfigServiceBackend *backend,
GtkBox *parent)
{
CamelSettings *settings;
GtkLabel *label;
GtkWidget *widget;
GtkWidget *container;
GtkWidget *use_custom_binary_check;
GtkWidget *custom_binary_entry;
GtkWidget *use_custom_args_check;
GtkWidget *custom_args_entry;
GtkWidget *send_in_offline;
gchar *markup;
PangoAttribute *attr;
PangoAttrList *attr_list;
settings = e_mail_config_service_backend_get_settings (backend);
markup = g_markup_printf_escaped ("<b>%s</b>", _("Configuration"));
widget = gtk_label_new (markup);
gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (parent), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
g_free (markup);
widget = gtk_grid_new ();
gtk_widget_set_margin_left (widget, 12);
gtk_grid_set_row_spacing (GTK_GRID (widget), 6);
gtk_grid_set_column_spacing (GTK_GRID (widget), 6);
gtk_box_pack_start (GTK_BOX (parent), widget, FALSE, FALSE, 0);
container = widget;
widget = gtk_check_button_new_with_mnemonic (_("_Use custom binary, instead of 'sendmail'"));
gtk_grid_attach (GTK_GRID (container), widget, 0, 0, 2, 1);
use_custom_binary_check = widget;
widget = gtk_label_new_with_mnemonic (_("_Custom binary:"));
gtk_widget_set_margin_left (widget, 12);
gtk_grid_attach (GTK_GRID (container), widget, 0, 1, 1, 1);
label = GTK_LABEL (widget);
widget = gtk_entry_new ();
gtk_label_set_mnemonic_widget (label, widget);
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (widget, TRUE);
gtk_grid_attach (GTK_GRID (container), widget, 1, 1, 1, 1);
custom_binary_entry = widget;
e_binding_bind_property (
use_custom_binary_check, "active",
label, "sensitive",
G_BINDING_SYNC_CREATE);
widget = gtk_check_button_new_with_mnemonic (_("U_se custom arguments"));
gtk_grid_attach (GTK_GRID (container), widget, 0, 2, 2, 1);
use_custom_args_check = widget;
widget = gtk_label_new_with_mnemonic (_("Cus_tom arguments:"));
gtk_widget_set_margin_left (widget, 12);
gtk_grid_attach (GTK_GRID (container), widget, 0, 3, 1, 1);
label = GTK_LABEL (widget);
widget = gtk_entry_new ();
gtk_label_set_mnemonic_widget (label, widget);
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (widget, TRUE);
gtk_grid_attach (GTK_GRID (container), widget, 1, 3, 1, 1);
custom_args_entry = widget;
e_binding_bind_property (
use_custom_args_check, "active",
label, "sensitive",
G_BINDING_SYNC_CREATE);
widget = gtk_label_new (_(
"Default arguments are '-i -f %F -- %R', where\n"
" %F - stands for the From address\n"
" %R - stands for the recipient addresses"));
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (widget, TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
gtk_label_set_selectable (GTK_LABEL (widget), TRUE);
gtk_grid_attach (GTK_GRID (container), widget, 1, 4, 1, 1);
attr_list = pango_attr_list_new ();
attr = pango_attr_style_new (PANGO_STYLE_ITALIC);
pango_attr_list_insert (attr_list, attr);
gtk_label_set_attributes (GTK_LABEL (widget), attr_list);
pango_attr_list_unref (attr_list);
widget = gtk_check_button_new_with_mnemonic (_("Send mail also when in offline _mode"));
gtk_grid_attach (GTK_GRID (container), widget, 0, 5, 2, 1);
send_in_offline = widget;
e_binding_bind_property (
use_custom_binary_check, "active",
custom_binary_entry, "sensitive",
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
settings, "use-custom-binary",
use_custom_binary_check, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_object_text_property (
settings, "custom-binary",
custom_binary_entry, "text",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
use_custom_args_check, "active",
custom_args_entry, "sensitive",
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
settings, "use-custom-args",
use_custom_args_check, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_object_text_property (
settings, "custom-args",
custom_args_entry, "text",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
settings, "send-in-offline",
send_in_offline, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
gtk_widget_show_all (container);
}
/**
* gimp_label_set_attributes:
* @label: a #GtkLabel
* @...: a list of PangoAttrType and value pairs terminated by -1.
*
* Sets Pango attributes on a #GtkLabel in a more convenient way than
* gtk_label_set_attributes().
*
* This function is useful if you want to change the font attributes
* of a #GtkLabel. This is an alternative to using PangoMarkup which
* is slow to parse and akward to handle in an i18n-friendly way.
*
* The attributes are set on the complete label, from start to end. If
* you need to set attributes on part of the label, you will have to
* use the PangoAttributes API directly.
*
* Since: 2.2
**/
void
gimp_label_set_attributes (GtkLabel *label,
...)
{
PangoAttribute *attr = NULL;
PangoAttrList *attrs;
va_list args;
g_return_if_fail (GTK_IS_LABEL (label));
attrs = pango_attr_list_new ();
va_start (args, label);
do
{
PangoAttrType attr_type = va_arg (args, PangoAttrType);
if (attr_type == -1)
attr_type = PANGO_ATTR_INVALID;
switch (attr_type)
{
case PANGO_ATTR_LANGUAGE:
attr = pango_attr_language_new (va_arg (args, PangoLanguage *));
break;
case PANGO_ATTR_FAMILY:
attr = pango_attr_family_new (va_arg (args, const gchar *));
break;
case PANGO_ATTR_STYLE:
attr = pango_attr_style_new (va_arg (args, PangoStyle));
break;
case PANGO_ATTR_WEIGHT:
attr = pango_attr_weight_new (va_arg (args, PangoWeight));
break;
case PANGO_ATTR_VARIANT:
attr = pango_attr_variant_new (va_arg (args, PangoVariant));
break;
case PANGO_ATTR_STRETCH:
attr = pango_attr_stretch_new (va_arg (args, PangoStretch));
break;
case PANGO_ATTR_SIZE:
attr = pango_attr_size_new (va_arg (args, gint));
break;
case PANGO_ATTR_FONT_DESC:
attr = pango_attr_font_desc_new (va_arg (args,
const PangoFontDescription *));
break;
case PANGO_ATTR_FOREGROUND:
{
const PangoColor *color = va_arg (args, const PangoColor *);
attr = pango_attr_foreground_new (color->red,
color->green,
color->blue);
}
break;
case PANGO_ATTR_BACKGROUND:
{
const PangoColor *color = va_arg (args, const PangoColor *);
attr = pango_attr_background_new (color->red,
color->green,
color->blue);
}
break;
case PANGO_ATTR_UNDERLINE:
attr = pango_attr_underline_new (va_arg (args, PangoUnderline));
break;
case PANGO_ATTR_STRIKETHROUGH:
attr = pango_attr_strikethrough_new (va_arg (args, gboolean));
break;
case PANGO_ATTR_RISE:
attr = pango_attr_rise_new (va_arg (args, gint));
break;
case PANGO_ATTR_SCALE:
attr = pango_attr_scale_new (va_arg (args, gdouble));
break;
default:
g_warning ("%s: invalid PangoAttribute type %d",
G_STRFUNC, attr_type);
case PANGO_ATTR_INVALID:
attr = NULL;
break;
}
if (attr)
{
attr->start_index = 0;
attr->end_index = -1;
pango_attr_list_insert (attrs, attr);
}
}
while (attr);
va_end (args);
gtk_label_set_attributes (label, attrs);
pango_attr_list_unref (attrs);
}
/*
* This function is used by gail_text_cell_get_offset_at_point()
* and gail_text_cell_get_character_extents(). There is no
* cached PangoLayout for gailtextcell so we must create a temporary
* one using this function.
*/
static PangoLayout*
create_pango_layout(GtkCellRendererText *gtk_renderer,
GtkWidget *widget)
{
PangoAttrList *attr_list;
PangoLayout *layout;
PangoUnderline uline;
PangoFontMask mask;
layout = gtk_widget_create_pango_layout (widget, gtk_renderer->text);
if (gtk_renderer->extra_attrs)
attr_list = pango_attr_list_copy (gtk_renderer->extra_attrs);
else
attr_list = pango_attr_list_new ();
if (gtk_renderer->foreground_set)
{
PangoColor color;
color = gtk_renderer->foreground;
add_attr (attr_list, pango_attr_foreground_new (color.red,
color.green, color.blue));
}
if (gtk_renderer->strikethrough_set)
add_attr (attr_list,
pango_attr_strikethrough_new (gtk_renderer->strikethrough));
mask = pango_font_description_get_set_fields (gtk_renderer->font);
if (mask & PANGO_FONT_MASK_FAMILY)
add_attr (attr_list,
pango_attr_family_new (pango_font_description_get_family (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_STYLE)
add_attr (attr_list, pango_attr_style_new (pango_font_description_get_style (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_VARIANT)
add_attr (attr_list, pango_attr_variant_new (pango_font_description_get_variant (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_WEIGHT)
add_attr (attr_list, pango_attr_weight_new (pango_font_description_get_weight (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_STRETCH)
add_attr (attr_list, pango_attr_stretch_new (pango_font_description_get_stretch (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_SIZE)
add_attr (attr_list, pango_attr_size_new (pango_font_description_get_size (gtk_renderer->font)));
if (gtk_renderer->scale_set &&
gtk_renderer->font_scale != 1.0)
add_attr (attr_list, pango_attr_scale_new (gtk_renderer->font_scale));
if (gtk_renderer->underline_set)
uline = gtk_renderer->underline_style;
else
uline = PANGO_UNDERLINE_NONE;
if (uline != PANGO_UNDERLINE_NONE)
add_attr (attr_list,
pango_attr_underline_new (gtk_renderer->underline_style));
if (gtk_renderer->rise_set)
add_attr (attr_list, pango_attr_rise_new (gtk_renderer->rise));
pango_layout_set_attributes (layout, attr_list);
pango_layout_set_width (layout, -1);
pango_attr_list_unref (attr_list);
return layout;
}
static void draw_page(GtkPrintOperation *operation, GtkPrintContext *context,
gint page_nr, gpointer user_data)
{
DocInfo *dinfo = user_data;
GeanyEditor *editor;
cairo_t *cr;
gdouble width, height;
gdouble x = 0.0, y = 0.0;
/*gint layout_h;*/
gint count;
GString *str;
if (dinfo == NULL || page_nr >= dinfo->n_pages)
return;
editor = dinfo->doc->editor;
if (dinfo->n_pages > 0)
{
gdouble fraction = (page_nr + 1) / (gdouble) dinfo->n_pages;
gchar *text = g_strdup_printf(_("Page %d of %d"), page_nr, dinfo->n_pages);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(main_widgets.progressbar), fraction);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(main_widgets.progressbar), text);
g_free(text);
}
#ifdef GEANY_PRINT_DEBUG
geany_debug("draw_page = %d, pages = %d, (real) lines_per_page = %d",
page_nr, dinfo->n_pages, dinfo->lines_per_page);
#endif
str = g_string_sized_new(256);
cr = gtk_print_context_get_cairo_context(context);
width = gtk_print_context_get_width(context);
height = gtk_print_context_get_height(context);
cairo_set_source_rgb(cr, 0, 0, 0);
#ifdef GEANY_PRINT_DEBUG
cairo_set_line_width(cr, 0.2);
cairo_rectangle(cr, 0, 0, width, height);
cairo_stroke(cr);
#endif
cairo_move_to(cr, 0, 0);
pango_layout_set_width(dinfo->layout, width * PANGO_SCALE);
pango_layout_set_alignment(dinfo->layout, PANGO_ALIGN_LEFT);
pango_layout_set_ellipsize(dinfo->layout, FALSE);
pango_layout_set_justify(dinfo->layout, FALSE);
if (printing_prefs.print_page_header)
add_page_header(dinfo, cr, width, page_nr);
count = 0; /* the actual line counter for the current page, might be different from
* dinfo->cur_line due to possible line breaks */
while (count < dinfo->lines_per_page)
{
gchar c = 'a';
gint style = -1;
PangoAttrList *layout_attr;
PangoAttribute *attr;
gint colours[3] = { 0 };
gboolean add_linenumber = TRUE;
gboolean at_eol;
while (count < dinfo->lines_per_page && c != '\0')
{
at_eol = FALSE;
g_string_erase(str, 0, str->len); /* clear the string */
/* line numbers */
if (printing_prefs.print_line_numbers && add_linenumber)
{
/* if we had a wrapped line on the last page which needs to be continued, don't
* add a line number */
if (dinfo->long_line)
{
add_linenumber = FALSE;
}
else
{
gchar *line_number = NULL;
gint cur_line_number_margin = get_line_numbers_arity(dinfo->cur_line + 1);
gchar *fill = g_strnfill(
dinfo->max_line_number_margin - cur_line_number_margin - 1, ' ');
line_number = g_strdup_printf("%s%d ", fill, dinfo->cur_line + 1);
g_string_append(str, line_number);
dinfo->cur_line++; /* increase document line */
add_linenumber = FALSE;
style = STYLE_LINENUMBER;
c = 'a'; /* dummy value */
g_free(fill);
g_free(line_number);
}
}
/* data */
else
{
style = sci_get_style_at(dinfo->doc->editor->sci, dinfo->cur_pos);
c = sci_get_char_at(dinfo->doc->editor->sci, dinfo->cur_pos);
if (c == '\0' || style == -1)
{ /* if c gets 0, we are probably out of document boundaries,
* so stop to break out of outer loop */
count = dinfo->lines_per_page;
break;
}
dinfo->cur_pos++;
/* convert tabs to spaces which seems to be better than using Pango tabs */
if (c == '\t')
{
gint tab_width = sci_get_tab_width(editor->sci);
gchar *s = g_strnfill(tab_width, ' ');
g_string_append(str, s);
g_free(s);
}
/* don't add line breaks, they are handled manually below */
else if (c == '\r' || c == '\n')
{
gchar c_next = sci_get_char_at(dinfo->doc->editor->sci, dinfo->cur_pos);
at_eol = TRUE;
if (c == '\r' && c_next == '\n')
dinfo->cur_pos++; /* skip LF part of CR/LF */
}
else
{
g_string_append_c(str, c); /* finally add the character */
/* handle UTF-8: since we add char by char (better: byte by byte), we need to
* keep UTF-8 characters together(e.g. two bytes for one character)
* the input is always UTF-8 and c is signed, so all non-Ascii
* characters are less than 0 and consist of all bytes less than 0.
* style doesn't change since it is only one character with multiple bytes. */
while (c < 0)
{
c = sci_get_char_at(dinfo->doc->editor->sci, dinfo->cur_pos);
if (c < 0)
{ /* only add the byte when it is part of the UTF-8 character
* otherwise we could add e.g. a '\n' and it won't be visible in the
* printed document */
g_string_append_c(str, c);
dinfo->cur_pos++;
}
}
}
}
if (! at_eol)
{
/* set text */
pango_layout_set_text(dinfo->layout, str->str, -1);
/* attributes */
layout_attr = pango_attr_list_new();
/* foreground colour */
get_rgb_values(dinfo->styles[style][FORE], &colours[0], &colours[1], &colours[2]);
attr = pango_attr_foreground_new(colours[0], colours[1], colours[2]);
ADD_ATTR(layout_attr, attr);
/* background colour */
get_rgb_values(dinfo->styles[style][BACK], &colours[0], &colours[1], &colours[2]);
attr = pango_attr_background_new(colours[0], colours[1], colours[2]);
ADD_ATTR(layout_attr, attr);
/* bold text */
if (dinfo->styles[style][BOLD])
{
attr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
ADD_ATTR(layout_attr, attr);
}
/* italic text */
if (dinfo->styles[style][ITALIC])
{
attr = pango_attr_style_new(PANGO_STYLE_ITALIC);
ADD_ATTR(layout_attr, attr);
}
pango_layout_set_attributes(dinfo->layout, layout_attr);
pango_layout_context_changed(dinfo->layout);
pango_attr_list_unref(layout_attr);
}
cairo_get_current_point(cr, &x, &y);
/* normal line break at eol character in document */
if (at_eol)
{
/*pango_layout_get_size(dinfo->layout, NULL, &layout_h);*/
/*cairo_move_to(cr, 0, y + (gdouble)layout_h / PANGO_SCALE);*/
cairo_move_to(cr, 0, y + dinfo->line_height);
count++;
/* we added a new document line so request a new line number */
add_linenumber = TRUE;
}
else
{
gint x_offset = 0;
/* maybe we need to force a line break because of too long line */
if (x >= (width - dinfo->font_width))
{
/* don't start the line at horizontal origin because we need to skip the
* line number margin */
if (printing_prefs.print_line_numbers)
{
x_offset = (dinfo->max_line_number_margin + 1) * dinfo->font_width;
}
/*pango_layout_get_size(dinfo->layout, NULL, &layout_h);*/
/*cairo_move_to(cr, x_offset, y + (gdouble)layout_h / PANGO_SCALE);*/
/* this is faster but not exactly the same as above */
cairo_move_to(cr, x_offset, y + dinfo->line_height);
cairo_get_current_point(cr, &x, &y);
count++;
}
if (count < dinfo->lines_per_page)
{
/* str->len is counted in bytes not characters, so use g_utf8_strlen() */
x_offset = (g_utf8_strlen(str->str, -1) * dinfo->font_width);
if (dinfo->long_line && count == 0)
{
x_offset = (dinfo->max_line_number_margin + 1) * dinfo->font_width;
dinfo->long_line = FALSE;
}
pango_cairo_show_layout(cr, dinfo->layout);
cairo_move_to(cr, x + x_offset, y);
}
else
/* we are on a wrapped line but we are out of lines on this page, so continue
* the current line on the next page and remember to continue in current line */
dinfo->long_line = TRUE;
}
}
}
if (printing_prefs.print_line_numbers)
{ /* print a thin line between the line number margin and the data */
gint y_start = 0;
if (printing_prefs.print_page_header)
y_start = (dinfo->line_height * 3) - 2; /* "- 2": to connect the line number line to
* the page header frame */
cairo_set_line_width(cr, 0.3);
cairo_move_to(cr, (dinfo->max_line_number_margin * dinfo->font_width) + 1, y_start);
cairo_line_to(cr, (dinfo->max_line_number_margin * dinfo->font_width) + 1,
y + dinfo->line_height); /* y is last added line, we reuse it */
cairo_stroke(cr);
}
if (printing_prefs.print_page_numbers)
{
gchar *line = g_strdup_printf("<small>- %d -</small>", page_nr + 1);
pango_layout_set_markup(dinfo->layout, line, -1);
pango_layout_set_alignment(dinfo->layout, PANGO_ALIGN_CENTER);
cairo_move_to(cr, 0, height - dinfo->line_height);
pango_cairo_show_layout(cr, dinfo->layout);
g_free(line);
#ifdef GEANY_PRINT_DEBUG
cairo_set_line_width(cr, 0.3);
cairo_move_to(cr, 0, height - (1.25 * dinfo->line_height));
cairo_line_to(cr, width - 1, height - (1.25 * dinfo->line_height));
cairo_stroke(cr);
#endif
}
g_string_free(str, TRUE);
}
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;
}
static gboolean
span_parse_func (MarkupData *md,
OpenTag *tag,
const gchar **names,
const gchar **values,
GMarkupParseContext *context,
GError **error)
{
int line_number, char_number;
int i;
const char *family = NULL;
const char *size = NULL;
const char *style = NULL;
const char *weight = NULL;
const char *variant = NULL;
const char *stretch = NULL;
const char *desc = NULL;
const char *foreground = NULL;
const char *background = NULL;
const char *underline = NULL;
const char *underline_color = NULL;
const char *strikethrough = NULL;
const char *strikethrough_color = NULL;
const char *rise = NULL;
const char *letter_spacing = NULL;
const char *lang = NULL;
const char *fallback = NULL;
const char *gravity = NULL;
const char *gravity_hint = NULL;
g_markup_parse_context_get_position (context,
&line_number, &char_number);
#define CHECK_DUPLICATE(var) G_STMT_START{ \
if ((var) != NULL) { \
g_set_error (error, G_MARKUP_ERROR, \
G_MARKUP_ERROR_INVALID_CONTENT, \
_("Attribute '%s' occurs twice on <span> tag " \
"on line %d char %d, may only occur once"), \
names[i], line_number, char_number); \
return FALSE; \
}}G_STMT_END
#define CHECK_ATTRIBUTE2(var, name) \
if (attr_strcmp (names[i], (name)) == 0) { \
CHECK_DUPLICATE (var); \
(var) = values[i]; \
found = TRUE; \
break; \
}
#define CHECK_ATTRIBUTE(var) CHECK_ATTRIBUTE2 (var, G_STRINGIFY (var))
i = 0;
while (names[i])
{
gboolean found = FALSE;
switch (names[i][0]) {
case 'f':
CHECK_ATTRIBUTE (fallback);
CHECK_ATTRIBUTE2(desc, "font");
CHECK_ATTRIBUTE2(desc, "font_desc");
CHECK_ATTRIBUTE2(family, "face");
CHECK_ATTRIBUTE2(family, "font_family");
CHECK_ATTRIBUTE2(size, "font_size");
CHECK_ATTRIBUTE2(stretch, "font_stretch");
CHECK_ATTRIBUTE2(style, "font_style");
CHECK_ATTRIBUTE2(variant, "font_variant");
CHECK_ATTRIBUTE2(weight, "font_weight");
CHECK_ATTRIBUTE (foreground);
CHECK_ATTRIBUTE2 (foreground, "fgcolor");
break;
case 's':
CHECK_ATTRIBUTE (size);
CHECK_ATTRIBUTE (stretch);
CHECK_ATTRIBUTE (strikethrough);
CHECK_ATTRIBUTE (strikethrough_color);
CHECK_ATTRIBUTE (style);
break;
case 'g':
CHECK_ATTRIBUTE (gravity);
CHECK_ATTRIBUTE (gravity_hint);
break;
case 'l':
CHECK_ATTRIBUTE (lang);
CHECK_ATTRIBUTE (letter_spacing);
break;
case 'u':
CHECK_ATTRIBUTE (underline);
CHECK_ATTRIBUTE (underline_color);
break;
default:
CHECK_ATTRIBUTE (background);
CHECK_ATTRIBUTE2 (background, "bgcolor");
CHECK_ATTRIBUTE2(foreground, "color");
CHECK_ATTRIBUTE (rise);
CHECK_ATTRIBUTE (variant);
CHECK_ATTRIBUTE (weight);
break;
}
if (!found)
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
_("Attribute '%s' is not allowed on the <span> tag "
"on line %d char %d"),
names[i], line_number, char_number);
return FALSE;
}
++i;
}
/* Parse desc first, then modify it with other font-related attributes. */
if (G_UNLIKELY (desc))
{
PangoFontDescription *parsed;
parsed = pango_font_description_from_string (desc);
if (parsed)
{
add_attribute (tag, pango_attr_font_desc_new (parsed));
if (tag)
open_tag_set_absolute_font_size (tag, pango_font_description_get_size (parsed));
pango_font_description_free (parsed);
}
}
if (G_UNLIKELY (family))
{
add_attribute (tag, pango_attr_family_new (family));
}
if (G_UNLIKELY (size))
{
if (g_ascii_isdigit (*size))
{
const char *end;
gint n;
/* cap size from the top at an arbitrary 2048 */
#define MAX_SIZE (2048 * PANGO_SCALE)
if ((end = size, !pango_scan_int (&end, &n)) || *end != '\0' || n < 0 || n > MAX_SIZE)
{
g_set_error (error,
G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("Value of 'size' attribute on <span> tag on line %d "
"could not be parsed; should be an integer less than %d, or a "
"string such as 'small', not '%s'"),
line_number, MAX_SIZE+1, size);
goto error;
}
add_attribute (tag, pango_attr_size_new (n));
if (tag)
open_tag_set_absolute_font_size (tag, n);
}
else if (strcmp (size, "smaller") == 0)
{
if (tag)
{
tag->scale_level_delta -= 1;
tag->scale_level -= 1;
}
}
else if (strcmp (size, "larger") == 0)
{
if (tag)
{
tag->scale_level_delta += 1;
tag->scale_level += 1;
}
}
else if (parse_absolute_size (tag, size))
; /* nothing */
else
{
g_set_error (error,
G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("Value of 'size' attribute on <span> tag on line %d "
"could not be parsed; should be an integer, or a "
"string such as 'small', not '%s'"),
line_number, size);
goto error;
}
}
if (G_UNLIKELY (style))
{
PangoStyle pango_style;
if (pango_parse_style (style, &pango_style, FALSE))
add_attribute (tag, pango_attr_style_new (pango_style));
else
{
g_set_error (error,
G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("'%s' is not a valid value for the 'style' attribute "
"on <span> tag, line %d; valid values are "
"'normal', 'oblique', 'italic'"),
style, line_number);
goto error;
}
}
if (G_UNLIKELY (weight))
{
PangoWeight pango_weight;
if (pango_parse_weight (weight, &pango_weight, FALSE))
add_attribute (tag,
pango_attr_weight_new (pango_weight));
else
{
g_set_error (error,
G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("'%s' is not a valid value for the 'weight' "
"attribute on <span> tag, line %d; valid "
"values are for example 'light', 'ultrabold' or a number"),
weight, line_number);
goto error;
}
}
if (G_UNLIKELY (variant))
{
PangoVariant pango_variant;
if (pango_parse_variant (variant, &pango_variant, FALSE))
add_attribute (tag, pango_attr_variant_new (pango_variant));
else
{
g_set_error (error,
G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("'%s' is not a valid value for the 'variant' "
"attribute on <span> tag, line %d; valid values are "
"'normal', 'smallcaps'"),
variant, line_number);
goto error;
}
}
if (G_UNLIKELY (stretch))
{
PangoStretch pango_stretch;
if (pango_parse_stretch (stretch, &pango_stretch, FALSE))
add_attribute (tag, pango_attr_stretch_new (pango_stretch));
else
{
g_set_error (error,
G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("'%s' is not a valid value for the 'stretch' "
"attribute on <span> tag, line %d; valid "
"values are for example 'condensed', "
"'ultraexpanded', 'normal'"),
stretch, line_number);
goto error;
}
}
if (G_UNLIKELY (foreground))
{
PangoColor color;
if (!span_parse_color ("foreground", foreground, &color, line_number, error))
goto error;
add_attribute (tag, pango_attr_foreground_new (color.red, color.green, color.blue));
}
if (G_UNLIKELY (background))
{
PangoColor color;
if (!span_parse_color ("background", background, &color, line_number, error))
goto error;
add_attribute (tag, pango_attr_background_new (color.red, color.green, color.blue));
}
if (G_UNLIKELY (underline))
{
PangoUnderline ul = PANGO_UNDERLINE_NONE;
if (!span_parse_enum ("underline", underline, PANGO_TYPE_UNDERLINE, &ul, line_number, error))
goto error;
add_attribute (tag, pango_attr_underline_new (ul));
}
if (G_UNLIKELY (underline_color))
{
PangoColor color;
if (!span_parse_color ("underline_color", underline_color, &color, line_number, error))
goto error;
add_attribute (tag, pango_attr_underline_color_new (color.red, color.green, color.blue));
}
if (G_UNLIKELY (gravity))
{
PangoGravity gr = PANGO_GRAVITY_SOUTH;
if (!span_parse_enum ("gravity", gravity, PANGO_TYPE_GRAVITY, &gr, line_number, error))
goto error;
add_attribute (tag, pango_attr_gravity_new (gr));
}
if (G_UNLIKELY (gravity_hint))
{
PangoGravityHint hint = PANGO_GRAVITY_HINT_NATURAL;
if (!span_parse_enum ("gravity_hint", gravity_hint, PANGO_TYPE_GRAVITY_HINT, &hint, line_number, error))
goto error;
add_attribute (tag, pango_attr_gravity_hint_new (hint));
}
if (G_UNLIKELY (strikethrough))
{
gboolean b = FALSE;
if (!span_parse_boolean ("strikethrough", strikethrough, &b, line_number, error))
goto error;
add_attribute (tag, pango_attr_strikethrough_new (b));
}
if (G_UNLIKELY (strikethrough_color))
{
PangoColor color;
if (!span_parse_color ("strikethrough_color", strikethrough_color, &color, line_number, error))
goto error;
add_attribute (tag, pango_attr_strikethrough_color_new (color.red, color.green, color.blue));
}
if (G_UNLIKELY (fallback))
{
gboolean b = FALSE;
if (!span_parse_boolean ("fallback", fallback, &b, line_number, error))
goto error;
add_attribute (tag, pango_attr_fallback_new (b));
}
if (G_UNLIKELY (rise))
{
gint n = 0;
if (!span_parse_int ("rise", rise, &n, line_number, error))
goto error;
add_attribute (tag, pango_attr_rise_new (n));
}
if (G_UNLIKELY (letter_spacing))
{
gint n = 0;
if (!span_parse_int ("letter_spacing", letter_spacing, &n, line_number, error))
goto error;
add_attribute (tag, pango_attr_letter_spacing_new (n));
}
if (G_UNLIKELY (lang))
{
add_attribute (tag,
pango_attr_language_new (pango_language_from_string (lang)));
}
return TRUE;
error:
return FALSE;
}
static void
gm_cell_renderer_bitext_update_text (GmCellRendererBitext *renderer,
GtkWidget *widget,
gboolean is_selected)
{
GtkStyle *style = NULL;
PangoAttrList *attr_list = NULL;
GdkColor color;
PangoAttribute *attr_color = NULL;
PangoAttribute *attr_style = NULL;
PangoAttribute *attr_size = NULL;
gchar *str = NULL;
if (renderer->priv->is_valid && renderer->priv->is_selected == is_selected)
return;
style = gtk_widget_get_style (widget);
attr_list = pango_attr_list_new ();
/* secondary text will be in italic */
attr_style = pango_attr_style_new (PANGO_STYLE_NORMAL);
attr_style->start_index = strlen (renderer->priv->primary_text) + 1;
attr_style->end_index = (guint) - 1;
pango_attr_list_insert (attr_list, attr_style);
if (!is_selected) {
color = style->text_aa[GTK_STATE_NORMAL];
attr_color = pango_attr_foreground_new (color.red,
color.green, color.blue);
attr_color->start_index = attr_style->start_index;
attr_color->end_index = (guint) - 1;
pango_attr_list_insert (attr_list, attr_color);
}
attr_size = pango_attr_size_new ((int) (pango_font_description_get_size (style->font_desc) * 0.8)); /* we want the secondary text smaller */
attr_size->start_index = attr_style->start_index;
attr_size->end_index = (guint) - 1;
pango_attr_list_insert (attr_list, attr_size);
if (renderer->priv->secondary_text && strcmp (renderer->priv->secondary_text, ""))
str = g_strdup_printf ("%s\n%s",
renderer->priv->primary_text,
renderer->priv->secondary_text);
else
str = g_strdup_printf ("%s",
renderer->priv->primary_text);
g_object_set (renderer,
"visible", TRUE,
"weight", PANGO_WEIGHT_NORMAL,
"text", str,
"attributes", attr_list,
NULL);
g_free (str);
pango_attr_list_unref (attr_list);
renderer->priv->is_selected = is_selected;
renderer->priv->is_valid = TRUE;
}
void
table_populate_profiles (GstUsersTool *tool,
GList *profiles)
{
GstUserProfile *profile;
GtkWidget *table;
GtkWidget *radio;
GtkWidget *label;
GHashTable *radios;
GHashTable *labels;
GHashTableIter iter;
gpointer value;
GList *l;
static int ncols, nrows; /* original size of the table */
PangoAttribute *attribute;
PangoAttrList *attributes;
int i;
table = gst_dialog_get_widget (GST_TOOL (tool)->main_dialog, "user_profile_table");
radios = g_object_get_data (G_OBJECT (table), "radio_buttons");
labels = g_object_get_data (G_OBJECT (table), "labels");
/* create the hash table to hold references to radio buttons and their labels */
if (radios == NULL) {
/* keys are names owned by GstUserProfiles, values are pointers:
* no need to free anything */
radios = g_hash_table_new (g_str_hash, g_str_equal);
labels = g_hash_table_new (g_str_hash, g_str_equal);
g_object_set_data (G_OBJECT (table), "radio_buttons", radios);
g_object_set_data (G_OBJECT (table), "labels", labels);
g_object_get (G_OBJECT (table), "n-rows", &nrows, "n-columns", &ncols, NULL);
}
else {
/* free the radio buttons and labels if they were already here */
g_hash_table_iter_init (&iter, radios);
while (g_hash_table_iter_next (&iter, NULL, &value)) {
gtk_widget_destroy (GTK_WIDGET (value));
}
g_hash_table_iter_init (&iter, labels);
while (g_hash_table_iter_next (&iter, NULL, &value)) {
gtk_widget_destroy (GTK_WIDGET (value));
}
g_hash_table_remove_all (radios);
g_hash_table_remove_all (labels);
}
/* increase table's size based on it's "empty" size
* we leave an empty line after a radio and its decription label */
gtk_table_resize (GTK_TABLE (table), g_list_length (profiles) * 3 + nrows, ncols);
radio = gst_dialog_get_widget (GST_TOOL (tool)->main_dialog, "user_profile_custom");
label = gst_dialog_get_widget (GST_TOOL (tool)->main_dialog, "user_profile_custom_label");
attributes = pango_attr_list_new ();
attribute = pango_attr_size_new (9 * PANGO_SCALE);
pango_attr_list_insert (attributes, attribute);
attribute = pango_attr_style_new (PANGO_STYLE_ITALIC);
pango_attr_list_insert (attributes, attribute);
gtk_label_set_attributes (GTK_LABEL (label), attributes);
i = 1; /* empty line after "Custom" radio and label */
for (l = profiles; l; l = l->next) {
profile = (GstUserProfile *) l->data;
radio = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio),
profile->name);
label = gtk_label_new (profile->description);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label), 16, 0);
gtk_label_set_attributes (GTK_LABEL (label), attributes);
gtk_table_attach_defaults (GTK_TABLE (table),
radio, 0, ncols,
nrows + i, nrows + i + 1);
gtk_table_attach_defaults (GTK_TABLE (table),
label, 1, ncols,
nrows + i + 1, nrows + i + 2);
gtk_widget_show (radio);
gtk_widget_show (label);
g_hash_table_replace (radios, profile->name, radio);
g_hash_table_replace (labels, profile->name, label);
i += 3;
}
}
/**
* 填充群组数据(grpinf)到数据集(model)指定位置(iter).
* @param model model
* @param iter iter
* @param grpinf class GroupInfo
*/
void palTreeModelFillFromGroupInfo(GtkTreeModel *model,
GtkTreeIter *iter,
const GroupInfo *grpinf,
const char* font) {
GtkIconTheme *theme;
GdkPixbuf *cpixbuf, *opixbuf= nullptr;
PangoAttrList *attrs;
PangoAttribute *attr;
gchar *info, *extra;
PalInfo *pal;
GError* error = nullptr;
/* 创建图标 */
theme = gtk_icon_theme_get_default();
if (grpinf->type == GROUP_BELONG_TYPE_REGULAR) {
pal = static_cast<PalInfo *>(grpinf->member->data);
auto file = iptux_erase_filename_suffix(pal->iconfile);
cpixbuf = gtk_icon_theme_load_icon(theme, file, MAX_ICONSIZE,
GtkIconLookupFlags(0), &error);
if(cpixbuf == nullptr) {
LOG_WARN("gtk_icon_theme_load_icon failed: [%d] %s", error->code, error->message);
g_error_free(error);
error = nullptr;
} else {
opixbuf = GDK_PIXBUF(g_object_ref(cpixbuf));
}
g_free(file);
} else {
cpixbuf = gtk_icon_theme_load_icon(theme, "tip-hide", MAX_ICONSIZE,
GtkIconLookupFlags(0), NULL);
opixbuf = gtk_icon_theme_load_icon(theme, "tip-show", MAX_ICONSIZE,
GtkIconLookupFlags(0), NULL);
}
/* 创建主信息 */
if (grpinf->type == GROUP_BELONG_TYPE_REGULAR) {
char ipstr[INET_ADDRSTRLEN];
pal = static_cast<PalInfo *>(grpinf->member->data);
inet_ntop(AF_INET, &pal->ipv4, ipstr, INET_ADDRSTRLEN);
info = g_strdup_printf("%s\n%s", pal->name, ipstr);
} else
info = g_strdup(grpinf->name);
/* 创建扩展信息 */
if (grpinf->type == GROUP_BELONG_TYPE_REGULAR)
extra = NULL;
else
extra = g_strdup_printf("(%u)", g_slist_length(grpinf->member));
/* 创建字体风格 */
attrs = pango_attr_list_new();
if (grpinf->type == GROUP_BELONG_TYPE_REGULAR) {
auto dspt = pango_font_description_from_string(font);
attr = pango_attr_font_desc_new(dspt);
pango_attr_list_insert(attrs, attr);
pango_font_description_free(dspt);
} else {
attr = pango_attr_size_new(8192);
pango_attr_list_insert(attrs, attr);
attr = pango_attr_style_new(PANGO_STYLE_ITALIC);
pango_attr_list_insert(attrs, attr);
attr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
pango_attr_list_insert(attrs, attr);
}
/* 设置相应的数据 */
gtk_tree_store_set(GTK_TREE_STORE(model), iter,
PalTreeModelColumn ::CLOSED_EXPANDER, cpixbuf,
PalTreeModelColumn ::OPEN_EXPANDER, opixbuf,
PalTreeModelColumn ::INFO, info,
PalTreeModelColumn ::EXTRAS, extra,
PalTreeModelColumn ::STYLE, attrs,
PalTreeModelColumn ::COLOR, &color,
PalTreeModelColumn ::DATA, grpinf,
-1);
/* 释放资源 */
if (cpixbuf) g_object_unref(cpixbuf);
if (opixbuf) g_object_unref(opixbuf);
g_free(info);
g_free(extra);
pango_attr_list_unref(attrs);
}
static void
cell_renderer_text_update_text (EmpathyCellRendererText *cell,
GtkWidget *widget,
gboolean selected)
{
EmpathyCellRendererTextPriv *priv;
PangoAttrList *attr_list;
PangoAttribute *attr_color, *attr_style, *attr_size;
GtkStyle *style;
gchar *str;
priv = GET_PRIV (cell);
if (priv->is_valid && priv->is_selected == selected) {
return;
}
if (priv->is_group) {
g_object_set (cell,
"visible", TRUE,
"weight", PANGO_WEIGHT_BOLD,
"text", priv->name,
"attributes", NULL,
"xpad", 1,
"ypad", 1,
NULL);
priv->is_selected = selected;
priv->is_valid = TRUE;
return;
}
style = gtk_widget_get_style (widget);
attr_list = pango_attr_list_new ();
attr_style = pango_attr_style_new (PANGO_STYLE_ITALIC);
attr_style->start_index = strlen (priv->name) + 1;
attr_style->end_index = -1;
pango_attr_list_insert (attr_list, attr_style);
if (!selected) {
GdkColor color;
color = style->text_aa[GTK_STATE_NORMAL];
attr_color = pango_attr_foreground_new (color.red, color.green, color.blue);
attr_color->start_index = attr_style->start_index;
attr_color->end_index = -1;
pango_attr_list_insert (attr_list, attr_color);
}
attr_size = pango_attr_size_new (pango_font_description_get_size (style->font_desc) / 1.2);
attr_size->start_index = attr_style->start_index;
attr_size->end_index = -1;
pango_attr_list_insert (attr_list, attr_size);
if (!priv->status || !priv->status[0] || !priv->show_status) {
str = g_strdup (priv->name);
} else {
str = g_strdup_printf ("%s\n%s", priv->name, priv->status);
}
g_object_set (cell,
"visible", TRUE,
"weight", PANGO_WEIGHT_NORMAL,
"text", str,
"attributes", attr_list,
"xpad", 0,
"ypad", 1,
NULL);
g_free (str);
pango_attr_list_unref (attr_list);
priv->is_selected = selected;
priv->is_valid = TRUE;
}
