int
make_textview() {
if(!textview1) {
textview1 =(GtkWidget *)gtk_text_view_new();
text1 = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview1));
gtk_widget_set_size_request(textview1, 150, 300);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview1), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview1), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview1), GTK_WRAP_WORD_CHAR);
debug("make textview1");
}
if(!textview2) {
textview2 =(GtkWidget *)gtk_text_view_new();
text2 = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview2));
gtk_widget_set_size_request(textview2, 520, 300);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview2), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview2), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview2), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(textview2), 8);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(textview2), 16);
g_signal_connect(textview2, "key_press_event", G_CALLBACK(textview2_key_press_event_cb), NULL);
debug("make textview2");
}
return 0;
}
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;
}
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;
}
/*
* Set the default style
*/
static void
set_default_tag (GtkTextBuffer *buffer, GtkTextTag *tag)
{
PangoFontDescription *font_desc;
GdkColor *color = (GdkColor *)g_malloc(sizeof(GdkColor));
PangoUnderline *underline;
int val;
GtkJustification justification;
if(!tag)
return;
g_object_get (G_OBJECT (tag), "foreground-gdk", &color, NULL);
g_object_get (G_OBJECT (tag), "underline", &underline, NULL);
g_object_get (G_OBJECT (tag), "font-desc", &font_desc, NULL);
gtk_widget_modify_font (view, font_desc);
gtk_widget_modify_text (view, GTK_STATE_NORMAL, color);
g_object_get (G_OBJECT (tag), "left-margin", &val, NULL);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (view), val);
g_object_get (G_OBJECT (tag), "justification", &justification, NULL);
gtk_text_view_set_justification(GTK_TEXT_VIEW (view), justification);
g_object_get (G_OBJECT (tag), "pixels-below-lines", &val, NULL);
gtk_text_view_set_pixels_below_lines(GTK_TEXT_VIEW (view), val);
g_object_get (G_OBJECT (tag), "pixels-above-lines", &val, NULL);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW (view), val);
}
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 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 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 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);
}
/*****************************************************************************
Initilialize a lua console.
*****************************************************************************/
static void luaconsole_dialog_create(struct luaconsole_data *pdialog)
{
GtkWidget *entry, *box, *vbox, *sw, *text, *notebook;
fc_assert_ret(NULL != pdialog);
if (gui_gtk2_message_chat_location == GUI_GTK_MSGCHAT_SPLIT) {
notebook = right_notebook;
} else {
notebook = bottom_notebook;
}
gui_dialog_new(&pdialog->shell, GTK_NOTEBOOK(notebook), pdialog, TRUE);
gui_dialog_set_title(pdialog->shell, _("Client Lua Console"));
box = GTK_WIDGET(pdialog->shell->vbox);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), vbox, TRUE, TRUE, 0);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
text = gtk_text_view_new_with_buffer(pdialog->message_buffer);
set_message_buffer_view_link_handlers(text);
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
gtk_container_add(GTK_CONTAINER(sw), text);
g_signal_connect(text, "size-allocate",
G_CALLBACK(luaconsole_dialog_area_size_allocate), NULL);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
gtk_widget_realize(text);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text), 5);
pdialog->message_area = GTK_TEXT_VIEW(text);
/* The lua console input line. */
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, TRUE, 2);
g_signal_connect(entry, "activate", G_CALLBACK(luaconsole_input_return),
NULL);
g_signal_connect(entry, "key_press_event",
G_CALLBACK(luaconsole_input_handler), NULL);
pdialog->entry = entry;
/* Load lua script command button. */
gui_dialog_add_stockbutton(pdialog->shell, GTK_STOCK_OPEN,
_("Load Lua Script"), LUACONSOLE_RES_OPEN);
gui_dialog_add_button(pdialog->shell, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gui_dialog_response_set_callback(pdialog->shell,
luaconsole_response_callback);
luaconsole_dialog_refresh(pdialog);
gui_dialog_show_all(pdialog->shell);
}
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 void text_insert_help(struct menu *menu)
{
GtkTextBuffer *buffer;
GtkTextIter start, end;
const char *prompt = menu_get_prompt(menu);
gchar *name;
const char *help = _(nohelp_text);
if (!menu->sym)
help = "";
else if (menu->sym->help)
help = _(menu->sym->help);
if (menu->sym && menu->sym->name)
name = g_strdup_printf(_(menu->sym->name));
else
name = g_strdup("");
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
gtk_text_buffer_get_bounds(buffer, &start, &end);
gtk_text_buffer_delete(buffer, &start, &end);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_w), 15);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_insert_with_tags(buffer, &end, prompt, -1, tag1,
NULL);
gtk_text_buffer_insert_at_cursor(buffer, " ", 1);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_insert_with_tags(buffer, &end, name, -1, tag1,
NULL);
gtk_text_buffer_insert_at_cursor(buffer, "\n\n", 2);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_insert_with_tags(buffer, &end, help, -1, tag2,
NULL);
}
/////**********************************************************************
///// 函数名称 ： 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;
}
/**
* 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
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);
}
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));
}
}
/*
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;
}
GtkSourceView *
init_buffer_view(GtkSourceBuffer *source_buffer) {
GtkSourceView *source_view = GTK_SOURCE_VIEW(gtk_source_view_new_with_buffer(source_buffer));
set_class(GTK_WIDGET(source_view), "editor");
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(source_view), 4);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(source_view), GTK_WRAP_CHAR);
gtk_source_view_set_draw_spaces(source_view, GTK_SOURCE_DRAW_SPACES_TAB);
gtk_source_view_set_auto_indent(source_view, TRUE);
gtk_source_view_set_indent_on_tab(source_view, TRUE);
//gtk_source_view_set_show_line_numbers(source_view, TRUE);
return source_view;
}
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);
}
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;
}
GtkWidget *create_chat_widget(void)
{
GtkWidget *vbox, *text, *inputline;
ChatWidgets *list;
GtkWidget *sw;
vbox = gtk_vbox_new(FALSE, 0);
/* Create a scrolled window for the chat lines. */
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
gtk_widget_set_size_request(sw, -1, 50);
/* The chatlines themselves go into a text window. */
text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(text), FALSE);
gtk_container_add(GTK_CONTAINER(sw), text);
gtk_widget_set_name(text, "chatline");
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text), 5);
/* Text entry widget. */
inputline = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox), inputline, FALSE, FALSE, 3);
gtk_widget_show_all(vbox);
list = ggz_malloc(sizeof(*list));
list->next = chats;
list->container = vbox;
list->text = text;
chats = list;
g_signal_connect(inputline, "activate",
G_CALLBACK(inputline_return), NULL);
g_signal_connect(vbox, "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&list->container);
return vbox;
}
/*
* 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);
}
/**
* 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;
}
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;
}
GLADE_CB void
on_button11_clicked (GtkButton *button,
gpointer user_data)
{
GtkTextIter start, end;
GtkWidget *text = GTK_WIDGET(button);
GtkTextBuffer *txtbuf;
// clear text
txtbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_get_bounds(txtbuf, &start, &end);
gtk_text_buffer_delete(txtbuf, &start, &end);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text), 15);
// clear buffer
g_free(logger.link_buf);
logger.link_buf = (uint16_t *)g_malloc0(logger.link_size * sizeof(uint16_t));
logger.link_ptr = 0;
}
/*
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 void text_insert_msg(const char *title, const char *message)
{
GtkTextBuffer *buffer;
GtkTextIter start, end;
const char *msg = message;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
gtk_text_buffer_get_bounds(buffer, &start, &end);
gtk_text_buffer_delete(buffer, &start, &end);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_w), 15);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_insert_with_tags(buffer, &end, title, -1, tag1,
NULL);
gtk_text_buffer_insert_at_cursor(buffer, "\n\n", 2);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_insert_with_tags(buffer, &end, msg, -1, tag2,
NULL);
}
