static GtkWidget *build_widget(void)
{
textview = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(textview), 4);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(textview), 4);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
scrollview = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollview), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollview), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_container_add(GTK_CONTAINER(scrollview), textview);
gtk_box_pack_start(GTK_BOX(vbox), scrollview, TRUE, TRUE, 0);
gtk_widget_show(textview);
gtk_widget_show(scrollview);
gtk_widget_show(vbox);
gtk_text_buffer_create_tag(GTK_TEXT_BUFFER(textbuffer), "weight_bold", "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_create_tag(GTK_TEXT_BUFFER(textbuffer), "size_x_large", "scale", PANGO_SCALE_X_LARGE, NULL);
gtk_text_buffer_create_tag(GTK_TEXT_BUFFER(textbuffer), "style_italic", "style", PANGO_STYLE_ITALIC, NULL);
g_signal_connect (vbox, "destroy", (GCallback) gtk_widget_destroyed, & vbox);
return vbox;
}
/////**********************************************************************
///// 函数名称 ： GtkWidget *build_scrolled_win()
/////
///// 函数功能 ： 创 建 scrolled滚动窗口及文本框
/////
///// 返 回 值 ： Send_scrolled_win
/////**********************************************************************
GtkWidget *build_scrolled_win()
{
//GtkWidget *text;
GtkWidget *scrolled;
Send_scrolled_win = gtk_scrolled_window_new(NULL,NULL);
Send_textview = gtk_text_view_new();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(Send_textview),GTK_WRAP_WORD);
gtk_text_view_set_justification(GTK_TEXT_VIEW(Send_textview),GTK_JUSTIFY_LEFT);
gtk_text_view_set_editable(GTK_TEXT_VIEW(Send_textview),TRUE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(Send_textview),TRUE);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(Send_textview),5);
gtk_text_view_set_pixels_below_lines(GTK_TEXT_VIEW(Send_textview),5);
gtk_text_view_set_pixels_inside_wrap(GTK_TEXT_VIEW(Send_textview),5);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(Send_textview),10);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(Send_textview),10);
Send_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(Send_textview));
//////////**********************************************************************************************字体、颜色 的消息循环
g_signal_connect(G_OBJECT(font), "clicked", G_CALLBACK(select_font),(gpointer)Send_textview);
g_signal_connect(G_OBJECT(font_color), "clicked", G_CALLBACK(select_color),(gpointer)Send_textview);//将color对象与clicked相关联，回调函数为select_font
gtk_container_add(GTK_CONTAINER(Send_scrolled_win),Send_textview);
return Send_scrolled_win;
}
static GObject*
_gcr_display_view_constructor (GType type, guint n_props, GObjectConstructParam *props)
{
GObject *obj = G_OBJECT_CLASS (_gcr_display_view_parent_class)->constructor (type, n_props, props);
GcrDisplayView *self = NULL;
GtkTextView *view = NULL;
GtkTextTagTable *tags;
g_return_val_if_fail (obj, NULL);
self = GCR_DISPLAY_VIEW (obj);
view = GTK_TEXT_VIEW (obj);
tags = create_tag_table (self);
self->pv->buffer = gtk_text_buffer_new (tags);
g_object_unref (tags);
gtk_text_view_set_buffer (view, self->pv->buffer);
gtk_text_view_set_editable (view, FALSE);
gtk_text_view_set_left_margin (view, NORMAL_MARGIN);
gtk_text_view_set_right_margin (view, NORMAL_MARGIN);
gtk_text_view_set_cursor_visible (view, FALSE);
return obj;
}
static GtkWidget * create_credits_notebook (const char * const * credits,
const char * const * translators)
{
const char * titles[2] = {_("Credits"), _("Translators")};
const char * const * lists[2] = {credits, translators};
GtkWidget * notebook = gtk_notebook_new ();
for (int i = 0; i < 2; i ++)
{
GtkWidget * label = gtk_label_new (titles[i]);
GtkWidget * scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled,
GTK_SHADOW_IN);
gtk_widget_set_size_request (scrolled, -1, 200);
GtkWidget * text = gtk_text_view_new_with_buffer (create_text_buffer (lists[i]));
gtk_text_view_set_editable ((GtkTextView *) text, FALSE);
gtk_text_view_set_cursor_visible ((GtkTextView *) text, FALSE);
gtk_text_view_set_left_margin ((GtkTextView *) text, 6);
gtk_text_view_set_right_margin ((GtkTextView *) text, 6);
gtk_container_add ((GtkContainer *) scrolled, text);
gtk_notebook_append_page ((GtkNotebook *) notebook, scrolled, label);
}
return notebook;
}
static GtkWidget *
gimp_profile_view_new (GtkTextBuffer *buffer)
{
GtkWidget *frame;
GtkWidget *scrolled_window;
GtkWidget *text_view;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (frame), scrolled_window);
gtk_widget_show (scrolled_window);
text_view = gtk_text_view_new_with_buffer (buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (text_view), 2);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (text_view), 2);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (text_view), 2);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
gtk_widget_show (text_view);
gtk_widget_set_size_request (scrolled_window, 200, -1);
return frame;
}
static GtkWidget *about_create_child_page_session_stats(void)
{
GtkWidget *scrolledwin;
GtkWidget *text;
GtkTextIter iter;
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text), 6);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(text), 6);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(text), FALSE);
gtk_container_add(GTK_CONTAINER(scrolledwin), text);
stats_text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_get_iter_at_offset(stats_text_buffer, &iter, 0);
gtk_text_buffer_create_tag(stats_text_buffer, "indented-list-item",
"indent", 8,
NULL);
gtk_text_buffer_create_tag(stats_text_buffer, "underlined-list-title",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_create_tag(stats_text_buffer, "bold", "weight", PANGO_WEIGHT_BOLD,
NULL);
about_update_stats();
return scrolledwin;
}
static void
dma_sparse_view_instance_init (DmaSparseView *view)
{
PangoFontDescription *font_desc;
view->priv = g_new0 (DmaSparseViewPrivate, 1);
view->priv->buffer = NULL;
view->priv->goto_window = NULL;
view->priv->goto_entry = NULL;
view->priv->show_line_numbers = TRUE;
view->priv->show_line_markers = TRUE;
view->priv->stamp = 0;
memset (view->priv->marker_pixbuf, 0, sizeof (view->priv->marker_pixbuf));
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (view), 2);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (view), 2);
g_signal_connect (view, "populate_popup",
G_CALLBACK (dma_sparse_view_populate_popup), view);
gtk_text_view_set_border_window_size (GTK_TEXT_VIEW (view),
GTK_TEXT_WINDOW_LEFT,
MIN_NUMBER_WINDOW_WIDTH);
font_desc = pango_font_description_from_string ("Monospace 10");
gtk_widget_modify_font (GTK_WIDGET (view), font_desc);
pango_font_description_free (font_desc);
dma_sparse_view_initialize_marker (view);
}
static void markdown_textview_init(MarkdownTextView * self)
{
self->markdown = egg_markdown_new();
self->image_directory = g_strdup(".");
egg_markdown_set_output(self->markdown, EGG_MARKDOWN_OUTPUT_PANGO);
egg_markdown_set_escape(self->markdown, TRUE);
egg_markdown_set_autocode(self->markdown, TRUE);
egg_markdown_set_smart_quoting(self->markdown, TRUE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(self), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(self), FALSE);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(self), 10);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(self), 10);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(self), 3);
gtk_text_view_set_pixels_below_lines(GTK_TEXT_VIEW(self), 3);
g_signal_connect(self, "event-after",
G_CALLBACK(event_after), NULL);
g_signal_connect(self, "key-press-event",
G_CALLBACK(key_press_event), NULL);
g_signal_connect(self, "motion-notify-event",
G_CALLBACK(motion_notify_event), NULL);
g_signal_connect(self, "visibility-notify-event",
G_CALLBACK(visibility_notify_event), NULL);
}
/**
* second page of the assistant
*
* \param
*
* \return the new page
* */
GtkWidget *file_obfuscate_page_2 ( void )
{
GtkWidget *vbox, *text_view;
GtkTextBuffer * buffer;
GtkTextIter iter;
gchar * text, * filename;
vbox = gtk_vbox_new (FALSE, 5);
text_view = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD);
gtk_text_view_set_editable ( GTK_TEXT_VIEW(text_view), FALSE );
gtk_text_view_set_cursor_visible ( GTK_TEXT_VIEW(text_view), FALSE );
gtk_text_view_set_left_margin ( GTK_TEXT_VIEW(text_view), 12 );
gtk_text_view_set_right_margin ( GTK_TEXT_VIEW(text_view), 12 );
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
gtk_text_buffer_create_tag ( buffer, "bold", "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_create_tag ( buffer, "x-large", "scale", PANGO_SCALE_X_LARGE, NULL);
gtk_text_buffer_create_tag ( buffer, "indented", "left-margin", 24, NULL);
gtk_text_buffer_get_iter_at_offset (buffer, &iter, 1);
gtk_text_buffer_insert ( buffer, &iter, "\n", -1 );
if (nom_fichier_comptes)
{
gchar * base_filename = g_strdup ( nom_fichier_comptes );
gchar * complete_filename;
base_filename[strlen(base_filename) - 4] = 0;
complete_filename = g_strconcat ( base_filename, "-obfuscated.gsb", NULL);
filename = g_path_get_basename ( complete_filename );
g_free ( complete_filename );
g_free ( base_filename );
}
else
{
filename = g_strconcat ( "No_name-obfuscated.gsb", NULL);
}
text = g_strdup_printf ( _("Please press the 'Close' button to obfuscate your file\n\n"
"Obfuscated file will be named %s, in the same directory as original file.\n\n"
"Please check the bug is still there and send your file with the explanation to "
"make the bug at [email protected] or on the bugracker (Mantis) "
"at http://grisbi.tuxfamily.org/mantis/main_page.php\n\n"
"The account is saved in text, you may double check with a text editor if there "
"is no personal information anymore in this file."
"Grisbi will close immediatly after saving the obfuscated file"),
filename );
gtk_text_buffer_insert ( buffer, &iter, text, -1 );
gtk_box_pack_start ( GTK_BOX (vbox), text_view, TRUE, TRUE, 0);
g_free ( text );
g_free ( filename );
gtk_widget_show_all (vbox);
return vbox;
}
void EditorActionCreateNoteParagraph::apply (GtkTextTagTable * texttagtable, bool editable, EditorActionCreateParagraph * focused_paragraph, GtkWidget *& to_focus)
{
// Horizontal box to store the note.
hbox = gtk_hbox_new (false, 0);
gtk_widget_show (hbox);
gtk_box_pack_start(GTK_BOX(parent_vbox), hbox, false, false, 0);
// Eventbox to catch a few events on the caller of the note.
eventbox = gtk_event_box_new ();
gtk_widget_show (eventbox);
gtk_box_pack_start(GTK_BOX(hbox), eventbox, false, false, 0);
g_signal_connect ((gpointer) eventbox, "enter_notify_event", G_CALLBACK (on_caller_enter_notify_event), gpointer (this));
g_signal_connect ((gpointer) eventbox, "leave_notify_event", G_CALLBACK (on_caller_leave_notify_event), gpointer (this));
// The background of the caller is going to be grey.
// Courier font is chosen to make the spacing of the callers equal so they line up nicely.
label = gtk_label_new ("");
gtk_widget_show (label);
char *markup = g_markup_printf_escaped("<span background=\"grey\" size=\"x-small\"> </span><span background=\"grey\" face=\"Courier\">%s</span><span background=\"grey\" size=\"x-small\"> </span>", caller_text.c_str());
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_container_add (GTK_CONTAINER (eventbox), label);
// The textbuffer uses the text tag table.
textbuffer = gtk_text_buffer_new(texttagtable);
// Text view to view the text buffer.
textview = gtk_text_view_new_with_buffer(textbuffer);
gtk_widget_show(textview);
gtk_box_pack_start(GTK_BOX(hbox), textview, true, true, 0);
// Set some parameters of the view.
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), editable);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(textview), 5);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(textview), 5);
// Move the widget to the right position. To be calculated.
/*
vector <GtkWidget *> widgets = editor_get_widgets (parent_vbox);
gint new_paragraph_offset = 0;
if (focused_paragraph) {
for (unsigned int i = 0; i < widgets.size(); i++) {
if (focused_paragraph->textview == widgets[i]) {
new_paragraph_offset = i + 1;
break;
}
}
}
gtk_box_reorder_child (GTK_BOX(parent_vbox), textview, new_paragraph_offset);
*/
// Let the newly created textview be earmarked to grab focus
// so that the user can type in it,
// and the internal Editor logic knows about it.
to_focus = textview;
}
void bug_information_window_new(GtkWidget * window)
{
GtkWidget *dialog;
GtkTextBuffer *buffer;
GtkWidget *scrolled_window, *text_view;
PangoTabArray *tab_array;
/* Basic dialog with a close button */
dialog = gtk_dialog_new_with_buttons(_("Bug information"),
(window) ? (GtkWindow *) playlist3_get_window() : NULL,
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CLOSE, GTK_RESPONSE_YES, NULL);
/* Set default window size */
gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 800);
/* The buffer that holds the "report" */
buffer = gtk_text_buffer_new(NULL);
bug_information_generate_message(buffer);
/* View to show the textbuffer */
text_view = gtk_text_view_new();
/* setup textview */
/* set tabarray */
tab_array = pango_tab_array_new_with_positions(1, TRUE, PANGO_TAB_LEFT, 500);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(text_view), TRUE);
gtk_text_view_set_tabs(GTK_TEXT_VIEW(text_view), tab_array);
pango_tab_array_free(tab_array);
/* not editable */
gtk_text_view_set_editable(GTK_TEXT_VIEW(text_view), FALSE);
/* set margins */
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_view), 12);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(text_view), 12);
/* Add the text buffer */
gtk_text_view_set_buffer(GTK_TEXT_VIEW(text_view), buffer);
/* scrolled window, this allows the text view to scroll */
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
/* setup scrolled window */
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* add text view to scrolled_window */
gtk_container_add(GTK_CONTAINER(scrolled_window), text_view);
/* add scrolled_window to dialog */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolled_window, TRUE, TRUE, 0);
/* Add dialogs response handler */
g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL);
/* show dialog */
gtk_widget_show_all(dialog);
if (window == NULL)
{
gtk_dialog_run(GTK_DIALOG(dialog));
}
}
void
eog_imgur_ui_get_message (GtkWindow *parent,
const gchar *service,
gint character_limit,
EogImgurUiMessageCallback *callback)
{
GtkWidget *dialogue;
GtkWidget *content;
GtkWidget *label;
GtkWidget *textview;
MessageDetails *details = g_malloc (sizeof (MessageDetails));
details->parent = parent;
details->textview = gtk_text_view_new ();
details->character_limit = character_limit;
details->service = service;
details->callback = callback;
gtk_text_view_set_editable (GTK_TEXT_VIEW (details->textview), TRUE);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (details->textview), 10);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (details->textview), 10);
if (details->character_limit)
{
GtkTextBuffer *buffer =
gtk_text_view_get_buffer (GTK_TEXT_VIEW (details->textview));
g_signal_connect (G_OBJECT (buffer),
"changed",
G_CALLBACK (restrict_message_length),
details);
}
dialogue = gtk_dialog_new_with_buttons ("Eye of GNOME",
parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
NULL);
content = gtk_dialog_get_content_area (GTK_DIALOG (dialogue));
label = gtk_label_new ("Enter any text you'd like to add beside the link. "
"(You may leave this blank and simply press OK.)");
gtk_container_add (GTK_CONTAINER (content), label);
gtk_container_add (GTK_CONTAINER (content), details->textview);
g_signal_connect (dialogue,
"response",
G_CALLBACK (message_response),
details);
gtk_widget_show_all (dialogue);
}
/*
Main sidegadget's function
*/
GtkWidget*
sidegadget_new (void)
{
block_notes = g_new0 (block_notes_s, 1);
block_notes->work_dir = g_strdup_printf ("sidegadget/block-notes/%s", BLOCK_NOTES_DATA_FILE);
/* Get initial text */
block_notes_conf_get_initial_text (block_notes, block_notes->work_dir);
block_notes->view = gtk_text_view_new ();
gtk_widget_set_size_request (block_notes->view, -1, 200 - 25);
/* Set textview's color*/
// gtk_widget_modify_base (block_notes->view, GTK_STATE_NORMAL, &sidegadget->color_gadget);
gtk_widget_grab_focus (block_notes->view);
gtk_text_view_set_editable (GTK_TEXT_VIEW (block_notes->view), TRUE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (block_notes->view), TRUE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (block_notes->view), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_justification (GTK_TEXT_VIEW (block_notes->view), GTK_JUSTIFY_LEFT);
/* Set space between two rows */
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (block_notes->view), 1);
gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (block_notes->view), 1);
/* Set borders */
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (block_notes->view), 2);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (block_notes->view), 2);
/* Set font color */
gtk_widget_modify_text (block_notes->view, GTK_STATE_NORMAL, &block_notes->color_text);
/* Set font */
gtk_widget_modify_font (block_notes->view, block_notes->font_pango);
gtk_widget_show (block_notes->view);
/* Create a buffer*/
block_notes->buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(block_notes->view));
/* Insert init_text in the buffer */
gtk_text_buffer_set_text (block_notes->buffer, block_notes->string_init, -1);
/* Create scrolled window */
block_notes->scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (block_notes->scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* Insert the textview in the scrolled win */
gtk_container_add (GTK_CONTAINER(block_notes->scrolled_win), block_notes->view);
g_signal_connect (G_OBJECT (block_notes->buffer), "changed", G_CALLBACK (block_notes_save_text), block_notes);
return block_notes->scrolled_win;
}
void
show_text(GtkWidget *window, const char *text)
{
GtkWidget *dialog, *content_area, *view, *sw;
GtkDialogFlags flags = GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT;
dialog = gtk_dialog_new_with_buttons(PACKAGE_NAME " Help",
GTK_WINDOW(window),
flags,
"_Close",
GTK_RESPONSE_CANCEL,
NULL);
content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_container_add_with_properties(GTK_CONTAINER(content_area), sw,
"expand", TRUE,
"fill", TRUE,
NULL);
view = gtk_text_view_new();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_WORD);
gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(view)),
text, -1);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(view), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(view), FALSE);
/* Use font metrics to set the size of the text view. */
PangoContext *context = gtk_widget_get_pango_context(view);
PangoFontMetrics *metrics = pango_context_get_metrics(context, NULL, NULL);
gint char_width = pango_font_metrics_get_approximate_char_width(metrics);
gint ascent = pango_font_metrics_get_ascent(metrics);
gint descent = pango_font_metrics_get_descent(metrics);
gint height = PANGO_PIXELS(ascent + descent);
gint width = PANGO_PIXELS(char_width);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(view), 2 * width);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(view), 2 * width);
gtk_window_set_default_size(GTK_WINDOW(dialog), 70 * width, 20 * height);
gtk_container_add(GTK_CONTAINER(sw), view);
gtk_widget_show_all(dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
/**
* class_properties_new:
*
* Returns: a new #GtkWidget
*/
GtkWidget *
class_properties_new (TConnection *tcnc)
{
ClassProperties *cprop;
g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL);
cprop = CLASS_PROPERTIES (g_object_new (CLASS_PROPERTIES_TYPE, NULL));
cprop->priv->tcnc = g_object_ref (tcnc);
GtkWidget *sw;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (cprop), sw, TRUE, TRUE, 0);
GtkWidget *textview;
textview = gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (sw), textview);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (textview), 5);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (textview), 5);
gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), FALSE);
cprop->priv->text = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
cprop->priv->view = GTK_TEXT_VIEW (textview);
gtk_widget_show_all (sw);
gtk_text_buffer_create_tag (cprop->priv->text, "section",
"weight", PANGO_WEIGHT_BOLD,
"foreground", "blue", NULL);
gtk_text_buffer_create_tag (cprop->priv->text, "error",
"foreground", "red", NULL);
gtk_text_buffer_create_tag (cprop->priv->text, "data",
"left-margin", 20, NULL);
gtk_text_buffer_create_tag (cprop->priv->text, "starter",
"indent", -10,
"left-margin", 20, NULL);
g_signal_connect (textview, "key-press-event",
G_CALLBACK (key_press_event), cprop);
g_signal_connect (textview, "event-after",
G_CALLBACK (event_after), cprop);
g_signal_connect (textview, "motion-notify-event",
G_CALLBACK (motion_notify_event), cprop);
g_signal_connect (textview, "visibility-notify-event",
G_CALLBACK (visibility_notify_event), cprop);
class_properties_set_class (cprop, NULL);
return (GtkWidget*) cprop;
}
static GtkWidget *
create_window (GtkTextBuffer *buffer)
{
GtkWidget *window;
GtkWidget *scrolledwin;
GtkWidget *box;
GtkWidget *terminal;
GtkWidget *bbox;
GtkWidget *close_button;
PangoTabArray *tabs;
int width, height;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW (window), _("Boot messages"));
gtk_container_set_border_width (GTK_CONTAINER (window), 12);
width = MIN (800, 0.75 * gdk_screen_get_width (gdk_screen_get_default ()));
height = MIN (600, 0.75 * gdk_screen_get_height (gdk_screen_get_default ()));
gtk_window_set_default_size (GTK_WINDOW (window), width, height);
box = gtk_vbox_new (FALSE, 0);
scrolledwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwin),
GTK_SHADOW_IN);
terminal = gtk_text_view_new_with_buffer (buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (terminal), FALSE);
tabs = pango_tab_array_new_with_positions (1, TRUE, PANGO_TAB_LEFT, width - 130);
gtk_text_view_set_tabs (GTK_TEXT_VIEW (terminal), tabs);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (terminal), 12);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (terminal), 12);
bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
close_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_box_pack_start (GTK_BOX (box), scrolledwin, TRUE, TRUE, 6);
gtk_container_add (GTK_CONTAINER (scrolledwin), terminal);
gtk_box_pack_start (GTK_BOX (box), bbox, FALSE, TRUE, 6);
gtk_box_pack_start (GTK_BOX (bbox), close_button, FALSE, TRUE, 6);
g_signal_connect (window, "delete-event",
G_CALLBACK (close_window), NULL);
g_signal_connect_swapped (close_button, "clicked",
G_CALLBACK (close_window), window);
gtk_widget_show_all (box);
return window;
}
static GtkWidget *about_create_child_page_release_notes(void)
{
GtkWidget *scrolledwin;
GtkWidget *text;
GtkTextBuffer *buffer;
GtkTextIter iter;
gchar *path, buf[1024];
FILE *fp;
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text), 6);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(text), 6);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(text), FALSE);
gtk_container_add(GTK_CONTAINER(scrolledwin), text);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
path = g_strconcat(DOCDIR, G_DIR_SEPARATOR_S, RELEASE_NOTES_FILE, NULL);
if ((fp = g_fopen(path, "rb")) == NULL) {
if (ENOENT != errno) FILE_OP_ERROR(path, "fopen");
g_free(path);
return scrolledwin;
}
g_free(path);
while (fgets(buf, sizeof(buf), fp) != NULL) {
const gchar *src_codeset = conv_get_locale_charset_str();
const gchar *dest_codeset = CS_UTF_8;
gchar *tmp;
tmp = conv_codeset_strdup(buf, src_codeset, dest_codeset);
if (!tmp) {
g_warning("Failed to convert character set of action configuration");
tmp = g_strdup(buf);
}
gtk_text_buffer_insert(buffer, &iter, tmp, -1);
g_free(tmp);
}
fclose(fp);
return scrolledwin;
}
static void
create_properties_widget ()
{
pwidget = gtk_vbox_new (FALSE, 10);
GtkWidget *finish_label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL(finish_label), "<b>When Finished:</b>");
GtkWidget *buttonbox = gtk_hbutton_box_new ();
open = gtk_check_button_new_with_label ("Open File");
notify = gtk_check_button_new_with_label ("Show Notification");
open_location = gtk_check_button_new_with_label ("Open Location");
gtk_box_pack_start (GTK_BOX(buttonbox), notify, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(buttonbox), open, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(buttonbox), open_location, FALSE, FALSE, 0);
GtkWidget *comment_label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL(comment_label), "<b>Comment:</b>");
GtkWidget *text_view = gtk_text_view_new ();
comment = gtk_text_view_get_buffer (GTK_TEXT_VIEW(text_view));
gtk_widget_set_size_request (text_view, -1, 60);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW(text_view), 10);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW(text_view), 10);
gtk_box_pack_start (GTK_BOX(pwidget), finish_label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(pwidget), buttonbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(pwidget), comment_label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(pwidget), text_view, FALSE, FALSE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_START);
gtk_misc_set_alignment (GTK_MISC(finish_label), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC(comment_label), 0.0, 0.5);
gtk_widget_set_margin_left (pwidget, 15);
gtk_widget_set_margin_left (buttonbox, 15);
gtk_widget_set_margin_left (text_view, 15);
gtk_widget_set_margin_right (text_view, 20);
gtk_widget_set_margin_top (pwidget, 15);
g_signal_connect (notify, "toggled", G_CALLBACK (on_toggle),
GINT_TO_POINTER (G_DOWNLOADABLE_FINISH_ACTION_NOTIFY));
g_signal_connect (open, "toggled", G_CALLBACK (on_toggle),
GINT_TO_POINTER (G_DOWNLOADABLE_FINISH_ACTION_OPEN));
g_signal_connect (open_location, "toggled", G_CALLBACK (on_toggle),
GINT_TO_POINTER (G_DOWNLOADABLE_FINISH_ACTION_OPEN_LOCATION));
g_signal_connect (text_view, "focus-out-event", G_CALLBACK (on_comment_save), NULL);
gtk_widget_show_all (pwidget);
}
/*
* make the list widget
*/
static GtkWidget *
balsa_information_list_new(void)
{
GtkTextView *view;
view = GTK_TEXT_VIEW(gtk_text_view_new());
gtk_text_view_set_editable(view, FALSE);
gtk_text_view_set_left_margin(view, 2);
gtk_text_view_set_indent(view, -12);
gtk_text_view_set_right_margin(view, 2);
gtk_text_view_set_wrap_mode(view, GTK_WRAP_WORD_CHAR);
return GTK_WIDGET(view);
}
static GtkWidget *get_text_panel(void)
{
GtkWidget *textview;
textview = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), TRUE);
gtk_text_view_set_accepts_tab (GTK_TEXT_VIEW (textview), TRUE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), TRUE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (textview), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (textview), 2);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (textview), 2);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (textview), 2);
gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (textview), 2);
gtk_container_set_border_width(GTK_CONTAINER(textview), 5);
return textview;
}
/**
* create a normalised text view for grisbi and add the value inside
*
* \param value a pointer to a string
*
* \return a GtkWidget which is a text_view with the string inside
* */
GtkWidget *gsb_editable_text_view_new ( const gchar *value )
{
GtkWidget * text_view;
GtkTextBuffer *buffer;
text_view = gtk_text_view_new ();
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (text_view), 3);
gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (text_view), 3);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (text_view), 3);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (text_view), 3);
gtk_text_view_set_wrap_mode ( GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD );
if (value)
gtk_text_buffer_set_text (buffer, value, -1);
return text_view;
}
/*
Create main textview
*/
void
arduino_csr_create_textview_buffer (arduino_csr_dialog_core_s *dialog)
{
GtkWidget *v_box;
v_box = gtk_vbox_new (FALSE, 0);
dialog->view = gtk_text_view_new ();
// gtk_widget_modify_font (dialog->view, font_pango);
gtk_widget_grab_focus (dialog->view);
gtk_text_view_set_editable (GTK_TEXT_VIEW (dialog->view), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (dialog->view), TRUE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (dialog->view), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_justification (GTK_TEXT_VIEW (dialog->view), GTK_JUSTIFY_LEFT);
/* Set space between two rows */
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (dialog->view), 1);
gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (dialog->view), 1);
/* Set borders */
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (dialog->view), 2);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (dialog->view), 2);
gtk_widget_set_can_focus (dialog->view, TRUE);
gtk_widget_grab_focus (dialog->view);
dialog->buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(dialog->view));
dialog->scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(dialog->scrolled_win), dialog->view);
gtk_widget_show (dialog->view);
gtk_widget_set_can_focus (dialog->scrolled_win, TRUE);
gtk_widget_grab_focus (dialog->scrolled_win);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog->window)->vbox), dialog->scrolled_win, TRUE, TRUE, 1);
gtk_widget_show (dialog->scrolled_win);
}
static GtkWidget *dlg_text_edit_new (int *hsize, gboolean s)
{
GtkTextBuffer *tbuf;
GtkWidget *tview;
tbuf = gtk_text_buffer_new(NULL);
tview = gtk_text_view_new_with_buffer(tbuf);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tview), GTK_WRAP_WORD);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(tview), 4);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(tview), 4);
gtk_widget_modify_font(GTK_WIDGET(tview), fixed_font);
*hsize *= get_char_width(tview);
*hsize += 48;
gtk_text_view_set_editable(GTK_TEXT_VIEW(tview), s);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(tview), s);
return tview;
}
GtkWidget *gtk_mail_qr_new(void)
{
GtkWidget *gtk_mail_label = gtk_label_new(NULL);
GtkWidget *gtk_mail_vertical = gtk_box_new(GTK_ORIENTATION_VERTICAL, 15);
GtkWidget *gtk_mail_scrolled = gtk_scrolled_window_new(NULL, NULL);
GtkWidget *gtk_mail_button_clear = gtk_button_new_with_label("Clear and reset");
GtkWidget *gtk_mail_horizontal_buttons = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
gtk_mail_entry_to = gtk_entry_new();
gtk_mail_entry_subject = gtk_entry_new();
GtkWidget *gtk_mail_text_view_scrolled_frame = gtk_frame_new(NULL);
GtkWidget *gtk_mail_text_view_scrolled = gtk_scrolled_window_new(NULL, NULL);
GtkWidget *gtk_mail_text_view = gtk_text_view_new();
gtk_mail_text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtk_mail_text_view));
gtk_label_set_markup(GTK_LABEL(gtk_mail_label), "<span size=\"xx-large\">Generate from e-mail</span>");
gtk_widget_set_halign(gtk_mail_label, GTK_ALIGN_START);
gtk_entry_set_placeholder_text(GTK_ENTRY(gtk_mail_entry_to), "Recipient e-mail address");
gtk_entry_set_placeholder_text(GTK_ENTRY(gtk_mail_entry_subject), "E-mail subject");
gtk_container_set_border_width(GTK_CONTAINER(gtk_mail_vertical), 15);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(gtk_mail_text_view), 5);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(gtk_mail_text_view), 5);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(gtk_mail_text_view), 2);
gtk_text_view_set_pixels_below_lines(GTK_TEXT_VIEW(gtk_mail_text_view), 2);
gtk_widget_set_size_request(gtk_mail_text_view_scrolled, -1, 200);
gtk_text_buffer_set_text(gtk_mail_text_buffer, "E-mail message", -1);
gtk_box_pack_start(GTK_BOX(gtk_mail_vertical), gtk_mail_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_mail_vertical), gtk_mail_entry_to, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_mail_vertical), gtk_mail_entry_subject, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(gtk_mail_text_view_scrolled), gtk_mail_text_view);
gtk_container_add(GTK_CONTAINER(gtk_mail_text_view_scrolled_frame), gtk_mail_text_view_scrolled);
gtk_box_pack_start(GTK_BOX(gtk_mail_vertical), gtk_mail_text_view_scrolled_frame, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(gtk_mail_horizontal_buttons), gtk_mail_button_clear, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_mail_vertical), gtk_mail_horizontal_buttons, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(gtk_mail_scrolled), gtk_mail_vertical);
g_signal_connect(G_OBJECT(gtk_mail_button_clear), "clicked", G_CALLBACK(cb_clicked_mail_clear), NULL);
return gtk_mail_scrolled;
}
void EditorActionCreateParagraph::apply (GtkTextTagTable * texttagtable, bool editable, EditorActionCreateParagraph * focused_paragraph, GtkWidget *& to_focus)
{
// The textbuffer uses the text tag table.
textbuffer = gtk_text_buffer_new(texttagtable);
// New text view to view the text buffer.
textview = gtk_text_view_new_with_buffer(textbuffer);
gtk_widget_show(textview);
// Add text view to the GUI.
gtk_box_pack_start(GTK_BOX(parent_vbox), textview, false, false, 0);
// Set some parameters of the view.
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), editable);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(textview), 5);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(textview), 5);
// Move the widget to the right position,
// which is next to the currently focused paragraph.
// This move is important since a new paragraph can be created anywhere among the current ones.
vector <GtkWidget *> widgets = editor_get_widgets (parent_vbox);
gint new_paragraph_offset = 0;
if (focused_paragraph) {
for (unsigned int i = 0; i < widgets.size(); i++) {
if (focused_paragraph->textview == widgets[i]) {
new_paragraph_offset = i + 1;
break;
}
}
}
gtk_box_reorder_child (GTK_BOX(parent_vbox), textview, new_paragraph_offset);
// Let the newly created textview be earmarked to grab focus
// so that the user can type in it,
// and the internal Editor logic knows about it.
to_focus = textview;
}
static void
display_text (gchar *title, gchar *text, gboolean editable)
{
GtkWidget *dialog, *scrolled_window, *text_view;
GtkTextBuffer *buffer;
GdkPixbuf *pixbuf;
dialog = gtk_dialog_new_with_buttons (title, NULL, 0,
GTK_STOCK_CLOSE, GTK_RESPONSE_NONE, NULL);
gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 450);
g_signal_connect_swapped (dialog, "response",
G_CALLBACK (gtk_widget_destroy), dialog);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), scrolled_window);
text_view = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), editable);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (text_view), 8);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (text_view), 8);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
gtk_text_buffer_set_text (buffer, text, strlen (text));
pixbuf = gtk_widget_render_icon (dialog,
ICON_CLIPBOARD_DEFAULT,
(GtkIconSize)-1,
NULL);
gtk_window_set_icon (GTK_WINDOW (dialog), pixbuf);
g_object_unref(pixbuf);
gtk_widget_show_all (dialog);
}
static void add_page (GtkNotebook * notebook, const gchar * name, const gchar * buf,gboolean hscrolling)
{
GtkTextBuffer *textbuffer;
GtkWidget *textview;
GtkWidget *label;
GtkWidget *view;
GtkWidget *sw;
label = gtk_label_new (name);
gtk_widget_show (label);
view = gtk_frame_new (NULL);
gtk_container_set_border_width (GTK_CONTAINER (view), BORDER);
gtk_frame_set_shadow_type (GTK_FRAME (view), GTK_SHADOW_IN);
gtk_widget_show (view);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
hscrolling ? GTK_POLICY_AUTOMATIC :
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (sw);
gtk_container_add (GTK_CONTAINER (view), sw);
textbuffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_set_text (textbuffer, buf, strlen(buf));
textview = gtk_text_view_new_with_buffer (textbuffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), FALSE);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (textview), BORDER);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (textview), BORDER);
gtk_widget_show (textview);
gtk_container_add (GTK_CONTAINER (sw), textview);
gtk_notebook_append_page (notebook, view, label);
}
static void
gimp_color_profile_view_constructed (GObject *object)
{
GtkTextBuffer *buffer;
G_OBJECT_CLASS (parent_class)->constructed (object);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (object));
gtk_text_buffer_create_tag (buffer, "strong",
"weight", PANGO_WEIGHT_BOLD,
"scale", PANGO_SCALE_LARGE,
NULL);
gtk_text_buffer_create_tag (buffer, "emphasis",
"style", PANGO_STYLE_OBLIQUE,
NULL);
gtk_text_view_set_editable (GTK_TEXT_VIEW (object), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (object), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (object), 6);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (object), 6);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (object), 6);
}
void i_fileinfo_gui( const gchar * filename_uri )
{
static GtkWidget *fileinfowin = NULL;
GtkWidget *fileinfowin_vbox, *fileinfowin_columns_hbox;
GtkWidget *midiinfoboxes_vbox, *miditextboxes_vbox, *miditextboxes_paned;
GtkWidget *title_hbox, *title_icon_image, *title_name_f_label, *title_name_v_entry;
GtkWidget *info_frame, *info_frame_tl, *info_grid;
GtkWidget *text_frame, *text_frame_tl, *text_tv, *text_tv_sw;
GtkWidget *lyrics_frame, *lyrics_tv, *lyrics_tv_sw;
GtkTextBuffer *text_tb, *lyrics_tb;
GtkWidget *footer_hbbox, *footer_bclose;
GdkPixbuf *title_icon_pixbuf;
PangoAttrList *pangoattrlist;
PangoAttribute *pangoattr;
GString *value_gstring;
gchar *title , *filename, *filename_utf8;
gint bpm = 0, wavg_bpm = 0;
midifile_t *mf;
if ( fileinfowin )
return;
mf = g_malloc(sizeof(midifile_t));
/****************** midifile parser ******************/
if ( !i_midi_parse_from_filename( filename_uri , mf ) )
return;
/* midifile is filled with information at this point,
bpm information is needed too */
i_midi_get_bpm( mf , &bpm , &wavg_bpm );
/*****************************************************/
fileinfowin = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_type_hint( GTK_WINDOW(fileinfowin), GDK_WINDOW_TYPE_HINT_DIALOG );
gtk_window_set_position( GTK_WINDOW(fileinfowin) , GTK_WIN_POS_CENTER );
g_signal_connect( G_OBJECT(fileinfowin) , "destroy" , G_CALLBACK(i_fileinfo_ev_destroy) , mf );
g_signal_connect( G_OBJECT(fileinfowin) , "destroy" , G_CALLBACK(gtk_widget_destroyed) , &fileinfowin );
gtk_container_set_border_width( GTK_CONTAINER(fileinfowin), 10 );
fileinfowin_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10 );
gtk_container_add( GTK_CONTAINER(fileinfowin) , fileinfowin_vbox );
/* pango attributes */
pangoattrlist = pango_attr_list_new();
pangoattr = pango_attr_weight_new( PANGO_WEIGHT_BOLD );
pangoattr->start_index = 0;
pangoattr->end_index = G_MAXINT;
pango_attr_list_insert( pangoattrlist , pangoattr );
/******************
*** TITLE LINE ***/
title_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5 );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , title_hbox , FALSE , FALSE , 0 );
title_icon_pixbuf = gdk_pixbuf_new_from_xpm_data( (const gchar **)amidiplug_xpm_midiicon );
title_icon_image = gtk_image_new_from_pixbuf( title_icon_pixbuf );
g_object_unref( title_icon_pixbuf );
gtk_misc_set_alignment( GTK_MISC(title_icon_image) , 0 , 0 );
gtk_box_pack_start( GTK_BOX(title_hbox) , title_icon_image , FALSE , FALSE , 0 );
title_name_f_label = gtk_label_new( _("Name:") );
gtk_label_set_attributes( GTK_LABEL(title_name_f_label) , pangoattrlist );
gtk_box_pack_start( GTK_BOX(title_hbox) , title_name_f_label , FALSE , FALSE , 0 );
title_name_v_entry = gtk_entry_new();
gtk_editable_set_editable( GTK_EDITABLE(title_name_v_entry) , FALSE );
gtk_widget_set_size_request( GTK_WIDGET(title_name_v_entry) , 200 , -1 );
gtk_box_pack_start(GTK_BOX(title_hbox) , title_name_v_entry , TRUE , TRUE , 0 );
fileinfowin_columns_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2 );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , fileinfowin_columns_hbox , TRUE , TRUE , 0 );
/*********************
*** MIDI INFO BOX ***/
midiinfoboxes_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2 );
/* pick the entire space if both comments and lyrics boxes are not displayed,
pick only required space if at least one of them is displayed */
if (( amidiplug_cfg_ap.ap_opts_comments_extract == 0 ) &&
( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 ))
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , midiinfoboxes_vbox , TRUE , TRUE , 0 );
else
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , midiinfoboxes_vbox , FALSE , FALSE , 0 );
info_frame_tl = gtk_label_new( "" );
gtk_label_set_markup( GTK_LABEL(info_frame_tl) , _("<span size=\"smaller\"> MIDI Info </span>") );
gtk_box_pack_start( GTK_BOX(midiinfoboxes_vbox) , info_frame_tl , FALSE , FALSE , 0 );
info_frame = gtk_frame_new( NULL );
gtk_box_pack_start( GTK_BOX(midiinfoboxes_vbox) , info_frame , TRUE , TRUE , 0 );
info_grid = gtk_grid_new();
gtk_grid_set_row_spacing( GTK_GRID(info_grid) , 4 );
gtk_grid_set_column_spacing( GTK_GRID(info_grid) , 10 );
gtk_container_set_border_width( GTK_CONTAINER(info_grid) , 3 );
gtk_container_add( GTK_CONTAINER(info_frame) , info_grid );
value_gstring = g_string_new( "" );
/* midi format */
G_STRING_PRINTF( value_gstring , "type %i" , mf->format );
i_fileinfo_grid_add_entry( _("Format:") , value_gstring->str , info_grid , 0 , pangoattrlist );
/* midi length */
G_STRING_PRINTF( value_gstring , "%i" , (gint)(mf->length / 1000) );
i_fileinfo_grid_add_entry( _("Length (msec):") , value_gstring->str , info_grid , 1 , pangoattrlist );
/* midi num of tracks */
G_STRING_PRINTF( value_gstring , "%i" , mf->num_tracks );
i_fileinfo_grid_add_entry( _("No. of Tracks:") , value_gstring->str , info_grid , 2 , pangoattrlist );
/* midi bpm */
if ( bpm > 0 )
G_STRING_PRINTF( value_gstring , "%i" , bpm ); /* fixed bpm */
else
G_STRING_PRINTF( value_gstring , _("variable") ); /* variable bpm */
i_fileinfo_grid_add_entry( _("BPM:") , value_gstring->str , info_grid , 3 , pangoattrlist );
/* midi weighted average bpm */
if ( bpm > 0 )
G_STRING_PRINTF( value_gstring , "/" ); /* fixed bpm, don't care about wavg_bpm */
else
G_STRING_PRINTF( value_gstring , "%i" , wavg_bpm ); /* variable bpm, display wavg_bpm */
i_fileinfo_grid_add_entry( _("BPM (wavg):") , value_gstring->str , info_grid , 4 , pangoattrlist );
/* midi time division */
G_STRING_PRINTF( value_gstring , "%i" , mf->time_division );
i_fileinfo_grid_add_entry( _("Time Div:") , value_gstring->str , info_grid , 5 , pangoattrlist );
g_string_free( value_gstring , TRUE );
/**********************************
*** MIDI COMMENTS/LYRICS BOXES ***/
miditextboxes_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2 );
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , miditextboxes_vbox , TRUE , TRUE , 0 );
text_frame_tl = gtk_label_new( "" );
gtk_label_set_markup( GTK_LABEL(text_frame_tl) ,
_("<span size=\"smaller\"> MIDI Comments and Lyrics </span>") );
gtk_box_pack_start( GTK_BOX(miditextboxes_vbox) , text_frame_tl , FALSE , FALSE , 0 );
miditextboxes_paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start( GTK_BOX(miditextboxes_vbox) , miditextboxes_paned , TRUE , TRUE , 0 );
text_frame = gtk_frame_new( NULL );
gtk_paned_pack1( GTK_PANED(miditextboxes_paned) , text_frame , TRUE , TRUE );
text_tv = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW(text_tv) , FALSE );
gtk_text_view_set_cursor_visible( GTK_TEXT_VIEW(text_tv) , FALSE );
gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(text_tv) , GTK_WRAP_WORD );
gtk_text_view_set_right_margin( GTK_TEXT_VIEW(text_tv) , 4 );
gtk_text_view_set_left_margin( GTK_TEXT_VIEW(text_tv) , 4 );
gtk_widget_set_size_request( text_tv , 300 , 113 );
text_tv_sw = gtk_scrolled_window_new( NULL , NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(text_tv_sw) ,
GTK_POLICY_AUTOMATIC , GTK_POLICY_ALWAYS );
gtk_container_add( GTK_CONTAINER(text_frame) , text_tv_sw );
gtk_container_add( GTK_CONTAINER(text_tv_sw) , text_tv );
lyrics_frame = gtk_frame_new( NULL );
gtk_paned_pack2( GTK_PANED(miditextboxes_paned) , lyrics_frame , TRUE , TRUE );
lyrics_tv = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW(lyrics_tv) , FALSE );
gtk_text_view_set_cursor_visible( GTK_TEXT_VIEW(lyrics_tv) , FALSE );
gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(lyrics_tv) , GTK_WRAP_WORD );
gtk_text_view_set_right_margin( GTK_TEXT_VIEW(lyrics_tv) , 4 );
gtk_text_view_set_left_margin( GTK_TEXT_VIEW(lyrics_tv) , 4 );
gtk_widget_set_size_request( lyrics_tv , 300 , 113 );
lyrics_tv_sw = gtk_scrolled_window_new( NULL , NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(lyrics_tv_sw) ,
GTK_POLICY_AUTOMATIC , GTK_POLICY_ALWAYS );
gtk_container_add( GTK_CONTAINER(lyrics_frame) , lyrics_tv_sw );
gtk_container_add( GTK_CONTAINER(lyrics_tv_sw) , lyrics_tv );
text_tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(text_tv) );
lyrics_tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(lyrics_tv) );
/* call the buffer fill routine if at least one between comments and lyrics is enabled */
if (( amidiplug_cfg_ap.ap_opts_comments_extract > 0 ) ||
( amidiplug_cfg_ap.ap_opts_lyrics_extract > 0 ))
i_fileinfo_text_fill( mf , text_tb , lyrics_tb );
if (( amidiplug_cfg_ap.ap_opts_comments_extract > 0 ) &&
( gtk_text_buffer_get_char_count( text_tb ) == 0 ))
{
GtkTextIter start, end;
GtkTextTag *tag = gtk_text_buffer_create_tag( text_tb , "italicstyle" ,
"style" , PANGO_STYLE_ITALIC , NULL );
/*gtk_text_view_set_justification( GTK_TEXT_VIEW(text_tv) , GTK_JUSTIFY_CENTER );*/
gtk_text_buffer_set_text( text_tb , _("* no comments available in this MIDI file *") , -1 );
gtk_text_buffer_get_iter_at_offset( text_tb , &start , 0 );
gtk_text_buffer_get_iter_at_offset( text_tb , &end , -1 );
gtk_text_buffer_apply_tag( text_tb , tag , &start , &end );
}
if (( amidiplug_cfg_ap.ap_opts_lyrics_extract > 0 ) &&
( gtk_text_buffer_get_char_count( lyrics_tb ) == 0 ))
{
GtkTextIter start, end;
GtkTextTag *tag = gtk_text_buffer_create_tag( lyrics_tb , "italicstyle" ,
"style" , PANGO_STYLE_ITALIC , NULL );
/*gtk_text_view_set_justification( GTK_TEXT_VIEW(lyrics_tv) , GTK_JUSTIFY_CENTER );*/
gtk_text_buffer_set_text( lyrics_tb , _("* no lyrics available in this MIDI file *") , -1 );
gtk_text_buffer_get_iter_at_offset( lyrics_tb , &start , 0 );
gtk_text_buffer_get_iter_at_offset( lyrics_tb , &end , -1 );
gtk_text_buffer_apply_tag( lyrics_tb , tag , &start , &end );
}
/* hide boxes for disabled options (comments and/or lyrics) */
if (( amidiplug_cfg_ap.ap_opts_comments_extract == 0 ) &&
( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 ))
{
gtk_widget_set_no_show_all( miditextboxes_vbox , TRUE );
gtk_widget_hide( miditextboxes_vbox );
}
else if ( amidiplug_cfg_ap.ap_opts_comments_extract == 0 )
{
gtk_widget_set_no_show_all( text_frame , TRUE );
gtk_widget_hide( text_frame );
}
else if ( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 )
{
gtk_widget_set_no_show_all( lyrics_frame , TRUE );
gtk_widget_hide( lyrics_frame );
}
/**************
*** FOOTER ***/
footer_hbbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout( GTK_BUTTON_BOX(footer_hbbox) , GTK_BUTTONBOX_END );
footer_bclose = gtk_button_new_from_stock( GTK_STOCK_CLOSE );
g_signal_connect( G_OBJECT(footer_bclose) , "clicked" , G_CALLBACK(i_fileinfo_ev_close) , fileinfowin );
gtk_container_add( GTK_CONTAINER(footer_hbbox) , footer_bclose );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , footer_hbbox , FALSE , FALSE , 0 );
/* utf8-ize filename and set window title */
filename = g_filename_from_uri( filename_uri , NULL , NULL );
if ( !filename )
filename = g_strdup( filename_uri );
filename_utf8 = g_strdup(g_filename_to_utf8( filename , -1 , NULL , NULL , NULL ));
if ( !filename_utf8 )
{
/* utf8 fallback */
gchar *chr , *convert_str = g_strdup( filename );
for ( chr = convert_str ; *chr ; chr++ )
{
if ( *chr & 0x80 )
*chr = '?';
}
filename_utf8 = g_strconcat( convert_str , _(" (invalid UTF-8)") , NULL );
g_free(convert_str);
}
title = g_path_get_basename (filename_utf8);
gtk_window_set_title( GTK_WINDOW(fileinfowin) , title);
g_free(title);
/* set the text for the filename header too */
gtk_entry_set_text( GTK_ENTRY(title_name_v_entry) , filename_utf8 );
gtk_editable_set_position( GTK_EDITABLE(title_name_v_entry) , -1 );
g_free(filename_utf8);
g_free(filename);
gtk_widget_grab_focus( GTK_WIDGET(footer_bclose) );
gtk_widget_show_all( fileinfowin );
}
/**
* Create and initialize a new grisbi assistant. It is basically
* composed of a GtkDialog with a notebook that is switched from page
* to page when user click on dialog buttons.
*
* \param title Title of the assistant.
* \param explanation Short text to display in the first
* page of the assistant.
* \param image_filename Icon to display in the title. (if NULL, use grisbi.png, default logo)
* \param enter_callback A callback to connect to the "switch-page" callback when go to the first page
* of the Grisbi assistant notebook. (the callback should
* be : gboolean callback ( GtkWidget *assistant, gint new_page ) )
*
*/
GtkWidget * gsb_assistant_new ( const gchar * title, const gchar * explanation,
gchar * image_filename,
GCallback enter_callback )
{
GtkWidget * assistant, *notebook, *hbox, *label, *image, *view, *eb;
GtkWidget * button_cancel, * button_prev, * button_next;
GtkWidget *button_select;
GtkStyle * style;
GtkTextBuffer * buffer;
gchar *tmpstr;
gint width = 140;
assistant = gtk_dialog_new_with_buttons ( title,
GTK_WINDOW ( run.window ),
GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR,
NULL );
gtk_window_set_default_size ( GTK_WINDOW ( assistant ), 800, 500 );
gtk_window_set_position ( GTK_WINDOW ( assistant ), GTK_WIN_POS_CENTER_ON_PARENT );
gtk_window_set_resizable ( GTK_WINDOW ( assistant ), TRUE );
g_object_set_data ( G_OBJECT ( run.window ), "assistant", assistant );
button_select = gtk_toggle_button_new_with_label ( _("Select all") );
gtk_widget_set_size_request ( button_select, width, -1 );
gtk_box_pack_start ( GTK_BOX ( GTK_DIALOG ( assistant )->action_area ),
button_select, FALSE, FALSE, 0 );
g_object_set_data ( G_OBJECT(assistant), "button_select", button_select );
button_cancel = gtk_dialog_add_button ( GTK_DIALOG(assistant),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL );
gtk_widget_set_size_request ( button_cancel, width, -1 );
g_object_set_data ( G_OBJECT(assistant), "button_cancel", button_cancel );
button_prev = gtk_dialog_add_button ( GTK_DIALOG(assistant),
GTK_STOCK_GO_BACK, GTK_RESPONSE_NO );
gtk_widget_set_size_request ( button_prev, width, -1 );
g_object_set_data ( G_OBJECT(assistant), "button_prev", button_prev );
gtk_widget_set_sensitive ( button_prev, FALSE );
button_next = gtk_dialog_add_button ( GTK_DIALOG(assistant),
GTK_STOCK_GO_FORWARD, GTK_RESPONSE_YES );
gtk_widget_set_size_request ( button_next, width, -1 );
g_object_set_data ( G_OBJECT(assistant), "button_next", button_next );
eb = gtk_event_box_new ();
style = gtk_widget_get_style ( eb );
gtk_widget_modify_bg ( eb, 0, &(style -> bg[GTK_STATE_ACTIVE]) );
hbox = gtk_hbox_new ( FALSE, 12 );
gtk_container_add ( GTK_CONTAINER(eb), hbox );
gtk_container_set_border_width ( GTK_CONTAINER(hbox), 12 );
label = gtk_label_new ( NULL );
tmpstr = g_markup_printf_escaped (
"<b><span size=\"x-large\">%s</span></b>", title );
gtk_label_set_markup ( GTK_LABEL(label), tmpstr );
g_free ( tmpstr );
gtk_box_pack_start ( GTK_BOX(hbox), label, TRUE, TRUE, 0 );
if (!image_filename)
image_filename = "grisbi.png";
tmpstr = g_build_filename ( gsb_dirs_get_pixmaps_dir ( ), image_filename, NULL);
image = gtk_image_new_from_file ( tmpstr );
g_free ( tmpstr );
gtk_box_pack_start ( GTK_BOX(hbox), image, FALSE, FALSE, 0 );
gtk_box_pack_start ( GTK_BOX ( GTK_DIALOG(assistant) -> vbox ), eb, FALSE, FALSE, 0 );
notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs ( GTK_NOTEBOOK(notebook), FALSE );
gtk_notebook_set_show_border ( GTK_NOTEBOOK(notebook), FALSE );
gtk_box_pack_start ( GTK_BOX ( GTK_DIALOG(assistant) -> vbox ), notebook, TRUE, TRUE, 0 );
view = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), GTK_WRAP_WORD);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
tmpstr = g_strconcat ( "\n", explanation, "\n", NULL );
gtk_text_buffer_set_text (buffer, tmpstr, -1);
g_free ( tmpstr );
gtk_text_view_set_editable ( GTK_TEXT_VIEW(view), FALSE );
gtk_text_view_set_cursor_visible ( GTK_TEXT_VIEW(view), FALSE );
gtk_text_view_set_left_margin ( GTK_TEXT_VIEW(view), 12 );
gtk_text_view_set_right_margin ( GTK_TEXT_VIEW(view), 12 );
/* Create some handy fonts. */
gtk_text_buffer_create_tag ( buffer, "bold", "weight", PANGO_WEIGHT_BOLD, NULL );
gtk_text_buffer_create_tag ( buffer, "x-large", "scale", PANGO_SCALE_X_LARGE, NULL );
gtk_text_buffer_create_tag ( buffer, "indented", "left-margin", 24, NULL );
gtk_notebook_append_page ( GTK_NOTEBOOK(notebook), view, gtk_label_new(NULL) );
g_signal_connect_after ( notebook, "switch-page",
G_CALLBACK ( gsb_assistant_change_page ), assistant );
gsb_assistant_set_next ( assistant, 0, 1 );
g_object_set_data ( G_OBJECT(assistant), "notebook", notebook );
/* need to set (gchar *) because title is const gchar, the good way should be my_strdup,
* but we don't touch/free title later so it should be ok... */
g_object_set_data ( G_OBJECT(assistant), "title", (gchar *) title );
g_object_set_data ( G_OBJECT(assistant), "enter0", enter_callback );
return assistant;
}
