void highlight_init (void)
{
GSList *highlights, *cur;
highlight_tag_table = gtk_text_tag_table_new();
/* setup the tags */
add_general_tag (TITLE_TAG, PREF_TITLE_TEXT_COLOR,
PREF_TITLE_BASE_COLOR, PREF_TITLE_FONT);
add_general_tag (MONSTER_TAG, PREF_MONSTER_TEXT_COLOR,
PREF_MONSTER_BASE_COLOR, PREF_MONSTER_FONT);
add_general_tag (ECHO_TAG, PREF_ECHO_TEXT_COLOR, PREF_ECHO_BASE_COLOR,
PREF_ECHO_FONT);
/* add the user defined highlights */
preferences_notify_add (preferences_get_key (PREF_HIGHLIGHTS_INDEX),
change_index, NULL);
highlights = preferences_get_list (preferences_get_key
(PREF_HIGHLIGHTS_INDEX), PREFERENCES_VALUE_INT);
for (cur = highlights; cur != NULL; cur = cur->next) {
highlight_add (GPOINTER_TO_INT (cur->data));
}
}
/*#
@class GtkTextTagTable
@brief Collection of tags that can be used together
You may wish to begin by reading the text widget conceptual overview which gives
an overview of all the objects and data types related to the text widget and
how they work together.
*/
FALCON_FUNC TextTagTable::init( VMARG )
{
NO_ARGS
MYSELF;
GtkTextTagTable* tab = gtk_text_tag_table_new();
self->setObject( (GObject*) tab );
}
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;
}
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;
}
static GtkTextTagTable*
create_tag_table (GcrDisplayView *self)
{
GtkTextTagTable *tags;
gint width, height;
g_assert (GCR_IS_DISPLAY_VIEW (self));
tags = gtk_text_tag_table_new ();
if (!gtk_icon_size_lookup (GTK_ICON_SIZE_DIALOG, &width, &height))
width = 48;
self->pv->title_tag = g_object_new (GTK_TYPE_TEXT_TAG,
"name", "title",
"scale", PANGO_SCALE_LARGE,
"right-margin", (ICON_MARGIN * 2) + width,
"pixels-above-lines", 9,
"pixels-below-lines", 6,
"weight", PANGO_WEIGHT_BOLD,
NULL);
gtk_text_tag_table_add (tags, self->pv->title_tag);
self->pv->content_tag = g_object_new (GTK_TYPE_TEXT_TAG,
"name", "content",
"right-margin", (ICON_MARGIN * 2) + width,
"left-margin", FIELD_MARGIN,
"pixels-below-lines", 3,
NULL);
gtk_text_tag_table_add (tags, self->pv->content_tag);
self->pv->heading_tag = g_object_new (GTK_TYPE_TEXT_TAG,
"name", "heading",
"pixels-above-lines", 9,
"pixels-below-lines", 3,
"weight", PANGO_WEIGHT_BOLD,
NULL);
gtk_text_tag_table_add (tags, self->pv->heading_tag);
self->pv->monospace_tag = g_object_new (GTK_TYPE_TEXT_TAG,
"name", "monospace",
"family", "monospace",
NULL);
gtk_text_tag_table_add (tags, self->pv->monospace_tag);
return tags;
}
static GtkTextTagTable*
create_tag_table (GcrCertificateDetailsWidget *self)
{
GtkTextTagTable *tags;
GtkTextTag *tag;
g_assert (GCR_IS_CERTIFICATE_DETAILS_WIDGET (self));
tags = gtk_text_tag_table_new ();
tag = g_object_new (GTK_TYPE_TEXT_TAG,
"name", "heading",
"left-margin", 5,
"right-margin", 5,
"pixels-above-lines", 9,
"pixels-below-lines", 3,
"weight", PANGO_WEIGHT_BOLD,
NULL);
gtk_text_tag_table_add (tags, tag);
g_object_unref (tag);
tag = g_object_new (GTK_TYPE_TEXT_TAG,
"name", "monospace",
"family", "monospace",
NULL);
gtk_text_tag_table_add (tags, tag);
g_object_unref (tag);
g_assert (!self->pv->field_tag);
self->pv->field_width = 0;
self->pv->field_tag = g_object_new (GTK_TYPE_TEXT_TAG,
"name", "field",
"left-margin", self->pv->field_width + FIELD_MARGIN,
"indent", self->pv->field_width,
"right-margin", 5,
"pixels-below-lines", 3,
"wrap-mode", GTK_WRAP_WORD_CHAR,
NULL);
gtk_text_tag_table_add (tags, self->pv->field_tag);
return tags;
}
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;
}
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;
}
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 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;
}
int main(int argc, char *argv[]) {
GtkWidget *button;
GtkWidget *box1;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "hart");
g_signal_connect(window, "delete-event", G_CALLBACK(delete_event), NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
box1 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), box1);
//Create tree model
store = gtk_tree_store_new(N_COLUMNS,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
create_file_tree(".", NULL);
//Sort the model for convenience
sorted_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(sorted_model),
FILE_COLUMN, GTK_SORT_ASCENDING);
//Create the tree's view
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(sorted_model));
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("File",
renderer,
"text", FILE_COLUMN,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes("Locked",
renderer,
"active", LOCKED_COLUMN,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
//Add ui callbacks for the tree
GtkTreeSelection *select;
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK(tree_selection_changed_cb),
NULL);
//Add tree to box
gtk_box_pack_start(GTK_BOX(box1), tree, TRUE, TRUE, 0);
//Create console output label
GtkWidget* frame = gtk_frame_new("Console output");
GtkWidget* text_view = gtk_text_view_new();
GtkTextTagTable* text_tag_table = gtk_text_tag_table_new();
GtkTextBuffer* console_buffer = gtk_text_buffer_new(text_tag_table);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(text_view), console_buffer);
gchar* test_str = "blah\nwoiajheoih\nwoeihoiwha\nweoihewoih\nwoeihoi";
gtk_text_buffer_set_text(console_buffer,
test_str,
strlen(test_str));
gtk_container_add(GTK_CONTAINER(frame), text_view);
gtk_box_pack_start(GTK_BOX(box1), frame, TRUE, TRUE, 0);
//Create button w/ label
GtkWidget* file_button = gtk_file_chooser_button_new("Select a folder",
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_box_pack_start(GTK_BOX(box1), file_button, TRUE, TRUE, 0);
g_signal_connect(file_button, "file-set", G_CALLBACK(file_button_callback), (gpointer)"file_button");
//Show all of the widgets
gtk_widget_show(file_button);
gtk_widget_show(tree);
gtk_widget_show(frame);
gtk_widget_show(text_view);
gtk_widget_show(box1);
gtk_widget_show(window); //Show window last so they all appear at once.
gtk_main ();
return 0;
}
static VALUE
rg_initialize(VALUE self)
{
G_INITIALIZE(self, gtk_text_tag_table_new());
return Qnil;
}
struct _rdiswindow * rdiswindow_create (struct _gui * gui)
{
struct _rdiswindow * rdiswindow;
rdiswindow = (struct _rdiswindow *) malloc(sizeof(struct _rdiswindow));
rdiswindow->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
rdiswindow->buttonsBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
rdiswindow->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
rdiswindow->hexButton = gtk_button_new_with_label(LANG_HEXVIEW);
rdiswindow->functionsButton = gtk_button_new_with_label(LANG_FUNCTIONS);
rdiswindow->refButton = gtk_button_new_with_label(LANG_REFERENCES);
rdiswindow->scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
rdiswindow->consoleTagTable = gtk_text_tag_table_new();
rdiswindow->consoleBuffer =
gtk_text_buffer_new(rdiswindow->consoleTagTable);
rdiswindow->consoleView =
gtk_text_view_new_with_buffer(rdiswindow->consoleBuffer);
rdiswindow->inputEntry = gtk_entry_new();
rdiswindow->menu = gtk_menu_bar_new();
rdiswindow->gui = gui;
gtk_text_buffer_create_tag(rdiswindow->consoleBuffer, "console",
"font", "monospace",
"size-points", 9.0,
NULL);
GtkWidget * menuItemFile = gtk_menu_item_new_with_label(LANG_MENUFILE);
GtkWidget * menuItemOpen = gtk_menu_item_new_with_label(LANG_OPENRDIS);
GtkWidget * menuItemSave = gtk_menu_item_new_with_label(LANG_SAVERDIS);
GtkWidget * menuItemLoad = gtk_menu_item_new_with_label(LANG_LOADEXEC);
GtkWidget * menuFile = gtk_menu_new();
gtk_container_add(GTK_CONTAINER(menuFile), menuItemOpen);
gtk_container_add(GTK_CONTAINER(menuFile), menuItemSave);
gtk_container_add(GTK_CONTAINER(menuFile), menuItemLoad);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItemFile), menuFile);
gtk_container_add(GTK_CONTAINER(rdiswindow->menu), menuItemFile);
gtk_widget_show(menuItemFile);
gtk_widget_show(menuItemOpen);
gtk_widget_show(menuItemSave);
gtk_widget_show(menuItemLoad);
gtk_widget_show(menuFile);
g_signal_connect(menuItemSave,
"activate",
G_CALLBACK(rdiswindow_save),
rdiswindow);
g_signal_connect(menuItemOpen,
"activate",
G_CALLBACK(rdiswindow_open),
rdiswindow);
g_signal_connect(menuItemLoad,
"activate",
G_CALLBACK(rdiswindow_load),
rdiswindow);
g_signal_connect(rdiswindow->functionsButton,
"clicked",
G_CALLBACK(rdiswindow_functions_activate),
rdiswindow);
g_signal_connect(rdiswindow->hexButton,
"clicked",
G_CALLBACK(rdiswindow_hex_activate),
rdiswindow);
g_signal_connect(rdiswindow->refButton,
"clicked",
G_CALLBACK(rdiswindow_ref_activate),
rdiswindow);
g_signal_connect(rdiswindow->inputEntry,
"activate",
G_CALLBACK(rdiswindow_input_activate),
rdiswindow);
g_signal_connect(rdiswindow->scrolledWindow,
"size-allocate",
G_CALLBACK(rdiswindow_size_allocate),
rdiswindow);
g_signal_connect(rdiswindow->window,
"destroy",
G_CALLBACK(rdiswindow_destroy_event),
rdiswindow);
gtk_box_pack_start(GTK_BOX(rdiswindow->buttonsBox),
rdiswindow->functionsButton,
FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rdiswindow->buttonsBox),
rdiswindow->hexButton,
FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rdiswindow->buttonsBox),
rdiswindow->refButton,
FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rdiswindow->vbox),
rdiswindow->menu,
FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rdiswindow->vbox),
rdiswindow->buttonsBox,
FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rdiswindow->vbox),
rdiswindow->scrolledWindow,
TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rdiswindow->vbox),
rdiswindow->inputEntry,
FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(rdiswindow->scrolledWindow),
rdiswindow->consoleView);
gtk_container_add(GTK_CONTAINER(rdiswindow->window), rdiswindow->vbox);
gtk_window_set_default_size(GTK_WINDOW(rdiswindow->window), 600, 400);
gtk_widget_show(rdiswindow->menu);
gtk_widget_show(rdiswindow->functionsButton);
gtk_widget_show(rdiswindow->hexButton);
gtk_widget_show(rdiswindow->refButton);
gtk_widget_show(rdiswindow->scrolledWindow);
gtk_widget_show(rdiswindow->consoleView);
gtk_widget_show(rdiswindow->inputEntry);
gtk_widget_show(rdiswindow->buttonsBox);
gtk_widget_show(rdiswindow->vbox);
return rdiswindow;
}
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;
}
void GtkTextTagTable_::__construct()
{
instance = (gpointer *)gtk_text_tag_table_new ();
}
/**
*创建右边主界面内容
*/
GtkWidget* init_right_main_view(void) {
GtkWidget *vBox = NULL; //竖盒布局
GtkWidget *hBox = NULL;//竖盒布局
GtkWidget *titleLabel = NULL;//标题标签
GtkWidget *contentTitle = NULL;//内容标题标签
//GtkWidget *contentTitleEntry = NULL;//内容标题输入框
GtkWidget *contentContent = NULL;//具体内容标签
//GtkWidget *contentContentTextView = NULL; //内容输入框
//GtkWidget *saveButton = NULL;//保存按钮
//GtkWidget *deleteButton = NULL;//删除按钮
//GtkWidget *modifyButton = NULL;//修改按钮
GtkAdjustment *vAdjustment = NULL;
GtkAdjustment *hAdjustment = NULL;
GtkWidget *scrollWindow = NULL;
if(textTagTable == NULL)
textTagTable = gtk_text_tag_table_new();
if(textBuffer == NULL)
textBuffer = gtk_text_buffer_new(textTagTable);
vBox = gtk_vbox_new(FALSE,5); //新建布局
titleLabel = gtk_label_new("欢迎使用"); //新建标题标签
contentTitle = gtk_label_new("标题:");
contentTitleEntry = gtk_entry_new();
contentContent = gtk_label_new("内容:");
contentContentTextView = gtk_text_view_new();
gtk_box_pack_start(GTK_BOX(vBox),
titleLabel,
FALSE,FALSE,5);
hBox = gtk_hbox_new(FALSE,5);
gtk_box_pack_start(GTK_BOX(hBox),
contentTitle,
FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(hBox),
contentTitleEntry,
TRUE,TRUE,5);
gtk_box_pack_start(GTK_BOX(vBox),
hBox,
FALSE,FALSE,5);
hBox = gtk_hbox_new(FALSE,5);
gtk_box_pack_start(GTK_BOX(hBox),
contentContent,
FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(hBox),
contentContentTextView,
TRUE,TRUE,5);
gtk_box_pack_start(GTK_BOX(vBox),
hBox,
FALSE,FALSE,5);
saveButton = gtk_button_new_with_label("保存");
g_signal_connect(G_OBJECT(saveButton),"clicked",G_CALLBACK(button_save_signal),NULL);
deleteButton = gtk_button_new_with_label("删除");
g_signal_connect(G_OBJECT(deleteButton),"clicked",G_CALLBACK(button_delete_signal),NULL);
modifyButton = gtk_button_new_with_label("修改");
g_signal_connect(G_OBJECT(modifyButton),"clicked",G_CALLBACK(button_modify_signal),NULL);
hBox = gtk_hbox_new(FALSE,5);
gtk_box_pack_start(GTK_BOX(hBox),
gtk_label_new(""),
TRUE,TRUE,5);
gtk_box_pack_start(GTK_BOX(hBox),
saveButton,
FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(hBox),
deleteButton,
FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(hBox),
modifyButton,
FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(vBox),
hBox,
FALSE,FALSE,5);
vAdjustment = gtk_adjustment_new(0,0,100,10,10,10);
hAdjustment = gtk_adjustment_new(0,0,100,10,10,10);
scrollWindow = gtk_scrolled_window_new(hAdjustment,vAdjustment);
gtk_scrolled_window_add_with_viewport(scrollWindow,vBox);
return scrollWindow;
}
GtkTextBuffer *
cainteoir_document_create_buffer(CainteoirDocument *doc)
{
GtkTextTagTable *tags = gtk_text_tag_table_new();
GtkTextBuffer *buffer = gtk_text_buffer_new(tags);
GtkTextIter position;
gtk_text_buffer_get_end_iter(buffer, &position);
std::list<std::string> anchor;
std::stack<tag_block> contexts;
bool need_linebreak = false;
for (auto &entry : CAINTEOIR_DOCUMENT_PRIVATE(doc)->doc->children())
{
if (entry.type & events::begin_context)
{
GtkTextTag *tag = nullptr;
if (entry.styles)
{
tag = gtk_text_tag_table_lookup(tags, entry.styles->name.c_str());
if (!tag)
{
tag = create_text_tag_from_style(*entry.styles);
gtk_text_tag_table_add(tags, tag);
}
}
if (need_linebreak && entry.styles) switch (entry.styles->display)
{
case cainteoir::css::display::block:
case cainteoir::css::display::line_break:
case cainteoir::css::display::list_item:
case cainteoir::css::display::table:
case cainteoir::css::display::table_row:
case cainteoir::css::display::table_cell:
gtk_text_buffer_insert(buffer, &position, "\n", 1);
gtk_text_buffer_get_end_iter(buffer, &position);
need_linebreak = false;
break;
}
contexts.push({ tag, gtk_text_iter_get_offset(&position) });
}
if (entry.type & cainteoir::events::anchor)
anchor.push_back(entry.anchor.str());
if (entry.type & cainteoir::events::text)
{
for (auto &a : anchor)
(void)gtk_text_buffer_create_mark(buffer, a.c_str(), &position, TRUE);
anchor.clear();
const gchar *start = entry.content->begin();
const gchar *end = entry.content->end();
while (start < end)
{
const gchar *next = start;
bool valid = g_utf8_validate(start, end - start, &next);
if (start != next)
gtk_text_buffer_insert(buffer, &position, start, next - start);
if (!valid)
{
char text[20];
int n = snprintf(text, 20, "<%02X>", (uint8_t)*next++);
gtk_text_buffer_insert(buffer, &position, text, n);
}
start = next;
}
gtk_text_buffer_get_end_iter(buffer, &position);
need_linebreak = true;
}
if (entry.type & events::end_context)
{
if (!contexts.empty())
{
GtkTextTag *tag = contexts.top().tag;
if (tag)
{
GtkTextIter start;
gtk_text_buffer_get_iter_at_offset(buffer, &start, contexts.top().offset);
gtk_text_buffer_apply_tag(buffer, tag, &start, &position);
}
contexts.pop();
}
}
}
return buffer;
}
