Exemple #1
1
GtkWidget * about_widget_create_view_from_file(char * file, char * default_text)
{
	GtkTextView * view = GTK_TEXT_VIEW(gtk_text_view_new());
	gtk_text_view_set_editable(view, FALSE);
	gtk_text_view_set_cursor_visible(view, FALSE);
	gtk_text_view_set_wrap_mode(view, GTK_WRAP_WORD_CHAR);

	char * file_path = vex_term_find_ressource(file);
	if (file_path != NULL){
		SrtParser * srt = srt_parser_new();
		//TODO: need to free the SrtParser
		GtkTextBuffer * buffer = srt_parser_parse_file(srt, file_path);
		free(file_path);
		if (buffer != NULL){
			gtk_text_view_set_buffer(view, buffer);
			return GTK_WIDGET(view);
		}
	}
	GtkTextBuffer * buffer = gtk_text_buffer_new(NULL);
	GtkTextIter iter;
	gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
	gtk_text_view_set_buffer(view, buffer);
	gtk_text_buffer_insert(buffer, &iter, default_text, -1);
	return GTK_WIDGET(view);
}
DisplayChangesGui::DisplayChangesGui(GtkWidget * box)
// Creates a GUI that displays changes on the screen.
// box: the parent box where it goes in.
{
  vbox = gtk_vbox_new(FALSE, 0);
  gtk_widget_show(vbox);
  gtk_box_pack_start(GTK_BOX(box), vbox, TRUE, TRUE, 0);

  label = gtk_label_new_with_mnemonic("");
  gtk_widget_show(label);
  gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);

  scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
  gtk_widget_show(scrolledwindow);
  gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_SHADOW_IN);

  textview = gtk_text_view_new();
  gtk_widget_show(textview);
  gtk_container_add(GTK_CONTAINER(scrolledwindow), textview);
  gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview), FALSE);
  gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);

  // Create tags.
  textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
  heavy_weight_tag = gtk_text_buffer_create_tag(textbuffer, NULL, "weight", PANGO_WEIGHT_HEAVY, "background", "hot pink", NULL);
  strike_through_tag = gtk_text_buffer_create_tag(textbuffer, NULL, "strikethrough", TRUE, "background", "hot pink", NULL);
}
Exemple #3
0
void log_show_debug_messages_dialog(void)
{
	GtkWidget *dialog, *textview, *vbox, *swin;

	dialog = gtk_dialog_new_with_buttons(_("Debug Messages"), GTK_WINDOW(main_widgets.window),
				GTK_DIALOG_DESTROY_WITH_PARENT,
				_("Cl_ear"), DIALOG_RESPONSE_CLEAR,
				GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
	vbox = ui_dialog_vbox_new(GTK_DIALOG(dialog));
	gtk_box_set_spacing(GTK_BOX(vbox), 6);
	gtk_widget_set_name(dialog, "GeanyDialog");

	gtk_window_set_default_size(GTK_WINDOW(dialog), 550, 300);
	gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);

	textview = gtk_text_view_new();
	dialog_textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
	g_object_set_data(G_OBJECT(dialog_textbuffer), "textview", textview);
	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_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD_CHAR);

	swin = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
		GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_container_add(GTK_CONTAINER(swin), textview);

	gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0);

	g_signal_connect(dialog, "response", G_CALLBACK(on_dialog_response), textview);
	gtk_widget_show_all(dialog);

	update_dialog(); /* set text after showing the window, to not scroll an unrealized textview */
}
Exemple #4
0
static void create_gpl(GtkTextView *view)
{
	GtkTextTag    *tag;
	GtkTextIter    iter;
	char           *buf1 = N_("This program is free software; you can redistribute it and/or modify "
				"it under the terms of the GNU General Public License as published by "
				"the Free Software Foundation; either version 2 of the License, or "
				"(at your option) any later version.\n\n");
	char           *buf2 = N_("This program is distributed in the hope that it will be useful, "
				"but WITHOUT ANY WARRANTY; without even the implied warranty of "
				"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the "
				"GNU General Public License for more details.\n\n");
	char           *buf3 = N_("You should have received a copy of the GNU General Public License "
				"along with this program; if not, see \n");

	gtk_text_view_set_editable(view, FALSE);
	gtk_text_view_set_wrap_mode(view, GTK_WRAP_WORD);
	g_signal_connect (view, "motion-notify-event", 
			G_CALLBACK (motion_notify_event), NULL);

	GtkTextBuffer *buffer = gtk_text_view_get_buffer(view);

	tag = gtk_text_buffer_create_tag (buffer, NULL, 
                                    "left-margin", 5, 
                                    "right-margin", 5, 
                                    NULL);

	gtk_text_buffer_get_start_iter(buffer, &iter);
  
	gtk_text_buffer_insert_with_tags(buffer, &iter, _(buf1), -1, tag, NULL);
	gtk_text_buffer_insert_with_tags(buffer, &iter, _(buf2), -1, tag, NULL);
	gtk_text_buffer_insert_with_tags(buffer, &iter, _(buf3), -1, tag, NULL);
	insert_link(buffer, &iter, "http://www.gnu.org/licenses/gpl-2.0.txt");
}
Exemple #5
0
static GtkWidget *
create_text (GtkTextBuffer **buffer,
	     gboolean        is_source)
{
  GtkWidget *scrolled_window;
  GtkWidget *text_view;
  PangoFontDescription *font_desc;

  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_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
				       GTK_SHADOW_IN);
  
  text_view = gtk_text_view_new ();
  gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
  
  *buffer = gtk_text_buffer_new (NULL);
  gtk_text_view_set_buffer (GTK_TEXT_VIEW (text_view), *buffer);
  gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE);
  gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (text_view), FALSE);

  if (is_source)
    {
      font_desc = pango_font_description_from_string ("Courier 10");
      gtk_widget_modify_font (text_view, font_desc);
      pango_font_description_free (font_desc);
    }
  
  gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), !is_source);
  
  return scrolled_window;
}
Exemple #6
0
/**
 * 创建好友信息区域.
 * @return 主窗体
 */
