/*
* 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;
}
