static void
insert_chocolate_detail_codepoints (MucharmapCharmap *charmap,
	                                GtkTextBuffer *buffer,
	                                GtkTextIter *iter,
	                                const gchar *name,
	                                const gunichar *ucs)
{
  gint i;

  gtk_text_buffer_insert (buffer, iter, name, -1);
  gtk_text_buffer_insert (buffer, iter, "\n", -1);

  for (i = 0;  ucs[i] != (gunichar)(-1);  i++)
	{
	  gtk_text_buffer_insert (buffer, iter, " • ", -1);
	  insert_codepoint (charmap, buffer, iter, ucs[i]);
	  gtk_text_buffer_insert (buffer, iter, "\n", -1);
	}

  gtk_text_buffer_insert (buffer, iter, "\n", -1);
}
Example #2
0
static void
xfce_about_copyright (GtkTextBuffer *buffer)
{
  GtkTextIter end;

  g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));

  gtk_text_buffer_get_end_iter (buffer, &end);

  gtk_text_buffer_insert (buffer, &end,
      _("Xfce 4 is copyright Olivier Fourdan ([email protected]). The different "
        "components are copyrighted by their respective authors."), -1);

  gtk_text_buffer_insert (buffer, &end, "\n\n", -1);
  gtk_text_buffer_insert (buffer, &end,
      _("The libxfce4ui, libxfce4util and exo packages are "
        "distributed under the terms of the GNU Library General Public License as "
        "published by the Free Software Foundation; either version 2 of the License, or "
        "(at your option) any later version."), -1);

  gtk_text_buffer_insert (buffer, &end, "\n\n", -1);
  gtk_text_buffer_insert (buffer, &end,
      _("The packages thunar, xfce4-appfinder, xfce4-panel, xfce4-session, "
        "xfce4-settings, xfconf, xfdesktop and xfwm4 are "
        "distributed 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."), -1);

  gtk_text_buffer_insert (buffer, &end, "\n", -1);
}
Example #3
0
/* values is a null-terminated array of strings */
static void
insert_chocolate_detail (GucharmapCharmap *charmap,
                         GtkTextBuffer *buffer,
                         GtkTextIter *iter,
                         const gchar *name,
                         const gchar **values,
                         gboolean expand_codepoints)
{
  gint i;

  gtk_text_buffer_insert (buffer, iter, name, -1);
  gtk_text_buffer_insert (buffer, iter, "\n", -1);

  for (i = 0;  values[i];  i++)
    {
      gtk_text_buffer_insert (buffer, iter, " • ", -1);
      if (expand_codepoints)
        insert_string_link_codepoints (charmap, buffer, iter, values[i]);
      else
        gtk_text_buffer_insert (buffer, iter, values[i], -1);
      gtk_text_buffer_insert (buffer, iter, "\n", -1);
    }

  gtk_text_buffer_insert (buffer, iter, "\n", -1);
}
Example #4
0
static void
change_cb (GeditSpellCheckerDialog *dlg,
	   const gchar             *word,
	   const gchar             *change,
	   GeditView               *view)
{
	GeditDocument *doc;
	CheckRange *range;
	gchar *w = NULL;
	GtkTextIter start, end;

	gedit_debug (DEBUG_PLUGINS);

	g_return_if_fail (view != NULL);
	g_return_if_fail (word != NULL);
	g_return_if_fail (change != NULL);

	doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
	g_return_if_fail (doc != NULL);

	range = get_check_range (doc);
	g_return_if_fail (range != NULL);

	gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &start, range->mw_start);
	if (range->mw_end < 0)
		gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &end);
	else
		gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &end, range->mw_end);

	w = gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (doc), &start, &end, TRUE);
	g_return_if_fail (w != NULL);

	if (strcmp (w, word) != 0)
	{
		g_free (w);
		return;
	}

	g_free (w);

	gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER(doc));

	gtk_text_buffer_delete (GTK_TEXT_BUFFER (doc), &start, &end);
	gtk_text_buffer_insert (GTK_TEXT_BUFFER (doc), &start, change, -1);

	gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER(doc));

	update_current (doc, range->mw_start + g_utf8_strlen (change, -1));

	/* go to next misspelled word */
	ignore_cb (dlg, word, view);
}
Example #5
0
static gboolean remmina_log_print_real(gpointer data)
{
	GtkTextIter iter;

	if (log_window)
	{
		gtk_text_buffer_get_end_iter(REMMINA_LOG_WINDOW (log_window)->log_buffer, &iter);
		gtk_text_buffer_insert(REMMINA_LOG_WINDOW (log_window)->log_buffer, &iter, (const gchar*) data, -1);
		IDLE_ADD(remmina_log_scroll_to_end, NULL);
	}
	g_free(data);
	return FALSE;
}
// Fügt eine Zeile Text ein
void settings_import_messages_add (gchar *text)
{
	GtkTextView *view;
	GtkTextBuffer *buf;
	GtkTextIter iter;
	
	view = (GtkTextView*) interface_get_widget ("settings_textview_import");
	buf = gtk_text_view_get_buffer (view);

	gtk_text_buffer_get_end_iter (buf, &iter);
	gtk_text_buffer_insert (buf, &iter, g_strdup_printf ("%s\n", text), -1);
	
}
Example #7
0
static void
app_text_print (const char *line, PrintFormat format, gboolean newline)
{
	GtkTextIter iter;

	gtk_text_buffer_get_end_iter (app->text_buffer, &iter);
	gtk_text_buffer_insert_with_tags (
		app->text_buffer, &iter, line, -1, app->text_tags[format], NULL);
	if (newline) {
		gtk_text_buffer_insert (app->text_buffer, &iter, "\n", -1);
	}
	gtk_text_view_scroll_mark_onscreen (app->text_view, app->text_end);
}
Example #8
0
static void salida_imprimir(const char *value, GladeXML *xml) {
  if(value) {
    GString *valor = g_string_new("");
    g_string_sprintf(valor, "%s\n", (char *)value);
    GtkWidget* texto =  glade_xml_get_widget(xml, "txt_salida");
    GtkTextIter iter;
    GtkTextBuffer * buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(texto));
    gtk_text_buffer_get_iter_at_offset(buffer, &iter, -1);
    gtk_text_buffer_insert(buffer, &iter, valor->str, -1);
    g_string_free(valor, TRUE);
    gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(texto), &iter, 0.0, FALSE, 1.0, 1.0);
  }
}
Example #9
0
File: console.c Project: 3Nigma/AVI
void avi_console_append_text(GtkWidget *textview, gchar *text) {
  GtkTextBuffer *tbuffer;
  GtkTextIter ei;

  if(NULL == textview) {
    g_assert(NULL != consoleView);
    textview = consoleView;
  }

  tbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
  gtk_text_buffer_get_end_iter(tbuffer, &ei);
  gtk_text_buffer_insert(tbuffer, &ei, text, -1);
}
Example #10
0
File: gui.c Project: rosedu/osmo
void
display_about(void) {

    gui_url_remove_links (&about_links_list, &about_link_index);

    gui_clear_text_buffer (entry_buffer, &entry_iter);

    sprintf(tmpbuf, "\n%s\n", _("A handy personal organizer"));
    gtk_text_buffer_insert_with_tags_by_name (entry_buffer, &entry_iter, tmpbuf, -1, "big", "center", NULL);

    sprintf(tmpbuf, "\n(%s %s, %s)\n\n", _("compiled on"), __DATE__, __TIME__);
    gtk_text_buffer_insert_with_tags_by_name (entry_buffer, &entry_iter, tmpbuf, -1, "center", "italic", NULL);

    sprintf(tmpbuf, "\n %s: ", _("Homepage"));
    gtk_text_buffer_insert_with_tags_by_name (entry_buffer, &entry_iter, tmpbuf, -1, "bold", NULL);     

    gui_url_insert_link(&about_links_list, &about_link_index, about_textview, &entry_iter, NULL, 0, "http://clay.ll.pl/osmo");
    gtk_text_buffer_insert (entry_buffer, &entry_iter, "\n\n", -1);

    sprintf(tmpbuf, "\n %s:\n", _("Programming"));
    gtk_text_buffer_insert_with_tags_by_name (entry_buffer, &entry_iter, tmpbuf, -1, "bold", NULL);     
    gtk_text_buffer_insert (entry_buffer, &entry_iter, "     Tomasz Mąka <", -1);
    gui_url_insert_link(&about_links_list, &about_link_index, about_textview, &entry_iter, NULL, 0, "*****@*****.**");
    gtk_text_buffer_insert (entry_buffer, &entry_iter, ">\n", -1);
    
    sprintf(tmpbuf, "\n %s:\n", _("Graphics"));
    gtk_text_buffer_insert_with_tags_by_name (entry_buffer, &entry_iter, tmpbuf, -1, "bold", NULL);     
    gtk_text_buffer_insert (entry_buffer, &entry_iter, "     Maja Kocoń (", -1);
    gui_url_insert_link(&about_links_list, &about_link_index, about_textview, &entry_iter, NULL, 0, "http://ironya.ll.pl");
    gtk_text_buffer_insert (entry_buffer, &entry_iter, ")\n", -1);

    sprintf(tmpbuf, "\n %s:\n", _("Translators"));
    gtk_text_buffer_insert_with_tags_by_name (entry_buffer, &entry_iter, tmpbuf, -1, "bold", NULL);     

    gtk_text_buffer_insert (entry_buffer, &entry_iter, "     [pl]\tPiotr Mąka <", -1);
    gui_url_insert_link(&about_links_list, &about_link_index, about_textview, &entry_iter, NULL, 0, "*****@*****.**");
    gtk_text_buffer_insert (entry_buffer, &entry_iter, ">\n", -1);

    gtk_text_buffer_insert (entry_buffer, &entry_iter, "     [pt]\tBruno Miguel <", -1);
    gui_url_insert_link(&about_links_list, &about_link_index, about_textview, &entry_iter, NULL, 0, "*****@*****.**");
    gtk_text_buffer_insert (entry_buffer, &entry_iter, ">\n", -1);

    gtk_widget_grab_focus(GTK_WIDGET(scrolled_window));
}
Example #11
0
/* the "changed" signal should be blocked before calling this */
static void keyword_list_push(GtkWidget *textview, GList *list)
{
	GtkTextBuffer *buffer;
	GtkTextIter start, end;

	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
	gtk_text_buffer_get_bounds(buffer, &start, &end);
	gtk_text_buffer_delete(buffer, &start, &end);

	while (list)
		{
		const gchar *word = list->data;
		GtkTextIter iter;

		gtk_text_buffer_get_end_iter(buffer, &iter);
		if (word) gtk_text_buffer_insert(buffer, &iter, word, -1);
		gtk_text_buffer_get_end_iter(buffer, &iter);
		gtk_text_buffer_insert(buffer, &iter, "\n", -1);

		list = list->next;
		}
}
Example #12
0
void append_textview(GtkTextView * textv, const char *s, size_t bytes)
{

    GtkTextIter endit;
    GtkTextBuffer *gtkbuf;
    /*get text view buffer */
    gtkbuf = gtk_text_view_get_buffer(textv);
    /*set iterator to the end of the buffer */
    gtk_text_buffer_get_end_iter(gtkbuf, &endit);
    /* insert buf to the end */
    gtk_text_buffer_insert(gtkbuf, &endit, s, (gint)bytes);

}
Example #13
0
/*
 * Insert some text to a text page.
 */