GtkWidget *DialogPeer::CreateInfoArea()
{
        GtkWidget *frame, *sw;
        GtkWidget *widget;
        GtkTextBuffer *buffer;

        frame = gtk_frame_new(_("Info."));
        g_datalist_set_data(&widset, "info-frame", frame);
        gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
        sw = gtk_scrolled_window_new(NULL, NULL);
        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
                 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
                                                 GTK_SHADOW_ETCHED_IN);
        gtk_container_add(GTK_CONTAINER(frame), sw);

        buffer = gtk_text_buffer_new(progdt.table);
        if (grpinf->member)
                FillPalInfoToBuffer(buffer, (PalInfo *)grpinf->member->data);
        widget = gtk_text_view_new_with_buffer(buffer);
        gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(widget), FALSE);
        gtk_text_view_set_editable(GTK_TEXT_VIEW(widget), FALSE);
        gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(widget), GTK_WRAP_NONE);
        gtk_container_add(GTK_CONTAINER(sw), widget);
        g_datalist_set_data(&widset, "info-textview-widget", widget);

        return frame;
}
Exemple #7
0
GtkWidget*
hybrid_chat_textview_create(void)
{
	GtkWidget *textview;
	GtkTextBuffer *buffer;
	GtkTextIter end_iter;

	textview = gtk_text_view_new();

	gtk_widget_set_size_request(textview, 0, 100);

	gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview), FALSE);
	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_CHAR);
	gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);

	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
	gtk_text_buffer_create_tag(buffer, "blue", "foreground", "#639900", NULL);
	gtk_text_buffer_create_tag(buffer, "grey", "foreground", "#808080", NULL);
	gtk_text_buffer_create_tag(buffer, "green", "foreground", "#0088bf", NULL);
	gtk_text_buffer_create_tag(buffer, "bold", "weight", PANGO_WEIGHT_BOLD, NULL);
	gtk_text_buffer_create_tag(buffer, "lm10", "left_margin", 3, NULL);
	gtk_text_buffer_create_tag(buffer, "wrap", "wrap-mode", GTK_WRAP_WORD_CHAR, NULL);
	gtk_text_buffer_create_tag(buffer, "small", "size-points", 9.0, NULL);
	gtk_text_buffer_get_end_iter(buffer, &end_iter);
	gtk_text_buffer_create_mark(buffer, "scroll", &end_iter, FALSE);

	return textview;
}
Exemple #8
0
static GtkTextBuffer *text_view(GtkWidget *box, const char *label)
{
	GtkWidget *view, *vbox;
	GtkTextBuffer *buffer;
	GtkWidget *frame = gtk_frame_new(label);

	gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 0);
	box = gtk_hbox_new(FALSE, 3);
	gtk_container_add(GTK_CONTAINER(frame), box);
	vbox = gtk_vbox_new(FALSE, 3);
	gtk_container_add(GTK_CONTAINER(box), vbox);

	GtkWidget* scrolled_window = gtk_scrolled_window_new(0, 0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_IN);
	gtk_widget_show(scrolled_window);

	view = gtk_text_view_new();
	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_WORD);
	gtk_container_add(GTK_CONTAINER(scrolled_window), view);

	buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));

	gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
	return buffer;
}
Exemple #9
0
static void OnCheatListDlg_AddClicked(GtkWidget *widget, gpointer user_data) {
	GtkWidget *dlg;
	GtkWidget *box, *scroll, *label, *descr_edit, *code_edit;

	dlg = gtk_dialog_new_with_buttons(_("Add New Cheat"), GTK_WINDOW(CheatListDlg),
		GTK_DIALOG_MODAL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
		GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);

	gtk_window_set_default_size(GTK_WINDOW(dlg), 350, 350);

	box = GTK_WIDGET(gtk_dialog_get_content_area(GTK_DIALOG(dlg)));

	label = gtk_label_new(_("Cheat Description:"));
	gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 5);
	gtk_widget_show(label);

	descr_edit = gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(box), descr_edit, FALSE, FALSE, 5);
	gtk_widget_show(descr_edit);

	label = gtk_label_new(_("Cheat Code:"));
	gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 5);
	gtk_widget_show(label);

	code_edit = gtk_text_view_new();
	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(code_edit), GTK_WRAP_CHAR);

	scroll = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
		GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), code_edit);
	gtk_widget_show(code_edit);

	gtk_box_pack_start(GTK_BOX(box), scroll, TRUE, TRUE, 5);
	gtk_widget_show(scroll);

	gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);

	gtk_widget_show_all(dlg);

	if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_ACCEPT) {
		GtkTextBuffer *b = gtk_text_view_get_buffer(GTK_TEXT_VIEW(code_edit));
		GtkTextIter s, e;
		char *codetext;

		gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(b), &s, &e);
		codetext = strdup(gtk_text_buffer_get_text(GTK_TEXT_BUFFER(b), &s, &e, FALSE));

		if (AddCheat(gtk_entry_get_text(GTK_ENTRY(descr_edit)), codetext) != 0) {
			SysErrorMessage(_("Error"), _("Invalid cheat code!"));
		}

		LoadCheatListItems(NumCheats - 1);

		free(codetext);
	}

	gtk_widget_destroy(dlg);
}
Exemple #10
0
GtkWidget* linphone_gtk_init_chatroom(LinphoneChatRoom *cr, const LinphoneAddress *with){
	GtkWidget *chat_view=linphone_gtk_create_widget("main","chatroom_frame");
	GtkWidget *main_window=linphone_gtk_get_main_window();
	GtkNotebook *notebook=(GtkNotebook *)linphone_gtk_get_widget(main_window,"viewswitch");
	GtkWidget *text=linphone_gtk_get_widget(chat_view,"textview");
	GdkColor color;
	GdkColor colorb;
	int idx;
	GtkWidget *button;
	GtkWidget *entry = linphone_gtk_get_widget(chat_view,"text_entry");
	MSList *messages;
	GHashTable *table;
	char *with_str;

	color.red = 32512;
  	color.green = 32512;
  	color.blue = 32512;
	colorb.red = 56832;
  	colorb.green = 60928;
  	colorb.blue = 61952;

	with_str=linphone_address_as_string_uri_only(with);
	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text),GTK_WRAP_WORD_CHAR);
	gtk_text_view_set_editable(GTK_TEXT_VIEW(text),FALSE);
	gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(text),FALSE);
	gtk_notebook_append_page(notebook,chat_view,create_tab_chat_header(cr,with));
	idx = gtk_notebook_page_num(notebook, chat_view);
	gtk_notebook_set_current_page(notebook, idx);
	gtk_widget_show(chat_view);
	table=g_hash_table_new_full(g_direct_hash,g_direct_equal,NULL,NULL);
	g_object_set_data(G_OBJECT(chat_view),"cr",cr);
	g_object_set_data(G_OBJECT(chat_view),"from_message",NULL);
	g_object_set_data(G_OBJECT(chat_view),"table",table);
	gtk_text_buffer_create_tag(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
	                        "right","justification", GTK_JUSTIFY_RIGHT,NULL);
	gtk_text_buffer_create_tag(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
	                        "left","justification", GTK_JUSTIFY_LEFT,NULL);
	gtk_text_buffer_create_tag(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
	                       	    "bold","weight", PANGO_WEIGHT_BOLD,NULL);
	gtk_text_buffer_create_tag(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
								"italic","style", PANGO_STYLE_ITALIC,NULL);
	gtk_text_buffer_create_tag(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
	                           	"small","size",9*PANGO_SCALE,NULL);
	gtk_text_buffer_create_tag(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
	                           	"font_grey","foreground-gdk",&color,NULL);
	gtk_text_buffer_create_tag(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
	                           	"margin","indent",10,NULL);
	gtk_text_buffer_create_tag(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
	                           	"bg","paragraph-background-gdk",&colorb,NULL);
	messages = linphone_chat_room_get_history(cr,NB_MSG_HIST);
	display_history_message(chat_view,messages,with);
	button = linphone_gtk_get_widget(chat_view,"send");
	g_signal_connect_swapped(G_OBJECT(button),"clicked",(GCallback)linphone_gtk_send_text,NULL);
	
	g_signal_connect_swapped(G_OBJECT(entry),"activate",(GCallback)linphone_gtk_send_text,NULL);
	g_signal_connect_swapped(G_OBJECT(entry),"changed",(GCallback)linphone_gtk_compose_text,NULL);
	g_signal_connect(G_OBJECT(notebook),"switch_page",(GCallback)linphone_gtk_notebook_tab_select,NULL);
	ms_free(with_str);
	return chat_view;
}
Exemple #11
0
void LogWindow::Init(void)
{
	if(window)
		return;

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window), _("Log window"));
	gtk_window_set_default_size(GTK_WINDOW(window), 400, 400);
	g_signal_connect(window, "destroy", G_CALLBACK(on_destroy), this);

	scrolled_window = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
	gtk_container_set_border_width(GTK_CONTAINER (scrolled_window), 5);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
		GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_IN);
	gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(scrolled_window));

	textview = GTK_TEXT_VIEW(gtk_text_view_new());
	gtk_text_view_set_editable(textview, FALSE);
	gtk_text_view_set_cursor_visible(textview, FALSE);
	gtk_text_view_set_wrap_mode(textview, GTK_WRAP_CHAR);
	gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(textview));

	append_in_window(text_buf.c_str());
	text_buf.clear();

	gtk_widget_show_all(window);
}
Exemple #12
0
bg_gtk_textview_t * bg_gtk_textview_create()
  {
  bg_gtk_textview_t * t;
  
  t = calloc(1, sizeof(*t));
  
  if(!tag_table)
    {
    tag_table = gtk_text_tag_table_new();
    
    text_tag = gtk_text_tag_new("Font");
    g_object_set(text_tag, "editable", 0, NULL);
    
    gtk_text_tag_table_add(tag_table,
                           text_tag);
    }
  
  t->buffer = gtk_text_buffer_new(tag_table);
  t->textview = gtk_text_view_new_with_buffer(t->buffer);

  g_signal_connect(G_OBJECT(t->textview), "realize",
                   G_CALLBACK(set_bg), NULL);
  
  gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(t->textview), FALSE);
  
  gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(t->textview), GTK_WRAP_NONE);
  gtk_text_view_set_editable(GTK_TEXT_VIEW(t->textview), 0);
  
  gtk_widget_show(t->textview);
  return t;
  }
