/* Indentation with tabs */
void
gtk_text_buffer_insert_at_cursor (GtkTextBuffer *buffer,
const gchar *text,
gint len)
{
GtkTextIter iter;
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (text != NULL);
gtk_text_buffer_get_iter_at_mark (buffer,
&iter,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_insert (buffer, &iter, text, len);
}
void shoes_native_edit_box_scroll_to_end(SHOES_CONTROL_REF ref) {
GtkWidget *textview;
GTK_CHILD(textview, ref);
GtkTextIter end;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_end_iter (buffer, &end);
/* get the current ( cursor )mark name */
GtkTextMark *insert_mark = gtk_text_buffer_get_insert (buffer);
/* move mark and selection bound to the end */
gtk_text_buffer_place_cursor(buffer, &end);
/* scroll to the end view */
gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW (textview),
insert_mark, 0.0, TRUE, 0.0, 1.0);
}
static void
ensure_anchor_selected (Movement *mv)
{
GtkTextBuffer *buffer;
GtkTextMark *selection_mark;
GtkTextMark *insert_mark;
GtkTextIter anchor_begin;
GtkTextIter anchor_end;
GtkTextIter insert_iter;
GtkTextIter selection_iter;
GtkTextMark *selection_anchor_begin;
GtkTextMark *selection_anchor_end;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
selection_anchor_begin = gtk_text_buffer_get_mark (buffer, ANCHOR_BEGIN);
selection_anchor_end = gtk_text_buffer_get_mark (buffer, ANCHOR_END);
if (!selection_anchor_begin || !selection_anchor_end)
return;
gtk_text_buffer_get_iter_at_mark (buffer, &anchor_begin, selection_anchor_begin);
gtk_text_buffer_get_iter_at_mark (buffer, &anchor_end, selection_anchor_end);
insert_mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &insert_iter, insert_mark);
selection_mark = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &selection_iter, selection_mark);
if ((gtk_text_iter_compare (&selection_iter, &anchor_end) < 0) &&
(gtk_text_iter_compare (&insert_iter, &anchor_end) < 0))
{
if (gtk_text_iter_compare (&insert_iter, &selection_iter) < 0)
select_range (mv, &insert_iter, &anchor_end);
else
select_range (mv, &anchor_end, &selection_iter);
}
else if ((gtk_text_iter_compare (&selection_iter, &anchor_begin) > 0) &&
(gtk_text_iter_compare (&insert_iter, &anchor_begin) > 0))
{
if (gtk_text_iter_compare (&insert_iter, &selection_iter) < 0)
select_range (mv, &anchor_begin, &selection_iter);
else
select_range (mv, &insert_iter, &anchor_begin);
}
}
static void
gedit_document_mark_set (GtkTextBuffer *buffer,
const GtkTextIter *iter,
GtkTextMark *mark)
{
GeditDocument *doc = GEDIT_DOCUMENT (buffer);
if (GTK_TEXT_BUFFER_CLASS (gedit_document_parent_class)->mark_set != NULL)
{
GTK_TEXT_BUFFER_CLASS (gedit_document_parent_class)->mark_set (buffer, iter, mark);
}
if (mark == gtk_text_buffer_get_insert (buffer))
{
g_signal_emit (doc, document_signals[CURSOR_MOVED], 0);
}
}
static void
ide_source_view_movements_scroll (Movement *mv)
{
GtkTextBuffer *buffer;
GtkTextMark *mark;
gint count = MAX (1, mv->count);
if (mv->type == IDE_SOURCE_VIEW_MOVEMENT_SCREEN_DOWN)
count = -count;
ide_source_view_movements_scroll_by_lines (mv, count);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &mv->insert, mark);
ide_source_view_move_mark_onscreen (mv->self, mark);
}
static void
ide_source_view_movements_get_selection (Movement *mv)
{
GtkTextBuffer *buffer;
GtkTextMark *mark;
g_assert (mv);
g_assert (IDE_IS_SOURCE_VIEW (mv->self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &mv->insert, mark);
mark = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &mv->selection, mark);
}
void andsearch(GtkWidget *widget, gpointer data)
{
GtkTextBuffer *gbuffer;
GtkTextMark *mark;
GtkTextIter iter;
gchar *search_text;
char buffer[1024];
Result result;
search_text = gtk_entry_get_text(GTK_ENTRY(data));
if(strlen(search_text) <= 0)
{
return;
}
sprintf(buffer, "sa %s", (char*)search_text);
search(buffer, tok, files, cache);
gbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
mark = gtk_text_buffer_get_insert (gbuffer);
gtk_text_buffer_get_iter_at_mark (gbuffer, &iter, mark);
gtk_text_buffer_insert (gbuffer, &iter, "**** RESULTS ****\n", -1);
gtk_text_buffer_insert (gbuffer, &iter, "Query: ", -1);
gtk_text_buffer_insert (gbuffer, &iter, buffer, -1);
gtk_text_buffer_insert (gbuffer, &iter, "\n", -1);
result = files->results;
while(result != NULL)
{
if(result->frequency > 0)
{
gtk_text_buffer_insert (gbuffer, &iter, files->list[result->filenum], -1);
gtk_text_buffer_insert (gbuffer, &iter, "\n", -1);
printf("%s\n", files->list[result->filenum]);
}
result = result->next;
}
resetResults(files);
}
static void
gimp_text_style_editor_baseline_changed (GtkAdjustment *adjustment,
GimpTextStyleEditor *editor)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (editor->buffer);
GtkTextIter start, end;
if (! gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
{
gtk_text_buffer_get_iter_at_mark (buffer, &start,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_get_end_iter (buffer, &end);
}
gimp_text_buffer_set_baseline (editor->buffer, &start, &end,
gtk_adjustment_get_value (adjustment) *
PANGO_SCALE);
}
void
parasite_python_shell_append_text(ParasitePythonShell *python_shell,
const char *str,
const char *tag)
{
ParasitePythonShellPrivate *priv = python_shell->priv;
GtkTextIter end;
GtkTextBuffer *buffer =
gtk_text_view_get_buffer(GTK_TEXT_VIEW(priv->textview));
GtkTextMark *mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_move_mark(buffer, mark, &end);
gtk_text_buffer_insert_with_tags_by_name(buffer, &end, str, -1, tag, NULL);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(priv->textview), mark,
0, TRUE, 0, 1);
}
void Gobby::GotoDialog::on_show()
{
Gtk::Dialog::on_show();
m_entry_line.grab_focus();
if(m_current_view != NULL)
{
GtkTextBuffer* buffer = GTK_TEXT_BUFFER(
m_current_view->get_text_buffer());
GtkTextIter cursor;
gtk_text_buffer_get_iter_at_mark(
buffer, &cursor, gtk_text_buffer_get_insert(buffer));
m_entry_line.set_value(gtk_text_iter_get_line(&cursor) + 1);
m_entry_line.select_region(
0, m_entry_line.get_text().length());
}
}
/* Move the insert mark before popping up the menu, otherwise it
* will contain the wrong set of suggestions.
*/
static gboolean
popup_menu_event (GtkTextView *view, GeditAutomaticSpellChecker *spell)
{
GtkTextIter iter;
GtkTextBuffer *buffer;
buffer = gtk_text_view_get_buffer (view);
/* handle deferred check if it exists */
if (spell->deferred_check)
check_deferred_range (spell, TRUE);
gtk_text_buffer_get_iter_at_mark (buffer, &iter,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_move_mark (buffer, spell->mark_click, &iter);
return FALSE;
}
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;
}
static void
ide_source_view_movements_select_range (Movement *mv)
{
GtkTextBuffer *buffer;
GtkTextMark *mark;
g_assert (mv);
g_assert (IDE_IS_SOURCE_VIEW (mv->self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
if (mv->extend_selection)
gtk_text_buffer_select_range (buffer, &mv->insert, &mv->selection);
else
gtk_text_buffer_select_range (buffer, &mv->insert, &mv->insert);
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW (mv->self), mark);
}
void enter_socket_text(char * data){
app.mark = gtk_text_buffer_get_insert (app.buffer);
const gchar * text = (const gchar * )data;
gtk_text_buffer_get_iter_at_mark (app.buffer, &app.end, app.mark);
gtk_text_buffer_get_end_iter(app.buffer, &app.end);
//gtk_text_buffer_get_iter_at_line (app.buffer, &app.end, 0);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW(windowIO->textview),app.mark);
gtk_text_buffer_insert (app.buffer, &app.end, text, -1);
//gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(windowIO->textview), app.mark, 0.0, FALSE, 1.0,1.0);
}
guint
dma_sparse_view_get_location (DmaSparseView *view)
{
GtkTextMark *mark;
GtkTextBuffer *buffer;
GtkTextIter iter;
DmaSparseIter buf_iter;
gint line;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(view));
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, mark);
line = gtk_text_iter_get_line (&iter);
dma_sparse_iter_copy (&buf_iter, &view->priv->start);
dma_sparse_iter_forward_lines (&buf_iter, line);
return dma_sparse_iter_get_address (&buf_iter);
}
/*
* Count char from TextArea
* Tweet have 140 to 0 char
*
*/
void update_statusbar(GtkTextBuffer *buffer,GtkStatusbar *statusbar){
gchar *msg;
gint tot_char;
GtkTextIter iter;
/* Get message from statusbar and position */
gtk_statusbar_pop(statusbar, 0);
gtk_text_buffer_get_iter_at_mark(buffer,&iter, gtk_text_buffer_get_insert(buffer));
/*Count input char */
tot_char = 139 - gtk_text_iter_get_line_offset(&iter);
tot_char = tot_char - gtk_text_iter_get_line(&iter);
msg = g_strdup_printf("%d", tot_char+1);
/* Push numer of char to statusbar */
gtk_statusbar_push(statusbar, 0, msg);
g_free(msg);
}
/**
* gsc_utils_get_word_iter:
*
* @text_buffer: The #GtkTextBuffer
* @start_word: if != NULL then assign it the start position of the word
* @end_word: if != NULL then assing it the end position of the word
*
* Returns: the current word
*
*/
gchar *
gsc_utils_get_word_iter (GtkTextBuffer *text_buffer,
GtkTextIter *current,
GtkTextIter *start_word,
GtkTextIter *end_word)
{
gunichar ch;
gboolean no_doc_start;
if (current == NULL)
{
gtk_text_buffer_get_iter_at_mark (text_buffer,
start_word,
gtk_text_buffer_get_insert (text_buffer));
}
else
{
*start_word = *current;
}
*end_word = *start_word;
while ((no_doc_start = gtk_text_iter_backward_char (start_word)) == TRUE)
{
ch = gtk_text_iter_get_char (start_word);
if (gsc_utils_is_separator (ch))
{
break;
}
}
if (!no_doc_start)
{
gtk_text_buffer_get_start_iter (text_buffer, start_word);
return gtk_text_iter_get_text (start_word, end_word);
}
else
{
gtk_text_iter_forward_char (start_word);
return gtk_text_iter_get_text (start_word, end_word);
}
}
static void
gimp_text_tool_change_baseline (GimpTextTool *text_tool,
gdouble amount)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
GtkTextIter start;
GtkTextIter end;
if (! gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
{
gtk_text_buffer_get_iter_at_mark (buffer, &start,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_get_end_iter (buffer, &end);
}
gtk_text_iter_order (&start, &end);
gimp_text_buffer_change_baseline (text_tool->buffer, &start, &end,
amount * PANGO_SCALE);
}
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));
}
void Gobby::StatusBar::update_pos_display()
{
if(m_current_view != NULL)
{
GtkTextBuffer* buffer = GTK_TEXT_BUFFER(
m_current_view->get_text_buffer());
GtkTextIter iter;
// TODO: Use TextSessionView::get_cursor_position()?
gtk_text_buffer_get_iter_at_mark(
buffer, &iter, gtk_text_buffer_get_insert(buffer));
gint offset = gtk_text_iter_get_line_offset(&iter);
unsigned int column = 0;
const unsigned int tab_width = m_preferences.editor.tab_width;
for(gtk_text_iter_set_line_offset(&iter, 0);
gtk_text_iter_get_line_offset(&iter) < offset;
gtk_text_iter_forward_char(&iter))
{
if(gtk_text_iter_get_char(&iter) == '\t')
column += (tab_width - column % tab_width);
else
++ column;
}
// TODO: We might want to have a separate widget for the
// OVR/INS display.
m_lbl_position.set_text(
Glib::ustring::compose(
_("Ln %1, Col %2\t%3"),
gtk_text_iter_get_line(&iter) + 1,
column + 1,
gtk_text_view_get_overwrite(GTK_TEXT_VIEW(m_current_view->get_text_view())) ? _("OVR") : _("INS")
)
);
}
else
{
m_lbl_position.set_text("");
}
}
/*
* 'Search...'
*/
void av_editor_search(const av_editor *editor, const gchar *text_search)
{
GtkTextIter iter_start;
GtkTextIter iter_match_start, iter_match_end;
GtkTextSearchFlags flags_search;
gboolean found = FALSE;
g_return_if_fail(editor != NULL && editor->textbuf != NULL);
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(editor->textbuf), &iter_start);
flags_search = GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY;
found = editor_search_forward(editor,
text_search,
flags_search,
&iter_start,
NULL,
&iter_match_start,
&iter_match_end);
if (found)
{
gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(editor->textbuf), &iter_match_start);
gtk_text_buffer_move_mark_by_name (GTK_TEXT_BUFFER(editor->textbuf),
AV_EDITOR_MARK_NAME_SELECTION_BOUND,
&iter_match_end);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(editor->textview),
gtk_text_buffer_get_insert(editor->textbuf),
AV_EDITOR_VIEW_SCROLL_MARGIN,
FALSE,
AV_EDITOR_VIEW_SCROLL_XALIGN,
AV_EDITOR_VIEW_SCROLL_YALIGN);
}
else
{
// Do nothing here
AV_DBG("%s: search text: %s: not found\n", __func__, text_search);
}
}
void indent_multi_line_unindent(GtkTextBuffer *buffer)
{
GtkTextIter start_iter, end_iter, iter;
gint start_line, end_line, i, len;
gboolean pos;
gchar *ind;
gtk_text_buffer_get_selection_bounds(buffer, &start_iter, &end_iter);
start_line = gtk_text_iter_get_line(&start_iter);
end_line = gtk_text_iter_get_line(&end_iter);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, gtk_text_buffer_get_insert(buffer));
pos = gtk_text_iter_equal(&iter, &start_iter);
i = start_line;
do {
ind = compute_indentation(buffer, NULL, i);
if (ind && strlen(ind)) {
len = compute_indent_offset_length(ind);
gtk_text_buffer_get_iter_at_line(buffer, &start_iter, i);
gtk_text_buffer_place_cursor(buffer, &start_iter);
end_iter = start_iter;
gtk_text_iter_forward_chars(&end_iter, len);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &end_iter);
g_signal_emit_by_name(G_OBJECT(buffer), "begin-user-action");
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
g_signal_emit_by_name(G_OBJECT(buffer), "end-user-action");
undo_set_sequency(TRUE);
g_free(ind);
}
i++;
} while (i < end_line);
undo_set_sequency(FALSE);
gtk_text_buffer_get_iter_at_line(buffer, &start_iter, start_line);
gtk_text_buffer_get_iter_at_line(buffer, &end_iter, end_line);
if (pos) {
gtk_text_buffer_place_cursor(buffer, &end_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &start_iter);
} else {
gtk_text_buffer_place_cursor(buffer, &start_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &end_iter);
}
}
static void
ide_editor_view_request_documentation (IdeEditorView *self,
IdeSourceView *source_view)
{
g_autofree gchar *word = NULL;
IdeBuffer *buffer;
GtkTextMark *mark;
GtkTextIter iter;
g_assert (IDE_IS_EDITOR_VIEW (self));
g_assert (IDE_IS_SOURCE_VIEW (source_view));
buffer = IDE_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view)));
mark = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (buffer));
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (buffer), &iter, mark);
word = ide_buffer_get_word_at_iter (buffer, &iter);
g_signal_emit (self, signals [REQUEST_DOCUMENTATION], 0, word);
}
/* when this button is clicked, the text in entry will be inserted into textview */
static void insert_clicked( GtkButton *button, Data *data ) {
GtkTextBuffer *buffer;
GtkTextMark *mark;
GtkTextIter iter; /* it is created on stack, re-usibility. */
buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW( data->textview ) );
const gchar *text = gtk_entry_get_text( GTK_ENTRY( data->entry ) );
/*
* There are two marks that are created by default, insert and
* selection-bound.
*/
/* retrieve the mark 'insert' */
mark = gtk_text_buffer_get_insert( buffer );
/*
* Once we get the mark, we can translate it into iterator, so it can be used
* to maniputlate text buffer.
*/
gtk_text_buffer_get_iter_at_mark( buffer, &iter, mark );
gtk_text_buffer_insert( buffer, &iter, text, -1 );
gtk_entry_set_text( GTK_ENTRY( data->entry ), "" );
}
/**
* gsc_utils_view_replace_current_word:
* @text_buffer: The #GtkTextBuffer
* @text: The text to be inserted instead of the current word
*
* Replaces the current word in the #GtkTextBuffer with the new word
*
*/
void
gsc_utils_replace_current_word (GtkTextBuffer *text_buffer,
const gchar *text,
gint len)
{
GtkTextIter iter;
GtkTextMark *mark;
g_return_if_fail (GTK_IS_TEXT_BUFFER (text_buffer));
mark = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (text_buffer));
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (text_buffer),
&iter,
mark);
gsc_utils_replace_word (text_buffer,
&iter,
text,
len);
}
void goto_local_label (const gchar *l)
{
gchar *t = g_utf8_find_next_char (l, NULL);
gchar *s = g_strconcat ("<a name=\"", t, NULL);
GtkTextIter iter;
GtkTextIter match_start;
GtkTextMark *m = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER(cur_text_doc->text_buffer));
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER(cur_text_doc->text_buffer), &iter, m);
if (gtk_text_iter_forward_search (&iter, s, GTK_TEXT_SEARCH_TEXT_ONLY, &match_start, NULL, NULL))
{
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER(cur_text_doc->text_buffer), &match_start );
gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW(cur_text_doc->text_view), &match_start, 0.0, TRUE, 0.0, 0.0 );
gtk_text_view_place_cursor_onscreen (GTK_TEXT_VIEW (cur_text_doc->text_view));
}
g_free (s);
}
int update_statusbar(GtkTextBuffer *buffer, GtkStatusbar *statusbar) {
gchar *msg;
gint row, col;
GtkTextIter iter;
gtk_statusbar_pop(statusbar, 0);
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("Col %d Ln %d", col+1, row+1);
gtk_statusbar_push(statusbar, 0, msg);
g_free(msg);
return 0;
}
gboolean
peacock_file_find_and_select (PeacockFile *file, const gchar *search_str,
gboolean from_start, gboolean case_sensitive)
{
GtkTextIter start_iter;
GtkTextIter end_iter;
GtkTextIter match_start;
GtkTextIter match_end;
GtkSourceSearchFlags flags;
gboolean retval;
/* Get start iter or current cursor pos iter. */
if (from_start)
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (file),
&start_iter);
else
gtk_text_buffer_get_iter_at_mark (
GTK_TEXT_BUFFER (file), &start_iter,
gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (file)));
/* Get the end iter. */
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (file), &end_iter);
/* Setup search flags. */
flags = GTK_SOURCE_SEARCH_TEXT_ONLY;
if (!case_sensitive)
flags |= GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
/* Perform search. */
retval = gtk_source_iter_forward_search (&start_iter, search_str,
flags, &match_start,
&match_end, &end_iter);
/* It found something, highlight it. */
if (retval)
peacock_file_set_selection (PEACOCK_FILE (file), &match_start,
&match_end);
return retval;
}
static void
gimp_text_tool_backspace (GimpTextTool *text_tool)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
gimp_text_tool_reset_im_context (text_tool);
if (gtk_text_buffer_get_has_selection (buffer))
{
gtk_text_buffer_delete_selection (buffer, TRUE, TRUE);
}
else
{
GtkTextIter cursor;
gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_backspace (buffer, &cursor, TRUE, TRUE);
}
}
/*
* Get clipboard and 'Cut'
*/
void av_editor_cut_clipboard(const av_editor *editor)
{
GtkClipboard *clipboard = NULL;
g_return_if_fail(editor != NULL
&& editor->textview != NULL
&& editor->textbuf != NULL);
clipboard = gtk_widget_get_clipboard(GTK_WIDGET(editor->textview), GDK_SELECTION_CLIPBOARD);
gtk_text_buffer_cut_clipboard(editor->textbuf,
clipboard,
editor->pref.editable);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(editor->textview),
gtk_text_buffer_get_insert(editor->textbuf),
AV_EDITOR_VIEW_SCROLL_MARGIN,
FALSE,
AV_EDITOR_VIEW_SCROLL_XALIGN,
AV_EDITOR_VIEW_SCROLL_YALIGN);
}
