Ejemplo n.º 1
0
void linphone_gtk_create_log_window(void){
	GtkTextBuffer *b;
	log_window=linphone_gtk_create_window("log");
	b=gtk_text_view_get_buffer(GTK_TEXT_VIEW(linphone_gtk_get_widget(log_window,"textview")));
	gtk_text_buffer_create_tag(b,"red","foreground","red",NULL);
	gtk_text_buffer_create_tag(b,"orange","foreground","orange",NULL);
}
Ejemplo n.º 2
0
void on_about_button_clicked (GtkButton *button, gpointer user_data)
{
	gchar         *labeltext;
	GtkWidget     *label;
	GtkWidget     *credits_text;
	GtkWidget     *notes_text;
	GtkTextBuffer *textbuffer;
	GtkTextTag    *boldtag;
	GtkTextIter    start, end;
	
	if (aboutdialog != NULL)
	{
		gtk_window_present (GTK_WINDOW (aboutdialog));
		return;
	}
	
	aboutdialog = create_about_dialog ();
	labeltext = g_strdup_printf (_("<span weight=\"bold\" size=\"larger\">gcolor2 v%s</span>"), VERSION);
	label = lookup_widget (aboutdialog, "about_label");
	gtk_label_set_markup (GTK_LABEL (label), labeltext);
	g_free (labeltext);
	
	/* credits tab */
	credits_text = lookup_widget (aboutdialog, "about_credits_text");
	textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (credits_text));
	gtk_text_buffer_set_text (textbuffer, _(ABOUT_CREDITS_TEXT), -1);
	
	/* make main sections bold */
	boldtag = gtk_text_buffer_create_tag (textbuffer, "bold", "weight", "bold", NULL);
	gtk_text_buffer_get_iter_at_line (textbuffer, &start, 0);
	gtk_text_buffer_get_iter_at_line (textbuffer, &end, 1);
	gtk_text_buffer_apply_tag (textbuffer, boldtag, &start, &end);
	
	gtk_text_buffer_get_iter_at_line (textbuffer, &start, 3);
	gtk_text_buffer_get_iter_at_line (textbuffer, &end, 4);
	gtk_text_buffer_apply_tag (textbuffer, boldtag, &start, &end);
	
	gtk_text_buffer_get_iter_at_line (textbuffer, &start, 10);
	gtk_text_buffer_get_iter_at_line (textbuffer, &end, 11);
	gtk_text_buffer_apply_tag (textbuffer, boldtag, &start, &end);
	
	
	/* release notes tab */
	notes_text = lookup_widget (aboutdialog, "about_notes_text");
	textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (notes_text));
	gtk_text_buffer_set_text (textbuffer, _(ABOUT_NOTES_TEXT), -1);
	
	/* make main sections bold */
	boldtag = gtk_text_buffer_create_tag (textbuffer, "bold", "weight", "bold", NULL);
	gtk_text_buffer_get_iter_at_line (textbuffer, &start, 0);
	gtk_text_buffer_get_iter_at_line (textbuffer, &end, 1);
	gtk_text_buffer_apply_tag (textbuffer, boldtag, &start, &end);
	
	gtk_text_buffer_get_iter_at_line (textbuffer, &start, 3);
	gtk_text_buffer_get_iter_at_line (textbuffer, &end, 4);
	gtk_text_buffer_apply_tag (textbuffer, boldtag, &start, &end);
	
	
	gtk_window_present (GTK_WINDOW (aboutdialog));
}
Ejemplo n.º 3
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;
}
Ejemplo n.º 4
0
static void gather_widgets(GtkBuilder *builder, struct widgets *widgets)
{
	widgets->window = GTK_WIDGET(gtk_builder_get_object(builder,
				"window"));
	widgets->about = GTK_WIDGET(gtk_builder_get_object(builder,
				"about_cashflo"));
	widgets->readme = GTK_WIDGET(gtk_builder_get_object(builder,
				"readme"));
	widgets->amount_entry = GTK_WIDGET(gtk_builder_get_object(builder,
				"amount_entry"));
	widgets->ir_entry = GTK_WIDGET(gtk_builder_get_object(builder,
				"ir_entry"));
	widgets->itype = GTK_WIDGET(gtk_builder_get_object(builder,
				"itype"));
	gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->itype), 0);
	widgets->pt_entry = GTK_WIDGET(gtk_builder_get_object(builder,
				"pt_entry"));
	widgets->msc_entry = GTK_WIDGET(gtk_builder_get_object(builder,
				"msc_entry"));
	widgets->buffer = GTK_TEXT_BUFFER(gtk_builder_get_object(builder,
				"result_buffer"));
	widgets->readme_buffer = GTK_TEXT_BUFFER(gtk_builder_get_object(
				builder, "readme_buffer"));

	gtk_text_buffer_create_tag(widgets->buffer, "bold", "weight",
			PANGO_WEIGHT_BOLD, NULL);
	gtk_text_buffer_create_tag(widgets->buffer, "light", "weight",
			PANGO_WEIGHT_LIGHT, NULL);
	gtk_text_buffer_create_tag(widgets->buffer, "italic", "style",
			PANGO_STYLE_ITALIC, NULL);
	gtk_text_buffer_create_tag(widgets->buffer, "red", "foreground", "red",
			NULL);
	gtk_text_buffer_create_tag(widgets->buffer, "green", "foreground",
			"green", NULL);
}
Ejemplo n.º 5
0
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);
}
Ejemplo n.º 6
0
Archivo: about.c Proyecto: Mortal/claws
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;
}
Ejemplo n.º 7
0
void init_Code(GtkWidget *Main)
{
  GtkWidget *widget;
  PangoFontDescription *codefont;

  codetext = lookup_widget(Main, "Code_Text");
  code_textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(codetext));

  codefont = pango_font_description_from_string("Monospace");
  gtk_widget_modify_font(codetext, codefont);

  redtag = gtk_text_buffer_create_tag(code_textbuffer, "redtag", 
	"foreground", "red", NULL); 
  greentag = gtk_text_buffer_create_tag(code_textbuffer, "greentag", 
	"foreground", "green", NULL); 
  bluetag = gtk_text_buffer_create_tag(code_textbuffer, "bluetag", 
	"foreground", "blue", NULL); 
  boldtag = gtk_text_buffer_create_tag(code_textbuffer, "boldtag", 
	"weight", PANGO_WEIGHT_BOLD, NULL); 

