/* * called from debugger module to clear messages tab */ static void on_debugger_messages_clear () { /* clear debug messages window */ GtkTextIter start, end; GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(debugger_messages_textview)); gtk_text_buffer_get_bounds(buffer, &start, &end); gtk_text_buffer_delete(buffer, &start, &end); }
static void help_window_load_text(GtkWidget *text, const gchar *path) { gchar *pathl; FILE *f; gchar s_buf[1024]; GtkTextBuffer *buffer; GtkTextIter iter; GtkTextIter start, end; if (!text || !path) return; buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)); gtk_text_buffer_get_bounds(buffer, &start, &end); gtk_text_buffer_delete(buffer, &start, &end); gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0); pathl = path_from_utf8(path); f = fopen(pathl, "r"); g_free(pathl); if (!f) { gchar *buf; buf = g_strdup_printf(_("Unable to load:\n%s"), path); gtk_text_buffer_insert(buffer, &iter, buf, -1); g_free(buf); } else { while (fgets(s_buf, sizeof(s_buf), f)) { gchar *buf; gint l; l = strlen(s_buf); if (!g_utf8_validate(s_buf, l, NULL)) { buf = g_locale_to_utf8(s_buf, l, NULL, NULL, NULL); if (!buf) buf = g_strdup("\n"); } else { buf = NULL; } gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, (buf) ? buf : s_buf, -1, "monospace", NULL); g_free(buf); } fclose(f); } gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0); gtk_text_buffer_place_cursor(buffer, &iter); gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(text), &iter, 0.0, TRUE, 0, 0); }
/** * gtkspell_new_attach: * @view: The #GtkTextView to attach to. * @lang: The language to use, in a form pspell understands (it appears to * be a locale specifier?). * @error: Return location for error. * * Create a new #GtkSpell object attached to @view with language @lang. * * Returns: a new #GtkSpell object, or %NULL on error. */ GtkSpell* gtkspell_new_attach(GtkTextView *view, const gchar *lang, GError **error) { GtkTextBuffer *buffer; GtkTextIter start, end; GtkSpell *spell; if (error) g_return_val_if_fail(*error == NULL, NULL); spell = g_object_get_data(G_OBJECT(view), GTKSPELL_OBJECT_KEY); g_assert(spell == NULL); /* attach to the widget */ spell = g_new0(GtkSpell, 1); spell->view = view; if (!gtkspell_set_language_internal(spell, lang, error)) { g_free(spell); return NULL; } g_object_set_data(G_OBJECT(view), GTKSPELL_OBJECT_KEY, spell); g_signal_connect_swapped(G_OBJECT(view), "destroy", G_CALLBACK(gtkspell_free), spell); g_signal_connect(G_OBJECT(view), "button-press-event", G_CALLBACK(button_press_event), spell); g_signal_connect(G_OBJECT(view), "populate-popup", G_CALLBACK(populate_popup), spell); buffer = gtk_text_view_get_buffer(view); g_signal_connect(G_OBJECT(buffer), "insert-text", G_CALLBACK(insert_text_before), spell); g_signal_connect_after(G_OBJECT(buffer), "insert-text", G_CALLBACK(insert_text_after), spell); g_signal_connect_after(G_OBJECT(buffer), "delete-range", G_CALLBACK(delete_range_after), spell); spell->tag_highlight = gtk_text_buffer_create_tag(buffer, "gtkspell-misspelled", "foreground", "red", "underline", PANGO_UNDERLINE_SINGLE, NULL); /* we create the mark here, but we don't use it until text is * inserted, so we don't really care where iter points. */ gtk_text_buffer_get_bounds(buffer, &start, &end); spell->mark_insert = gtk_text_buffer_create_mark(buffer, "gtkspell-insert", &start, TRUE); /* now check the entire text buffer. */ gtkspell_recheck_all(spell); return spell; }
static void mousepad_util_search_get_iters (GtkTextBuffer *buffer, MousepadSearchFlags flags, GtkTextIter *start, GtkTextIter *end, GtkTextIter *iter) { GtkTextIter sel_start, sel_end, tmp; /* get selection bounds */ gtk_text_buffer_get_selection_bounds (buffer, &sel_start, &sel_end); if (flags & MOUSEPAD_SEARCH_FLAGS_AREA_DOCUMENT) { /* get document bounds */ gtk_text_buffer_get_bounds (buffer, start, end); /* set the start iter */ if (flags & MOUSEPAD_SEARCH_FLAGS_ITER_AREA_START) *iter = *start; else if (flags & MOUSEPAD_SEARCH_FLAGS_ITER_AREA_END) *iter = *end; else goto set_selection_iter; } else if (flags & MOUSEPAD_SEARCH_FLAGS_AREA_SELECTION) { /* set area iters */ *start = sel_start; *end = sel_end; set_selection_iter: /* set the start iter */ if (flags & (MOUSEPAD_SEARCH_FLAGS_ITER_AREA_START | MOUSEPAD_SEARCH_FLAGS_ITER_SEL_START)) *iter = sel_start; else if (flags & (MOUSEPAD_SEARCH_FLAGS_ITER_AREA_END | MOUSEPAD_SEARCH_FLAGS_ITER_SEL_END)) *iter = sel_end; else g_assert_not_reached (); } else { /* this should never happen */ g_assert_not_reached (); } /* invert the start and end iter on backwards searching */ if (flags & MOUSEPAD_SEARCH_FLAGS_DIR_BACKWARD) { tmp = *start; *start = *end; *end = tmp; /* when searching backwards, we need to start before the selection */ gtk_text_iter_backward_char (iter); } }
/** * sync_entry: * * Writes the information stored in the GtkTextBuffer to the * entry structure in memory. To be called whenever a page is * leaved, or saved. */ void sync_entry (void) { static GtkTextIter s, e; gtk_text_buffer_get_bounds (entryBuf, &s, &e); grg_entries_set_Body (gtk_text_buffer_get_text (entryBuf, &s, &e, FALSE)); }
static void remove_all_marks (GtkSourceBuffer *buffer) { GtkTextIter start; GtkTextIter end; gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (buffer), &start, &end); gtk_source_buffer_remove_source_marks (buffer, &start, &end, NULL); }
void tree_selection_changed_cb(GtkTreeSelection * selection, gpointer data) { GtkTreeIter iter; GtkTreeModel * model; GtkTextBuffer * buffer; GtkTextIter a_iter, b_iter; buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(comment_view)); gtk_text_buffer_get_bounds(buffer, &a_iter, &b_iter); gtk_text_buffer_delete(buffer, &a_iter, &b_iter); gtk_label_set_text(GTK_LABEL(statusbar_ms), ""); if (gtk_tree_selection_get_selected(selection, &model, &iter)) { switch (iter_get_store_type(&iter)) { case STORE_TYPE_FILE: if (options.enable_mstore_toolbar) { store_file_set_toolbar_sensitivity(&iter, toolbar_edit_button, toolbar_add_button, toolbar_remove_button); } store_file_selection_changed(&iter, buffer, GTK_LABEL(statusbar_ms)); break; #ifdef HAVE_CDDA case STORE_TYPE_CDDA: if (options.enable_mstore_toolbar) { gtk_widget_set_sensitive(toolbar_edit_button, FALSE); gtk_widget_set_sensitive(toolbar_add_button, FALSE); gtk_widget_set_sensitive(toolbar_remove_button, FALSE); } store_cdda_selection_changed(&iter, buffer, GTK_LABEL(statusbar_ms)); break; #endif /* HAVE_CDDA */ #ifdef HAVE_PODCAST case STORE_TYPE_PODCAST: if (options.enable_mstore_toolbar) { store_podcast_set_toolbar_sensitivity(&iter, toolbar_edit_button, toolbar_add_button, toolbar_remove_button); } store_podcast_selection_changed(&iter, buffer, GTK_LABEL(statusbar_ms)); break; #endif /* HAVE_PODCAST */ } } }
static gchar * get_buffer_contents (GtkTextBuffer *buffer) { GtkTextIter start; GtkTextIter end; gtk_text_buffer_get_bounds (buffer, &start, &end); return gtk_text_iter_get_visible_text (&start, &end); }
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 ide_lsp_formatter_format_async (IdeFormatter *formatter, IdeBuffer *buffer, IdeFormatterOptions *options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { IdeLspFormatter *self = (IdeLspFormatter *)formatter; IdeLspFormatterPrivate *priv = ide_lsp_formatter_get_instance_private (self); g_autoptr(GVariant) params = NULL; g_autoptr(IdeTask) task = NULL; g_autofree gchar *uri = NULL; g_autofree gchar *text = NULL; GtkTextIter begin; GtkTextIter end; gint64 version; gint tab_size; gboolean insert_spaces; g_assert (IDE_IS_LSP_FORMATTER (self)); g_assert (!cancellable || G_IS_CANCELLABLE (cancellable)); task = ide_task_new (self, cancellable, callback, user_data); ide_task_set_source_tag (task, ide_lsp_formatter_format_async); ide_task_set_task_data (task, g_object_ref (buffer), g_object_unref); gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (buffer), &begin, &end); gtk_text_iter_order (&begin, &end); version = ide_buffer_get_change_count (buffer); uri = ide_buffer_dup_uri (buffer); text = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (buffer), &begin, &end, TRUE); tab_size = ide_formatter_options_get_tab_width (options); insert_spaces = ide_formatter_options_get_insert_spaces (options); params = JSONRPC_MESSAGE_NEW ( "textDocument", "{", "uri", JSONRPC_MESSAGE_PUT_STRING (uri), "text", JSONRPC_MESSAGE_PUT_STRING (text), "version", JSONRPC_MESSAGE_PUT_INT64 (version), "}", "options", "{", "tabSize", JSONRPC_MESSAGE_PUT_INT32 (tab_size), "insertSpaces", JSONRPC_MESSAGE_PUT_BOOLEAN (insert_spaces), "}" ); ide_lsp_client_call_async (priv->client, "textDocument/formatting", params, cancellable, ide_lsp_formatter_format_call_cb, g_steal_pointer (&task)); }
/** * Print the current contents of a text buffer. * @param buffer text buffer to print information about */ void mk_print_GtkTextBuffer_info(GtkTextBuffer* buffer) { GtkTextIter start; GtkTextIter end; gtk_text_buffer_get_bounds(buffer, &start, &end); const gchar* text = gtk_text_buffer_get_text(buffer, &start, &end, 0); gint lines = gtk_text_buffer_get_line_count(buffer); g_printf("\t%d\n%s", lines, text); }
char * go_math_editor_get_itex (GoMathEditor const *gme) { GtkTextIter start; GtkTextIter end; g_return_val_if_fail (GO_IS_MATH_EDITOR (gme), NULL); gtk_text_buffer_get_bounds (gme->itex, &start, &end); return gtk_text_buffer_get_text (gme->itex, &start, &end, TRUE); }
void MultilineOptionView::onValueChanged() { ZLMultilineOptionEntry &o = (ZLMultilineOptionEntry&)*myOption; if (o.useOnValueEdited()) { GtkTextIter start, end; gtk_text_buffer_get_bounds(myTextBuffer, &start, &end); gchar *value = gtk_text_buffer_get_text(myTextBuffer, &start, &end, true); o.onValueEdited(value); g_free(value); } }
/* return new string and clones the string passed to it */ gchar * gui_editor_get_text (GUIEditor * self) { g_assert (self); GtkTextIter *start = g_malloc0 (sizeof (GtkTextIter)); GtkTextIter *end = g_malloc0 (sizeof (GtkTextIter)); gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER(self->buffer), start, end); return gtk_text_buffer_get_text(GTK_TEXT_BUFFER(self->buffer),start,end,FALSE); }
void utl_gui_clear_text_buffer (GtkTextBuffer *buffer, GtkTextIter *iter) { GtkTextIter iter_s, iter_e; gtk_text_buffer_get_bounds (buffer, &iter_s, &iter_e); gtk_text_buffer_delete (buffer, &iter_s, &iter_e); if (iter != NULL) gtk_text_buffer_get_iter_at_offset (buffer, iter, 0); }
/** * gstyle_palette_new_from_buffer: * @buffer: a #GtkTextBUffer * @begin: (nullable): a begin #GtkTextIter * @end: (nullable): a end #GtkTextIter * @cancellable: A #GCancellable * @error: (nullable): a #GError location or %NULL * * Create a new #GstylePalette from a text buffer. * if @begin is %NULL, the buffer start iter is used. * if @end is %NULL, the buffer end is used. * * Returns: A #GstylePalette or %NULL if an error occur. */ GstylePalette * gstyle_palette_new_from_buffer (GtkTextBuffer *buffer, GtkTextIter *begin, GtkTextIter *end, GCancellable *cancellable, GError **error) { g_autofree gchar *text = NULL; GstylePalette *palette = NULL; g_autofree gchar *name = NULL; GtkTextIter real_begin, real_end; GtkTextIter buffer_begin, buffer_end; GstyleColorItem *item; GstyleColor *color; GPtrArray *items; GError *tmp_error = NULL; g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL); g_return_val_if_fail (begin == NULL || gtk_text_iter_get_buffer (begin) == buffer, NULL); g_return_val_if_fail (end == NULL || gtk_text_iter_get_buffer (end) == buffer, NULL); gtk_text_buffer_get_bounds (buffer, &buffer_begin, &buffer_end); real_begin = (begin == NULL) ? buffer_begin : *begin; real_end = (end == NULL) ? buffer_end : *end; text = gtk_text_buffer_get_slice (buffer, &real_begin, &real_end, FALSE); items = gstyle_color_parse (text); if (items == NULL) { g_set_error (error, GSTYLE_PALETTE_ERROR, GSTYLE_PALETTE_ERROR_PARSE, _("failed to parse\n")); return NULL; } if (items->len > 0) { /* To translators: always in singular form like in: generated palette number <generated_count> */ name = g_strdup_printf ("%s %i", _("Generated"), ++generated_count); palette = g_object_new (GSTYLE_TYPE_PALETTE, "id", NULL, "name", name, "file", NULL, NULL); for (gint i = 0; i < items->len; ++i) { item = g_ptr_array_index (items, i); color = (GstyleColor *)gstyle_color_item_get_color (item); gstyle_palette_add (palette, color, &tmp_error); } } g_ptr_array_free (items, TRUE); return palette; }
void error_console_select_all_cmd_callback (GtkAction *action, gpointer data) { GimpErrorConsole *console = GIMP_ERROR_CONSOLE (data); GtkTextIter start_iter; GtkTextIter end_iter; gtk_text_buffer_get_bounds (console->text_buffer, &start_iter, &end_iter); gtk_text_buffer_select_range (console->text_buffer, &start_iter, &end_iter); }
/** * gtkspell_recheck_all: * @spell: The #GtkSpell object. * * Recheck the spelling in the entire buffer. */ void gtkspell_recheck_all(GtkSpell *spell) { GtkTextBuffer *buffer; GtkTextIter start, end; buffer = gtk_text_view_get_buffer(spell->view); gtk_text_buffer_get_bounds(buffer, &start, &end); check_range(spell, buffer, start, end); }
/* * 'Select All' */ void av_editor_selectall(const av_editor *editor) { GtkTextIter start, end; g_return_if_fail(editor != NULL && editor->textview != NULL && editor->textbuf != NULL); gtk_text_buffer_get_bounds(editor->textbuf, &start, &end); gtk_text_buffer_select_range(editor->textbuf, &start, &end); }
void gedit_automatic_spell_checker_recheck_all (GeditAutomaticSpellChecker *spell) { GtkTextIter start, end; g_return_if_fail (spell != NULL); gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (spell->doc), &start, &end); check_range (spell, start, end, TRUE); }
static void chat_text_view_highlight (EmpathyChatView *view, const gchar *text, gboolean match_case) { GtkTextBuffer *buffer; GtkTextIter iter; GtkTextIter iter_start; GtkTextIter iter_end; GtkTextIter iter_match_start; GtkTextIter iter_match_end; gboolean found; g_return_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view)); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)); gtk_text_buffer_get_start_iter (buffer, &iter); gtk_text_buffer_get_bounds (buffer, &iter_start, &iter_end); gtk_text_buffer_remove_tag_by_name (buffer, EMPATHY_CHAT_TEXT_VIEW_TAG_HIGHLIGHT, &iter_start, &iter_end); if (EMP_STR_EMPTY (text)) { return; } while (1) { if (match_case) { found = gtk_text_iter_forward_search (&iter, text, 0, &iter_match_start, &iter_match_end, NULL); } else { found = empathy_text_iter_forward_search (&iter, text, &iter_match_start, &iter_match_end, NULL); } if (!found) { break; } gtk_text_buffer_apply_tag_by_name (buffer, EMPATHY_CHAT_TEXT_VIEW_TAG_HIGHLIGHT, &iter_match_start, &iter_match_end); iter = iter_match_end; } }
char *getTextViewText(GtkWidget *object) { GtkTextIter start, end; GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(object)); char *text; gtk_text_buffer_get_bounds (buffer, &start, &end); text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE); return text; }
static void preset_desc_callback (GtkTextBuffer *buffer, gpointer data) { char *str; GtkTextIter start, end; gtk_text_buffer_get_bounds (buffer, &start, &end); str = gtk_text_buffer_get_text (buffer, &start, &end, FALSE); g_strlcpy (presetdesc, str, sizeof (presetdesc)); g_free (str); }
gchar * ag_chart_edit_get_note(AgChartEdit *chart_edit) { GET_PRIV(chart_edit); GtkTextIter start_iter, end_iter; gtk_text_buffer_get_bounds(priv->note_buffer, &start_iter, &end_iter); return gtk_text_buffer_get_text(priv->note_buffer, &start_iter, &end_iter, TRUE); }
void text_tool_clear_cmd_callback (GtkAction *action, gpointer data) { GimpTextTool *text_tool = GIMP_TEXT_TOOL (data); GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer); GtkTextIter start, end; gtk_text_buffer_get_bounds (buffer, &start, &end); gtk_text_buffer_select_range (buffer, &start, &end); gimp_text_tool_delete_selection (text_tool); }
static void gbp_line_spacing_buffer_addin_apply (GbpLineSpacingBufferAddin *self) { GtkTextIter begin; GtkTextIter end; g_assert (IDE_IS_BUFFER (self->buffer)); g_assert (GTK_IS_TEXT_TAG (self->tag)); gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (self->buffer), &begin, &end); gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (self->buffer), self->tag, &begin, &end); }
void cb_close (GtkWidget *p_widget, gpointer user_data) { /* Avant de fermer, il faut verifier qu'un document a bien ete ouvert */ if (docs.actif) { if (!docs.actif->sauve) { GtkWidget *dialog; GtkWidget *p_label; dialog = gtk_dialog_new_with_buttons ("Sauvegarder", docs.main_window, GTK_DIALOG_MODAL, GTK_STOCK_YES, GTK_RESPONSE_YES, GTK_STOCK_NO, GTK_RESPONSE_NO, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); p_label = gtk_label_new ("Voulez-vous sauvegarder les modifications ?"); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), p_label, TRUE, TRUE, 0); gtk_widget_show_all (GTK_DIALOG (dialog)->vbox); switch (gtk_dialog_run (GTK_DIALOG (dialog))) { case GTK_RESPONSE_YES: cb_save (p_widget, user_data); break; case GTK_RESPONSE_NO: break; case GTK_RESPONSE_CANCEL: gtk_widget_destroy (dialog); break; } gtk_widget_destroy (dialog); } { GtkTextIter start; GtkTextIter end; GtkTextBuffer *text_buffer; text_buffer = gtk_text_view_get_buffer (docs.actif->text_view); gtk_text_buffer_get_bounds (text_buffer, &start, &end); gtk_text_buffer_delete (text_buffer, &start, &end); gtk_widget_set_sensitive (GTK_WIDGET (docs.actif->text_view), FALSE); g_free (docs.actif->path), docs.actif->path = NULL; docs.actif->text_view = NULL; g_free (docs.actif), docs.actif = NULL; } } else print_warning ("Aucun document ouvert"); /* Parametres inutilises */ (void)p_widget; (void)user_data; }
void clear_text_buffer() { GtkTextIter start, end; LOG(LOG_DEBUG, "IN : clear_text_buffer()"); gtk_text_buffer_get_bounds (text_buffer, &start, &end); gtk_text_buffer_delete(text_buffer, &start, &end); clear_link(); LOG(LOG_DEBUG, "OUT : clear_text_buffer()"); }
static void mesg_body_callback (GtkTextBuffer *buffer, gpointer data) { GtkTextIter start_iter; GtkTextIter end_iter; gtk_text_buffer_get_bounds (buffer, &start_iter, &end_iter); g_free (mesg_body); mesg_body = gtk_text_buffer_get_text (buffer, &start_iter, &end_iter, FALSE); }
static void cb_changed(GtkTextBuffer *buffer) { GtkTextIter start, end; gtk_text_buffer_get_bounds(buffer, &start, &end); // gtk_text_buffer_remove_tag_by_name(buffer, // "searched", &start, &end); gtk_text_buffer_remove_all_tags(buffer, &start, &end); g_signal_handlers_block_by_func(G_OBJECT(buffer), G_CALLBACK(cb_changed), NULL); searched_flag = FALSE; }