Exemple #13
0
static GtkWidget *build_messages_panel(void)
{
	GtkWidget *vbox;
	GtkWidget *label;
	GtkWidget *scroll_win;

	vbox = gtk_vbox_new(FALSE, 5);
	gtk_widget_show(vbox);

	/* Label for messages log */
	label = gtk_label_new(NULL);
	gtk_label_set_markup(GTK_LABEL(label), _("<b>Messages</b>"));
	gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
	gtk_widget_show(label);
	gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);

	scroll_win = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_set_size_request(scroll_win, -1, 80);
	gtk_widget_show(scroll_win);
	gtk_box_pack_start(GTK_BOX(vbox), scroll_win, TRUE, TRUE, 0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
				       GTK_POLICY_AUTOMATIC,
				       GTK_POLICY_AUTOMATIC);

	messages_txt = gtk_text_view_new();
	gtk_widget_show(messages_txt);
	gtk_container_add(GTK_CONTAINER(scroll_win), messages_txt);
	gtk_text_view_set_editable(GTK_TEXT_VIEW(messages_txt), FALSE);
	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(messages_txt),
				    GTK_WRAP_WORD);

	message_window_set_text(messages_txt);

	return vbox;
}
Exemple #14
0
GtkWidget* Console_constructWindow( GtkWindow* toplevel ){
	GtkWidget* scr = gtk_scrolled_window_new( 0, 0 );
	gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
	gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scr ), GTK_SHADOW_IN );
	gtk_widget_show( scr );

	{
		GtkWidget* text = gtk_text_view_new();
		gtk_widget_set_size_request( text, 0, -1 ); // allow shrinking
		gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( text ), GTK_WRAP_WORD );
		gtk_text_view_set_editable( GTK_TEXT_VIEW( text ), FALSE );
		gtk_container_add( GTK_CONTAINER( scr ), text );
		gtk_widget_show( text );
		g_console = text;

		//globalExtendedASCIICharacterSet().print();

		widget_connect_escape_clear_focus_widget( g_console );

		//g_consoleWidgetFocusPrinter.connect(g_console);

		g_signal_connect( G_OBJECT( g_console ), "populate-popup", G_CALLBACK( console_populate_popup ), 0 );
		g_signal_connect( G_OBJECT( g_console ), "destroy", G_CALLBACK( destroy_set_null ), &g_console );
	}

	//prevent focusing on text view after click on tab of floating group dialog (np, if called via hotkey)
	GtkWidget* vbox = gtk_vbox_new( FALSE, 0 );
	gtk_widget_show( vbox );
	gtk_box_pack_start( GTK_BOX( vbox ), scr, TRUE, TRUE, 0 );
	gtk_container_set_focus_chain( GTK_CONTAINER( vbox ), NULL );

	return vbox;
}
static void
pluma_prefs_manager_wrap_mode_changed (GSettings *settings,
                                       gchar         *key,
                                       gpointer       user_data)
{
    pluma_debug (DEBUG_PREFS);

    if (strcmp (key, GPM_WRAP_MODE) == 0)
    {
        GtkWrapMode wrap_mode;
        GList *views;
        GList *l;

        wrap_mode = get_wrap_mode_from_string (g_settings_get_string(settings, key));

        views = pluma_app_get_views (pluma_app_get_default ());
        l = views;

        while (l != NULL)
        {
            gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (l->data),
                                         wrap_mode);

            l = l->next;
        }

        g_list_free (views);
    }
}
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;
}
Exemple #17
0
/*****************************************************************************
  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);
}
void pHexEdit::constructor() {
  gtkWidget = gtk_hbox_new(false, 0);

  container = gtk_scrolled_window_new(0, 0);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(container), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(container), GTK_SHADOW_ETCHED_IN);

  subWidget = gtk_text_view_new();
  gtk_text_view_set_editable(GTK_TEXT_VIEW(subWidget), false);
  gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(subWidget), GTK_WRAP_NONE);
  gtk_container_add(GTK_CONTAINER(container), subWidget);
  g_signal_connect(G_OBJECT(subWidget), "key-press-event", G_CALLBACK(HexEdit_keyPress), (gpointer)&hexEdit);

  scrollBar = gtk_vscrollbar_new((GtkAdjustment*)0);
  gtk_range_set_range(GTK_RANGE(scrollBar), 0, 255);
  gtk_range_set_increments(GTK_RANGE(scrollBar), 1, 16);
  gtk_widget_set_sensitive(scrollBar, false);
  g_signal_connect(G_OBJECT(scrollBar), "change-value", G_CALLBACK(HexEdit_scroll), (gpointer)&hexEdit);

  gtk_box_pack_start(GTK_BOX(gtkWidget), container, true, true, 0);
  gtk_box_pack_start(GTK_BOX(gtkWidget), scrollBar, false, false, 1);

  textBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(subWidget));
  textCursor = gtk_text_buffer_get_mark(textBuffer, "insert");

  gtk_widget_show(scrollBar);
  gtk_widget_show(subWidget);
  gtk_widget_show(container);
}
Exemple #19
0
/*
 * Construct a simple text page widget from a file.
 */