/* default the machine code button to FALSE */

  widget = lookup_widget(Main, "OpcodeButton");
  gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), FALSE);

/* Set up the runslow stuff. Note that the widget holds values in mS */
/* but the internal values are in usecs */

  run_slow_pref = RUN_SLOW_MSECS * 1000;
  widget = lookup_widget(Main, "SlowRunSpin");
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), RUN_SLOW_MSECS);

  Code_Selected = FALSE;
  build_code_cache();
}
void set_help_text(void)
{
    GtkTextIter iter;

    gtk_text_buffer_create_tag(buffer, "heading",
			       "weight", PANGO_WEIGHT_BOLD,
			       "size", 15 * PANGO_SCALE, NULL);
    gtk_text_buffer_create_tag(buffer, "x-large",
			       "scale", PANGO_SCALE_X_LARGE, NULL);
    gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);

    gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, _("HELP\n\n"),
					     -1, "heading", NULL);
    gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
					     _("Admin user\n"), -1,
					     "x-large", NULL);
    gtk_text_buffer_insert(buffer, &iter,
			   _
			   ("The admin user is an user that have special permissions respect to the other users. With this user one can access the administration tools (software installation, configuration tools...).\n\n"),
			   -1);

    gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
					     _("My Computer\n"), -1,
					     "x-large", NULL);
    gtk_text_buffer_insert(buffer, &iter,
			   _
			   ("In systems like this is a common thing to name the computer for identification. You can name it \"home\", \"office\" or any other name you want, though it must be a single word.\n\n"),
			   -1);
}
Ejemplo n.º 9
0
Archivo: gconf.c Proyecto: hajuuk/R7000
/* Main Window Initialization */
void init_main_window(const gchar * glade_file)
{
	GladeXML *xml;
	GtkWidget *widget;
	GtkTextBuffer *txtbuf;
	char title[256];
	GtkStyle *style;

	xml = glade_xml_new(glade_file, "window1", NULL);
	if (!xml)
		g_error(_("GUI loading failed !\n"));
	glade_xml_signal_autoconnect(xml);

	main_wnd = glade_xml_get_widget(xml, "window1");
	hpaned = glade_xml_get_widget(xml, "hpaned1");
	vpaned = glade_xml_get_widget(xml, "vpaned1");
	tree1_w = glade_xml_get_widget(xml, "treeview1");
	tree2_w = glade_xml_get_widget(xml, "treeview2");
	text_w = glade_xml_get_widget(xml, "textview3");

	back_btn = glade_xml_get_widget(xml, "button1");
	gtk_widget_set_sensitive(back_btn, FALSE);

	widget = glade_xml_get_widget(xml, "show_name1");
	gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
				       show_name);

	widget = glade_xml_get_widget(xml, "show_range1");
	gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
				       show_range);

	widget = glade_xml_get_widget(xml, "show_data1");
	gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
				       show_value);

	style = gtk_widget_get_style(main_wnd);
	widget = glade_xml_get_widget(xml, "toolbar1");

	replace_button_icon(xml, main_wnd->window, style,
			    "button4", (gchar **) xpm_single_view);
	replace_button_icon(xml, main_wnd->window, style,
			    "button5", (gchar **) xpm_split_view);
	replace_button_icon(xml, main_wnd->window, style,
			    "button6", (gchar **) xpm_tree_view);

	txtbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
	tag1 = gtk_text_buffer_create_tag(txtbuf, "mytag1",
					  "foreground", "red",
					  "weight", PANGO_WEIGHT_BOLD,
					  NULL);
	tag2 = gtk_text_buffer_create_tag(txtbuf, "mytag2",
					  /*"style", PANGO_STYLE_OBLIQUE, */
					  NULL);

	sprintf(title, _("BusyBox %s Configuration"),
		getenv("KERNELVERSION"));
	gtk_window_set_title(GTK_WINDOW(main_wnd), title);

	gtk_widget_show(main_wnd);
}
Ejemplo n.º 10
0
static void
gimp_text_buffer_constructed (GObject *object)
{
  GimpTextBuffer *buffer = GIMP_TEXT_BUFFER (object);

  G_OBJECT_CLASS (parent_class)->constructed (object);

  gtk_text_buffer_set_text (GTK_TEXT_BUFFER (buffer), "", -1);

  buffer->bold_tag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (buffer),
                                                 "bold",
                                                 "weight", PANGO_WEIGHT_BOLD,
                                                 NULL);

  buffer->italic_tag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (buffer),
                                                   "italic",
                                                   "style", PANGO_STYLE_ITALIC,
                                                   NULL);

  buffer->underline_tag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (buffer),
                                                      "underline",
                                                      "underline", PANGO_UNDERLINE_SINGLE,
                                                      NULL);

  buffer->strikethrough_tag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (buffer),
                                                          "strikethrough",
                                                          "strikethrough", TRUE,
                                                          NULL);
}
Ejemplo n.º 11
0
static void
put_text_in_textview_impl(const gchar * txt, GtkWidget * textview_output)
{
    GtkTextBuffer * text_buffer;
    GtkTextIter end;
    GtkTextTag *tt;
    GtkTextTagTable *tt_table;

    text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_output));
    tt_table = gtk_text_buffer_get_tag_table(text_buffer);    
    tt = gtk_text_tag_table_lookup(tt_table, "mono");

    if (!tt)
    {
#ifdef win32
	tt = gtk_text_buffer_create_tag(text_buffer, "mono", 
					"font", "Courier", NULL);
#else
	tt = gtk_text_buffer_create_tag(text_buffer, "mono", "font", "Mono",
                                        "size-points", (double)8.0, NULL);
#endif
    }

    if (gtk_text_buffer_get_char_count(text_buffer) > 0)
    {
        GtkTextIter b, e;

        gtk_text_buffer_get_start_iter(text_buffer, &b);
        gtk_text_buffer_get_end_iter(text_buffer, &e);
        gtk_text_buffer_delete(text_buffer, &b, &e);
    }

    gtk_text_buffer_get_end_iter(text_buffer, &end);
    gtk_text_buffer_insert_with_tags(text_buffer, &end, txt, -1, tt, NULL);
}
Ejemplo n.º 12
0
/**
 * 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;
}
Ejemplo n.º 13
0
GtkWidget *
do_css_basics (GtkWidget *do_widget)
{
  if (!window)
    {
      GtkWidget *container, *child;
      GtkStyleProvider *provider;
      GtkTextBuffer *text;
      GBytes *bytes;

      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_title (GTK_WINDOW (window), "CSS Basics");
      gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
      gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
      g_signal_connect (window, "destroy",
                        G_CALLBACK (gtk_widget_destroyed), &window);

      text = gtk_text_buffer_new (NULL);
      gtk_text_buffer_create_tag (text,
                                  "warning",
                                  "underline", PANGO_UNDERLINE_SINGLE,
                                  NULL);
      gtk_text_buffer_create_tag (text,
                                  "error",
                                  "underline", PANGO_UNDERLINE_ERROR,
                                  NULL);

      provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());

      container = gtk_scrolled_window_new (NULL, NULL);
      gtk_container_add (GTK_CONTAINER (window), container);
      child = gtk_text_view_new_with_buffer (text);
      gtk_container_add (GTK_CONTAINER (container), child);
      g_signal_connect (text, "changed",
                        G_CALLBACK (css_text_changed), provider);

      bytes = g_resources_lookup_data ("/css_basics/css_basics.css", 0, NULL);
      gtk_text_buffer_set_text (text, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
      g_bytes_unref (bytes);

      g_signal_connect (provider,
                        "parsing-error",
                        G_CALLBACK (show_parsing_error),
                        gtk_text_view_get_buffer (GTK_TEXT_VIEW (child)));

      apply_css (window, provider);
    }

  if (!gtk_widget_get_visible (window))
    gtk_widget_show_all (window);
  else
    {
      gtk_widget_destroy (window);
      window = NULL;
    }

  return window;
}
Ejemplo n.º 14
0
static void
xfce_about_credits (GtkTextBuffer *buffer)
{
  guint                   i;
  GtkTextTag             *title;
  GtkTextTag             *indent;
  GtkTextIter             end;
  const ContributorGroup *group;
  const ContributorInfo  *user;

  g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));

  title = gtk_text_buffer_create_tag (buffer, "title",
                                      "scale", 1.1,
                                      "weight", PANGO_WEIGHT_BOLD, NULL);

  indent = gtk_text_buffer_create_tag (buffer, "indent",
                                       "left-margin", MARGIN,
                                       "indent", -MARGIN, NULL);

  gtk_text_buffer_get_end_iter (buffer, &end);

  for (i = 0; i < G_N_ELEMENTS (xfce_contributors); i++)
    {
      group = xfce_contributors + i;

      gtk_text_buffer_insert_with_tags (buffer, &end, _(group->name), -1, title, NULL);
      gtk_text_buffer_insert (buffer, &end, "\n", -1);

      if (group->contributors != NULL)
        {
          for (user = group->contributors; user->name != NULL; user++)
            {
              gtk_text_buffer_insert_with_tags (buffer, &end, user->name, -1, indent, NULL);
              gtk_text_buffer_insert (buffer, &end, " <", -1);
              gtk_text_buffer_insert (buffer, &end, user->email, -1);
              gtk_text_buffer_insert (buffer, &end, ">\n", -1);
            }
        }
      else
        {
          /* add the translators */
          xfce_about_credits_translators (buffer, &end);
        }

      gtk_text_buffer_insert (buffer, &end, "\n", -1);
    }

  gtk_text_buffer_insert (buffer, &end,
      _("If you know of anyone missing from this list; don't hesitate and "
        "file a bug on <https://bugzilla.xfce.org> ."), -1);
  gtk_text_buffer_insert (buffer, &end, "\n\n", -1);
  gtk_text_buffer_insert_with_tags (buffer, &end,
      _("Thanks to all who helped making this software available!"), -1, title, NULL);

  gtk_text_buffer_insert (buffer, &end, "\n", -1);
}
Ejemplo n.º 15
0
static GtkTextBuffer *message_window(void)
{
    GtkTextBuffer *buffer;
    GtkWidget *vbox, *result, *ok;
    GtkWindow *window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
    gtk_window_set_title(GTK_WINDOW(window), _("Messages"));
    gtk_widget_set_size_request(GTK_WIDGET(window), SIZEX, SIZEY);
    gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(main_window));
    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ON_PARENT);
    gtk_window_set_destroy_with_parent(GTK_WINDOW(window), TRUE);

    vbox = gtk_grid_new();
    gtk_container_add (GTK_CONTAINER (window), vbox);

    result = gtk_text_view_new();
    ok = gtk_button_new_with_label(_("OK"));

    GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
    gtk_container_set_border_width(GTK_CONTAINER(scrolled_window), 10);
