static void
update_fonts (UmEditableButton *button)
{
PangoAttrList *attrs;
PangoAttribute *attr;
GtkWidget *label;
UmEditableButtonPrivate *priv = button->priv;
attrs = pango_attr_list_new ();
if (priv->scale_set) {
attr = pango_attr_scale_new (priv->scale);
pango_attr_list_insert (attrs, attr);
}
if (priv->weight_set) {
attr = pango_attr_weight_new (priv->weight);
pango_attr_list_insert (attrs, attr);
}
gtk_label_set_attributes (priv->label, attrs);
label = gtk_bin_get_child (GTK_BIN (priv->button));
gtk_label_set_attributes (GTK_LABEL (label), attrs);
pango_attr_list_unref (attrs);
}
static void
append_item (NemoImagePropertiesPage *page,
const char *name,
const char *value)
{
GtkWidget *name_label;
GtkWidget *label;
PangoAttrList *attrs;
name_label = gtk_label_new (name);
attrs = pango_attr_list_new ();
pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
gtk_label_set_attributes (GTK_LABEL (name_label), attrs);
pango_attr_list_unref (attrs);
gtk_misc_set_alignment (GTK_MISC (name_label), 0, 0);
gtk_container_add (GTK_CONTAINER (page->details->grid), name_label);
gtk_widget_show (name_label);
if (value != NULL) {
label = gtk_label_new (value);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_grid_attach_next_to (GTK_GRID (page->details->grid), label,
name_label, GTK_POS_RIGHT,
1, 1);
gtk_widget_show (label);
}
}
void gnome_main_section_new_with_grid(const gchar *title, GtkWidget **frame, GtkWidget **grid)
{
PangoAttrList *attrs = pango_attr_list_new();
PangoAttribute *attr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
attr->start_index = 0;
attr->end_index = -1;
pango_attr_list_insert(attrs, attr);
*frame = gtk_frame_new(title);
gtk_frame_set_shadow_type(GTK_FRAME(*frame), GTK_SHADOW_NONE);
gtk_container_set_border_width(GTK_CONTAINER(*frame), 2);
GtkWidget *label = gtk_frame_get_label_widget(GTK_FRAME(*frame));
gtk_label_set_attributes(GTK_LABEL(label), attrs);
pango_attr_list_unref(attrs);
GtkWidget *align = gtk_alignment_new(0.08, 0.2, 0.1, 0.1);
gtk_container_add(GTK_CONTAINER(*frame), align);
*grid = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(*grid), 2);
gtk_grid_set_column_spacing(GTK_GRID(*grid), 2);
gtk_widget_show(*grid);
gtk_container_add(GTK_CONTAINER(align), *grid);
}
static GtkWidget *app_window_common(void)
{
GtkWidget *window;
PangoAttrList *attr;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
gtk_window_set_title(GTK_WINDOW(window), WINDOW_TITLE);
g_signal_connect(window, "delete-event", G_CALLBACK(delete_event),
NULL);
tokencode_text = gtk_label_new(NULL);
attr = pango_attr_list_new();
pango_attr_list_insert(attr, pango_attr_scale_new(PANGO_SCALE_XX_LARGE));
pango_attr_list_insert(attr, pango_attr_weight_new(PANGO_WEIGHT_BOLD));
gtk_label_set_attributes(GTK_LABEL(tokencode_text), attr);
pango_attr_list_unref(attr);
/* hack to turn off progress bar animation seen on some themes */
gtk_rc_parse_string("style \"default\" { engine \"\" { }\n"
"bg[PRELIGHT] = \"#4b6785\" }\n"
"widget_class \"*.<GtkProgressBar>\" style \"default\"");
return window;
}
static AboutRenderer *
make_text_item (AboutState *state, const char *text, int duration)
{
AboutRenderer *r = g_new0 (AboutRenderer, 1);
PangoAttrList *attrlist;
PangoAttribute *attr;
duration = (int)(duration / SPEED_FACTOR);
r->start_time = state->now;
r->duration = duration;
r->layout = gtk_widget_create_pango_layout (state->anim_area, NULL);
r->renderer = text_item_renderer;
r->fade_in = r->fade_out = TRUE;
set_text_motion (r, 0.5, 0.5, 0.5, 0.5);
pango_layout_set_text (r->layout, text, -1);
pango_layout_get_size (r->layout, &r->natural_width, NULL);
attrlist = pango_attr_list_new ();
attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
pango_attr_list_change (attrlist, attr);
pango_layout_set_attributes (r->layout, attrlist);
pango_attr_list_unref (attrlist);
state->now += duration;
return r;
}
/**
* thunar_pango_attr_list_bold:
*
* Returns a #PangoAttrList for rendering bold 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 bold text.
**/
PangoAttrList*
thunar_pango_attr_list_bold (void)
{
static PangoAttrList *attr_list = NULL;
if (G_UNLIKELY (attr_list == NULL))
attr_list = thunar_pango_attr_list_wrap (pango_attr_weight_new (PANGO_WEIGHT_BOLD), NULL);
return attr_list;
}
GtkWidget *
gnome_prefs_subsection_new (GtkWidget *window,
GtkWidget *container,
const gchar *frame_name,
int rows,
int cols)
{
GnomePrefsWindow *gpw = NULL;
GtkWidget *hbox = NULL;
GtkWidget *frame = NULL;
GtkWidget *table = NULL;
GtkWidget *label = NULL;
PangoAttrList *attrs = NULL;
PangoAttribute *attr = NULL;
if (window)
gpw = (GnomePrefsWindow *) g_object_get_data (G_OBJECT (window), "gpw");
hbox = gtk_hbox_new (FALSE, 6);
frame = gtk_frame_new (frame_name);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
attrs = pango_attr_list_new ();
attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
attr->start_index = 0;
attr->end_index = -1;
pango_attr_list_insert (attrs, attr);
label = gtk_frame_get_label_widget (GTK_FRAME (frame));
gtk_label_set_attributes (GTK_LABEL (label), attrs);
pango_attr_list_unref (attrs);
gtk_box_pack_start (GTK_BOX (container), frame,
FALSE, FALSE, 0);
table = gtk_table_new (rows, cols, FALSE);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 3);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
if (gpw)
g_object_set_data (G_OBJECT (table), "gpw", gpw);
gtk_widget_show_all (table);
return table;
}
/**
* fo_property_font_weight_new_attr:
* @property: #FoProperty from which to create a #PangoAttribute.
*
* Makes a new #PangoAttribute representing the current property.
*
* Return value: New #PangoAttribute.
**/
PangoAttribute*
fo_property_font_weight_new_attr (FoProperty *property)
{
gint pango_font_weight;
g_return_val_if_fail (FO_IS_PROPERTY_FONT_WEIGHT (property), NULL);
pango_font_weight =
fo_integer_get_value (property->value);
return pango_attr_weight_new (pango_font_weight);
}
static gboolean
b_parse_func (MarkupData *md,
OpenTag *tag,
const gchar **names,
const gchar **values,
GMarkupParseContext *context,
GError **error)
{
CHECK_NO_ATTRS("b");
add_attribute (tag, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
return TRUE;
}
void
gtk_label_set_attribute_bold(GtkLabel *label)
{
PangoAttrList *Bold = pango_attr_list_new();
PangoAttribute *Attribute = NULL;
Attribute = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
pango_attr_list_insert(Bold, Attribute);
gtk_label_set_attributes(label, Bold);
pango_attr_list_unref(Bold);
}
static void
trust_prompt_add_info_line (GtkGrid *grid,
const gchar *label_text,
const gchar *value_text,
gboolean ellipsize,
gboolean wrap,
gboolean use_bold,
gint *at_row)
{
GtkWidget *widget;
PangoAttribute *attr;
PangoAttrList *bold;
g_return_if_fail (grid != NULL);
g_return_if_fail (label_text != NULL);
g_return_if_fail (at_row != NULL);
if (!value_text || !*value_text)
return;
bold = pango_attr_list_new ();
attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
pango_attr_list_insert (bold, attr);
widget = gtk_label_new (label_text);
gtk_misc_set_padding (GTK_MISC (widget), 0, 0);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
gtk_grid_attach (grid, widget, 1, *at_row, 1, 1);
widget = gtk_label_new (value_text);
gtk_label_set_line_wrap (GTK_LABEL (widget), wrap);
g_object_set (
G_OBJECT (widget),
"hexpand", TRUE,
"halign", GTK_ALIGN_FILL,
"justify", GTK_JUSTIFY_LEFT,
"attributes", use_bold ? bold : NULL,
"selectable", TRUE,
"ellipsize", ellipsize ? PANGO_ELLIPSIZE_END : PANGO_ELLIPSIZE_NONE,
"width-chars", 60,
"max-width-chars", 80,
"xalign", 0.0,
"yalign", 0.0,
NULL);
gtk_grid_attach (grid, widget, 2, *at_row, 1, 1);
*at_row = (*at_row) + 1;
pango_attr_list_unref (bold);
}
static void
label_set_bold (GtkLabel *label,
gboolean bold)
{
PangoAttrList *attrs;
PangoAttribute *attr;
attrs = pango_attr_list_new ();
attr = pango_attr_weight_new (bold ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL);
pango_attr_list_insert (attrs, attr);
gtk_label_set_attributes (label, attrs);
pango_attr_list_unref (attrs);
}
static GtkWidget *getTitleLabel() {
GtkWidget *label = gtk_label_new (_("Home"));
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
PangoAttrList *attr_list = pango_attr_list_new ();
PangoAttribute *attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
pango_attr_list_insert (attr_list, attr);
gtk_label_set_attributes (GTK_LABEL (label), attr_list);
pango_attr_list_unref (attr_list);
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
return label;
}
static void
text_input_preedit_styling(void *data,
struct wl_text_input *text_input,
uint32_t index,
uint32_t length,
uint32_t style)
{
struct text_entry *entry = data;
PangoAttribute *attr1 = NULL;
PangoAttribute *attr2 = NULL;
if (!entry->preedit_info.attr_list)
entry->preedit_info.attr_list = pango_attr_list_new();
switch (style) {
case WL_TEXT_INPUT_PREEDIT_STYLE_DEFAULT:
case WL_TEXT_INPUT_PREEDIT_STYLE_UNDERLINE:
attr1 = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
break;
case WL_TEXT_INPUT_PREEDIT_STYLE_INCORRECT:
attr1 = pango_attr_underline_new(PANGO_UNDERLINE_ERROR);
attr2 = pango_attr_underline_color_new(65535, 0, 0);
break;
case WL_TEXT_INPUT_PREEDIT_STYLE_SELECTION:
attr1 = pango_attr_background_new(0.3 * 65535, 0.3 * 65535, 65535);
attr2 = pango_attr_foreground_new(65535, 65535, 65535);
break;
case WL_TEXT_INPUT_PREEDIT_STYLE_HIGHLIGHT:
case WL_TEXT_INPUT_PREEDIT_STYLE_ACTIVE:
attr1 = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
attr2 = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
break;
case WL_TEXT_INPUT_PREEDIT_STYLE_INACTIVE:
attr1 = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
attr2 = pango_attr_foreground_new(0.3 * 65535, 0.3 * 65535, 0.3 * 65535);
break;
}
if (attr1) {
attr1->start_index = entry->cursor + index;
attr1->end_index = entry->cursor + index + length;
pango_attr_list_insert(entry->preedit_info.attr_list, attr1);
}
if (attr2) {
attr2->start_index = entry->cursor + index;
attr2->end_index = entry->cursor + index + length;
pango_attr_list_insert(entry->preedit_info.attr_list, attr2);
}
}
/**
* terminal_tab_label_set_bold:
* @tab_label: a #TerminalTabLabel
* @bold: whether to enable label bolding
*
* Sets the tab label text bold, or unbolds it.
*/
void
terminal_tab_label_set_bold (TerminalTabLabel *tab_label,
gboolean bold)
{
TerminalTabLabelPrivate *priv = tab_label->priv;
PangoAttrList *attr_list;
PangoAttribute *weight_attr;
gboolean free_list = FALSE;
bold = bold != FALSE;
if (priv->bold == bold)
return;
priv->bold = bold;
attr_list = gtk_label_get_attributes (GTK_LABEL (priv->label));
if (!attr_list) {
attr_list = pango_attr_list_new ();
free_list = TRUE;
}
if (bold)
weight_attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
else
weight_attr = pango_attr_weight_new (PANGO_WEIGHT_NORMAL);
/* gtk_label_get_attributes() returns the label's internal list,
* which we're probably not supposed to modify directly.
* It seems to work ok however.
*/
pango_attr_list_change (attr_list, weight_attr);
gtk_label_set_attributes (GTK_LABEL (priv->label), attr_list);
if (free_list)
pango_attr_list_unref (attr_list);
}
static void
nautilus_trash_bar_init (NautilusTrashBar *bar)
{
GtkWidget *content_area, *action_area, *w;
GtkWidget *label;
PangoAttrList *attrs;
bar->priv = NAUTILUS_TRASH_BAR_GET_PRIVATE (bar);
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (bar));
action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (bar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (action_area),
GTK_ORIENTATION_HORIZONTAL);
attrs = pango_attr_list_new ();
pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
label = gtk_label_new (_("Trash"));
gtk_label_set_attributes (GTK_LABEL (label), attrs);
pango_attr_list_unref (attrs);
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (content_area), label);
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("_Restore"),
TRASH_BAR_RESPONSE_RESTORE);
gtk_widget_set_tooltip_text (w,
_("Restore selected items to their original position"));
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
/* Translators: "Empty" is an action (for the trash) , not a state */
_("_Empty"),
TRASH_BAR_RESPONSE_EMPTY);
gtk_widget_set_tooltip_text (w,
_("Delete all items in the Trash"));
g_signal_connect_object (nautilus_trash_monitor_get (),
"trash-state-changed",
G_CALLBACK (nautilus_trash_bar_trash_state_changed),
bar,
0);
nautilus_trash_bar_trash_state_changed (nautilus_trash_monitor_get (),
FALSE, bar);
g_signal_connect (bar, "response",
G_CALLBACK (trash_bar_response_cb), bar);
}
static void
gimp_frame_label_widget_notify (GtkFrame *frame)
{
GtkWidget *label_widget = gtk_frame_get_label_widget (frame);
if (label_widget)
{
GtkLabel *label = NULL;
if (GTK_IS_LABEL (label_widget))
{
gfloat xalign, yalign;
label = GTK_LABEL (label_widget);
gtk_frame_get_label_align (frame, &xalign, &yalign);
gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign);
}
else if (GTK_IS_BIN (label_widget))
{
GtkWidget *child = gtk_bin_get_child (GTK_BIN (label_widget));
if (GTK_IS_LABEL (child))
label = GTK_LABEL (child);
}
if (label)
{
PangoAttrList *attrs = pango_attr_list_new ();
PangoAttribute *attr;
gboolean bold;
gtk_widget_style_get (GTK_WIDGET (frame), "label_bold", &bold, NULL);
attr = pango_attr_weight_new (bold ?
PANGO_WEIGHT_BOLD :
PANGO_WEIGHT_NORMAL);
attr->start_index = 0;
attr->end_index = -1;
pango_attr_list_insert (attrs, attr);
gtk_label_set_attributes (label, attrs);
pango_attr_list_unref (attrs);
}
}
}
static gint
get_cell_renderer_width (GtkWidget *widget, GtkCellRenderer *cell, const gchar *text, gint weight)
{
PangoLayout *layout = gtk_widget_create_pango_layout (widget, text);
PangoAttrList *attrbs = pango_attr_list_new();
PangoRectangle rect;
gint xpad = 0;
pango_attr_list_insert (attrbs, pango_attr_weight_new (weight));
pango_layout_set_attributes (layout, attrbs);
pango_attr_list_unref (attrbs);
pango_layout_get_pixel_extents (layout, NULL, &rect);
g_object_unref (G_OBJECT (layout));
gtk_cell_renderer_get_padding (cell, &xpad, NULL);
return (xpad * 2) + rect.x + rect.width;
}
//____________________________________________________
GtkWidget* InfoWidget::boldLabel( void ) const
{
GtkWidget* label = gtk_label_new( 0L );
// create pango attributes list
PangoAttrList* attributes( pango_attr_list_new() );
pango_attr_list_insert( attributes, pango_attr_weight_new( PANGO_WEIGHT_BOLD ) );
GValue val = { 0, };
g_value_init(&val, PANGO_TYPE_ATTR_LIST );
g_value_set_boxed( &val, attributes );
g_object_set_property( G_OBJECT( label ), "attributes", &val );
pango_attr_list_unref( attributes );
return label;
}
void ygtk_steps_append_heading (YGtkSteps *steps, const gchar *heading)
{
GtkWidget *label = gtk_label_new (heading);
GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };
gtk_widget_override_color (label, GTK_STATE_NORMAL, &black);
g_object_set_data (G_OBJECT (label), "is-header", GINT_TO_POINTER (1));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
PangoAttrList *attrbs = pango_attr_list_new();
pango_attr_list_insert (attrbs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
pango_attr_list_insert (attrbs, pango_attr_scale_new (PANGO_SCALE_LARGE));
gtk_label_set_attributes (GTK_LABEL (label), attrbs);
pango_attr_list_unref (attrbs);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (steps), label, FALSE, TRUE, 6);
}
GtkWidget *gnome_main_section_new(const gchar * const title)
{
PangoAttrList *attrs = pango_attr_list_new();
PangoAttribute *attr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
attr->start_index = 0;
attr->end_index = -1;
pango_attr_list_insert(attrs, attr);
GtkWidget *frame = gtk_frame_new(title);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
gtk_container_set_border_width(GTK_CONTAINER(frame), 2);
GtkWidget *label = gtk_frame_get_label_widget(GTK_FRAME(frame));
gtk_label_set_attributes(GTK_LABEL(label), attrs);
pango_attr_list_unref(attrs);
return frame;
}
//_______________________________________________________
void DemoWidget::realize( void )
{
assert( !_mainWidget );
assert( _widget );
// create main widget (vbox)
_mainWidget = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
gtk_box_set_spacing( GTK_BOX( _mainWidget ), 10 );
gtk_widget_show( _mainWidget );
// horizontal box
GtkWidget* hbox( gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ) );
gtk_box_pack_start( GTK_BOX( _mainWidget ), hbox, false, true, 0 );
gtk_widget_show( hbox );
// label
std::string comments( _comments.empty() ? _name:_comments );
GtkWidget* label( gtk_label_new( comments.c_str() ) );
PangoAttrList* attributes( pango_attr_list_new() );
pango_attr_list_insert( attributes, pango_attr_weight_new( PANGO_WEIGHT_BOLD ) );
gtk_label_set_attributes( GTK_LABEL( label ), attributes );
pango_attr_list_unref( attributes );
gtk_box_pack_start( GTK_BOX( hbox ), label, false, true, 0 );
gtk_widget_show( label );
// icon
if( !_iconName.empty() )
{
GtkIconTheme* theme( gtk_icon_theme_get_default() );
GdkPixbuf* icon( gtk_icon_theme_load_icon( theme, _iconName.c_str(), 22, (GtkIconLookupFlags) 0, 0L ) );
GtkWidget* image( gtk_image_new_from_pixbuf( icon ) );
gtk_box_pack_end( GTK_BOX( hbox ), image, false, false, 0 );
gtk_widget_show( image );
}
// main content
gtk_box_pack_start( GTK_BOX( _mainWidget ), _widget, true, true, 0 );
gtk_widget_show( _widget );
}
void
gimp_pango_layout_set_weight (PangoLayout *layout,
PangoWeight weight)
{
PangoAttrList *attrs;
PangoAttribute *attr;
g_return_if_fail (PANGO_IS_LAYOUT (layout));
attrs = pango_attr_list_new ();
attr = pango_attr_weight_new (weight);
attr->start_index = 0;
attr->end_index = -1;
pango_attr_list_insert (attrs, attr);
pango_layout_set_attributes (layout, attrs);
pango_attr_list_unref (attrs);
}
static void ygtk_step_update_layout (YGtkSteps *steps, gint step)
{
if (step < 0) return;
gboolean bold = steps->current_step == step;
GList *children = gtk_container_get_children (GTK_CONTAINER (steps));
GtkWidget *label = (GtkWidget *) g_list_nth_data (children, step);
if (g_object_get_data (G_OBJECT (label), "is-header"))
return;
if (bold) {
PangoAttrList *attrbs = pango_attr_list_new();
pango_attr_list_insert (attrbs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
gtk_label_set_attributes (GTK_LABEL (label), attrbs);
pango_attr_list_unref (attrbs);
atk_object_set_description (gtk_widget_get_accessible (label), _("Current step"));
}
else {
gtk_label_set_attributes (GTK_LABEL (label), NULL);
atk_object_set_description (gtk_widget_get_accessible (label), "");
}
g_list_free (children);
}
static void
pos_label_set_pango_attrs (GtkLabel *label)
{
/* This is a workaround for glade 3.18.3 which can't handle decimal
places on my machine.
See https://bugzilla.gnome.org/show_bug.cgi?id=742969
Remove after fix released */
PangoAttrList *attr_list;
PangoAttribute *scale;
PangoAttribute *weight;
attr_list = pango_attr_list_new ();
scale = pango_attr_scale_new (1.5);
weight = pango_attr_weight_new (PANGO_WEIGHT_SEMIBOLD);
pango_attr_list_insert (attr_list, weight);
pango_attr_list_insert (attr_list, scale);
gtk_label_set_attributes (label, attr_list);
pango_attr_list_unref (attr_list);
}
PangoAttrList *token_match_get_pango_attr ( GRegex **tokens, const char *input, PangoAttrList *retv )
{
// Do a tokenized match.
if ( tokens ) {
for ( int j = 0; tokens[j]; j++ ) {
GMatchInfo *gmi = NULL;
g_regex_match ( (GRegex *) tokens[j], input, G_REGEX_MATCH_PARTIAL, &gmi );
while ( g_match_info_matches ( gmi ) ) {
int start, end;
g_match_info_fetch_pos ( gmi, 0, &start, &end );
PangoAttribute *pa = pango_attr_underline_new ( PANGO_UNDERLINE_SINGLE );
PangoAttribute *pa2 = pango_attr_weight_new ( PANGO_WEIGHT_BOLD );
pa2->start_index = pa->start_index = start;
pa2->end_index = pa->end_index = end;
pango_attr_list_insert ( retv, pa );
pango_attr_list_insert ( retv, pa2 );
g_match_info_next ( gmi, NULL );
}
g_match_info_free ( gmi );
}
}
return retv;
}
static void calendar_properties_dialog_polish(EConfigHookItemFactoryData *data)
{
GtkTable *table = GTK_TABLE(data->parent);
GtkFrame *frame = gtk_widget_get_parent(
GTK_WIDGET(gtk_widget_get_parent(GTK_WIDGET(table))));
GtkLabel *label = gtk_label_new("General");
gtk_widget_show(GTK_WIDGET(label));
PangoAttribute *attr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
PangoAttrList *list = pango_attr_list_new();
pango_attr_list_insert(list, attr);
gtk_label_set_attributes(label, list);
gtk_frame_set_label_widget(frame, GTK_WIDGET(label));
GSList *children = g_slist_reverse(gtk_container_get_children(GTK_CONTAINER(table)));
gtk_widget_hide(GTK_WIDGET(children->data));
gtk_widget_hide(GTK_WIDGET(children->next->data));
// XXX: Changing width of colorButton is not so easy, will see
//GSList *iter;
//for (iter = children; iter; iter = iter->next)
//{
// gchar *name = gtk_widget_get_name(GTK_WIDGET(iter->data));
// if (g_strcmp0(name, "GtkColorButton") == 0 )
// {
// gint x, y;
// gtk_widget_get_size_request(GTK_WIDGET(iter->data), &x, &y);
// printf("\tsize: %dx%d\n", x, y);
// gtk_widget_set_size_request(GTK_WIDGET(iter->data), 20, -1);
// gtk_widget_get_size_request(GTK_WIDGET(iter->data), &x, &y);
// printf("\tsize: %dx%d\n", x, y);
// }
//}
g_slist_free(children);
}
/* 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 GtkWidget *
account_assistant_build_error_page (EmpathyAccountAssistant *self,
GError *error, gint page_num)
{
GtkWidget *main_vbox, *w, *hbox;
const char *message;
PangoAttrList *list;
EmpathyAccountAssistantPriv *priv = GET_PRIV (self);
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_widget_show (main_vbox);
hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
w = gtk_image_new_from_stock (GTK_STOCK_DIALOG_ERROR,
GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
if (page_num == PAGE_IMPORT)
message = _("There has been an error while importing the accounts.");
else if (page_num >= PAGE_ENTER_CREATE &&
priv->first_resp == RESPONSE_ENTER_ACCOUNT)
message = _("There has been an error while parsing the account details.");
else if (page_num >= PAGE_ENTER_CREATE &&
priv->first_resp == RESPONSE_CREATE_ACCOUNT)
message = _("There has been an error while creating the account.");
else
message = _("There has been an error.");
w = gtk_label_new (message);
gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0);
list = pango_attr_list_new ();
pango_attr_list_insert (list, pango_attr_scale_new (PANGO_SCALE_LARGE));
pango_attr_list_insert (list, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
gtk_label_set_attributes (GTK_LABEL (w), list);
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_widget_show (w);
pango_attr_list_unref (list);
message = g_markup_printf_escaped
(_("The error message was: <span style=\"italic\">%s</span>"),
error->message);
w = gtk_label_new (message);
gtk_label_set_use_markup (GTK_LABEL (w), TRUE);
gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
gtk_widget_show (w);
w = gtk_label_new (_("You can either go back and try to enter your "
"accounts' details again or quit this assistant and add accounts "
"later from the Edit menu."));
gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 6);
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_widget_show (w);
return main_vbox;
}
void i_fileinfo_gui( const gchar * filename_uri )
{
static GtkWidget *fileinfowin = NULL;
GtkWidget *fileinfowin_vbox, *fileinfowin_columns_hbox;
GtkWidget *midiinfoboxes_vbox, *miditextboxes_vbox, *miditextboxes_paned;
GtkWidget *title_hbox, *title_icon_image, *title_name_f_label, *title_name_v_entry;
GtkWidget *info_frame, *info_frame_tl, *info_grid;
GtkWidget *text_frame, *text_frame_tl, *text_tv, *text_tv_sw;
GtkWidget *lyrics_frame, *lyrics_tv, *lyrics_tv_sw;
GtkTextBuffer *text_tb, *lyrics_tb;
GtkWidget *footer_hbbox, *footer_bclose;
GdkPixbuf *title_icon_pixbuf;
PangoAttrList *pangoattrlist;
PangoAttribute *pangoattr;
GString *value_gstring;
gchar *title , *filename, *filename_utf8;
gint bpm = 0, wavg_bpm = 0;
midifile_t *mf;
if ( fileinfowin )
return;
mf = g_malloc(sizeof(midifile_t));
/****************** midifile parser ******************/
if ( !i_midi_parse_from_filename( filename_uri , mf ) )
return;
/* midifile is filled with information at this point,
bpm information is needed too */
i_midi_get_bpm( mf , &bpm , &wavg_bpm );
/*****************************************************/
fileinfowin = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_type_hint( GTK_WINDOW(fileinfowin), GDK_WINDOW_TYPE_HINT_DIALOG );
gtk_window_set_position( GTK_WINDOW(fileinfowin) , GTK_WIN_POS_CENTER );
g_signal_connect( G_OBJECT(fileinfowin) , "destroy" , G_CALLBACK(i_fileinfo_ev_destroy) , mf );
g_signal_connect( G_OBJECT(fileinfowin) , "destroy" , G_CALLBACK(gtk_widget_destroyed) , &fileinfowin );
gtk_container_set_border_width( GTK_CONTAINER(fileinfowin), 10 );
fileinfowin_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10 );
gtk_container_add( GTK_CONTAINER(fileinfowin) , fileinfowin_vbox );
/* pango attributes */
pangoattrlist = pango_attr_list_new();
pangoattr = pango_attr_weight_new( PANGO_WEIGHT_BOLD );
pangoattr->start_index = 0;
pangoattr->end_index = G_MAXINT;
pango_attr_list_insert( pangoattrlist , pangoattr );
/******************
*** TITLE LINE ***/
title_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5 );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , title_hbox , FALSE , FALSE , 0 );
title_icon_pixbuf = gdk_pixbuf_new_from_xpm_data( (const gchar **)amidiplug_xpm_midiicon );
title_icon_image = gtk_image_new_from_pixbuf( title_icon_pixbuf );
g_object_unref( title_icon_pixbuf );
gtk_misc_set_alignment( GTK_MISC(title_icon_image) , 0 , 0 );
gtk_box_pack_start( GTK_BOX(title_hbox) , title_icon_image , FALSE , FALSE , 0 );
title_name_f_label = gtk_label_new( _("Name:") );
gtk_label_set_attributes( GTK_LABEL(title_name_f_label) , pangoattrlist );
gtk_box_pack_start( GTK_BOX(title_hbox) , title_name_f_label , FALSE , FALSE , 0 );
title_name_v_entry = gtk_entry_new();
gtk_editable_set_editable( GTK_EDITABLE(title_name_v_entry) , FALSE );
gtk_widget_set_size_request( GTK_WIDGET(title_name_v_entry) , 200 , -1 );
gtk_box_pack_start(GTK_BOX(title_hbox) , title_name_v_entry , TRUE , TRUE , 0 );
fileinfowin_columns_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2 );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , fileinfowin_columns_hbox , TRUE , TRUE , 0 );
/*********************
*** MIDI INFO BOX ***/
midiinfoboxes_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2 );
/* pick the entire space if both comments and lyrics boxes are not displayed,
pick only required space if at least one of them is displayed */
if (( amidiplug_cfg_ap.ap_opts_comments_extract == 0 ) &&
( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 ))
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , midiinfoboxes_vbox , TRUE , TRUE , 0 );
else
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , midiinfoboxes_vbox , FALSE , FALSE , 0 );
info_frame_tl = gtk_label_new( "" );
gtk_label_set_markup( GTK_LABEL(info_frame_tl) , _("<span size=\"smaller\"> MIDI Info </span>") );
gtk_box_pack_start( GTK_BOX(midiinfoboxes_vbox) , info_frame_tl , FALSE , FALSE , 0 );
info_frame = gtk_frame_new( NULL );
gtk_box_pack_start( GTK_BOX(midiinfoboxes_vbox) , info_frame , TRUE , TRUE , 0 );
info_grid = gtk_grid_new();
gtk_grid_set_row_spacing( GTK_GRID(info_grid) , 4 );
gtk_grid_set_column_spacing( GTK_GRID(info_grid) , 10 );
gtk_container_set_border_width( GTK_CONTAINER(info_grid) , 3 );
gtk_container_add( GTK_CONTAINER(info_frame) , info_grid );
value_gstring = g_string_new( "" );
/* midi format */
G_STRING_PRINTF( value_gstring , "type %i" , mf->format );
i_fileinfo_grid_add_entry( _("Format:") , value_gstring->str , info_grid , 0 , pangoattrlist );
/* midi length */
G_STRING_PRINTF( value_gstring , "%i" , (gint)(mf->length / 1000) );
i_fileinfo_grid_add_entry( _("Length (msec):") , value_gstring->str , info_grid , 1 , pangoattrlist );
/* midi num of tracks */
G_STRING_PRINTF( value_gstring , "%i" , mf->num_tracks );
i_fileinfo_grid_add_entry( _("No. of Tracks:") , value_gstring->str , info_grid , 2 , pangoattrlist );
/* midi bpm */
if ( bpm > 0 )
G_STRING_PRINTF( value_gstring , "%i" , bpm ); /* fixed bpm */
else
G_STRING_PRINTF( value_gstring , _("variable") ); /* variable bpm */
i_fileinfo_grid_add_entry( _("BPM:") , value_gstring->str , info_grid , 3 , pangoattrlist );
/* midi weighted average bpm */
if ( bpm > 0 )
G_STRING_PRINTF( value_gstring , "/" ); /* fixed bpm, don't care about wavg_bpm */
else
G_STRING_PRINTF( value_gstring , "%i" , wavg_bpm ); /* variable bpm, display wavg_bpm */
i_fileinfo_grid_add_entry( _("BPM (wavg):") , value_gstring->str , info_grid , 4 , pangoattrlist );
/* midi time division */
G_STRING_PRINTF( value_gstring , "%i" , mf->time_division );
i_fileinfo_grid_add_entry( _("Time Div:") , value_gstring->str , info_grid , 5 , pangoattrlist );
g_string_free( value_gstring , TRUE );
/**********************************
*** MIDI COMMENTS/LYRICS BOXES ***/
miditextboxes_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2 );
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , miditextboxes_vbox , TRUE , TRUE , 0 );
text_frame_tl = gtk_label_new( "" );
gtk_label_set_markup( GTK_LABEL(text_frame_tl) ,
_("<span size=\"smaller\"> MIDI Comments and Lyrics </span>") );
gtk_box_pack_start( GTK_BOX(miditextboxes_vbox) , text_frame_tl , FALSE , FALSE , 0 );
miditextboxes_paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start( GTK_BOX(miditextboxes_vbox) , miditextboxes_paned , TRUE , TRUE , 0 );
text_frame = gtk_frame_new( NULL );
gtk_paned_pack1( GTK_PANED(miditextboxes_paned) , text_frame , TRUE , TRUE );
text_tv = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW(text_tv) , FALSE );
gtk_text_view_set_cursor_visible( GTK_TEXT_VIEW(text_tv) , FALSE );
gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(text_tv) , GTK_WRAP_WORD );
gtk_text_view_set_right_margin( GTK_TEXT_VIEW(text_tv) , 4 );
gtk_text_view_set_left_margin( GTK_TEXT_VIEW(text_tv) , 4 );
gtk_widget_set_size_request( text_tv , 300 , 113 );
text_tv_sw = gtk_scrolled_window_new( NULL , NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(text_tv_sw) ,
GTK_POLICY_AUTOMATIC , GTK_POLICY_ALWAYS );
gtk_container_add( GTK_CONTAINER(text_frame) , text_tv_sw );
gtk_container_add( GTK_CONTAINER(text_tv_sw) , text_tv );
lyrics_frame = gtk_frame_new( NULL );
gtk_paned_pack2( GTK_PANED(miditextboxes_paned) , lyrics_frame , TRUE , TRUE );
lyrics_tv = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW(lyrics_tv) , FALSE );
gtk_text_view_set_cursor_visible( GTK_TEXT_VIEW(lyrics_tv) , FALSE );
gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(lyrics_tv) , GTK_WRAP_WORD );
gtk_text_view_set_right_margin( GTK_TEXT_VIEW(lyrics_tv) , 4 );
gtk_text_view_set_left_margin( GTK_TEXT_VIEW(lyrics_tv) , 4 );
gtk_widget_set_size_request( lyrics_tv , 300 , 113 );
lyrics_tv_sw = gtk_scrolled_window_new( NULL , NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(lyrics_tv_sw) ,
GTK_POLICY_AUTOMATIC , GTK_POLICY_ALWAYS );
gtk_container_add( GTK_CONTAINER(lyrics_frame) , lyrics_tv_sw );
gtk_container_add( GTK_CONTAINER(lyrics_tv_sw) , lyrics_tv );
text_tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(text_tv) );
lyrics_tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(lyrics_tv) );
/* call the buffer fill routine if at least one between comments and lyrics is enabled */
if (( amidiplug_cfg_ap.ap_opts_comments_extract > 0 ) ||
( amidiplug_cfg_ap.ap_opts_lyrics_extract > 0 ))
i_fileinfo_text_fill( mf , text_tb , lyrics_tb );
if (( amidiplug_cfg_ap.ap_opts_comments_extract > 0 ) &&
( gtk_text_buffer_get_char_count( text_tb ) == 0 ))
{
GtkTextIter start, end;
GtkTextTag *tag = gtk_text_buffer_create_tag( text_tb , "italicstyle" ,
"style" , PANGO_STYLE_ITALIC , NULL );
/*gtk_text_view_set_justification( GTK_TEXT_VIEW(text_tv) , GTK_JUSTIFY_CENTER );*/
gtk_text_buffer_set_text( text_tb , _("* no comments available in this MIDI file *") , -1 );
gtk_text_buffer_get_iter_at_offset( text_tb , &start , 0 );
gtk_text_buffer_get_iter_at_offset( text_tb , &end , -1 );
gtk_text_buffer_apply_tag( text_tb , tag , &start , &end );
}
if (( amidiplug_cfg_ap.ap_opts_lyrics_extract > 0 ) &&
( gtk_text_buffer_get_char_count( lyrics_tb ) == 0 ))
{
GtkTextIter start, end;
GtkTextTag *tag = gtk_text_buffer_create_tag( lyrics_tb , "italicstyle" ,
"style" , PANGO_STYLE_ITALIC , NULL );
/*gtk_text_view_set_justification( GTK_TEXT_VIEW(lyrics_tv) , GTK_JUSTIFY_CENTER );*/
gtk_text_buffer_set_text( lyrics_tb , _("* no lyrics available in this MIDI file *") , -1 );
gtk_text_buffer_get_iter_at_offset( lyrics_tb , &start , 0 );
gtk_text_buffer_get_iter_at_offset( lyrics_tb , &end , -1 );
gtk_text_buffer_apply_tag( lyrics_tb , tag , &start , &end );
}
/* hide boxes for disabled options (comments and/or lyrics) */
if (( amidiplug_cfg_ap.ap_opts_comments_extract == 0 ) &&
( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 ))
{
gtk_widget_set_no_show_all( miditextboxes_vbox , TRUE );
gtk_widget_hide( miditextboxes_vbox );
}
else if ( amidiplug_cfg_ap.ap_opts_comments_extract == 0 )
{
gtk_widget_set_no_show_all( text_frame , TRUE );
gtk_widget_hide( text_frame );
}
else if ( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 )
{
gtk_widget_set_no_show_all( lyrics_frame , TRUE );
gtk_widget_hide( lyrics_frame );
}
/**************
*** FOOTER ***/
footer_hbbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout( GTK_BUTTON_BOX(footer_hbbox) , GTK_BUTTONBOX_END );
footer_bclose = gtk_button_new_from_stock( GTK_STOCK_CLOSE );
g_signal_connect( G_OBJECT(footer_bclose) , "clicked" , G_CALLBACK(i_fileinfo_ev_close) , fileinfowin );
gtk_container_add( GTK_CONTAINER(footer_hbbox) , footer_bclose );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , footer_hbbox , FALSE , FALSE , 0 );
/* utf8-ize filename and set window title */
filename = g_filename_from_uri( filename_uri , NULL , NULL );
if ( !filename )
filename = g_strdup( filename_uri );
filename_utf8 = g_strdup(g_filename_to_utf8( filename , -1 , NULL , NULL , NULL ));
if ( !filename_utf8 )
{
/* utf8 fallback */
gchar *chr , *convert_str = g_strdup( filename );
for ( chr = convert_str ; *chr ; chr++ )
{
if ( *chr & 0x80 )
*chr = '?';
}
filename_utf8 = g_strconcat( convert_str , _(" (invalid UTF-8)") , NULL );
g_free(convert_str);
}
title = g_path_get_basename (filename_utf8);
gtk_window_set_title( GTK_WINDOW(fileinfowin) , title);
g_free(title);
/* set the text for the filename header too */
gtk_entry_set_text( GTK_ENTRY(title_name_v_entry) , filename_utf8 );
gtk_editable_set_position( GTK_EDITABLE(title_name_v_entry) , -1 );
g_free(filename_utf8);
g_free(filename);
gtk_widget_grab_focus( GTK_WIDGET(footer_bclose) );
gtk_widget_show_all( fileinfowin );
}
