/** * 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; }