#if (GTKVER == 3) && GTK_CHECK_VERSION(3,8,0)
    gtk_container_add(GTK_CONTAINER(scrolled_window), result);
#else
    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), result);
#endif

    gtk_grid_attach(GTK_GRID(vbox), scrolled_window, 0, 0, 1, 1);
    gtk_widget_set_hexpand(scrolled_window, TRUE);
    gtk_widget_set_vexpand(scrolled_window, TRUE);
    gtk_grid_attach(GTK_GRID(vbox), ok,            0, 2, 1, 1);
    gtk_widget_show_all(GTK_WIDGET(window));
    buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(result));

    PangoFontDescription *font_desc = pango_font_description_from_string("Courier 10");
    gtk_widget_override_font (GTK_WIDGET(result), font_desc);
    pango_font_description_free (font_desc);

    g_signal_connect (G_OBJECT (window), "delete_event",
                      G_CALLBACK (delete_event_message), NULL);
    g_signal_connect (G_OBJECT (window), "destroy",
                      G_CALLBACK (destroy_message), NULL);

    g_signal_connect(G_OBJECT(ok), "button-press-event", G_CALLBACK(ok_cb), window);

    gtk_text_buffer_create_tag (buffer, "red",
                                "foreground", "red", NULL);  
    gtk_text_view_set_editable(GTK_TEXT_VIEW(result), FALSE);

    gtk_text_buffer_create_tag (buffer, "bold",
                                "weight", PANGO_WEIGHT_BOLD, NULL);  
    gtk_text_buffer_create_tag (buffer, "underline",
			      "underline", PANGO_UNDERLINE_SINGLE, NULL);
    gtk_text_buffer_create_tag (buffer, "heading",
                                "weight", PANGO_WEIGHT_BOLD,
                                "size", 15 * PANGO_SCALE,
                                NULL);
    return buffer;
}
Ejemplo n.º 16
0
int init_chatbox(ifreechat_t *ifc, chatbox_t *chatbox, chatbox_type_t type, 
		const void *data) {
	char title[128];
	GladeXML *xml;
	GtkTextBuffer *display_buffer;

	xml = glade_xml_new("glade/chatbox.glade", NULL, NULL);
	if (xml == NULL) {
		return -1;
	}

	glade_xml_signal_autoconnect(xml);

	/* load widgets from xml */
	chatbox->window 			= glade_xml_get_widget(xml, "chat_window");
	chatbox->display_textview 	= (GtkTextView*)glade_xml_get_widget(xml, "display_textview");
	chatbox->input_textview 	= (GtkTextView*)glade_xml_get_widget(xml, "input_textview");
	chatbox->avatar_image 		= (GtkImage*)glade_xml_get_widget(xml, "avatar_image");
	chatbox->send_button 		= (GtkButton*)glade_xml_get_widget(xml, "send_btn");
	chatbox->close_button 		= (GtkButton*)glade_xml_get_widget(xml, "close_btn");
	chatbox->first_label 		= (GtkLabel*)glade_xml_get_widget(xml, "first_label");
	chatbox->second_label 		= (GtkLabel*)glade_xml_get_widget(xml, "second_label");
	chatbox->chose_face_button	= (GtkToolButton*)glade_xml_get_widget(xml, "chose_face_button");
	chatbox->ifreechat			= (void*)ifc;
	chatbox->data				= (void*)data;
	chatbox->type				= type;

	init_dlist_node(&(chatbox->chatbox_node));

//	sprintf(title, "Chat with %s", user->nickname);
//	gtk_window_set_title((GtkWindow*)chatbox->window, title);
//	gtk_image_set_from_file(chatbox->avatar_image, user->avatar);
//	gtk_label_set_text(chatbox->nickname_label, user->nickname);
//	gtk_label_set_text(chatbox->signature_label, ""/*user->signature*/);


	display_buffer = gtk_text_view_get_buffer(chatbox->display_textview);

	gtk_text_buffer_create_tag(display_buffer, "lmarg",
			"left_margin", 5, NULL);
	gtk_text_buffer_create_tag(display_buffer, "blue_fg",
			"foreground", "blue", NULL);
	gtk_text_buffer_create_tag(display_buffer, "title_font",
			"font", "Sans 9", NULL);

	g_signal_connect(GTK_OBJECT(chatbox->window), 
			"destroy", G_CALLBACK(close_chatbox), (gpointer)chatbox);

	g_signal_connect(GTK_OBJECT(chatbox->close_button), 
			"clicked", G_CALLBACK(on_close_button), (gpointer)chatbox);

	g_signal_connect(G_OBJECT(chatbox->chose_face_button), 
			"clicked", G_CALLBACK(chose_face), chatbox);

	return 0;
}
GtkWidget *gui_readerview_create_window(void)
{
  GtkWidget           *view;
  GtkWidget           *scrolled_window;
  GtkWidget           *base_container;
  GtkWidget           *toolbar;
  PangoFontDescription *font_desc;

  /* Create base window container */

  base_container = gtk_box_new(GTK_ORIENTATION_VERTICAL,0);

  /* Create the toolbar */

  toolbar = gui_toolbar_new(TB_READER_VIEW);

  gtk_box_pack_start (GTK_BOX (base_container), toolbar, FALSE, FALSE, 0);

  /* Create a new scrolled window, with scrollbars only if needed */
  scrolled_window = gtk_scrolled_window_new (NULL, NULL);
  
  gtk_box_pack_end (GTK_BOX (base_container), scrolled_window, TRUE, TRUE, 0);

  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
				  GTK_POLICY_AUTOMATIC, 
				  GTK_POLICY_AUTOMATIC);


  view = gtk_text_view_new ();

  font_desc = pango_font_description_from_string ("Monospace");
  gtk_widget_override_font (view, font_desc);
  pango_font_description_free (font_desc);

  gtk_container_add (GTK_CONTAINER (scrolled_window), view);

  /* Reader buffer */ 
 
  READER_BUFFER = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));

  gtk_text_view_set_editable(GTK_TEXT_VIEW (view),FALSE);

  gtk_text_buffer_create_tag(READER_BUFFER,"green_text",
			     "foreground","dark green",
			     NULL);

  gtk_text_buffer_create_tag(READER_BUFFER,"blue_text",
			     "foreground","dark blue",
			     NULL);

  gtk_text_buffer_create_tag(READER_BUFFER,"red_text",
			     "foreground","dark red",
			     NULL);

  return base_container;
}
Ejemplo n.º 18
0
void linphone_gtk_create_log_window(void){
	GtkTextBuffer *b;
	log_window=linphone_gtk_create_window("log", NULL);
	b=gtk_text_view_get_buffer(GTK_TEXT_VIEW(linphone_gtk_get_widget(log_window,"textview")));
	gtk_text_buffer_create_tag(b,"red","foreground","red",NULL);
	gtk_text_buffer_create_tag(b,"orange","foreground","orange",NULL);
	/*prevent the log window from being destroyed*/
	g_signal_connect (G_OBJECT (log_window), "delete-event",
		G_CALLBACK (gtk_widget_hide_on_delete), log_window);
}
Ejemplo n.º 19
0
static void
tenso_properties_dialog(GtkButton * CodecButt, struct ALL_DATA *all_data)
{
  struct GWIDGET *gwidget = all_data->gwidget;
  GtkTextIter start, end;
  GtkTextIter iter;

  GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
      gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
      gtk_window_set_default_size(GTK_WINDOW(window), 400, 200);
      gtk_window_set_title(GTK_WINDOW(window), "Tenso incoming data");
      gtk_container_set_border_width(GTK_CONTAINER(window), 5);

  GtkWidget *vbox = gtk_vbox_new(FALSE, 0);

  //-------------------------tool bar--------------------------------------------
  GtkWidget *toolbar = gtk_toolbar_new();
    gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);

  GtkToolItem *startBtn = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), startBtn, -1);

  GtkToolItem *stopBtn = gtk_tool_button_new_from_stock(GTK_STOCK_CANCEL);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), stopBtn, -1);

  gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 5);

  GtkWidget *view = gtk_text_view_new();
    gtk_box_pack_start(GTK_BOX(vbox), view, TRUE, TRUE, 0);

  gwidget->tenso_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
    gtk_text_buffer_create_tag(gwidget->tenso_buffer, "gap", "pixels_above_lines", 30, NULL);
    gtk_text_buffer_create_tag(gwidget->tenso_buffer, "lmarg", "left_margin", 5, NULL);
    gtk_text_buffer_create_tag(gwidget->tenso_buffer, "blue_fg", "foreground", "blue", NULL); 
    gtk_text_buffer_get_iter_at_offset(gwidget->tenso_buffer, &iter, 0);

    gtk_text_buffer_insert_with_tags_by_name(gwidget->tenso_buffer, &iter, "Tenso test output\n", -1, "blue_fg", "lmarg",  NULL);
    gtk_text_buffer_insert(gwidget->tenso_buffer, &iter, "Waiting...\n", -1);

  GtkWidget *statusbar = gtk_statusbar_new();
      gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
      update_statusbar(gwidget->tenso_buffer, GTK_STATUSBAR (statusbar));

  gtk_container_add(GTK_CONTAINER(window), vbox);

 
  g_signal_connect(G_OBJECT(startBtn), "clicked", 
        G_CALLBACK(tenso_startBtn_clicked), all_data);
  
  g_signal_connect(G_OBJECT(stopBtn), "clicked", 
        G_CALLBACK(tenso_stopBtn_clicked), all_data);
  
  gtk_widget_show_all(window);

}
Ejemplo n.º 20
0
/**
 * 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;
}
Ejemplo n.º 21
0
Archivo: main.c Proyecto: chipx86/gtk
int
main (int argc, char **argv)
{
  GtkWidget *window;
  GtkWidget *notebook;
  GtkWidget *hbox;
  GtkWidget *tree;
  GtkTextTag *tag;

  gtk_init (&argc, &argv);
  
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  g_signal_connect (window, "destroy",
                    G_CALLBACK (gtk_main_quit), NULL);

  hbox = gtk_hbox_new (FALSE, 0);
  gtk_container_add (GTK_CONTAINER (window), hbox);

  tree = create_tree ();
  gtk_box_pack_start (GTK_BOX (hbox), tree, FALSE, FALSE, 0);

  notebook = gtk_notebook_new ();
  gtk_box_pack_start (GTK_BOX (hbox), notebook, TRUE, TRUE, 0);

  gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
			    create_text (&info_buffer, FALSE),
			    gtk_label_new ("Info"));


  gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
			    create_text (&source_buffer, TRUE),
			    gtk_label_new ("Source"));

  tag = gtk_text_buffer_create_tag (info_buffer, "title");
  gtk_object_set (GTK_OBJECT (tag),
		 "font", "Sans 18",
		 NULL);

  tag = gtk_text_buffer_create_tag (info_buffer, "source");
  gtk_object_set (GTK_OBJECT (tag),
		  "font", "Courier 10",
		  "pixels_above_lines", 0,
		  "pixels_below_lines", 0,
		 NULL);

  gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
  gtk_widget_show_all (window);
  

  load_file (testgtk_demos[0].filename);
  
  gtk_main ();

  return 0;
}
Ejemplo n.º 22
0
static void
theme_irc_create_tags (EmpathyThemeIrc *theme)
{
	GtkTextBuffer *buffer;

	buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (theme));

	gtk_text_buffer_create_tag (buffer, EMPATHY_THEME_IRC_TAG_NICK_SELF, NULL);
	gtk_text_buffer_create_tag (buffer, EMPATHY_THEME_IRC_TAG_NICK_OTHER, NULL);
	gtk_text_buffer_create_tag (buffer, EMPATHY_THEME_IRC_TAG_NICK_HIGHLIGHT, NULL);
}
GtkSnippetsInPlaceParser*
gtksnippets_inplaceparser_new(GtkTextView *view)
{
	GtkSnippetsInPlaceParser *self = GTKSNIPPETS_INPLACEPARSER(g_object_new (GTKSNIPPETS_TYPE_INPLACEPARSER, NULL));
	self->priv->view = view;
	GtkTextBuffer *buffer = gtk_text_view_get_buffer(view);
	self->priv->var_tag = gtk_text_buffer_create_tag (buffer, VAR_TAG_NAME,
	   		            "background", "yellow", NULL);
	self->priv->var_tag_error = gtk_text_buffer_create_tag (buffer, VAR_ERROR_TAG_NAME,
	   		            "background", "red", NULL);
	
	return self;
}
Ejemplo n.º 24
0
static void
theme_boxes_create_tags (EmpathyThemeBoxes *theme)
{
	GtkTextBuffer *buffer;

	buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (theme));

	gtk_text_buffer_create_tag (buffer, EMPATHY_THEME_BOXES_TAG_HEADER,
				    "pixels-above-lines", HEADER_PADDING,
				    "pixels-below-lines", HEADER_PADDING,
				    NULL);

	gtk_text_buffer_create_tag (buffer, EMPATHY_THEME_BOXES_TAG_HEADER_LINE, NULL);
}
Ejemplo n.º 25
0
void
vivi_command_line_application_set (ViviViviDocklet *docklet, ViviApplication *app)
{
  GtkWidget *view = vivi_vivi_docklet_find_widget_by_type (docklet, GTK_TYPE_TEXT_VIEW);

  gtk_text_buffer_create_tag (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)),
      "error", "foreground", "red", "left-margin", 15, NULL);
  gtk_text_buffer_create_tag (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)),
      "input", "foreground", "dark grey", NULL);
  gtk_text_buffer_create_tag (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)),
      "output", "left-margin", 15, NULL);

  g_signal_connect (app, "message", G_CALLBACK (vivi_command_line_append_message), view);
}
Ejemplo n.º 26
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;
	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);
	entry = linphone_gtk_get_widget(chat_view,"text_entry");
	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;
}
Ejemplo n.º 27
0
static void create_intro(GtkTextView *view)
{
	GtkTextTag    *tag;
	GtkTextTag    *tag1;
	GtkTextIter    iter;
	const char title[] = N_("Openfetion "OPENFETION_VERSION"\n\n");
	const char intro[] = N_("OpenFetion is a Fetion client for linux based on GTK+2.0, "
				"implementing Fetion Protocol Version 4.\n"
				"It supports most features of Fetion. \n"
				"What's more, it's lightweight and efficient with intuitive interface.\n\n"
				"Project homepage: ");

	gtk_text_view_set_editable(view,FALSE);
	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_WORD_CHAR);
	g_signal_connect (view, "motion-notify-event", 
			G_CALLBACK (motion_notify_event), NULL);
	g_signal_connect(view, "event-after", 
                     G_CALLBACK (event_after), NULL);

	GtkTextBuffer *buffer = gtk_text_view_get_buffer(view);

	tag = gtk_text_buffer_create_tag (buffer, NULL, 
                                    "size", 15 * PANGO_SCALE, 
									"justification", GTK_JUSTIFY_CENTER,
									"weight", PANGO_WEIGHT_BOLD,
                                    NULL);

	tag1 = gtk_text_buffer_create_tag (buffer, NULL, 
                                    "left-margin", 25, 
                                    "right-margin", 25, 
                                    NULL);


	gtk_text_buffer_get_start_iter(buffer, &iter);
  
	gtk_text_buffer_insert_with_tags(buffer, &iter,
		   	title, -1, tag, NULL);
	gtk_text_buffer_insert_with_tags(buffer, &iter,
		   	_(intro), -1, tag1, NULL);
	insert_link(buffer, &iter, "http://code.google.com/p/ofetion/");
	gtk_text_buffer_insert_with_tags(buffer, &iter,
		   	_("\nBug report: "), -1, tag1, NULL);
	insert_link(buffer, &iter, "http://code.google.com/p/ofetion/issues/");
	
	gtk_text_buffer_insert_with_tags(buffer, &iter,
		   	_("\n\nPage on author's blog: "), -1, tag1, NULL);
	insert_link(buffer, &iter, "http://basiccoder.com/openfetion");
}
Ejemplo n.º 28
0
void gglk_text_set_hyperlink(GglkText *tb, glui32 linkval)
{
    if(tb->hyperval == linkval)
	return;
    if(tb->hyperval) {
	GtkTextTag *hypertag;
	GtkTextIter iter;
	hypertag = gtk_text_buffer_create_tag(tb->buffer, NULL, NULL);
	g_signal_connect(hypertag, "event",
			 G_CALLBACK(gglk_text_mouse),
			 GINT_TO_POINTER(tb->hyperval));

	/* compensate for GTK not sending through click on images if they're
	   not followed by text */
	iter = tb->iter;
	gtk_text_iter_backward_char(&iter);
	if(gtk_text_iter_get_pixbuf(&iter)) {
	    const gunichar space = ' ';
	    gglk_text_put_buffer(tb, &space, 1);
	}

	gtk_text_buffer_get_iter_at_mark(tb->buffer, &iter, tb->hypermark);
	gtk_text_buffer_apply_tag(tb->buffer, hypertag, &iter, &tb->iter);
	gtk_text_buffer_apply_tag_by_name(tb->buffer,
					  gglk_get_tag(style_Hyperlinks),
					  &iter, &tb->iter);
    }

    tb->hyperval = linkval;

    if(linkval) {
	gtk_text_buffer_move_mark(tb->buffer, tb->hypermark, &tb->iter);
    }
}
Ejemplo n.º 29
0
/**
  Kolorowanie słów.
  Słowa nie znajdujące się w słowniku - potencjalnie błędne - zostają
  oznaczone na czerwono.
  */