GtkWidget * text_page_new(const char *absolute_path)
{
  GtkWidget *page_vb, *txt_scrollw, *txt;

  page_vb = gtk_vbox_new(FALSE, 0);
  gtk_container_set_border_width(GTK_CONTAINER(page_vb), 1);
  txt_scrollw = scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(txt_scrollw),
                                   GTK_SHADOW_IN);
  gtk_box_pack_start(GTK_BOX(page_vb), txt_scrollw, TRUE, TRUE, 0);

  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(txt_scrollw),
				 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  txt = gtk_text_view_new();
  gtk_text_view_set_editable(GTK_TEXT_VIEW(txt), FALSE);
  gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(txt), GTK_WRAP_WORD);
  gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(txt), FALSE);
  /* XXX: there seems to be no way to add a small border *around* the whole text,
   * so the text will be "bump" against the edges.
   * the following is only working for left and right edges,
   * there is no such thing for top and bottom :-( */
  /* gtk_text_view_set_left_margin(GTK_TEXT_VIEW(txt), 3); */
  /* gtk_text_view_set_right_margin(GTK_TEXT_VIEW(txt), 3); */

  g_object_set_data(G_OBJECT(page_vb), TEXT_KEY, txt);

  text_page_set_text(page_vb, absolute_path);
  gtk_container_add(GTK_CONTAINER(txt_scrollw), txt);
  gtk_widget_show(txt_scrollw);
  gtk_widget_show(txt);

  return page_vb;
}
Exemple #20
0
int main (int argc, char *argv[])
{

    gtk_init(&argc, &argv);
    GtkWidget *window1;
    GtkButton *button,*button10;

    GtkBuilder *gtkbuilder = gtk_builder_new();
    gtk_builder_add_from_file(gtkbuilder,"arayuz-chat.glade",NULL);


    window1 = GTK_WIDGET( gtk_builder_get_object( gtkbuilder, "window1" ) );
    button = GTK_BUTTON(gtk_builder_get_object(gtkbuilder,"button11"));
    button10 = GTK_BUTTON(gtk_builder_get_object(gtkbuilder,"button10"));
    textentry2 = GTK_WIDGET(gtk_builder_get_object(gtkbuilder,"entry2"));
    text1 = GTK_TEXT_VIEW(gtk_builder_get_object(gtkbuilder,"textview1"));
    label3 = GTK_LABEL(gtk_builder_get_object(gtkbuilder,"label3"));
    g_object_unref(G_OBJECT(gtkbuilder));
    //Buton tıklama sinyalini tanımladık
    g_signal_connect( GTK_BUTTON( button ), "clicked", G_CALLBACK( on_button4_clicked ), NULL );
    g_signal_connect( GTK_BUTTON( button10 ), "clicked", G_CALLBACK( on_button10_clicked ), NULL );
    g_signal_connect(GTK_ENTRY(textentry2),"changed",G_CALLBACK(on_entry2_changed),NULL);

    textbuffer1 = gtk_text_buffer_new(NULL);
    gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text1), GTK_WRAP_WORD);


    //Arayüzü başlatır
    gtk_text_buffer_set_text(textbuffer1,"selam",-1);
    gtk_widget_show_all(window1);
    gtk_main ();

    return 0;
}
Exemple #21
0
int main (int argc, char *argv[])
{
    GtkWidget *window;
    GtkWidget *vbox;
    GtkWidget *entry;
    GtkWidget *scrolled;
    GtkWidget *textview;

    gtk_init (&argc, &argv);

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect (G_OBJECT (window), "destroy",
                      G_CALLBACK(on_destroy), NULL);

    vbox = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (window), vbox);

    entry = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, TRUE, 0);

    scrolled = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
				GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);

    textview = gtk_text_view_new();
    gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
    gtk_container_add(GTK_CONTAINER(scrolled), textview);

    gtk_widget_show_all(window);

    gtk_main ();

    return 0;
}
Exemple #22
0
/* ghtml_new */
GtkWidget * ghtml_new(Surfer * surfer)
{
	GHtml * ghtml;
	GtkWidget * widget;

	if((ghtml = malloc(sizeof(*ghtml))) == NULL)
		return NULL;
	ghtml->surfer = surfer;
	ghtml->title = NULL;
	ghtml->base = NULL;
	ghtml->history = NULL;
	ghtml->current = NULL;
	ghtml->conn = NULL;
	ghtml->buffer = NULL;
	ghtml->buffer_cnt = 0;
	widget = gtk_scrolled_window_new(NULL, NULL);
	g_object_set_data(G_OBJECT(widget), "ghtml", ghtml);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	ghtml->view = gtk_text_view_new();
	g_signal_connect(ghtml->view, "event-after", G_CALLBACK(
				_on_view_event_after), ghtml);
	ghtml->tbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ghtml->view));
	ghtml->zoom = gtk_text_buffer_create_tag(ghtml->tbuffer, NULL,
			"scale", 1.0, NULL);
	memcpy(ghtml->tags, _ghtml_tags, sizeof(_ghtml_tags));
	ghtml->tag = NULL;
	gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(ghtml->view),
			FALSE);
	gtk_text_view_set_editable(GTK_TEXT_VIEW(ghtml->view), FALSE);
	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(ghtml->view),
			GTK_WRAP_WORD_CHAR);
	gtk_container_add(GTK_CONTAINER(widget), ghtml->view);
	return widget;
}
void entries_vis_init (void){
	/*GtkTreeViewColumn *c1, *c2, *c3;
	GtkCellRenderer *cr1, *cr2, *cr3;
*/
	clip = gtk_clipboard_get (GDK_NONE);
	if (clip) //why shouldn't it?
		isThereAClip = TRUE;

	entryBuf = gtk_text_buffer_new (NULL);
	simpleSheet = gtk_text_view_new_with_buffer (entryBuf);
	gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (simpleSheet), GTK_WRAP_WORD);
	simpleSigID = g_signal_connect (G_OBJECT (entryBuf), "changed",
		G_CALLBACK (meta_saveable), GINT_TO_POINTER (GRG_SAVE_ACTIVE));