static void text_page_insert(GtkWidget *page, const char *buffer, int nchars)
{
    GtkWidget *txt = g_object_get_data(G_OBJECT(page), TEXT_KEY);

    GtkTextBuffer *buf= gtk_text_view_get_buffer(GTK_TEXT_VIEW(txt));
    GtkTextIter    iter;

    gtk_text_buffer_get_end_iter(buf, &iter);
    gtk_widget_modify_font(GTK_WIDGET(txt), user_font_get_regular());
    if (!g_utf8_validate(buffer, -1, NULL))
        printf("Invalid utf8 encoding: %s\n", buffer);
    gtk_text_buffer_insert(buf, &iter, buffer, nchars);
}
Example #14
0
void
gimp_color_profile_view_set_profile (GimpColorProfileView *view,
                                     GimpColorProfile      profile)
{
  GtkTextBuffer *buffer;
  GtkTextIter    iter;
  gchar         *label;
  gchar         *summary;

  g_return_if_fail (GIMP_IS_COLOR_PROFILE_VIEW (view));

  buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));

  gtk_text_buffer_set_text (buffer, "", 0);

  view->priv->profile = profile;

  if (! profile)
    return;

  gtk_text_buffer_get_start_iter (buffer, &iter);

  label   = gimp_lcms_profile_get_label (profile);
  summary = gimp_lcms_profile_get_summary (profile);

  if (label && strlen (label))
    {
      gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
                                                label, -1,
                                                "strong", NULL);
      gtk_text_buffer_insert (buffer, &iter, "\n", 1);
    }

  if (summary)
    gtk_text_buffer_insert (buffer, &iter, summary, -1);

  g_free (label);
  g_free (summary);
}
Example #15
0
File: about.c Project: Mortal/claws
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;
}
Example #16
0
static void
peacock_file_load_async_read_cb (GnomeVFSAsyncHandle *handle,
				 GnomeVFSResult result,
				 gpointer buffer,
				 GnomeVFSFileSize bytes_requested,
				 GnomeVFSFileSize bytes_read,
				 gpointer data)
{
	PeacockFile *file = PEACOCK_FILE (data);

#ifdef PEACOCK_FILE_DEBUG
	g_warning ("peacock_file_load_async_read_cb (): %s\n", gnome_vfs_result_to_string (result));
#endif

	if (result != GNOME_VFS_OK && result != GNOME_VFS_ERROR_EOF) {
		/*
		 * Read error. We destroy our PeacockFile object. Not adding
		 * it to the MDI is handled by peacock_mdi_add_file () called
		 * by the close callback.
		 */
		g_free (buffer);
		g_object_unref (data);
		data = NULL;

		gnome_vfs_async_close (handle, peacock_file_load_async_close_cb, data);
	} else {
		/*
		 * File has been loaded. Close up and go back.
		 */
		if (result == GNOME_VFS_ERROR_EOF) {
			gnome_vfs_async_close (handle, peacock_file_load_async_close_cb, data);
			return;
		}

		/*
		 * If we read bytes, append them to the buffer.
		 */
		if (bytes_read > 0) {
			GtkTextIter iter;

			gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (file),
						      &iter);
			gtk_text_buffer_insert (GTK_TEXT_BUFFER (file),
						&iter, buffer, bytes_read);
		}

		gnome_vfs_async_read (handle, buffer,
				      PEACOCK_FILE_READ_WRITE_BUF_SIZE,
				      peacock_file_load_async_read_cb, data);
	}
}
Example #17
0
// ========================== [ LOCAL FUNCTIONS ] ===============================
static void Trace(const gchar* format,...)
{
	va_list args;
	unsigned long length;
	static char log_buf[1024];
	va_start(args, format);
	length = vsprintf(log_buf,format,args);
	va_end(args);

	GtkTextIter Iter;
	//gtk_text_buffer_get_end_iter(pTextBuffer,&Iter);
	gtk_text_buffer_get_start_iter(pTextBuffer,&Iter);
	gtk_text_buffer_insert(pTextBuffer,&Iter,log_buf,length);
}
Example #18
0
void linphone_gtk_call_log_update(GtkWidget *w){
	GtkTextView *v=GTK_TEXT_VIEW(linphone_gtk_get_widget(w,"logtextview"));
	GtkTextBuffer *b=gtk_text_view_get_buffer(v);
	GtkTextIter iter,begin;
	int off;
	char *logmsg;
	const MSList *logs;
	for (logs=linphone_core_get_call_logs(linphone_gtk_get_core());logs!=NULL;logs=logs->next){
		LinphoneCallLog *cl=(LinphoneCallLog*)logs->data;
		logmsg=linphone_call_log_to_str(cl);
		gtk_text_buffer_get_end_iter(b,&iter);
		off=gtk_text_iter_get_offset(&iter);
		gtk_text_buffer_insert(b,&iter,logmsg,-1);
		gtk_text_buffer_get_end_iter(b,&iter);
		gtk_text_buffer_insert(b,&iter,"\n",-1);
		gtk_text_buffer_get_end_iter(b,&iter);
		gtk_text_buffer_get_iter_at_offset(b,&begin,off);
		gtk_text_buffer_apply_tag_by_name(b,cl->dir==LinphoneCallOutgoing ? "green" : "blue" ,&begin,&iter);
		ms_free(logmsg);	
	}
	gtk_text_buffer_get_end_iter(b,&iter);
	gtk_text_view_scroll_to_iter(v,&iter,0,FALSE,0,0);
}
Example #19
0
void
gimmix_lyrics_populate_textview (LYRICS_NODE *node)
{
	GtkTextBuffer	*buffer;
	GtkTextIter	iter;
	
	/* clear the textview */
	buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(lyrics_textview));
	gtk_text_buffer_set_text (buffer, "", 0);
	gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
	
	/* display the lyrics */
	if (node && node->lyrics)
	{
		gtk_text_buffer_insert (buffer, &iter, node->lyrics, -1);
	}
	else
	{
		gtk_text_buffer_insert (buffer, &iter, _("Lyrics not found"), -1);
	}

	return;
}
gint
main (gint    argc,
      gchar **argv)
{
	GtkSourceBuffer *source_buffer;
	GtkTextBuffer *text_buffer;
	GtkTextIter iter;
	GTimer *timer;
	gint nb_actions;
	gint i;

	gtk_init (&argc, &argv);

	source_buffer = gtk_source_buffer_new (NULL);
	text_buffer = GTK_TEXT_BUFFER (source_buffer);

	gtk_text_buffer_get_start_iter (text_buffer, &iter);

	for (i = 0; i < NB_LINES; i++)
	{
		gtk_text_buffer_begin_user_action (text_buffer);

		gtk_text_buffer_insert (text_buffer,
					&iter,
					"A line of text to fill the text buffer. Is it long enough?\n",
					-1);

		gtk_text_buffer_end_user_action (text_buffer);
	}

	timer = g_timer_new ();
	nb_actions = test_undo_redo (source_buffer, NB_LINES / 10);
	g_timer_stop (timer);

	g_print ("Undo/Redo %d actions: %lf seconds.\n",
		 nb_actions,
		 g_timer_elapsed (timer, NULL));

	g_timer_start (timer);
	nb_actions = test_undo_redo (source_buffer, NB_LINES);
	g_timer_stop (timer);

	g_print ("Undo/Redo %d actions: %lf seconds.\n",
		 nb_actions,
		 g_timer_elapsed (timer, NULL));

	g_object_unref (source_buffer);
	g_timer_destroy (timer);
	return 0;
}
Example #21
0
static void
buffer_change_quote(GtkTextBuffer *buffer,
                    GtkTextIter *pos, GtkTextIter *nextpos,
                    gunichar oldc, gunichar newc)
{
	char buf[6];
	int len;

	if (oldc == newc) return;

	gtk_text_buffer_delete(buffer, pos, nextpos);
	len = g_unichar_to_utf8(newc, buf); buf[len] = 0;
	gtk_text_buffer_insert(buffer, pos, buf, len);
}
gboolean
markdown_textview_load_file(MarkdownTextView * self,
			    const gchar * file_name)
{
    FILE *text_file;
    gchar *path;

    g_return_val_if_fail(IS_MARKDOWN_TEXTVIEW(self), FALSE);
    
    path = g_build_filename(self->image_directory, file_name, NULL);

    /* we do assume UTF-8 encoding */
    if ((text_file = fopen(path, "rb"))) {
	GtkTextBuffer *text_buffer;
	GtkTextIter iter;
	gchar *line;
	gchar buffer[EGG_MARKDOWN_MAX_LINE_LENGTH];

	text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self));

	gtk_text_buffer_set_text(text_buffer, "\n", 1);
	gtk_text_buffer_get_start_iter(text_buffer, &iter);

	egg_markdown_clear(self->markdown);

	while (fgets(buffer, EGG_MARKDOWN_MAX_LINE_LENGTH, text_file)) {
	    line = egg_markdown_parse(self->markdown, buffer);

	    if (line && *line) {
		gtk_text_buffer_insert_markup(text_buffer, &iter, line);
		gtk_text_buffer_insert(text_buffer, &iter, "\n", 1);
	    }

	    g_free(line);
	}
	fclose(text_file);
	
	load_images(self);
	
        g_signal_emit(self, markdown_textview_signals[FILE_LOAD_COMPLETE], 0, file_name);
        
        g_free(path);

	return TRUE;
    }
    
    g_free(path);

    return FALSE;
}
Example #23
0
void linphone_gtk_push_text(GtkTextView *v, const char *from, const char *message, gboolean me){
	GtkTextBuffer *b=gtk_text_view_get_buffer(v);
	GtkTextIter iter,begin;
	int off;
	gtk_text_buffer_get_end_iter(b,&iter);
	off=gtk_text_iter_get_offset(&iter);
	gtk_text_buffer_insert(b,&iter,from,-1);
	gtk_text_buffer_get_end_iter(b,&iter);
	gtk_text_buffer_insert(b,&iter,":\t",-1);
	gtk_text_buffer_get_end_iter(b,&iter);
	gtk_text_buffer_get_iter_at_offset(b,&begin,off);
	gtk_text_buffer_apply_tag_by_name(b,me ? "green" : "blue" ,&begin,&iter);
	gtk_text_buffer_insert(b,&iter,message,-1);
	gtk_text_buffer_get_end_iter(b,&iter);
	gtk_text_buffer_insert(b,&iter,"\n",-1);
	gtk_text_buffer_get_end_iter(b,&iter);
	
	GtkTextMark *mark=gtk_text_buffer_create_mark(b,NULL,&iter,FALSE);
	gtk_text_view_scroll_mark_onscreen(v,mark);
	//gtk_text_buffer_get_end_iter(b,&iter);
	//gtk_text_iter_forward_to_line_end(&iter);
	//gtk_text_view_scroll_to_iter(v,&iter,0,TRUE,1.0,1.0);
}
Example #24
0
File: cmUI.c Project: entalent/SkyQ
void insert_sticker(GtkWidget *widget,GdkEventButton *event, struct sticker_info *sinfo){
    GtkTextIter end;
    gtk_text_buffer_get_end_iter(sinfo->view2_buffer,&end);
    gtk_text_buffer_insert(sinfo->view2_buffer,&end,sinfo->str,-1);

    GtkWidget *sticker_window = sinfo->sticker_window;
    struct sticker_info **p = sinfo->spointer;

    int i;
    for (i=0;i<6;i++) free(p[i]);
    free(p);

    gtk_widget_destroy(sticker_window);
}
Example #25
0
void ctk_help_para(GtkTextBuffer *buffer, GtkTextIter *iter,
                   const gchar *fmt, ...)
{
    gchar *a, *b;

    NV_VSNPRINTF(a, fmt);

    b = g_strconcat("\n", a, "\n", NULL);

    gtk_text_buffer_insert(buffer, iter, b, -1);

    g_free(b);
    free(a);
}
void MainWindow::log(const char* msg){
    GtkTextBuffer *buffer;
    GtkTextIter end;

    buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(_log));
    gtk_text_buffer_get_end_iter (buffer, &end);

    gtk_text_buffer_insert (buffer, &end, msg, -1);

    // Scroll para o final do Textview
    GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW(_logScroll));
    gtk_adjustment_set_value(adj, (gtk_adjustment_get_upper(adj) -
                                   gtk_adjustment_get_page_size(adj)));
}
Example #27
0
void result_item_print_modified_range(result_item_t * item, const poldiff_range_t * range, GtkTextBuffer * tb, GtkTextIter * iter)
{
	poldiff_t *diff = result_item_get_diff(item);
	char *orig_s = poldiff_range_to_string_brief(diff, range);
	char *next_s = orig_s;
	GString *string = g_string_new("");

	/* first line should always be printed with normal font */
	char *s = strsep(&next_s, "\n");
	result_item_print_string(tb, iter, s, 1);
	gtk_text_buffer_insert(tb, iter, "\n", -1);

	/* if the next line is minimum category set differences then
	 * display it */
	if (strncmp(next_s, "     minimum categories:", strlen("     minimum categories:")) == 0) {
		s = strsep(&next_s, "\n");
		result_item_print_string_inline(tb, iter, s, 1);
		gtk_text_buffer_insert(tb, iter, "\n", -1);
	}
	/* all subsequent lines are printed as normal (yes, this
	 * discards lines from poldiff_range_to_string_brief() */
	free(orig_s);
	apol_vector_t *levels = poldiff_range_get_levels(range);
	size_t i;
	for (i = 0; i < apol_vector_get_size(levels); i++) {
		poldiff_level_t *l = apol_vector_get_element(levels, i);
		s = poldiff_level_to_string_brief(diff, l);
		g_string_printf(string, "     %s", s);
		if (poldiff_level_get_form(l) != POLDIFF_FORM_MODIFIED) {
			result_item_print_string(tb, iter, string->str, 1);
		} else {
			result_item_print_string_inline(tb, iter, string->str, 1);
		}
		free(s);
	}
	g_string_free(string, TRUE);
}
Example #28
0
/**************************************************************************
  Appends the string to the chat output window.  The string should be
  inserted on its own line, although it will have no newline.
**************************************************************************/
void real_output_window_append(const char *astring,
                               const struct text_tag_list *tags,
                               int conn_id)
{
  GtkTextBuffer *buf;
  GtkTextIter iter;
  GtkTextMark *mark;
  ft_offset_t text_start_offset;

  buf = message_buffer;

  if (buf == NULL) {
    log_error("Output when no message buffer: %s", astring);

    return;
  }

  gtk_text_buffer_get_end_iter(buf, &iter);
  gtk_text_buffer_insert(buf, &iter, "\n", -1);
  mark = gtk_text_buffer_create_mark(buf, NULL, &iter, TRUE);

  if (gui_gtk2_show_chat_message_time) {
    char timebuf[64];
    time_t now;
    struct tm *now_tm;

    now = time(NULL);
    now_tm = localtime(&now);
    strftime(timebuf, sizeof(timebuf), "[%H:%M:%S] ", now_tm);
    gtk_text_buffer_insert(buf, &iter, timebuf, -1);
  }

  text_start_offset = gtk_text_iter_get_offset(&iter);
  gtk_text_buffer_insert(buf, &iter, astring, -1);
  text_tag_list_iterate(tags, ptag) {
    apply_text_tag(ptag, buf, text_start_offset, astring);
  } text_tag_list_iterate_end;
Example #29
0
int add_to_text(Gui *gui, gchar *s){
  //get the iterator and buffer
  GtkTextIter iter;
  GtkTextBuffer *buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gui->text_view));
  
  //fprintf(stdout, "Text passed from the entry is %s\n", s);
  
  //add the string to the end of the buffer
  const gchar *string_to_add = s;
  //fprintf(stdout, "%s", string_to_add);
  gtk_text_buffer_get_end_iter(buff, &iter); //sets iterator to the end of the buffer
  gtk_text_buffer_insert(buff, &iter, string_to_add, -1);

  return 0;
}
Example #30
0
static void
combochange_log (const char *fmt,
     ...)
{
  GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
  GtkTextIter iter;
  va_list vap;
  char *msg;
  GString *order_string;
  GtkTextMark *tmp_mark;
  int i;

  va_start (vap, fmt);
  
  msg = g_strdup_vprintf (fmt, vap);

  gtk_text_buffer_get_end_iter (buffer, &iter);
  gtk_text_buffer_insert (buffer, &iter, msg, -1);

  order_string = g_string_new ("\n  ");
  for (i = 0; i < contents->len; i++)
    {
      if (i)
	g_string_append_c (order_string, ' ');
      g_string_append_c (order_string, g_array_index (contents, char, i));
    }
  g_string_append_c (order_string, '\n');
  gtk_text_buffer_insert (buffer, &iter, order_string->str, -1);
  g_string_free (order_string, TRUE);

  tmp_mark = gtk_text_buffer_create_mark (buffer, NULL, &iter, FALSE);
  gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW (text_view), tmp_mark);
  gtk_text_buffer_delete_mark (buffer, tmp_mark);

  g_free (msg);
}