static void show_errors() {
  GtkTextIter start, end, text_end;
  int i, range;
  char *word;
  gunichar *wword;

  gtk_text_buffer_create_tag(editor_buf, "red_fg", 
                             "foreground", "red", 
                             "weight", PANGO_WEIGHT_BOLD, NULL);
  gtk_text_buffer_get_end_iter(editor_buf, &text_end);
  gtk_text_buffer_get_start_iter(editor_buf, &end);
  range = gtk_text_buffer_get_char_count(editor_buf);
  while (!gtk_text_iter_is_end(&end)) {
    gtk_text_iter_forward_word_end(&end); 
    start = end;
    gtk_text_iter_backward_word_start(&start); 

    word = gtk_text_iter_get_text(&start, &end);
    wword = g_utf8_to_ucs4_fast(word, -1, NULL);
    if (make_lowercase(wword)) {
      if (!dictionary_find(dict, wword))
      gtk_text_buffer_apply_tag_by_name(editor_buf, "red_fg", 
                                      &start, &end);
    }
    g_free(word);
    g_free(wword);
  }

}
Ejemplo n.º 30
0
/****** 'text_tags' function *************************************************/
gint text_tags(GtkTextBuffer *buffer, const gchar *text)
{
	GtkTextTag *tag;	
	
	GtkTextIter start,
	            match_end,
	            match_start;

	gtk_text_buffer_get_iter_at_line_offset(buffer, &start, 
	                                        char_line,
	                                        char_line_offset);	
	
	if(gtk_text_iter_forward_search(&start, text,
		                                GTK_TEXT_SEARCH_CASE_INSENSITIVE,
										&match_start, &match_end, NULL))
	{
		tag = gtk_text_buffer_create_tag(buffer, NULL, 
									     "font", "italic 12", 
									     "weight", 650, "underline", 
									     PANGO_UNDERLINE_SINGLE, 
									     NULL);

		gtk_text_buffer_apply_tag(buffer, tag, &match_start, &match_end);
		
		char_line = gtk_text_iter_get_line(&match_end);
		char_line_offset = gtk_text_iter_get_line_offset(&match_end);
	
		return 0;	
	}	
	else 
	{
		return -1;	
	}
}