GtkTextTagTable *SourceEditor::createSharedTagTable()
{
GtkTextTagTable *tagTable = TextEditor::createSharedTagTable();
for (int i = 0; i < N_TOKEN_KINDS; ++i)
{
GtkTextTag *tag;
std::string tagName(SOURCE_EDITOR "/");
tagName += TOKEN_KIND_NAMES[i];
tag = gtk_text_tag_new(tagName.c_str());
g_object_set(tag, "foreground", TOKEN_COLORS[i], NULL);
gtk_text_tag_table_add(tagTable, tag);
g_object_unref(tag);
tokenTags[i] = tag;
}
GtkTextTag *tag;
tag = gtk_text_tag_new(SOURCE_EDITOR "/invisible");
g_object_set(tag, "invisible", TRUE, NULL);
gtk_text_tag_table_add(tagTable, tag);
g_object_unref(tag);
tagInvisible = tag;
return tagTable;
}
GtkWidget *
gui_chat_create ()
{
/* tag table */
tag_table = gtk_text_tag_table_new ();
tags[0] = gtk_text_tag_new ("team0");
g_object_set (tags[0], "foreground", "orange", NULL);
gtk_text_tag_table_add (tag_table, tags[0]);
tags[1] = gtk_text_tag_new ("team1");
g_object_set (tags[1], "foreground", "dark red", NULL);
gtk_text_tag_table_add (tag_table, tags[1]);
tags[2] = gtk_text_tag_new ("team2");
g_object_set (tags[2], "foreground", "dark blue", NULL);
gtk_text_tag_table_add (tag_table, tags[2]);
tags[3] = gtk_text_tag_new ("team3");
g_object_set (tags[3], "foreground", "dark gray", NULL);
gtk_text_tag_table_add (tag_table, tags[3]);
/* widgets */
logview = gtk_text_view_new ();
g_object_set (G_OBJECT (logview),
"editable", FALSE,
"wrap-mode", GTK_WRAP_WORD,
NULL);
GtkWidget *scrolled = gtk_scrolled_window_new (NULL, NULL);
g_object_set (G_OBJECT (scrolled),
"shadow-type", GTK_SHADOW_IN,
"hscrollbar-policy", GTK_POLICY_NEVER,
"vscrollbar-policy", GTK_POLICY_ALWAYS,
NULL);
gtk_container_add (GTK_CONTAINER (scrolled), logview);
entry = gtk_entry_new ();
g_object_set (G_OBJECT (entry),
"secondary-icon-stock", GTK_STOCK_MEDIA_PLAY,
NULL);
g_signal_connect (entry, "activate", G_CALLBACK (gui_chat_entry_activated), NULL);
g_signal_connect (entry, "icon-release", G_CALLBACK (gui_chat_entry_icon_clicked), NULL);
page = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
g_object_set (G_OBJECT (page),
"border-width", 2,
"sensitive", FALSE,
NULL);
gtk_box_pack_start (GTK_BOX (page), scrolled, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (page), entry, FALSE, TRUE, 0);
gtk_widget_show_all (page);
return page;
}
bg_gtk_textview_t * bg_gtk_textview_create()
{
bg_gtk_textview_t * t;
t = calloc(1, sizeof(*t));
if(!tag_table)
{
tag_table = gtk_text_tag_table_new();
text_tag = gtk_text_tag_new("Font");
g_object_set(text_tag, "editable", 0, NULL);
gtk_text_tag_table_add(tag_table,
text_tag);
}
t->buffer = gtk_text_buffer_new(tag_table);
t->textview = gtk_text_view_new_with_buffer(t->buffer);
g_signal_connect(G_OBJECT(t->textview), "realize",
G_CALLBACK(set_bg), NULL);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(t->textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(t->textview), GTK_WRAP_NONE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(t->textview), 0);
gtk_widget_show(t->textview);
return t;
}
void interface_image_add(GtkWidget * tab, GtkTextIter * iter,
GdkPixbuf * pixbuf)
{
if (pixbuf == NULL)
return;
GtkTextView *out1 = GTK_TEXT_VIEW(interface_get_widget(tab, "output1"));
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(out1));
GtkTextIter it;
if (iter != NULL)
it = *iter;
else
gtk_text_buffer_get_end_iter(buffer, &it);
gtk_text_buffer_insert_pixbuf(buffer, &it, pixbuf);
// append tag name, if needed
SESSION_STATE *session = g_object_get_data(G_OBJECT(tab), "session");
if (!session->imagemapName) return;
GtkTextTag *t = gtk_text_tag_new (session->imagemapName);
g_object_set_data(G_OBJECT(t), "imagemap",
g_strdup(session->imagemapName));
GtkTextTagTable *table =
gtk_text_buffer_get_tag_table(buffer);
gtk_text_tag_table_add(table, t);
gtk_text_buffer_apply_tag(buffer, t, &it, &it);
g_signal_connect(G_OBJECT(t), "event",
G_CALLBACK(on_tag_click), session);
}
static VALUE
initialize(int argc, VALUE *argv, VALUE self)
{
VALUE name;
rb_scan_args(argc, argv, "01", &name);
G_INITIALIZE(self, gtk_text_tag_new(NIL_P(name) ? NULL : RVAL2CSTR(name)));
return Qnil;
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE name;
rb_scan_args(argc, argv, "01", &name);
G_INITIALIZE(self, gtk_text_tag_new(RVAL2CSTR_ACCEPT_NIL(name)));
return Qnil;
}
static void
load_filters (LogviewPrefs *prefs)
{
gchar **filters;
gchar **tokens;
const gchar *str;
LogviewFilter *filter;
GtkTextTag *tag;
GdkRGBA color;
gint idx;
filters = g_settings_get_strv (prefs->priv->logview_prefs,
PREF_FILTERS);
prefs->priv->filters = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) g_free,
(GDestroyNotify) g_object_unref);
for (idx = 0; filters[idx] != NULL; idx++) {
str = filters[idx];
tokens = g_strsplit (str, DELIMITER, MAX_TOKENS);
filter = logview_filter_new (tokens[FILTER_NAME], tokens[FILTER_REGEX]);
tag = gtk_text_tag_new (tokens[FILTER_NAME]);
g_object_set (tag, "invisible",
g_str_equal (tokens[FILTER_INVISIBLE], "1"), NULL);
if (strlen (tokens[FILTER_FOREGROUND])) {
gdk_rgba_parse (&color, tokens[FILTER_FOREGROUND]);
g_object_set (tag, "foreground-rgba", &color,
"foreground-set", TRUE, NULL);
}
if (strlen (tokens[FILTER_BACKGROUND])) {
gdk_rgba_parse (&color, tokens[FILTER_BACKGROUND]);
g_object_set (tag, "paragraph-background-rgba", &color,
"paragraph-background-set", TRUE, NULL);
}
g_object_set (filter, "texttag", tag, NULL);
g_hash_table_insert (prefs->priv->filters,
g_strdup(tokens[FILTER_NAME]),
filter);
g_object_ref (filter);
g_object_unref (tag);
g_strfreev (tokens);
}
g_strfreev (filters);
}
/**
* \internal
* Appends \p text into validate log with pair of style/values, as seen in #GtkTextTag properties.
*
* \see GtkTextTag
*/
static GtkTextTag *
validate_append_text_with_property_list(struct validate *validate, const gchar * text,
const gchar * first_property_name, ...)
{
GtkTextTag *text_tag;
va_list argp;
text_tag = gtk_text_tag_new(NULL);
gtk_text_tag_table_add(gtk_text_buffer_get_tag_table(validate->text_buffer), text_tag);
va_start(argp, first_property_name);
g_object_set_valist(G_OBJECT(text_tag), first_property_name, argp);
va_end(argp);
validate_append_text_with_tag(validate, text_tag, text);
return text_tag;
}
GtkTextTag *get_bg_color_tag(GtkTextBuffer * buffer, int color)
{
/* "background" is property name for color */
char s[10];
colorCode(s, color, FALSE);
GtkTextTagTable *table = gtk_text_buffer_get_tag_table(buffer);
GtkTextTag *tag = gtk_text_tag_table_lookup(table, s);
if (!tag) {
// tag not found - need to create it
tag = gtk_text_tag_new(s);
// first character is F/B (foreground/background), hence we need to
// get the color name from the second char, hence that s+1
// g_object_set(tag, "background", s + 1, NULL);
g_object_set(tag, "background", g_strdup (s + 1), NULL);
gtk_text_tag_table_add(table, tag);
}
return tag;
}
static void highlight_add_tag (const char *name, const GdkRGBA *text,
const GdkRGBA *background, const char *font)
{
GtkTextTag *tag;
g_assert (highlight_tag_table != NULL);
tag = gtk_text_tag_table_lookup (highlight_tag_table, name);
g_assert (tag == NULL);
tag = gtk_text_tag_new (name);
g_object_set (G_OBJECT (tag),
"foreground-rgba", text,
"background-rgba", background,
"font", font, NULL);
gtk_text_tag_table_add (highlight_tag_table, tag);
gtk_text_tag_set_priority (tag, next_priority);
next_priority++;
}
static gboolean on_show_dlg(gpointer user_data)
{
FmProgressDisplay* data = (FmProgressDisplay*)user_data;
GtkBuilder* builder;
GtkLabel* to;
GtkWidget *to_label;
FmPath* dest;
const char* title = NULL;
GtkTextTagTable* tag_table;
GDK_THREADS_ENTER();
if(g_source_is_destroyed(g_main_current_source()))
goto _end;
builder = gtk_builder_new();
tag_table = gtk_text_tag_table_new();
gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/progress.ui", NULL);
data->dlg = GTK_DIALOG(gtk_builder_get_object(builder, "dlg"));
g_object_weak_ref(G_OBJECT(data->dlg), on_progress_dialog_destroy, data);
g_signal_connect(data->dlg, "response", G_CALLBACK(on_response), data);
/* FIXME: connect to "close" signal */
to_label = (GtkWidget*)gtk_builder_get_object(builder, "to_label");
to = GTK_LABEL(gtk_builder_get_object(builder, "dest"));
data->icon = GTK_IMAGE(gtk_builder_get_object(builder, "icon"));
data->msg = GTK_LABEL(gtk_builder_get_object(builder, "msg"));
data->act = GTK_LABEL(gtk_builder_get_object(builder, "action"));
data->src = GTK_LABEL(gtk_builder_get_object(builder, "src"));
data->dest = (GtkWidget*)gtk_builder_get_object(builder, "dest");
data->current = GTK_LABEL(gtk_builder_get_object(builder, "current"));
data->progress = GTK_PROGRESS_BAR(gtk_builder_get_object(builder, "progress"));
data->error_pane = (GtkWidget*)gtk_builder_get_object(builder, "error_pane");
data->error_msg = GTK_TEXT_VIEW(gtk_builder_get_object(builder, "error_msg"));
data->remaining_time = GTK_LABEL(gtk_builder_get_object(builder, "remaining_time"));
data->bold_tag = gtk_text_tag_new("bold");
g_object_set(data->bold_tag, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_tag_table_add(tag_table, data->bold_tag);
data->error_buf = gtk_text_buffer_new(tag_table);
g_object_unref(tag_table);
gtk_text_view_set_buffer(data->error_msg, data->error_buf);
g_object_unref(builder);
/* set the src label */
/* FIXME: direct access to job struct! */
if(data->job->srcs)
{
GList* l = fm_path_list_peek_head_link(data->job->srcs);
int i;
char* disp;
FmPath* path;
GString* str = g_string_sized_new(512);
path = FM_PATH(l->data);
disp = fm_path_display_basename(path);
g_string_assign(str, disp);
g_free(disp);
for( i =1, l=l->next; i < 10 && l; l=l->next, ++i)
{
path = FM_PATH(l->data);
g_string_append(str, _(", "));
disp = fm_path_display_basename(path);
g_string_append(str, disp);
g_free(disp);
}
if(l)
g_string_append(str, "...");
gtk_label_set_text(data->src, str->str);
g_string_free(str, TRUE);
}
/* FIXME: use accessor functions instead */
/* FIXME: direct access to job struct! */
switch(data->job->type)
{
case FM_FILE_OP_MOVE:
title = _("Moving files");
break;
case FM_FILE_OP_COPY:
title = _("Copying files");
break;
case FM_FILE_OP_TRASH:
title = _("Trashing files");
break;
case FM_FILE_OP_DELETE:
title = _("Deleting files");
break;
case FM_FILE_OP_LINK:
title = _("Creating symlinks");
break;
case FM_FILE_OP_CHANGE_ATTR:
title = _("Changing file attributes");
break;
case FM_FILE_OP_UNTRASH:
break;
case FM_FILE_OP_NONE: ;
}
if(title)
{
gtk_window_set_title(GTK_WINDOW(data->dlg), title);
gtk_label_set_text(data->act, title);
}
dest = fm_file_ops_job_get_dest(data->job);
if(dest)
{
char* dest_str = fm_path_display_name(dest, TRUE);
gtk_label_set_text(to, dest_str);
g_free(dest_str);
}
else
{
gtk_widget_destroy(data->dest);
gtk_widget_destroy(to_label);
}
gtk_window_set_transient_for(GTK_WINDOW(data->dlg), data->parent);
gtk_window_present(GTK_WINDOW(data->dlg));
data->update_timeout = g_timeout_add(500, on_update_dlg, data);
data->delay_timeout = 0;
_end:
GDK_THREADS_LEAVE();
return FALSE;
}
/* Process plain text in the font table (font names separated by semicolons) */
static void
font_table_text(ParserContext *ctx)
{
gchar *name, *semicolon, *tagname, *fontstring = NULL;
FontProperties *fontprop;
FontTableState *state = (FontTableState *)get_state(ctx);
GtkTextTag *tag;
static gchar *font_suggestions[] = {
"Sans", /* Default font for \fnil */
"Serif", /* \froman */
"Sans", /* \fswiss */
"Monospace", /* \fmodern */
"Script", /* \fscript */
NULL, /* \fdecor */
NULL, /* \ftech */
NULL /* \fbidi */
};
name = g_strdup(ctx->text->str);
semicolon = strchr(name, ';');
if(!semicolon)
{
gchar *newname = g_strconcat(state->name, name, NULL);
g_free(state->name);
state->name = newname;
g_string_truncate(ctx->text, 0);
return;
}
g_string_assign(ctx->text, semicolon + 1); /* Leave the text after the semicolon in the buffer */
*semicolon = '\0';
fontprop = g_slice_new0(FontProperties);
fontprop->index = state->index;
fontprop->codepage = state->codepage;
fontprop->font_name = g_strconcat(state->name, name, NULL);
ctx->font_table = g_slist_prepend(ctx->font_table, fontprop);
/* Add the tag to the buffer right now instead of when the font is used,
since any font might be declared the default font; remove any previous font
with this font table index first */
tagname = g_strdup_printf("osxcart-rtf-font-%i", state->index);
if((tag = gtk_text_tag_table_lookup(ctx->tags, tagname)))
gtk_text_tag_table_remove(ctx->tags, tag);
tag = gtk_text_tag_new(tagname);
if(fontprop->font_name && font_suggestions[state->family])
fontstring = g_strconcat(fontprop->font_name,
",",
font_suggestions[state->family],
NULL);
else if(fontprop->font_name)
fontstring = g_strdup(fontprop->font_name);
else if(font_suggestions[state->family])
fontstring = g_strdup(font_suggestions[state->family]);
if(fontstring)
{
g_object_set(tag,
"family", fontstring,
"family-set", TRUE,
NULL);
g_free(fontstring);
}
gtk_text_tag_table_add(ctx->tags, tag);
g_free(tagname);
g_free(state->name);
state->index = 0;
state->family = FONT_FAMILY_NIL;
state->codepage = -1;
state->name = g_strdup("");
}
void create_text_buffer()
{
gint i;
LOG(LOG_DEBUG, "IN : create_text_buffer()");
if(text_buffer != NULL){
g_object_unref(G_OBJECT(text_buffer));
/*
g_object_unref(G_OBJECT(text_buffer));
g_object_unref(tag_keyword);
g_object_unref(tag_bold);
g_object_unref(tag_link);
g_object_unref(tag_sound);
g_object_unref(tag_movie);
g_object_unref(tag_italic);
g_object_unref(tag_subscript);
g_object_unref(tag_superscript);
g_object_unref(tag_gaiji);
g_object_unref(tag_plain);
g_object_unref(tag_colored);
g_object_unref(tag_reverse);
for(i=0; i < MAX_INDENT ; i ++){
g_object_unref(tag_indent[i]);
}
*/
}
tag_table = gtk_text_tag_table_new();
text_buffer = gtk_text_buffer_new (tag_table);
/*
g_object_set(text_buffer,
"tag-table", tag_table);
*/
tag_keyword = gtk_text_tag_new("keyword");
g_object_set(tag_keyword,
"weight", PANGO_WEIGHT_BOLD,
"foreground", color_str[COLOR_KEYWORD],
"font", fontset_normal,
NULL);
gtk_text_tag_table_add(tag_table, tag_keyword);
tag_bold = gtk_text_tag_new("bold");
g_object_set(tag_bold,
"weight", PANGO_WEIGHT_BOLD,
"font", fontset_bold,
NULL);
gtk_text_tag_table_add(tag_table, tag_bold);
tag_link = gtk_text_tag_new("link");
g_object_set(tag_link,
"foreground", color_str[COLOR_LINK],
"font", fontset_normal,
NULL);
gtk_text_tag_table_add(tag_table, tag_link);
tag_sound = gtk_text_tag_new("sound");
g_object_set(tag_sound,
"foreground", color_str[COLOR_SOUND],
"font", fontset_normal,
NULL);
gtk_text_tag_table_add(tag_table, tag_sound);
tag_movie = gtk_text_tag_new("movie");
g_object_set(tag_movie,
"foreground", color_str[COLOR_MOVIE],
"font", fontset_normal,
NULL);
gtk_text_tag_table_add(tag_table, tag_movie);
tag_italic = gtk_text_tag_new("italic");
g_object_set(tag_italic,
"style", PANGO_STYLE_ITALIC,
"font", fontset_italic,
NULL);
gtk_text_tag_table_add(tag_table, tag_italic);
tag_superscript = gtk_text_tag_new("superscript");
g_object_set(tag_superscript,
"rise", 5 * PANGO_SCALE,
"rise", 3,
"font", fontset_superscript,
NULL);
gtk_text_tag_table_add(tag_table, tag_superscript);
tag_subscript = gtk_text_tag_new("subscript");
g_object_set(tag_subscript,
// "rise", -5 * PANGO_SCALE,
"rise", -3,
"font", fontset_superscript,
NULL);
gtk_text_tag_table_add(tag_table, tag_subscript);
tag_gaiji = gtk_text_tag_new("gaiji");
g_object_set(tag_gaiji,
"rise", -2 * PANGO_SCALE,
NULL);
gtk_text_tag_table_add(tag_table, tag_gaiji);
tag_center = gtk_text_tag_new("center");
g_object_set(tag_center,
"justification", GTK_JUSTIFY_CENTER,
"font", fontset_normal,
NULL);
gtk_text_tag_table_add(tag_table, tag_center);
tag_plain = gtk_text_tag_new("plain");
g_object_set(tag_plain,
"wrap_mode", GTK_WRAP_WORD,
"font", fontset_normal,
NULL);
gtk_text_tag_table_add(tag_table, tag_plain);
tag_colored = gtk_text_tag_new("colored");
g_object_set(tag_colored,
"foreground", color_str[COLOR_EMPHASIS],
NULL);
gtk_text_tag_table_add(tag_table, tag_colored);
tag_reverse = gtk_text_tag_new("reverse");
g_object_set(tag_reverse,
"background", color_str[COLOR_REVERSE_BG],
// "foreground", color_str[COLOR_EMPHASIS],
// "foreground", "#ff0000",
// "font", fontset_normal,
NULL);
gtk_text_tag_table_add(tag_table, tag_reverse);
for(i=0; i < MAX_INDENT ; i ++){
gchar name[16];
sprintf(name, "tag%d", i);
tag_indent[i] = gtk_text_tag_new(name);
g_object_set(tag_indent[i],
"left_margin", i * INDENT_LEFT_MARGIN + INITIAL_LEFT_MARGIN,
NULL);
gtk_text_tag_table_add(tag_table, tag_indent[i]);
}
/*
tag_keyword = gtk_text_buffer_create_tag(text_buffer, "keyword",
"weight", PANGO_WEIGHT_BOLD,
"foreground", color_str[COLOR_KEYWORD],
"font", fontset_normal,
NULL);
tag_bold = gtk_text_buffer_create_tag(text_buffer, "bold",
"weight", PANGO_WEIGHT_BOLD,
"font", fontset_bold,
NULL);
tag_link = gtk_text_buffer_create_tag(text_buffer, "link",
"foreground", color_str[COLOR_LINK],
"font", fontset_normal,
NULL);
tag_sound = gtk_text_buffer_create_tag(text_buffer, "sound",
"foreground", color_str[COLOR_SOUND],
"font", fontset_normal,
NULL);
tag_movie = gtk_text_buffer_create_tag(text_buffer, "movie",
"foreground", color_str[COLOR_MOVIE],
"font", fontset_normal,
NULL);
tag_italic = gtk_text_buffer_create_tag(text_buffer, "italic",
"style", PANGO_STYLE_ITALIC,
"font", fontset_italic,
NULL);
tag_superscript = gtk_text_buffer_create_tag(text_buffer, "superscript",
// "rise", 5 * PANGO_SCALE,
"rise", 3,
"font", fontset_superscript,
NULL);
tag_subscript = gtk_text_buffer_create_tag(text_buffer, "subscript",
// "rise", -5 * PANGO_SCALE,
"rise", -3,
"font", fontset_superscript,
NULL);
tag_gaiji = gtk_text_buffer_create_tag(text_buffer, "gaiji",
"rise", -2 * PANGO_SCALE,
NULL);
tag_center = gtk_text_buffer_create_tag(text_buffer, "center",
"justification", GTK_JUSTIFY_CENTER,
"font", fontset_normal,
NULL);
tag_plain = gtk_text_buffer_create_tag(text_buffer, "plain",
"wrap_mode", GTK_WRAP_WORD,
"font", fontset_normal,
NULL);
for(i=0; i < MAX_INDENT ; i ++){
gchar name[16];
sprintf(name, "tag%d", i);
tag_indent[i] = gtk_text_buffer_create_tag(text_buffer, name,
"left_margin", i * INDENT_LEFT_MARGIN + INITIAL_LEFT_MARGIN,
NULL);
}
*/
LOG(LOG_DEBUG, "OUT : create_text_buffer()");
}
static void
on_dialog_add_edit_reponse (GtkWidget *dialog, int response_id,
LogviewFilterManager *manager)
{
GtkWidget *entry_name, *entry_regex;
GtkWidget *radio_color, *radio_visible;
GtkWidget *check_foreground, *check_background;
GtkWidget *color_foreground, *color_background;
gchar *old_name;
const gchar *name;
const gchar *regex;
LogviewFilter *filter;
GtkTextTag *tag;
GtkBuilder *builder;
old_name = g_object_get_data (G_OBJECT (manager), "old_name");
builder = manager->priv->builder;
entry_name = GTK_WIDGET (gtk_builder_get_object (builder,
"entry_name"));
entry_regex = GTK_WIDGET (gtk_builder_get_object (builder,
"entry_regex"));
radio_color = GTK_WIDGET (gtk_builder_get_object (builder,
"radio_color"));
radio_visible = GTK_WIDGET (gtk_builder_get_object (builder,
"radio_visible"));
check_foreground = GTK_WIDGET (gtk_builder_get_object (builder,
"check_foreground"));
check_background = GTK_WIDGET (gtk_builder_get_object (builder,
"check_background"));
color_foreground = GTK_WIDGET (gtk_builder_get_object (builder,
"color_foreground"));
color_background = GTK_WIDGET (gtk_builder_get_object (builder,
"color_background"));
if (response_id == GTK_RESPONSE_APPLY) {
name = gtk_entry_get_text (GTK_ENTRY (entry_name));
regex = gtk_entry_get_text (GTK_ENTRY (entry_regex));
if (!check_name (manager, name) || !check_regex (manager, regex)) {
return;
}
filter = logview_filter_new (name, regex);
tag = gtk_text_tag_new (name);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (radio_color))) {
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_foreground))) {
GdkColor foreground_color;
gtk_color_button_get_color (GTK_COLOR_BUTTON (color_foreground),
&foreground_color);
g_object_set (G_OBJECT (tag),
"foreground-gdk", &foreground_color,
"foreground-set", TRUE, NULL);
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_background))) {
GdkColor background_color;
gtk_color_button_get_color (GTK_COLOR_BUTTON (color_background),
&background_color);
g_object_set (tag,
"paragraph-background-gdk", &background_color,
"paragraph-background-set", TRUE, NULL);
}
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_foreground))
&& !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_background))) {
GtkWidget *error_dialog;
error_dialog = gtk_message_dialog_new (GTK_WINDOW (manager),
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s",
_("Please specify either foreground or background color!"));
gtk_dialog_run (GTK_DIALOG (error_dialog));
gtk_widget_destroy (error_dialog);
g_object_unref (tag);
g_object_unref (filter);
return;
}
} else { /* !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (radio_color)) */
g_object_set (tag, "invisible", TRUE, NULL);
}
if (old_name && !g_str_equal (old_name, name)) {
logview_prefs_remove_filter (manager->priv->prefs, old_name);
}
g_object_set (G_OBJECT (filter), "texttag", tag, NULL);
g_object_unref (tag);
logview_prefs_add_filter (manager->priv->prefs, filter);
g_object_unref (filter);
logview_filter_manager_update_model (manager);
}
gtk_widget_destroy (dialog);
}
static void
entry_info_fetched_done (EntryProperties *eprop, GdaLdapEntry *entry)
{
GtkTextBuffer *tbuffer;
GtkTextIter start, end;
TConnection *tcnc = eprop->priv->tcnc;
tbuffer = eprop->priv->text;
gtk_text_buffer_get_start_iter (tbuffer, &start);
gtk_text_buffer_get_end_iter (tbuffer, &end);
gtk_text_buffer_delete (tbuffer, &start, &end);
guint i;
GtkTextIter current;
gtk_text_buffer_get_start_iter (tbuffer, ¤t);
/* DN */
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, _("Distinguished Name:"), -1,
"section", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1, "starter", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, entry->dn, -1,
"data", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
/* other attributes */
const gchar *basedn;
GdaDataHandler *ts_dh = NULL;
basedn = t_connection_ldap_get_base_dn (tcnc);
for (i = 0; i < entry->nb_attributes; i++) {
GdaLdapAttribute *attr;
gchar *tmp;
attr = entry->attributes [i];
tmp = g_strdup_printf ("%s:", attr->attr_name);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, tmp, -1, "section", NULL);
g_free (tmp);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
guint j;
for (j = 0; j < attr->nb_values; j++) {
const GValue *cvalue;
cvalue = attr->values [j];
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1,
"starter", NULL);
if (G_VALUE_TYPE (cvalue) == GDA_TYPE_BINARY) {
GValue *copyvalue;
GtkTextTagTable *table;
GtkTextTag *tag;
GtkTextMark *mark;
copyvalue = gda_value_copy (cvalue);
table = gtk_text_buffer_get_tag_table (tbuffer);
tag = gtk_text_tag_new (NULL);
gtk_text_tag_table_add (table, tag);
g_object_set_data_full ((GObject*) tag, "binvalue",
copyvalue, (GDestroyNotify) gda_value_free);
g_object_unref ((GObject*) tag);
mark = gtk_text_buffer_create_mark (tbuffer, NULL, ¤t, TRUE);
GdkPixbuf *pixbuf;
pixbuf = data_to_pixbuf (cvalue);
if (pixbuf) {
gtk_text_buffer_insert_pixbuf (tbuffer, ¤t, pixbuf);
g_object_unref (pixbuf);
}
else {
GdaDataHandler *dh;
dh = gda_data_handler_get_default (G_VALUE_TYPE (cvalue));
if (dh)
tmp = gda_data_handler_get_str_from_value (dh, cvalue);
else
tmp = gda_value_stringify (cvalue);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
tmp, -1,
"data", NULL);
g_free (tmp);
}
GtkTextIter before;
gtk_text_buffer_get_iter_at_mark (tbuffer, &before, mark);
gtk_text_buffer_apply_tag (tbuffer, tag, &before, ¤t);
gtk_text_buffer_delete_mark (tbuffer, mark);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
"\n", 1,
"data", NULL);
}
else {
GdaDataHandler *dh;
dh = gda_data_handler_get_default (G_VALUE_TYPE (cvalue));
if (dh)
tmp = gda_data_handler_get_str_from_value (dh, cvalue);
else
tmp = gda_value_stringify (cvalue);
if (tmp) {
if (*tmp &&
((basedn && g_str_has_suffix (tmp, basedn)) || !basedn) &&
gda_ldap_is_dn (tmp)) {
/* we have a DN */
GtkTextTag *tag;
tag = gtk_text_buffer_create_tag (tbuffer, NULL,
"foreground", "blue",
"weight", PANGO_WEIGHT_NORMAL,
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
g_object_set_data_full (G_OBJECT (tag), "dn",
g_strdup (tmp), g_free);
gtk_text_buffer_insert_with_tags (tbuffer, ¤t,
tmp, -1,
tag, NULL);
}
else if (attr->attr_name &&
!g_ascii_strcasecmp (attr->attr_name, "objectClass")) {
GtkTextTag *tag;
tag = gtk_text_buffer_create_tag (tbuffer, NULL,
"foreground", "blue",
"weight", PANGO_WEIGHT_NORMAL,
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
g_object_set_data_full (G_OBJECT (tag), "class",
g_strdup (tmp), g_free);
gtk_text_buffer_insert_with_tags (tbuffer, ¤t,
tmp, -1,
tag, NULL);
}
else
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, tmp, -1,
"data", NULL);
gchar *extrainfo = NULL;
if (!strncmp (attr->attr_name, "shadow", 6) &&
(!strcmp (attr->attr_name, "shadowLastChange") ||
!strcmp (attr->attr_name, "shadowMax") ||
!strcmp (attr->attr_name, "shadowMin") ||
!strcmp (attr->attr_name, "shadowInactive") ||
!strcmp (attr->attr_name, "shadowExpire")))
extrainfo = unix_shadow_to_string (tmp, attr->attr_name);
else if (!strcmp (attr->attr_name, "badPasswordTime") ||
!strcmp (attr->attr_name, "lastLogon") ||
!strcmp (attr->attr_name, "pwdLastSet") ||
!strcmp (attr->attr_name, "accountExpires") ||
!strcmp (attr->attr_name, "lockoutTime") ||
!strcmp (attr->attr_name, "lastLogonTimestamp"))
extrainfo = ad_1601_timestamp_to_string (tmp, attr->attr_name);
else if (!strcmp (attr->attr_name, "userAccountControl"))
extrainfo = ad_1601_uac_to_string (tmp);
else if (!strcmp (attr->attr_name, "sAMAccountType"))
extrainfo = ad_sam_account_type_to_string (tmp);
if (extrainfo) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
" ", 1,
"data", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
extrainfo, -1,
"convdata", NULL);
g_free (extrainfo);
}
g_free (tmp);
}
else {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, _("Can't display attribute value"), -1,
"error", NULL);
}
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
"\n", 1,
"data", NULL);
}
}
}
if (ts_dh)
g_object_unref (ts_dh);
gda_ldap_entry_free (entry);
if (eprop->priv->text_search && gtk_widget_get_visible (eprop->priv->text_search))
text_search_rerun (TEXT_SEARCH (eprop->priv->text_search));
}
GtkTextTagTable *ctk_help_create_tag_table(void)
{
GtkTextTagTable *table;
GtkTextTag *tag;
table = gtk_text_tag_table_new();
/* CTK_HELP_TITLE_TAG */
tag = gtk_text_tag_new(CTK_HELP_TITLE_TAG);
g_object_set(G_OBJECT(tag),
"weight", PANGO_WEIGHT_BOLD,
"size", 15 * PANGO_SCALE,
NULL);
gtk_text_tag_table_add(table, tag);
/* CTK_HELP_HEADING_TAG */
tag = gtk_text_tag_new(CTK_HELP_HEADING_TAG);
g_object_set(G_OBJECT(tag),
"weight", PANGO_WEIGHT_BOLD,
"size", 12 * PANGO_SCALE,
NULL);
gtk_text_tag_table_add(table, tag);
/* CTK_HELP_HEADING_NOT_EDITABLE */
tag = gtk_text_tag_new(CTK_HELP_HEADING_NOT_EDITABLE_TAG);
g_object_set(G_OBJECT(tag), "editable", FALSE, NULL);
gtk_text_tag_table_add(table, tag);
/* CTK_HELP_WORD_WRAP_TAG */
tag = gtk_text_tag_new(CTK_HELP_WORD_WRAP_TAG);
g_object_set(G_OBJECT(tag), "wrap_mode", GTK_WRAP_WORD, NULL);
gtk_text_tag_table_add(table, tag);
/* CTK_HELP_MARGIN_TAG */
tag = gtk_text_tag_new(CTK_HELP_MARGIN_TAG);
g_object_set(G_OBJECT(tag), "left_margin", 10, "right_margin", 10, NULL);
gtk_text_tag_table_add(table, tag);
/* CTK_HELP_SINGLE_SPACE_TAG */
tag = gtk_text_tag_new(CTK_HELP_SINGLE_SPACE_TAG);
g_object_set(G_OBJECT(tag), "pixels_inside_wrap", 0, NULL);
gtk_text_tag_table_add(table, tag);
/* CTK_HELP_BOLD_TAG */
tag = gtk_text_tag_new(CTK_HELP_BOLD_TAG);
g_object_set(G_OBJECT(tag), "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_tag_table_add(table, tag);
return table;
}
static gboolean on_show_dlg (FmProgressDisplay *data)
{
GtkBuilder *builder = gtk_builder_new ();
GtkWidget *to, *to_label;
FmPath *dest;
const char *title = NULL;
GtkTextTagTable *tag_table = gtk_text_tag_table_new ();
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
gtk_builder_add_from_string (builder, PROGRESS_DLG, -1, NULL);
data->dlg = (GtkWidget*) gtk_builder_get_object (builder, "dlg");
g_signal_connect (data->dlg, "response", (GCallback) on_response, data);
to_label = (GtkWidget*) gtk_builder_get_object (builder, "to_label");
to = (GtkWidget*) gtk_builder_get_object (builder, "dest");
data->icon = (GtkWidget*) gtk_builder_get_object (builder, "icon");
data->msg = (GtkWidget*) gtk_builder_get_object (builder, "msg");
data->act = (GtkWidget*) gtk_builder_get_object (builder, "action");
data->src = (GtkWidget*) gtk_builder_get_object (builder, "src");
data->dest = (GtkWidget*) gtk_builder_get_object (builder, "dest");
data->current = (GtkWidget*) gtk_builder_get_object (builder, "current");
data->progress = (GtkWidget*) gtk_builder_get_object (builder, "progress");
data->error_pane = (GtkWidget*) gtk_builder_get_object (builder, "error_pane");
data->error_msg = (GtkWidget*) gtk_builder_get_object (builder, "error_msg");
data->remaining_time = (GtkWidget*) gtk_builder_get_object (builder, "remaining_time");
data->bold_tag = gtk_text_tag_new ("bold");
g_object_set (data->bold_tag, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_tag_table_add (tag_table, data->bold_tag);
data->error_buf = gtk_text_buffer_new (tag_table);
g_object_unref (tag_table);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (data->error_msg), data->error_buf);
g_object_unref (builder);
// set the src label
if (data->job->srcs)
{
GList *l = fm_list_peek_head_link (data->job->srcs);
int i;
char *disp;
FmPath *path;
GString *str = g_string_sized_new (512);
path = FM_PATH (l->data);
disp = fm_path_display_basename (path);
g_string_assign (str, disp);
g_free (disp);
for ( i =1, l=l->next; i < 10 && l; l=l->next, ++i)
{
path = FM_PATH (l->data);
g_string_append (str, _(", "));
disp = fm_path_display_basename (path);
g_string_append (str, disp);
g_free (disp);
}
if (l)
g_string_append (str, "...");
gtk_label_set_text (GTK_LABEL (data->src), str->str);
g_string_free (str, TRUE);
}
// FIXME_pcm: use accessor functions instead
switch (data->job->type)
{
case FM_FILE_OP_MOVE:
title = _("Moving files");
break;
case FM_FILE_OP_COPY:
title = _("Copying files");
break;
case FM_FILE_OP_TRASH:
title = _("Trashing files");
break;
case FM_FILE_OP_DELETE:
title = _("Deleting files");
break;
case FM_FILE_OP_LINK:
title = _("Creating symlinks");
break;
case FM_FILE_OP_CHANGE_ATTR:
title = _("Changing file attributes");
break;
}
if (title)
{
gtk_window_set_title (GTK_WINDOW (data->dlg), title);
gtk_label_set_text (GTK_LABEL (data->act), title);
}
if (dest = fm_file_ops_job_get_dest (data->job))
{
char *dest_str = fm_path_display_name (dest, TRUE);
gtk_label_set_text (GTK_LABEL (to), dest_str);
g_free (dest_str);
}
else
{
gtk_widget_destroy (data->dest);
gtk_widget_destroy (to_label);
}
gtk_window_present (GTK_WINDOW (data->dlg));
data->update_timeout = g_timeout_add (500, (GSourceFunc)on_update_dlg, data);
data->delay_timeout = 0;
return FALSE;
}
void internal_output_add_text(SESSION_STATE *session, GtkTextView *output,
gchar * data, gsize len, TEXT_ATTR * ansi)
{
GtkTextBuffer *buffer;
GtkTextIter start, end;
gint offset;
GtkTextTagTable *tagtable;
g_return_if_fail(session != NULL);
// gsize read, written;
// GError *error = NULL;
// gchar *new_data;
g_return_if_fail(data != NULL);
buffer = gtk_text_view_get_buffer (output);
gtk_text_buffer_get_end_iter(buffer, &end);
offset = gtk_text_iter_get_offset(&end);
/*
Conversion sometimes causes weird crashes - disabled
new_data =
g_convert(data, len, "UTF-8", "ISO-8859-1", &read, &written,
&error);
gtk_text_buffer_insert(buffer, &end, new_data, -1);
g_free(new_data);
*/
gtk_text_buffer_insert( buffer, &end, data, len );
if (ansi == NULL)
return; // nothing to do
// apply some tags on inserted text
gtk_text_buffer_get_iter_at_offset(buffer, &start, offset);
gtk_text_buffer_get_end_iter(buffer, &end);
tagtable = gtk_text_buffer_get_tag_table(buffer);
if (ansi->boldfont) {
gtk_text_buffer_apply_tag_by_name(buffer, "bold", &start,
&end);
}
if (ansi->italic) {
gtk_text_buffer_apply_tag_by_name(buffer, "italic", &start,
&end);
}
if (ansi->underline) {
gtk_text_buffer_apply_tag_by_name(buffer, "underline",
&start, &end);
}
if (session->linkCmd) {
// create the link-tag
char *name = 0;
static char tmpln[] = "AAAAAAAAAA-tmplink";
if (session->linkName)
name = g_strdup(session->linkName);
else {
int i = 0;
name = strdup(tmpln);
while (i < 10) { // generate name for next unnamed link
tmpln[i]++;
if (tmpln[i] > 'Z') {
tmpln[i] = 'A';
i++;
} else
break;
}
}
GtkTextTag *t = gtk_text_tag_new(name);
g_object_set_data(G_OBJECT(t), "linkname",
g_strdup(session->linkName));
g_object_set_data(G_OBJECT(t), "action",
g_strdup(session->linkCmd));
g_object_set_data(G_OBJECT(t), "type",
session->isSendLink ? "command" : "url");
g_object_set_data(G_OBJECT(t), "menu",
session->isMenuLink ? "yes" : "no");
GtkTextTagTable *table =
gtk_text_buffer_get_tag_table(buffer);
gtk_text_tag_table_add(table, t);
gtk_text_buffer_apply_tag(buffer, t, &start, &end);
g_signal_connect(G_OBJECT(t), "event",
G_CALLBACK(on_tag_click), session);
g_free(name);
}
GtkTextTag *tag = get_fg_color_tag(buffer, ansi->fgcolor);
if (tag) gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
if (ansi->bgcolor != 0) {
GtkTextTag *tag = get_bg_color_tag(buffer, ansi->bgcolor);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
}
}
static gboolean _on_show_dlg(gpointer user_data)
{
FmProgressDisplay* data = (FmProgressDisplay*)user_data;
GtkBuilder* builder;
GtkLabel* to;
GtkWidget *to_label;
FmPath* dest;
const char* title = NULL;
GtkTextTagTable* tag_table;
builder = gtk_builder_new();
tag_table = gtk_text_tag_table_new();
gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/progress.ui", NULL);
data->dlg = GTK_DIALOG(gtk_builder_get_object(builder, "dlg"));
g_object_weak_ref(G_OBJECT(data->dlg), on_progress_dialog_destroy, data);
g_signal_connect(data->dlg, "response", G_CALLBACK(on_response), data);
/* FIXME: connect to "close" signal */
to_label = (GtkWidget*)gtk_builder_get_object(builder, "to_label");
to = GTK_LABEL(gtk_builder_get_object(builder, "dest"));
data->icon = GTK_IMAGE(gtk_builder_get_object(builder, "icon"));
data->msg = GTK_LABEL(gtk_builder_get_object(builder, "msg"));
data->act = GTK_LABEL(gtk_builder_get_object(builder, "action"));
data->src = GTK_LABEL(gtk_builder_get_object(builder, "src"));
data->dest = (GtkWidget*)gtk_builder_get_object(builder, "dest");
data->current = GTK_LABEL(gtk_builder_get_object(builder, "current"));
data->progress = GTK_PROGRESS_BAR(gtk_builder_get_object(builder, "progress"));
data->error_pane = (GtkWidget*)gtk_builder_get_object(builder, "error_pane");
data->error_msg = GTK_TEXT_VIEW(gtk_builder_get_object(builder, "error_msg"));
data->data_transferred = GTK_LABEL(gtk_builder_get_object(builder, "data_transferred"));
data->data_transferred_label = GTK_LABEL(gtk_builder_get_object(builder, "data_transferred_label"));
data->remaining_time = GTK_LABEL(gtk_builder_get_object(builder, "remaining_time"));
data->remaining_time_label = GTK_LABEL(gtk_builder_get_object(builder, "remaining_time_label"));
data->cancel = GTK_BUTTON(gtk_builder_get_object(builder, "cancel"));
data->suspend = GTK_BUTTON(gtk_dialog_add_button(data->dlg, _("_Pause"), 1));
gtk_button_set_use_stock(data->suspend, FALSE);
gtk_button_set_use_underline(data->suspend, TRUE);
gtk_button_set_image(data->suspend,
gtk_image_new_from_stock(GTK_STOCK_MEDIA_PAUSE,
GTK_ICON_SIZE_BUTTON));
gtk_dialog_set_alternative_button_order(data->dlg, 1, GTK_RESPONSE_CANCEL, -1);
data->bold_tag = gtk_text_tag_new("bold");
g_object_set(data->bold_tag, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_tag_table_add(tag_table, data->bold_tag);
data->error_buf = gtk_text_buffer_new(tag_table);
g_object_unref(tag_table);
gtk_text_view_set_buffer(data->error_msg, data->error_buf);
gtk_widget_hide(GTK_WIDGET(data->icon));
g_object_unref(builder);
/* set the src label */
/* FIXME: direct access to job struct! */
if(data->job->srcs)
{
GList* l = fm_path_list_peek_head_link(data->job->srcs);
int i;
char* disp;
FmPath* path;
GString* str = g_string_sized_new(512);
path = FM_PATH(l->data);
disp = fm_path_display_basename(path);
g_string_assign(str, disp);
g_free(disp);
for( i =1, l=l->next; i < 10 && l; l=l->next, ++i)
{
path = FM_PATH(l->data);
g_string_append(str, _(", "));
disp = fm_path_display_basename(path);
g_string_append(str, disp);
g_free(disp);
}
if(l)
g_string_append(str, "...");
gtk_label_set_text(data->src, str->str);
gtk_widget_set_tooltip_text(GTK_WIDGET(data->src), str->str);
g_string_free(str, TRUE);
}
/* FIXME: use accessor functions instead */
/* FIXME: direct access to job struct! */
switch(data->job->type)
{
/* we set title here if text is complex so may be different from
the op_text when is translated to other languages */
case FM_FILE_OP_MOVE:
/* translators: it is part of "Moving files:" or "Moving xxx.txt" */
data->op_text = _("Moving");
break;
case FM_FILE_OP_COPY:
/* translators: it is part of "Copying files:" or "Copying xxx.txt" */
data->op_text = _("Copying");
break;
case FM_FILE_OP_TRASH:
/* translators: it is part of "Trashing files:" or "Trashing xxx.txt" */
data->op_text = _("Trashing");
break;
case FM_FILE_OP_DELETE:
/* translators: it is part of "Deleting files:" or "Deleting xxx.txt" */
data->op_text = _("Deleting");
break;
case FM_FILE_OP_LINK:
/* translators: it is part of "Creating link /path/xxx.txt" */
data->op_text = _("Creating link");
/* translators: 'In:' string is followed by destination folder path */
gtk_label_set_markup(GTK_LABEL(to_label), _("<b>In:</b>"));
title = _("Creating links to files");
/* NOTE: on creating single symlink or shortcut all operation
is done in single I/O therefore it should fit into 0.5s
timeout and progress window will never be shown */
break;
case FM_FILE_OP_CHANGE_ATTR:
/* translators: it is part of "Changing attributes of xxx.txt" */
data->op_text = _("Changing attributes of");
title = _("Changing attributes of files");
/* NOTE: the same about single symlink is appliable here so
there is no need to add never used string for translation */
break;
case FM_FILE_OP_UNTRASH:
/* translators: it is part of "Restoring files:" or "Restoring xxx.txt" */
data->op_text = _("Restoring");
break;
case FM_FILE_OP_NONE: ;
}
data->str = g_string_sized_new(64);
if (title)
gtk_window_set_title(GTK_WINDOW(data->dlg), title);
else
{
/* note to translators: resulting string is such as "Deleting files" */
g_string_printf(data->str, _("%s files"), data->op_text);
gtk_window_set_title(GTK_WINDOW(data->dlg), data->str->str);
}
gtk_label_set_markup(data->msg, _("<b>File operation is in progress...</b>"));
gtk_widget_show(GTK_WIDGET(data->msg));
if (title) /* we already know the exact string */
g_string_printf(data->str, "<b>%s:</b>", title);
else if (fm_path_list_get_length(data->job->srcs) == 1)
/* note to translators: resulting string is such as "Deleting file" */
g_string_printf(data->str, _("<b>%s file:</b>"), data->op_text);
else
/* note to translators: resulting string is such as "Deleting files" */
g_string_printf(data->str, _("<b>%s files:</b>"), data->op_text);
gtk_label_set_markup(data->act, data->str->str);
dest = fm_file_ops_job_get_dest(data->job);
if(dest)
{
char* dest_str = fm_path_display_name(dest, TRUE);
gtk_label_set_text(to, dest_str);
gtk_widget_set_tooltip_text(GTK_WIDGET(data->dest), dest_str);
g_free(dest_str);
}
else
{
gtk_widget_destroy(data->dest);
gtk_widget_destroy(to_label);
}
gtk_window_set_transient_for(GTK_WINDOW(data->dlg), data->parent);
gtk_window_present(GTK_WINDOW(data->dlg));
data->delay_timeout = 0;
return FALSE;
}
static void
add_chat_msg(GtTwitchChatView* self,
const gchar* sender,
const gchar* colour,
const gchar* msg,
GList* emotes,
gint user_modes)
{
GtTwitchChatViewPrivate* priv = gt_twitch_chat_view_get_instance_private(self);
GtkTextTag* sender_colour_tag = NULL;
gint offset = 0;
gtk_text_buffer_get_end_iter(priv->chat_buffer, &priv->bottom_iter);
if (!colour || strlen(colour) < 1) //TODO: Set random colour instead of just black
colour = get_default_chat_colour(sender);
sender_colour_tag = gtk_text_tag_table_lookup(priv->tag_table, colour);
if (!sender_colour_tag)
{
sender_colour_tag = gtk_text_tag_new(colour);
g_object_set(sender_colour_tag,
"foreground", colour,
"weight", PANGO_WEIGHT_BOLD,
NULL);
gtk_text_tag_table_add(priv->tag_table, sender_colour_tag);
}
offset = strlen(sender) + 2;
//TODO: Cleanup?
#define INSERT_USER_MOD_PIXBUF(mode, name) \
if (user_modes & mode) \
{ \
gtk_text_buffer_insert_pixbuf(priv->chat_buffer, &priv->bottom_iter, priv->chat_badges->name); \
gtk_text_buffer_insert(priv->chat_buffer, &priv->bottom_iter, " ", -1); \
gtk_text_iter_forward_chars(&priv->bottom_iter, 2); \
offset += 2; \
} \
INSERT_USER_MOD_PIXBUF(USER_MODE_SUBSCRIBER, subscriber);
INSERT_USER_MOD_PIXBUF(USER_MODE_TURBO, turbo);
INSERT_USER_MOD_PIXBUF(USER_MODE_GLOBAL_MOD, global_mod);
INSERT_USER_MOD_PIXBUF(USER_MODE_BROADCASTER, broadcaster);
INSERT_USER_MOD_PIXBUF(USER_MODE_STAFF, staff);
INSERT_USER_MOD_PIXBUF(USER_MODE_ADMIN, admin);
INSERT_USER_MOD_PIXBUF(USER_MODE_MOD, mod);
#undef INSERT_USER_MOD_PIXBUF
gtk_text_buffer_insert_with_tags(priv->chat_buffer, &priv->bottom_iter, sender, -1, sender_colour_tag, NULL);
gtk_text_iter_forward_word_end(&priv->bottom_iter);
gtk_text_buffer_insert(priv->chat_buffer, &priv->bottom_iter, ": ", -1);
gtk_text_iter_forward_chars(&priv->bottom_iter, 2);
insert_message_with_emotes(priv->chat_buffer, &priv->bottom_iter, emotes, msg, offset);
gtk_text_iter_forward_to_line_end(&priv->bottom_iter);
gtk_text_buffer_insert(priv->chat_buffer, &priv->bottom_iter, "\n", -1);
gtk_text_buffer_move_mark(priv->chat_buffer, priv->bottom_mark, &priv->bottom_iter);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(priv->chat_view), priv->bottom_mark);
}
static void
gtk_text_buffer_insert_markup(GtkTextBuffer * buffer, GtkTextIter * iter,
const gchar * markup)
{
PangoAttrIterator *paiter;
PangoAttrList *attrlist;
GtkTextMark *mark;
GError *error = NULL;
gchar *text;
g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
g_return_if_fail(markup != NULL);
if (*markup == '\000')
return;
/* invalid */
if (!pango_parse_markup(markup, -1, 0, &attrlist, &text, NULL, &error)) {
g_warning("Invalid markup string: %s", error->message);
g_error_free(error);
return;
}
/* trivial, no markup */
if (attrlist == NULL) {
gtk_text_buffer_insert(buffer, iter, text, -1);
g_free(text);
return;
}
/* create mark with right gravity */
mark = gtk_text_buffer_create_mark(buffer, NULL, iter, FALSE);
paiter = pango_attr_list_get_iterator(attrlist);
do {
PangoAttribute *attr;
GtkTextTag *tag;
GtkTextTag *tag_para;
gint start, end;
pango_attr_iterator_range(paiter, &start, &end);
if (end == G_MAXINT) /* last chunk */
end = start - 1; /* resulting in -1 to be passed to _insert */
tag = gtk_text_tag_new(NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_LANGUAGE)))
g_object_set(tag, "language",
pango_language_to_string(((PangoAttrLanguage *)
attr)->value), NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_FAMILY)))
g_object_set(tag, "family", ((PangoAttrString *) attr)->value,
NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_STYLE)))
g_object_set(tag, "style", ((PangoAttrInt *) attr)->value,
NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_WEIGHT)))
g_object_set(tag, "weight", ((PangoAttrInt *) attr)->value,
NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_VARIANT)))
g_object_set(tag, "variant", ((PangoAttrInt *) attr)->value,
NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_STRETCH)))
g_object_set(tag, "stretch", ((PangoAttrInt *) attr)->value,
NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_SIZE)))
g_object_set(tag, "size", ((PangoAttrInt *) attr)->value,
NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_FONT_DESC)))
g_object_set(tag, "font-desc",
((PangoAttrFontDesc *) attr)->desc, NULL);
if ((attr =
pango_attr_iterator_get(paiter, PANGO_ATTR_FOREGROUND))) {
GdkColor col = { 0,
((PangoAttrColor *) attr)->color.red,
((PangoAttrColor *) attr)->color.green,
((PangoAttrColor *) attr)->color.blue
};
g_object_set(tag, "foreground-gdk", &col, NULL);
}
if ((attr =
pango_attr_iterator_get(paiter, PANGO_ATTR_BACKGROUND))) {
GdkColor col = { 0,
((PangoAttrColor *) attr)->color.red,
((PangoAttrColor *) attr)->color.green,
((PangoAttrColor *) attr)->color.blue
};
g_object_set(tag, "background-gdk", &col, NULL);
}
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_UNDERLINE)))
g_object_set(tag, "underline", ((PangoAttrInt *) attr)->value,
NULL);
if ((attr =
pango_attr_iterator_get(paiter, PANGO_ATTR_STRIKETHROUGH)))
g_object_set(tag, "strikethrough",
(gboolean) (((PangoAttrInt *) attr)->value != 0),
NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_RISE)))
g_object_set(tag, "rise", ((PangoAttrInt *) attr)->value,
NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_SCALE)))
g_object_set(tag, "scale", ((PangoAttrFloat *) attr)->value,
NULL);
gtk_text_tag_table_add(gtk_text_buffer_get_tag_table(buffer), tag);
tag_para =
gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table
(buffer), "para");
gtk_text_buffer_insert_with_tags(buffer, iter, text + start,
end - start, tag, tag_para, NULL);
/* mark had right gravity, so it should be
* at the end of the inserted text now */
gtk_text_buffer_get_iter_at_mark(buffer, iter, mark);
} while (pango_attr_iterator_next(paiter));
gtk_text_buffer_delete_mark(buffer, mark);
pango_attr_iterator_destroy(paiter);
pango_attr_list_unref(attrlist);
g_free(text);
}
static void bug_information_generate_message(GtkTextBuffer * buffer)
{
int i;
gchar *temp;
GtkTextIter iter;
GtkTextTag *bold_tag, *larger_tag;
GtkTextTagTable *table;
/* get buffer's tag table */
table = gtk_text_buffer_get_tag_table(buffer);
/* Create bold tag */
bold_tag = gtk_text_tag_new("bold");
g_object_set(G_OBJECT(bold_tag), "weight", PANGO_WEIGHT_BOLD, NULL);
/* add bold_tag to tag table */
gtk_text_tag_table_add(table, bold_tag);
/* Create bold tag */
larger_tag = gtk_text_tag_new("larger");
g_object_set(G_OBJECT(larger_tag), "scale", PANGO_SCALE_X_LARGE, NULL);
/* add larger_tag to tag table */
gtk_text_tag_table_add(table, larger_tag);
/* Get the start */
gtk_text_buffer_get_start_iter(buffer, &iter);
/* insert program name */
gtk_text_buffer_insert_with_tags(buffer, &iter, "Gnome Music Player Client\n", -1, bold_tag, larger_tag, NULL);
/* insert copyright */
gtk_text_buffer_insert_with_tags(buffer, &iter, GMPC_COPYRIGHT "\n\n", -1, bold_tag, NULL);
/* insert tagline */
gtk_text_buffer_insert_with_tags(buffer, &iter, "Tagline:\t", -1, bold_tag, NULL);
gtk_text_buffer_insert(buffer, &iter, GMPC_TAGLINE "\n", -1);
/* insert version */
gtk_text_buffer_insert_with_tags(buffer, &iter, "Version:\t", -1, bold_tag, NULL);
temp = g_strdup_printf("%i.%i.%i\n", GMPC_MAJOR_VERSION, GMPC_MINOR_VERSION, GMPC_MICRO_VERSION);
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
/* insert revision */
gtk_text_buffer_insert_with_tags(buffer, &iter, "Revision:\t", -1, bold_tag, NULL);
temp = g_strdup_printf("%s\n", revision);
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
/** support libs */
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nSupport libraries:\n", -1, bold_tag, larger_tag, NULL);
/* libmpd */
gtk_text_buffer_insert_with_tags(buffer, &iter, "Libmpd:\t", -1, bold_tag, NULL);
temp = g_strdup_printf("%i.%i.%i\n", LIBMPD_MAJOR_VERSION, LIBMPD_MINOR_VERSION, LIBMPD_MICRO_VERSION);
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
/* gtk+-2.0 */
gtk_text_buffer_insert_with_tags(buffer, &iter, "Compile time Gtk+-2.0:\t", -1, bold_tag, NULL);
temp = g_strdup_printf("%i.%i.%i\n", GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
gtk_text_buffer_insert_with_tags(buffer, &iter, "Runtime Gtk+-2.0:\t", -1, bold_tag, NULL);
temp = g_strdup_printf("%i.%i.%i\n", gtk_major_version, gtk_minor_version, gtk_micro_version);
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
/* glib-2.0 */
gtk_text_buffer_insert_with_tags(buffer, &iter, "Glib-2.0:\t", -1, bold_tag, NULL);
temp = g_strdup_printf("%i.%i.%i\n", GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
/* glib-2.0 */
gtk_text_buffer_insert_with_tags(buffer, &iter, "Runtime sqlite3:\t", -1, bold_tag, NULL);
gtk_text_buffer_insert(buffer, &iter, sqlite3_libversion(), -1);
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nCompile time sqlite3:\t", -1, bold_tag, NULL);
gtk_text_buffer_insert(buffer, &iter, SQLITE_VERSION, -1);
#ifdef HAVE_UNIQUE
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nLibunique:\t", -1, bold_tag, NULL);
temp = g_strdup_printf("%s\n", UNIQUE_VERSION_S);
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
#endif
/* platform */
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nPlatform:\t", -1, bold_tag, NULL);
#ifdef WIN32
gtk_text_buffer_insert(buffer, &iter, "Windows\n", -1);
gtk_text_buffer_insert_with_tags(buffer, &iter, "Windows version:\t", -1, bold_tag, NULL);
temp = g_strdup_printf("%i\n", g_win32_get_windows_version());
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
#else
#ifdef OSX
gtk_text_buffer_insert(buffer, &iter, "Mac OsX\n", -1);
#else
gtk_text_buffer_insert(buffer, &iter, "*nix\n", -1);
#endif
#endif
/** compile flags*/
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nCompile flags:\n", -1, bold_tag, larger_tag, NULL);
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nNLS Support:\t", -1, bold_tag, NULL);
#ifdef ENABLE_NLS
gtk_text_buffer_insert(buffer, &iter, "Enabled", -1);
#else
gtk_text_buffer_insert(buffer, &iter, "Disabled", -1);
#endif
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nMultimedia Keys:\t", -1, bold_tag, NULL);
#ifdef ENABLE_MMKEYS
gtk_text_buffer_insert(buffer, &iter, "Enabled", -1);
#else
gtk_text_buffer_insert(buffer, &iter, "Disabled", -1);
#endif
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nAppIndicator Support:\t", -1, bold_tag, NULL);
#ifdef HAVE_APP_INDICATOR
gtk_text_buffer_insert(buffer, &iter, "Enabled", -1);
#else
gtk_text_buffer_insert(buffer, &iter, "Disabled", -1);
#endif
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nLibspiff support:\t", -1, bold_tag, NULL);
#ifdef SPIFF
gtk_text_buffer_insert(buffer, &iter, "Enabled", -1);
#else
gtk_text_buffer_insert(buffer, &iter, "Disabled", -1);
#endif
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nLibunique support:\t", -1, bold_tag, NULL);
#ifdef HAVE_UNIQUE
gtk_text_buffer_insert(buffer, &iter, "Enabled", -1);
#else
gtk_text_buffer_insert(buffer, &iter, "Disabled", -1);
#endif
/** Plugins */
if (num_plugins > 0)
{
gtk_text_buffer_insert_with_tags(buffer, &iter, "\n\nExternal Plugins:\n", -1, bold_tag, larger_tag, NULL);
for (i = 0; i < num_plugins; i++)
{
if (!gmpc_plugin_is_internal(plugins[i]))
{
const gchar *name = gmpc_plugin_get_name(plugins[i]);
const int *version = gmpc_plugin_get_version(plugins[i]);
if(gmpc_plugin_get_enabled(plugins[i])) {
gtk_text_buffer_insert(buffer, &iter, "☑ ", -1);
}else {
gtk_text_buffer_insert(buffer, &iter, "☐ ", -1);
}
gtk_text_buffer_insert_with_tags(buffer, &iter, name, -1, bold_tag, NULL);
temp = g_strdup_printf("\t%i.%i.%i\n", version[0], version[1], version[2]);
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
}
}
}
if (num_plugins > 0)
{
gtk_text_buffer_insert_with_tags(buffer, &iter, "\n\nMetadata Plugins:\n", -1, bold_tag, larger_tag, NULL);
for (i = 0; i < num_plugins; i++)
{
if (gmpc_plugin_is_metadata(plugins[i]))
{
const gchar *name = gmpc_plugin_get_name(plugins[i]);
const int *version = gmpc_plugin_get_version(plugins[i]);
if(gmpc_plugin_get_enabled(plugins[i])) {
gtk_text_buffer_insert(buffer, &iter, "☑ ", -1);
}else {
gtk_text_buffer_insert(buffer, &iter, "☐ ", -1);
}
gtk_text_buffer_insert_with_tags(buffer, &iter, name, -1, bold_tag, NULL);
temp = g_strdup_printf("\t%i.%i.%i\n", version[0], version[1], version[2]);
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
}
}
}
if (mpd_check_connected(connection))
{
gchar **handlers;
/** Plugins */
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nMusic Player Daemon:\n", -1, bold_tag, larger_tag, NULL);
/* Version */
gtk_text_buffer_insert_with_tags(buffer, &iter, "Version:\t", -1, bold_tag, NULL);
temp = mpd_server_get_version(connection);
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
/* total songs */
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nSongs:\t", -1, bold_tag, NULL);
temp = g_strdup_printf("%i", mpd_stats_get_total_songs(connection));
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
/* hostname */
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nHostname:\t", -1, bold_tag, NULL);
temp = connection_get_hostname();
gtk_text_buffer_insert(buffer, &iter, temp, -1);
/* handlers */
gtk_text_buffer_insert_with_tags(buffer, &iter, "\nUrl handlers:\t", -1, bold_tag, NULL);
handlers = mpd_server_get_url_handlers(connection);
if (handlers)
{
temp = g_strjoinv(",", handlers);
g_strfreev(handlers);
handlers = NULL;
} else
temp = g_strdup("N/A");
gtk_text_buffer_insert(buffer, &iter, temp, -1);
g_free(temp);
}
}
GtkTextTag *
create_text_tag_from_style(const css::styles &aStyles)
{
GtkTextTag *tag = gtk_text_tag_new(aStyles.name.c_str());
switch (aStyles.vertical_align)
{
case css::vertical_align::inherit:
break;
case css::vertical_align::baseline:
g_object_set(G_OBJECT(tag), "rise-set", TRUE, "rise", 0, NULL);
break;
case css::vertical_align::sub:
g_object_set(G_OBJECT(tag), "rise-set", TRUE, "rise", -4096, NULL);
break;
case css::vertical_align::super:
g_object_set(G_OBJECT(tag), "rise-set", TRUE, "rise", 4096, NULL);
break;
}
switch (aStyles.text_align)
{
case css::text_align::inherit:
break;
case css::text_align::left:
g_object_set(G_OBJECT(tag), "justification-set", TRUE, "justification", GTK_JUSTIFY_LEFT, NULL);
break;
case css::text_align::right:
g_object_set(G_OBJECT(tag), "justification-set", TRUE, "justification", GTK_JUSTIFY_RIGHT, NULL);
break;
case css::text_align::center:
g_object_set(G_OBJECT(tag), "justification-set", TRUE, "justification", GTK_JUSTIFY_CENTER, NULL);
break;
case css::text_align::justify:
g_object_set(G_OBJECT(tag), "justification-set", TRUE, "justification", GTK_JUSTIFY_FILL, NULL);
break;
}
switch (aStyles.text_decoration)
{
case css::text_decoration::inherit:
break;
case css::text_decoration::none:
g_object_set(G_OBJECT(tag), "strikethrough-set", TRUE, "strikethrough", FALSE, NULL);
g_object_set(G_OBJECT(tag), "underline-set", TRUE, "underline", PANGO_UNDERLINE_NONE, NULL);
break;
case css::text_decoration::underline:
g_object_set(G_OBJECT(tag), "underline-set", TRUE, "underline", PANGO_UNDERLINE_SINGLE, NULL);
break;
case css::text_decoration::line_through:
g_object_set(G_OBJECT(tag), "strikethrough-set", TRUE, "strikethrough", TRUE, NULL);
break;
}
switch (aStyles.font_style)
{
case css::font_style::inherit:
break;
case css::font_style::normal:
g_object_set(G_OBJECT(tag), "style-set", TRUE, "style", PANGO_STYLE_NORMAL, NULL);
break;
case css::font_style::italic:
g_object_set(G_OBJECT(tag), "style-set", TRUE, "style", PANGO_STYLE_ITALIC, NULL);
break;
case css::font_style::oblique:
g_object_set(G_OBJECT(tag), "style-set", TRUE, "style", PANGO_STYLE_OBLIQUE, NULL);
break;
}
switch (aStyles.font_variant_caps)
{
case css::font_variant_caps::inherit:
break;
case css::font_variant_caps::normal:
g_object_set(G_OBJECT(tag), "variant-set", TRUE, "variant", PANGO_VARIANT_NORMAL, NULL);
break;
case css::font_variant_caps::small_caps:
g_object_set(G_OBJECT(tag), "variant-set", TRUE, "variant", PANGO_VARIANT_SMALL_CAPS, NULL);
break;
}
switch (aStyles.font_weight)
{
case css::font_weight::inherit:
break;
case css::font_weight::normal:
g_object_set(G_OBJECT(tag), "weight-set", TRUE, "weight", PANGO_WEIGHT_NORMAL, NULL);
break;
case css::font_weight::bold:
g_object_set(G_OBJECT(tag), "weight-set", TRUE, "weight", PANGO_WEIGHT_BOLD, NULL);
break;
}
if (!aStyles.font_family.empty())
g_object_set(G_OBJECT(tag), "family-set", TRUE, "family", aStyles.font_family.c_str(), NULL);
if (aStyles.font_size.units() != css::length::inherit)
g_object_set(G_OBJECT(tag), "size-set", TRUE, "size-points", gdouble(aStyles.font_size.as(css::length::points).value()), NULL);
if (aStyles.margin.top.units() != css::length::inherit)
g_object_set(G_OBJECT(tag), "pixels-above-lines-set", TRUE, "pixels-above-lines", gint(aStyles.margin.top.as(css::length::pixels).value()), NULL);
if (aStyles.margin.bottom.units() != css::length::inherit)
g_object_set(G_OBJECT(tag), "pixels-below-lines-set", TRUE, "pixels-below-lines", gint(aStyles.margin.bottom.as(css::length::pixels).value()), NULL);
if (aStyles.margin.left.units() != css::length::inherit)
g_object_set(G_OBJECT(tag), "left-margin-set", TRUE, "left-margin", gint(aStyles.margin.left.as(css::length::pixels).value()), NULL);
if (aStyles.margin.right.units() != css::length::inherit)
g_object_set(G_OBJECT(tag), "right-margin-set", TRUE, "right-margin", gint(aStyles.margin.right.as(css::length::pixels).value()), NULL);
return tag;
}