/*
	mdl = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
	structSheet = gtk_tree_view_new_with_model (GTK_TREE_MODEL (mdl));
	g_object_unref (G_OBJECT (mdl));
	
	cr1=gtk_cell_renderer_text_new ();
	cr2=gtk_cell_renderer_text_new ();
	cr3=gtk_cell_renderer_text_new ();
	c1=gtk_tree_view_column_new_with_attributes ("URL", cr1, "text", 0, NULL);
	c2=gtk_tree_view_column_new_with_attributes ("UserID", cr2, "text", 1, NULL);
	c3=gtk_tree_view_column_new_with_attributes ("Password", cr3, "text", 2, NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (structSheet), c1);
	gtk_tree_view_append_column (GTK_TREE_VIEW (structSheet), c2);
	gtk_tree_view_append_column (GTK_TREE_VIEW (structSheet), c3);*/
}
/////**********************************************************************
/////	函数名称	:	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;
}
Exemple #25
0
/*
 * Initialize the text view as per our template
 */
void html_text_view_init(GtkTextView *text_view, int ignore_font)
{
	char *str;
	PangoFontDescription *font_desc;

	hand_cursor = gdk_cursor_new(GDK_HAND2);
	regular_cursor = gdk_cursor_new(GDK_XTERM);

	str = cGetLocalPref("FontFace");

	gtk_text_view_set_editable(text_view, FALSE);
	gtk_text_view_set_wrap_mode(text_view, GTK_WRAP_WORD_CHAR);
	gtk_text_view_set_cursor_visible(text_view, FALSE);

	g_object_set(G_OBJECT(text_view), "pixels-below-lines", 5, NULL);

	g_signal_connect(text_view, "motion-notify-event",
		G_CALLBACK(mouse_move_callback), NULL);
	g_signal_connect(text_view, "visibility-notify-event",
		G_CALLBACK(toggle_visibility_callback), NULL);
	g_signal_connect(text_view, "button-press-event",
		G_CALLBACK(mouse_click_callback), NULL);

	if (str && ignore_font == 0) {
		font_desc = pango_font_description_from_string(str);
		gtk_widget_modify_font(GTK_WIDGET(text_view), font_desc);
		pango_font_description_free(font_desc);
	}
}
Exemple #26
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 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);
}
GtkWidget *
nh_message_new()
{
    GtkWidget *message_h;
    GtkWidget *sw;
    GtkTextIter iter;
    GtkTextBuffer *t;

    message_h = gtk_handle_box_new();
    GTK_HANDLE_BOX(message_h)->shrink_on_detach = 1;
    
    message_text = gtk_text_view_new();
    gtk_widget_show(message_text);
    GTK_WIDGET_UNSET_FLAGS(message_text, GTK_CAN_FOCUS);
    gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(message_text), GTK_WRAP_WORD);
    t = gtk_text_view_get_buffer(GTK_TEXT_VIEW(message_text));
    gtk_text_buffer_create_tag(t, "warning", "foreground", "red", NULL);
    gtk_text_buffer_get_end_iter(t, &iter);
    gtk_text_buffer_create_mark(t, "nh_end", &iter, FALSE);

    sw = nh_gtk_new_and_add(gtk_scrolled_window_new(NULL, NULL), message_h, "");
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
      GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_container_add(GTK_CONTAINER(sw), message_text);
 
    return message_h;
}
Exemple #29
0
void mape_edit_view_apply_preferences(MapeEditView* edit_view,
                                      MapePreferences* preferences)
{
	GtkSourceView* view;
	GtkSourceBuffer* buffer;
	GtkWrapMode wrap_mode;
	
	view = GTK_SOURCE_VIEW(edit_view->view);
	buffer = GTK_SOURCE_BUFFER(
		gtk_text_view_get_buffer(GTK_TEXT_VIEW(view))
	);

	gtk_source_view_set_tab_width(
		view,
		preferences->tab_width
	);

	gtk_source_view_set_insert_spaces_instead_of_tabs(
		view,
		preferences->tab_to_spaces
	);

	gtk_source_view_set_auto_indent(
		view,
		preferences->auto_indentation
	);

	wrap_mode = GTK_WRAP_CHAR;
	if(preferences->text_wrapping == FALSE)
		wrap_mode = GTK_WRAP_NONE;
	gtk_text_view_set_wrap_mode(
		GTK_TEXT_VIEW(view),
		wrap_mode
	);
	
	gtk_source_view_set_show_line_numbers(
		view,
		preferences->line_numbers
	);

	gtk_source_view_set_highlight_current_line(
		view,
		preferences->highlight_line
	);
	
	gtk_source_buffer_set_highlight_matching_brackets(
		buffer,
		preferences->bracket_matching
	);

	edit_view->fixed_seed = preferences->fixed_seed;
	edit_view->random_seed = preferences->random_seed;
	edit_view->map_width = preferences->map_width;
	edit_view->map_height = preferences->map_height;
	edit_view->map_zoom = preferences->map_zoom;

	/* Rerender with new random settings */
	mape_edit_view_reload(edit_view);
}
/**
 * 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;
}