/** 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); } }
//========================================================================== long GUI_edi_getEof (MemObj *mo) { //========================================================================== /// GUI_edi_getEof /// get total nr of chars (not bytes) /// gtk_text_buffer_get_char_count get nr of chars, not nr of bytes ! long fSiz, p1; // set GUI_ed1_view GUI_ed1_buff if(mo) { // for internal call: mo=NULL if(GUI_ed1_decode(mo)) return -1; } // get nr of chars in buffer, not nr of bytes ! fSiz = gtk_text_buffer_get_char_count (GUI_ed1_buff); // get startPos of text; gtk_text_iter_get_text // fSiz = g_utf8_offset_to_pointer (ptrStart, nrChar); // printf("ex GUI_Ed_getEof %ld\n",fSiz); return fSiz; }
gsize xedit_document_input_stream_get_total_size (XeditDocumentInputStream *stream) { g_return_val_if_fail (XEDIT_IS_DOCUMENT_INPUT_STREAM (stream), 0); return gtk_text_buffer_get_char_count (stream->priv->buffer); }
static void update_statusbar (GtkTextBuffer *buffer, GtkStatusbar *statusbar) { gchar *msg; gint row, col; gint count; GtkTextIter iter; /* clear any previous message, underflow is allowed */ gtk_statusbar_pop (statusbar, 0); count = gtk_text_buffer_get_char_count (buffer); gtk_text_buffer_get_iter_at_mark (buffer, &iter, gtk_text_buffer_get_insert (buffer)); row = gtk_text_iter_get_line (&iter); col = gtk_text_iter_get_line_offset (&iter); msg = g_strdup_printf ("Cursor at row %d column %d - %d chars in document", row, col, count); gtk_statusbar_push (statusbar, 0, msg); g_free (msg); }
static void timestamp_display(PurpleConversation *conv, time_t then, time_t now) { PidginConversation *gtk_conv = PIDGIN_CONVERSATION(conv); GtkWidget *imhtml = gtk_conv->imhtml; GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(imhtml)); GtkTextIter iter; const char *mdate; int y, height; GdkRectangle rect; /* display timestamp */ mdate = purple_utf8_strftime(then == 0 ? "%H:%M" : "\n%H:%M", localtime(&now)); gtk_text_buffer_get_end_iter(buffer, &iter); if (gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "TIMESTAMP") == NULL) gtk_text_buffer_create_tag(buffer, "TIMESTAMP", "foreground", "#888888", "justification", GTK_JUSTIFY_CENTER, "weight", PANGO_WEIGHT_BOLD, NULL); gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, mdate, strlen(mdate), "TIMESTAMP", NULL); /* scroll view if necessary */ gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(imhtml), &rect); gtk_text_view_get_line_yrange( GTK_TEXT_VIEW(imhtml), &iter, &y, &height); if (((y + height) - (rect.y + rect.height)) > height && gtk_text_buffer_get_char_count(buffer)) { gboolean smooth = purple_prefs_get_bool( PIDGIN_PREFS_ROOT "/conversations/use_smooth_scrolling"); gtk_imhtml_scroll_to_end(GTK_IMHTML(imhtml), smooth); } }
static void gail_scale_notify (GObject *obj, GParamSpec *pspec) { GailScale *scale = GAIL_SCALE (obj); if (strcmp (pspec->name, "accessible-value") == 0) { GtkWidget *widget; widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); if (widget) { GtkScale *gtk_scale; PangoLayout *layout; const gchar *txt; gtk_scale = GTK_SCALE (widget); layout = gtk_scale_get_layout (gtk_scale); if (layout) { txt = pango_layout_get_text (layout); if (txt) { g_signal_emit_by_name (obj, "text_changed::delete", 0, gtk_text_buffer_get_char_count (scale->textutil->buffer)); gail_text_util_text_setup (scale->textutil, txt); g_signal_emit_by_name (obj, "text_changed::insert", 0, g_utf8_strlen (txt, -1)); } } } } G_OBJECT_CLASS (gail_scale_parent_class)->notify (obj, pspec); }
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); }
void viewlog (gpointer data) { char *tempstr, *txt, *pos; gint textlen; ssize_t len; int fd; #if GTK_MAJOR_VERSION > 1 GtkTextBuffer * textbuf; GtkTextIter iter, iter2; #endif tempstr = g_strconcat (g_get_tmp_dir (), "/gftp-view.XXXXXXXXXX", NULL); if ((fd = mkstemp (tempstr)) < 0) { ftp_log (gftp_logging_error, NULL, _("Error: Cannot open %s for writing: %s\n"), tempstr, g_strerror (errno)); g_free (tempstr); return; } chmod (tempstr, S_IRUSR | S_IWUSR); #if GTK_MAJOR_VERSION == 1 textlen = gtk_text_get_length (GTK_TEXT (logwdw)); txt = gtk_editable_get_chars (GTK_EDITABLE (logwdw), 0, -1); #else textbuf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (logwdw)); textlen = gtk_text_buffer_get_char_count (textbuf); gtk_text_buffer_get_iter_at_offset (textbuf, &iter, 0); gtk_text_buffer_get_iter_at_offset (textbuf, &iter2, textlen); txt = gtk_text_buffer_get_text (textbuf, &iter, &iter2, 0); /* gtk_text_buffer_get_char_count() returns the number of characters, not bytes. So get the number of bytes that need to be written out */ textlen = strlen (txt); #endif pos = txt; while (textlen > 0) { if ((len = write (fd, pos, textlen)) == -1) { ftp_log (gftp_logging_error, NULL, _("Error: Error writing to %s: %s\n"), tempstr, g_strerror (errno)); break; } textlen -= len; pos += len; } fsync (fd); lseek (fd, 0, SEEK_SET); view_file (tempstr, fd, 1, 1, 0, 1, NULL, NULL); close (fd); g_free (tempstr); g_free (txt); }
static gunichar ev_view_accessible_get_character_at_offset (AtkText *text, gint offset) { GtkWidget *widget; GtkTextIter start, end; GtkTextBuffer *buffer; gchar *string; gunichar unichar; widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text)); if (widget == NULL) /* State is defunct */ return '\0'; buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget)); if (!buffer) return '\0'; if (offset >= gtk_text_buffer_get_char_count (buffer)) return '\0'; gtk_text_buffer_get_iter_at_offset (buffer, &start, offset); end = start; gtk_text_iter_forward_char (&end); string = gtk_text_buffer_get_slice (buffer, &start, &end, FALSE); unichar = g_utf8_get_char (string); g_free(string); return unichar; }
static void input_buffer_changed(GtkTextBuffer *text_buffer, GtkWidget *send_button) { if (gtk_text_buffer_get_char_count(text_buffer) != 0) gtk_widget_set_sensitive(send_button, TRUE); else gtk_widget_set_sensitive(send_button, FALSE); }
gint eel_accessibility_text_get_character_count (AtkText *text) { GailTextUtil *util = get_simple_text (text); g_return_val_if_fail (util != NULL, -1); return gtk_text_buffer_get_char_count (util->buffer); }
static void update_ui (GeditSpellPlugin *plugin) { GeditSpellPluginPrivate *priv; GeditView *view; GAction *check_spell_action; GAction *config_spell_action; GAction *auto_spell_action; gedit_debug (DEBUG_PLUGINS); priv = plugin->priv; view = gedit_window_get_active_view (priv->window); check_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window), "check-spell"); g_simple_action_set_enabled (G_SIMPLE_ACTION (check_spell_action), (view != NULL) && gtk_text_view_get_editable (GTK_TEXT_VIEW (view))); config_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window), "config-spell"); g_simple_action_set_enabled (G_SIMPLE_ACTION (config_spell_action), (view != NULL) && gtk_text_view_get_editable (GTK_TEXT_VIEW (view))); auto_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window), "auto-spell"); g_simple_action_set_enabled (G_SIMPLE_ACTION (auto_spell_action), (view != NULL) && gtk_text_view_get_editable (GTK_TEXT_VIEW (view))); if (view != NULL) { GeditDocument *doc; GeditTab *tab; GeditTabState state; gboolean autospell; doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view))); tab = gedit_window_get_active_tab (priv->window); state = gedit_tab_get_state (tab); autospell = (doc != NULL && gedit_automatic_spell_checker_get_from_document (doc) != NULL); /* If the document is loading we can't get the metadata so we endup with an useless speller */ if (state == GEDIT_TAB_STATE_NORMAL) { g_action_change_state (auto_spell_action, g_variant_new_boolean (autospell)); } g_simple_action_set_enabled (G_SIMPLE_ACTION (check_spell_action), gtk_text_buffer_get_char_count (GTK_TEXT_BUFFER (doc)) > 0); } }
extern void append_to_history_view( const char *buffer, const char *sender ) { GtkTextBuffer *historybuffer = NULL; GtkTextIter start; GtkTextIter end; GtkTextMark *mark; char *history = NULL; unsigned int char_count; char *to_append = NULL; gboolean need_newline = TRUE; historybuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(history_view)); /*check for "<No recent chats found>" at the top of historybuffer and remove it*/ char_count = gtk_text_buffer_get_char_count(historybuffer); if( char_count == strlen("<No recent chats found>") ) { gtk_text_buffer_get_bounds( historybuffer, &start, &end ); //TODO check if history needs to be free()d (look at source of gtk_text_buffer) history = gtk_text_buffer_get_text( historybuffer, &start, &end, FALSE ); if( strcmp( history, "<No recent chats found>" ) == 0 ) { gtk_text_buffer_delete( historybuffer, &start, &end ); need_newline = FALSE; } free(history); } /*"<No recent chats found>" is not or no longer at the top of historybuffer*/ /*prepend a '\n' to buffer and insert into historybuffer*/ if(need_newline) { to_append = calloc( 1 + strlen(sender) + 2 + strlen(buffer) + 1, sizeof(char) ); *to_append = '\n'; strncpy( to_append+1, sender, strlen(sender)+1 ); strncat( to_append, ": ", strlen(": ") ); strncat( to_append, buffer, strlen(buffer) ); } else { to_append = calloc( strlen(sender) + 2 + strlen(buffer) + 1, sizeof(char) ); strncpy( to_append, sender, strlen(sender)+1 );//TODO there was no +1 at first, that's not good or? (~10 lines above there was +1) strncat( to_append, ": ", strlen(": ") ); strncat( to_append, buffer, strlen(buffer) ); } gtk_text_buffer_get_end_iter( historybuffer, &end ); gtk_text_buffer_insert( historybuffer, &end, to_append, -1 ); /*scroll down*/ gtk_text_buffer_get_end_iter( historybuffer, &end ); mark = gtk_text_mark_new( NULL, FALSE ); gtk_text_buffer_add_mark( historybuffer, mark, &end ); gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(history_view), mark, 0, FALSE, 1.0, 1.0 ); return; }
static void delete_text_cb(GtkTextBuffer *textbuffer, GtkTextIter *start_pos, GtkTextIter *end_pos, gpointer user_data) { PurpleConversation *conv = (PurpleConversation *)user_data; PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv); GtkWidget *box, *counter = NULL; gchar *markup = NULL; gint service = get_service_type(conv); guint count = 0; g_return_if_fail(gtkconv != NULL); switch(service) { case twitter_service: case identica_service: case jisko_service: case ffeed_service: count= gtk_text_buffer_get_char_count(textbuffer) - (gtk_text_iter_get_offset(end_pos) - gtk_text_iter_get_offset(start_pos)); markup = g_markup_printf_escaped("<span color=\"%s\">%u</span>", count <= 140 ? "black" : "red", count); break; case wassr_service: count= gtk_text_buffer_get_char_count(textbuffer) - (gtk_text_iter_get_offset(end_pos) - gtk_text_iter_get_offset(start_pos)); markup = g_markup_printf_escaped("<span color=\"%s\">%u</span>", count <= 255 ? "black" : "red", count); break; default: twitter_debug("unknown service\n"); break; } box = gtkconv->toolbar; counter = g_object_get_data(G_OBJECT(box), PLUGIN_ID "-counter"); if(counter) gtk_label_set_markup(GTK_LABEL(counter), markup); g_free(markup); }
gsize _gtk_source_buffer_input_stream_get_total_size (GtkSourceBufferInputStream *stream) { g_return_val_if_fail (GTK_SOURCE_IS_BUFFER_INPUT_STREAM (stream), 0); if (stream->priv->buffer == NULL) { return 0; } return gtk_text_buffer_get_char_count (stream->priv->buffer); }
/* this function is designed to return a GtkTextView object's text in agxbuf send an initialized agxbuf and a GtkTextView object null termination is taken care by agxbuf */ void get_gtktextview_text(GtkTextView * w, agxbuf * xbuf) { int charcnt; GtkTextBuffer *gtkbuf; GtkTextIter startit; GtkTextIter endit; gtkbuf = gtk_text_view_get_buffer(w); charcnt = gtk_text_buffer_get_char_count(gtkbuf); gtk_text_buffer_get_start_iter(gtkbuf, &startit); gtk_text_buffer_get_end_iter(gtkbuf, &endit); agxbput(xbuf, gtk_text_buffer_get_text(gtkbuf, &startit, &endit, 0)); }
static void linphone_gtk_display_log(GtkTextView *v, OrtpLogLevel lev, const char *msg){ GtkTextIter iter,begin; int off; GtkTextBuffer *b; const char *lname="undef"; b=gtk_text_view_get_buffer(v); switch(lev){ case ORTP_DEBUG: lname="debug"; break; case ORTP_MESSAGE: lname="message"; break; case ORTP_WARNING: lname="warning"; break; case ORTP_ERROR: lname="error"; break; case ORTP_FATAL: lname="fatal"; break; default: g_error("Bad level !"); } gtk_text_buffer_get_end_iter(b,&iter); off=gtk_text_iter_get_offset(&iter); gtk_text_buffer_insert(b,&iter,lname,-1); gtk_text_buffer_get_end_iter(b,&iter); gtk_text_buffer_insert(b,&iter,": ",-1); gtk_text_buffer_get_end_iter(b,&iter); gtk_text_buffer_insert(b,&iter,msg,-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); if (lev==ORTP_ERROR || lev==ORTP_FATAL) gtk_text_buffer_apply_tag_by_name(b,"red",&begin,&iter); else if (lev==ORTP_WARNING) gtk_text_buffer_apply_tag_by_name(b,"orange",&begin,&iter); while(gtk_text_buffer_get_char_count(b)>LOG_MAX_CHARS){ GtkTextIter iter_line_after; gtk_text_buffer_get_start_iter(b,&iter); iter_line_after=iter; if (gtk_text_iter_forward_line(&iter_line_after)){ gtk_text_buffer_delete(b,&iter,&iter_line_after); } } }
void ap_assistant_finish (GtkAssistant *assistant, gpointer user_data) { AcctPeriodInfo *info = user_data; GtkTextBuffer * buffer; GtkTextIter startiter, enditer; gint len; const char *btitle; char *bnotes; Timespec closing_date; ENTER("info=%p", info); btitle = gtk_entry_get_text (GTK_ENTRY(info->book_title)); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(info->book_notes)); len = gtk_text_buffer_get_char_count (buffer); gtk_text_buffer_get_iter_at_offset(buffer, &startiter, 0); gtk_text_buffer_get_iter_at_offset(buffer, &enditer, len); bnotes = gtk_text_buffer_get_text(buffer, &startiter, &enditer , 0); PINFO("Book title is - %s\n", btitle); timespecFromTime64 (&closing_date, gnc_time64_get_day_end_gdate (&info->closing_date)); g_free(bnotes); /* Report the status back to the user. */ info->close_status = 0; /* XXX fixme success or failure? */ /* Find the next closing date ... */ info->prev_closing_date = info->closing_date; recurrenceListNextInstance (info->period, &info->prev_closing_date, &info->closing_date); /* FIXME Test for valid closing date, not sure why it won't be!!! */ if (g_date_valid(&info->closing_date) == TRUE) { /* If the next closing date is in the future, then we are done. */ if (gnc_time (NULL) > gnc_time64_get_day_end_gdate (&info->closing_date)) { /* Load up the GUI for the next closing period. */ gnc_frequency_setup_recurrence (info->period_menu, NULL, &info->closing_date); /* Jump back to the Close Book page. */ gtk_assistant_set_current_page (GTK_ASSISTANT(info->window), 1); } } }
static void vivi_command_line_append_message (ViviApplication *app, guint type, const char *message, GtkTextView *view) { GtkTextBuffer *buffer = gtk_text_view_get_buffer (view); GtkTextIter iter; GtkTextMark *mark; const char *tag_names[] = { "input", "output", "error" }; gtk_text_buffer_get_end_iter (buffer, &iter); mark = gtk_text_buffer_get_mark (buffer, "end"); if (mark == NULL) mark = gtk_text_buffer_create_mark (buffer, "end", &iter, FALSE); if (gtk_text_buffer_get_char_count (buffer) > 0) gtk_text_buffer_insert (buffer, &iter, "\n", 1); gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, message, -1, tag_names[type], NULL); gtk_text_view_scroll_to_mark (view, mark, 0.0, TRUE, 0.0, 0.0); }
static gint gail_scale_get_character_count (AtkText *text) { GtkWidget *widget; GailScale *scale; widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text)); if (widget == NULL) /* State is defunct */ return 0; scale = GAIL_SCALE (text); if (scale->textutil->buffer) return gtk_text_buffer_get_char_count (scale->textutil->buffer); else return 0; }
/* Return TRUE if the dialog box's widgets' state are such that clicking OK might not result in erroneous syntax being generated */ static gboolean contents_plausible (gpointer data) { struct compute_dialog *cd = data; GtkWidget *target = get_widget_assert (cd->xml, "compute-entry1"); GtkWidget *syntax_area = get_widget_assert (cd->xml, "compute-textview1"); GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (syntax_area)); if ( 0 == strcmp ("", gtk_entry_get_text (GTK_ENTRY (target)))) return FALSE; if ( gtk_text_buffer_get_char_count (buffer) == 0 ) return FALSE; return TRUE; }
static void update_marker_for_gtkconv(PidginConversation *gtkconv) { GtkTextIter iter; GtkTextBuffer *buffer; g_return_if_fail(gtkconv != NULL); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtkconv->imhtml)); if (!gtk_text_buffer_get_char_count(buffer)) return; gtk_text_buffer_get_end_iter(buffer, &iter); g_object_set_data(G_OBJECT(gtkconv->imhtml), "markerline", GINT_TO_POINTER(gtk_text_iter_get_offset(&iter))); gtk_widget_queue_draw(gtkconv->imhtml); }
gboolean check_event_log(gpointer user_data) { struct s_gui_data *gui_data = (struct s_gui_data *)user_data; zmq_msg_t message; int msgsize; char *strmsg; char has_msg ; zmq_msg_init(&message); has_msg = !zmq_recv(gui_data->sub_event_log, &message, ZMQ_NOBLOCK); gboolean found_msg = FALSE; while(has_msg) { found_msg = TRUE; msgsize = zmq_msg_size(&message); strmsg = (char *)malloc(msgsize); memcpy(strmsg, zmq_msg_data(&message), msgsize); GtkTextIter logIter; GtkTextMark *logMark = gtk_text_buffer_get_insert (gui_data->textbufferLog); gtk_text_buffer_get_iter_at_mark (gui_data->textbufferLog, &logIter, logMark); if (gtk_text_buffer_get_char_count(gui_data->textbufferLog)) gtk_text_buffer_insert (gui_data->textbufferLog, &logIter, "\n", 1); gtk_text_buffer_insert (gui_data->textbufferLog, &logIter, strmsg, msgsize); zmq_msg_close(&message); zmq_msg_init(&message); has_msg = !zmq_recv(gui_data->sub_event_log, &message, ZMQ_NOBLOCK); } if(found_msg != gui_data->logged_event) { gui_data->logged_event = found_msg; if(found_msg) { gtk_status_icon_set_from_pixbuf(gui_data->systrayIcon, gtk_image_get_pixbuf(gui_data->image_started_event)); } else { gtk_status_icon_set_from_pixbuf(gui_data->systrayIcon, gtk_image_get_pixbuf(gui_data->image_started)); } } if(gui_data->lstart.active) return TRUE; return FALSE; }
void context_output(int fd, const char *text, gint length) { static int last_fd = -1; GtkTextIter end; gchar *utf8; gtk_text_buffer_get_end_iter(context, &end); if (last_fd == 3 && fd != 0) gtk_text_buffer_insert(context, &end, "\n", 1); if (fd != last_fd) last_fd = fd; if (length == -1) length = strlen(text); dc_chars += length; utf8 = g_locale_to_utf8(text, length, NULL, NULL, NULL); if (utf8) { gtk_text_buffer_insert_with_tags(context, &end, utf8, -1, fd_tags[fd], NULL); g_free(utf8); } else gtk_text_buffer_insert_with_tags(context, &end, text, length, fd_tags[fd], NULL); if (dc_chars > DC_LIMIT + (DC_DELTA / 2)) { GtkTextIter start, delta; gtk_text_buffer_get_start_iter(context, &start); gtk_text_buffer_get_iter_at_offset(context, &delta, DC_DELTA); gtk_text_buffer_delete(context, &start, &delta); gtk_text_buffer_get_end_iter(context, &end); dc_chars = gtk_text_buffer_get_char_count(context); } gtk_text_buffer_place_cursor(context, &end); gtk_text_view_scroll_mark_onscreen(debug_context, gtk_text_buffer_get_insert(context)); }
// cut off the beginning lines if we have too many static void warlock_view_trim (WarlockView *view) { int size; // less than zero means unlimited if (max_buffer_size < 0) return; size = gtk_text_buffer_get_char_count (view->text_buffer); if (size > max_buffer_size) { GtkTextIter start, end; gtk_text_buffer_get_start_iter (view->text_buffer, &start); gtk_text_buffer_get_iter_at_offset (view->text_buffer, &end, size - max_buffer_size); gtk_text_buffer_delete (view->text_buffer, &start, &end); } }
static gint ev_view_accessible_get_character_count (AtkText *text) { GtkWidget *widget; GtkTextBuffer *buffer; gint retval; widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text)); if (widget == NULL) /* State is defunct */ return 0; buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget)); if (!buffer) return 0; retval = gtk_text_buffer_get_char_count (buffer); return retval; }
void clearlog (gpointer data) { gint len; #if GTK_MAJOR_VERSION == 1 len = gtk_text_get_length (GTK_TEXT (logwdw)); gtk_text_set_point (GTK_TEXT (logwdw), len); gtk_text_backward_delete (GTK_TEXT (logwdw), len); #else GtkTextBuffer * textbuf; GtkTextIter iter, iter2; textbuf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (logwdw)); len = gtk_text_buffer_get_char_count (textbuf); gtk_text_buffer_get_iter_at_offset (textbuf, &iter, 0); gtk_text_buffer_get_iter_at_offset (textbuf, &iter2, len); gtk_text_buffer_delete (textbuf, &iter, &iter2); #endif }
static void gmdb_sql_dnd_datareceived_cb( GtkWidget *w, GdkDragContext *dc, gint x, gint y, GtkSelectionData *selection_data, guint info, guint t, GladeXML *xml) { GtkTextIter iter; GtkTextBuffer *txtbuffer; GtkWidget *textview; textview = glade_xml_get_widget(xml, "sql_textview"); txtbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); if (gtk_text_buffer_get_char_count(txtbuffer)==0) { gtk_text_buffer_get_iter_at_offset (txtbuffer, &iter, 0); gtk_text_buffer_insert(txtbuffer, &iter, "select * from ", 14); } gtk_widget_grab_focus(GTK_WIDGET(textview)); }
void XAttGtk::action_text_inserted( GtkTextBuffer* w, GtkTextIter* iter, gchar* str, gint len, gpointer data) { XAttGtk* xatt = (XAttGtk*)data; int count = gtk_text_buffer_get_char_count(w); if (count > xatt->input_max_length) { // Remove inserted chars (note that iter now points at the end of the // inserted text) GtkTextIter start_iter; int offs = gtk_text_iter_get_offset(iter); gtk_text_buffer_get_iter_at_offset(w, &start_iter, offs - len); gtk_text_buffer_delete(w, &start_iter, iter); CoWowGtk wow(xatt->toplevel); wow.DisplayError("Error message", "Attribute size exceeded"); } }
void append_output(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 const char *fnt = "Courier"; #else const char *fnt = "Mono"; #endif tt = gtk_text_buffer_create_tag(text_buffer, "mono", "font", fnt, NULL); } 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); }