void gglk_text_update_scrollmark(GglkText *tb)
{
GtkTextIter olditer, pastiter, iter;
gtk_text_buffer_get_iter_at_mark(tb->buffer, &olditer, tb->scrollmark);
gtk_text_buffer_get_end_iter(tb->buffer, &iter);
gtk_text_buffer_move_mark(tb->buffer, tb->scrollmark, &iter);
gtk_text_view_move_mark_onscreen(GTK_TEXT_VIEW(tb),
tb->scrollmark);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &pastiter, tb->scrollmark);
iter = pastiter;
gtk_text_view_backward_display_line(GTK_TEXT_VIEW(tb), &iter);
/* If we're trying to scroll down, but the backward_display_line
made us fail, undo that. */
if(gtk_text_iter_compare(&pastiter, &olditer) >= 0 &&
gtk_text_iter_compare(&iter, &olditer) <= 0) {
iter = pastiter;
gtk_text_view_forward_display_line(GTK_TEXT_VIEW(tb), &iter);
}
gtk_text_buffer_move_mark(tb->buffer, tb->scrollmark, &iter);
}
static void
select_range (Movement *mv,
GtkTextIter *insert_iter,
GtkTextIter *selection_iter)
{
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextMark *selection;
gint insert_off;
gint selection_off;
g_assert (insert_iter);
g_assert (selection_iter);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
insert = gtk_text_buffer_get_insert (buffer);
selection = gtk_text_buffer_get_selection_bound (buffer);
mv->ignore_select = TRUE;
/*
* If the caller is requesting that we select a single character, we will
* keep the iter before that character. This more closely matches the visual
* mode in VIM.
*/
insert_off = gtk_text_iter_get_offset (insert_iter);
selection_off = gtk_text_iter_get_offset (selection_iter);
if ((insert_off - selection_off) == 1)
gtk_text_iter_order (insert_iter, selection_iter);
gtk_text_buffer_move_mark (buffer, insert, insert_iter);
gtk_text_buffer_move_mark (buffer, selection, selection_iter);
}
/* Set length to a positive number to enable line input; set to 0 to disable */
void gglk_text_line_input_set(GglkText *tb, int length,
const gunichar *text)
{
GtkTextIter b, e;
gchar *line_utf8;
if(tb->line_maxlen != 0) {
gglk_text_line_input_end(tb);
/* Clear out old text there */
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &e, tb->endedit);
gtk_text_buffer_delete(tb->buffer, &b, &e);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &tb->iter, tb->startedit);
}
tb->line_maxlen = length;
if(length == 0) {
gglk_text_line_input_end(tb);
return;
}
/* Add new text */
gtk_text_buffer_get_end_iter(tb->buffer, &b);
gtk_text_buffer_move_mark(tb->buffer, tb->startedit, &b);
line_utf8 = g_ucs4_to_utf8(text, -1, NULL, NULL, NULL);
gtk_text_buffer_insert(tb->buffer, &b, line_utf8, -1);
g_free(line_utf8);
/* Extra character at end to maintain editability */
gtk_text_buffer_get_end_iter(tb->buffer, &e);
gtk_text_buffer_insert(tb->buffer, &e, " ", -1);
/* Make editable */
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "Input", &b, &e);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "editable", &b, &e);
/* Set end mark */
gtk_text_iter_backward_char(&e);
gtk_text_buffer_move_mark(tb->buffer, tb->endedit, &e);
gtk_text_buffer_place_cursor(tb->buffer, &e);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(tb), tb->endedit, 0,FALSE,0,0);
/* Add signals to handle user interaction */
tb->cursor_handler = g_signal_connect(
tb->buffer, "mark-set",
GTK_SIGNAL_FUNC(gglk_text_cursor_event), tb);
tb->update_handler = g_signal_connect(
tb->buffer, "end-user-action",
GTK_SIGNAL_FUNC(gglk_text_update_editable_region), tb);
}
static void
update_current (GeditDocument *doc,
gint current)
{
CheckRange *range;
GtkTextIter iter;
GtkTextIter end_iter;
gedit_debug (DEBUG_PLUGINS);
g_return_if_fail (doc != NULL);
g_return_if_fail (current >= 0);
range = get_check_range (doc);
g_return_if_fail (range != NULL);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc),
&iter, current);
if (!gtk_text_iter_inside_word (&iter))
{
/* if we're not inside a word,
* we must be in some spaces.
* skip forward to the beginning of the next word. */
if (!gtk_text_iter_is_end (&iter))
{
gtk_text_iter_forward_word_end (&iter);
gtk_text_iter_backward_word_start (&iter);
}
}
else
{
if (!gtk_text_iter_starts_word (&iter))
gtk_text_iter_backward_word_start (&iter);
}
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
&end_iter,
range->end_mark);
if (gtk_text_iter_compare (&end_iter, &iter) < 0)
{
gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (doc),
range->current_mark,
&end_iter);
}
else
{
gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (doc),
range->current_mark,
&iter);
}
}
/* It is recommended to use this function with 2.4 and up. For
* earlier versions, we define it ourselves.
*/
void
gtk_text_buffer_select_range (GtkTextBuffer *text_buffer,
GtkTextIter *insertion_iterator,
GtkTextIter *bound_iterator)
{
gtk_text_buffer_move_mark (text_buffer,
gtk_text_buffer_get_insert (text_buffer),
insertion_iterator);
gtk_text_buffer_move_mark (text_buffer,
gtk_text_buffer_get_selection_bound (text_buffer),
bound_iterator);
}
static void
ide_highlight_engine_reload (IdeHighlightEngine *self)
{
GtkTextBuffer *buffer;
GtkTextIter begin;
GtkTextIter end;
GSList *iter;
IDE_ENTRY;
g_assert (IDE_IS_HIGHLIGHT_ENGINE (self));
if (self->work_timeout != 0)
{
g_source_remove (self->work_timeout);
self->work_timeout = 0;
}
if (self->buffer == NULL)
IDE_EXIT;
buffer = GTK_TEXT_BUFFER (self->buffer);
gtk_text_buffer_get_bounds (buffer, &begin, &end);
/*
* Invalidate the whole buffer.
*/
gtk_text_buffer_move_mark (buffer, self->invalid_begin, &begin);
gtk_text_buffer_move_mark (buffer, self->invalid_end, &end);
/*
* Remove our highlight tags from the buffer.
*/
for (iter = self->private_tags; iter; iter = iter->next)
gtk_text_buffer_remove_tag (buffer, iter->data, &begin, &end);
g_clear_pointer (&self->private_tags, g_slist_free);
for (iter = self->public_tags; iter; iter = iter->next)
gtk_text_buffer_remove_tag (buffer, iter->data, &begin, &end);
g_clear_pointer (&self->public_tags, g_slist_free);
if (self->highlighter == NULL)
IDE_EXIT;
ide_highlight_engine_queue_work (self);
IDE_EXIT;
}
void gglk_text_clear(GglkText *tb)
{
glui32 linkval = tb->hyperval;
gglk_text_set_hyperlink(tb, 0);
g_signal_emit(tb, gglk_text_signals[CLEAR_SIGNAL], 0);
gtk_text_buffer_get_start_iter(tb->buffer, &tb->iter);
gtk_text_buffer_place_cursor(tb->buffer, &tb->iter);
gtk_text_buffer_move_mark(tb->buffer, tb->scrollmark, &tb->iter);
gtk_text_buffer_move_mark(tb->buffer, tb->endmark, &tb->iter);
gtk_text_buffer_move_mark(tb->buffer, tb->hypermark, &tb->iter);
gglk_text_set_hyperlink(tb, linkval);
}
void Amt::LoggerImpl::insertLine(const char* _ctime, const char* _mess, unsigned _type, bool newString ){
if (_type >= riku::logger::NUM_ERR_MESS_TYPE )
return;
if (!_in_textbuffer || !_in_textview)
return;
GtkTextIter iter;
/*Добавим новое сообщение*/
gtk_text_buffer_get_end_iter (_in_textbuffer, &iter );
gtk_text_buffer_insert_with_tags ( _in_textbuffer, &iter, _ctime, -1, _in_tagArr[_type], NULL );
gtk_text_buffer_insert ( _in_textbuffer, &iter, " ", -1 );
gtk_text_buffer_insert_with_tags(_in_textbuffer, &iter, _mess, -1, _in_tagArr[_type], NULL );
if (newString)
gtk_text_buffer_insert(_in_textbuffer, &iter, "\n", -1);
/*Передвинем маркер скроллинга, и прокрутим список*/
GtkTextMark *mark = gtk_text_buffer_get_mark (_in_textbuffer, "scroll");
gtk_text_buffer_move_mark (_in_textbuffer, mark, &iter);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW(_in_textview), mark);
/*Удалим записи, если их стало больше чем maxLines*/
if (_in_maxLines < gtk_text_buffer_get_line_count(_in_textbuffer) ){
GtkTextIter startI, endI;
gtk_text_buffer_get_iter_at_line(_in_textbuffer, &endI, 9);
gtk_text_buffer_get_iter_at_line(_in_textbuffer, &startI, 9);
gtk_text_iter_forward_line(&endI );
gtk_text_buffer_delete(_in_textbuffer, &startI, &endI);
}
}
/* When the user right-clicks on a word, they want to check that word.
* Here, we do NOT move the cursor to the location of the clicked-upon word
* since that prevents the use of edit functions on the context menu.
*/
static gboolean
button_press_event (GtkTextView *view,
GdkEventButton *event,
GeditAutomaticSpellChecker *spell)
{
if (event->button == GDK_BUTTON_SECONDARY)
{
gint x, y;
GtkTextIter iter;
GtkTextBuffer *buffer = gtk_text_view_get_buffer (view);
/* handle deferred check if it exists */
if (spell->deferred_check)
check_deferred_range (spell, TRUE);
gtk_text_view_window_to_buffer_coords (view,
GTK_TEXT_WINDOW_TEXT,
event->x, event->y,
&x, &y);
gtk_text_view_get_iter_at_location (view, &iter, x, y);
gtk_text_buffer_move_mark (buffer, spell->mark_click, &iter);
}
return FALSE; /* false: let gtk process this event, too.
we don't want to eat any events. */
}
void gglk_text_set_hyperlink(GglkText *tb, glui32 linkval)
{
if(tb->hyperval == linkval)
return;
if(tb->hyperval) {
GtkTextTag *hypertag;
GtkTextIter iter;
hypertag = gtk_text_buffer_create_tag(tb->buffer, NULL, NULL);
g_signal_connect(hypertag, "event",
G_CALLBACK(gglk_text_mouse),
GINT_TO_POINTER(tb->hyperval));
/* compensate for GTK not sending through click on images if they're
not followed by text */
iter = tb->iter;
gtk_text_iter_backward_char(&iter);
if(gtk_text_iter_get_pixbuf(&iter)) {
const gunichar space = ' ';
gglk_text_put_buffer(tb, &space, 1);
}
gtk_text_buffer_get_iter_at_mark(tb->buffer, &iter, tb->hypermark);
gtk_text_buffer_apply_tag(tb->buffer, hypertag, &iter, &tb->iter);
gtk_text_buffer_apply_tag_by_name(tb->buffer,
gglk_get_tag(style_Hyperlinks),
&iter, &tb->iter);
}
tb->hyperval = linkval;
if(linkval) {
gtk_text_buffer_move_mark(tb->buffer, tb->hypermark, &tb->iter);
}
}
gint
add_text(gpointer data)
{
GtkTextBuffer *text_buffer = gtk_text_view_get_buffer(
GTK_TEXT_VIEW(text_view));
GtkTextIter text_iter;
gtk_text_buffer_get_end_iter(text_buffer, &text_iter);
if (count == 0) {
gtk_text_buffer_insert(text_buffer, &text_iter, "First line\n", -1);
}
else if (count % 5 == 0) {
gtk_text_buffer_insert(text_buffer, &text_iter, "world\n", -1);
}
else {
gtk_text_buffer_insert(text_buffer, &text_iter, "hello\n", -1);
}
count++;
/* - - DOES NOT WORK LIKE I EXPECT */
GtkTextMark *mark = gtk_text_buffer_get_insert(text_buffer);
gtk_text_buffer_move_mark(text_buffer, mark, &text_iter);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(text_view), mark, 0.0,
FALSE, 0, 0);
/* - - */
return TRUE;
}
static void gglk_text_update_editable_region(GtkTextBuffer *unused_widget,
gpointer user_data)
{
GglkText *tb = user_data;
GtkTextIter b, e;
gboolean fixup = FALSE;
gtk_text_buffer_get_iter_at_mark(tb->buffer, &e, tb->endedit);
if(gtk_text_iter_is_end(&e)) { /* deleted the end bit; add it back */
fixup = TRUE;
} else {
gtk_text_iter_forward_char(&e);
if(!gtk_text_iter_is_end(&e)) { /* user pasted extra stuff at end */
fixup = TRUE;
}
}
if(fixup) {
gtk_text_buffer_get_end_iter(tb->buffer, &e);
gtk_text_buffer_insert(tb->buffer, &e, " ", -1);
gtk_text_iter_backward_char(&e);
gtk_text_buffer_move_mark(tb->buffer, tb->endedit, &e);
}
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_get_end_iter(tb->buffer, &e);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "Input", &b, &e);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "editable", &b, &e);
gtk_text_buffer_get_end_iter(tb->buffer, &tb->iter);
}
void scroll_to_the_end(struct text_view_info *viewinfo){
GtkTextIter end;
gtk_text_buffer_get_end_iter(viewinfo->view1_buffer,&end);
GtkTextMark *mark=gtk_text_buffer_create_mark(viewinfo->view1_buffer,NULL,&end,1);
gtk_text_buffer_move_mark(viewinfo->view1_buffer,mark,&end);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(viewinfo->view1),mark,0,1,1,1);
}
/* Trap mark movement events in a Text, so that if line input is
in progress, the user can use C-a or C-e to move to the beginning /
end of the line input, not the beginning / end of the current line */
static void gglk_text_cursor_event(GtkTextBuffer *unused_widget,
GtkTextIter *unused_iter,
GtkTextMark *unused_mark,
gpointer user_data)
{
GglkText *tb = user_data;
GtkTextIter b, e;
int i;
gboolean moved[2] = { FALSE, FALSE };
g_signal_handler_block(tb->buffer, tb->cursor_handler);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &e, tb->endedit);
for(i = 0; i < 2; i++) {
GtkTextMark *this_mark = gtk_text_buffer_get_mark(
tb->buffer, i ? "selection_bound" : "insert");
GtkTextIter current;
gtk_text_buffer_get_iter_at_mark(tb->buffer, ¤t, this_mark);
/* If past the end mark, move back. */
if(gtk_text_iter_compare(¤t, &e) > 0) {
gtk_text_buffer_move_mark(tb->buffer, this_mark, &e);
moved[i] = TRUE;
}
/* If on the same line as the input, but before the region,
* move forward */
if(gtk_text_iter_get_line(¤t) == gtk_text_iter_get_line(&b) &&
gtk_text_iter_compare(¤t, &b) < 0) {
gtk_text_buffer_move_mark(tb->buffer, this_mark, &b);
moved[i] = TRUE;
}
}
if(moved[0]) {
/* This will make the cursor appear immediately */
g_signal_emit_by_name(tb, "move-cursor",
GTK_MOVEMENT_LOGICAL_POSITIONS, 0, TRUE);
}
g_signal_handler_unblock(tb->buffer, tb->cursor_handler);
}
static gboolean
invalidate_and_highlight (IdeHighlightEngine *self,
GtkTextIter *begin,
GtkTextIter *end)
{
g_assert (IDE_IS_HIGHLIGHT_ENGINE (self));
g_assert (begin != NULL);
g_assert (end != NULL);
if (!self->enabled)
return FALSE;
if (get_invalidation_area (begin, end))
{
GtkTextIter begin_tmp;
GtkTextIter end_tmp;
GtkTextBuffer *text_buffer = GTK_TEXT_BUFFER (self->buffer);
gtk_text_buffer_get_iter_at_mark (text_buffer, &begin_tmp, self->invalid_begin);
gtk_text_buffer_get_iter_at_mark (text_buffer, &end_tmp, self->invalid_end);
if (gtk_text_iter_equal (&begin_tmp, &end_tmp))
{
gtk_text_buffer_move_mark (text_buffer, self->invalid_begin, begin);
gtk_text_buffer_move_mark (text_buffer, self->invalid_end, end);
}
else
{
if (gtk_text_iter_compare (begin, &begin_tmp) < 0)
gtk_text_buffer_move_mark (text_buffer, self->invalid_begin, begin);
if (gtk_text_iter_compare (end, &end_tmp) > 0)
gtk_text_buffer_move_mark (text_buffer, self->invalid_end, end);
}
ide_highlight_engine_queue_work (self);
return TRUE;
}
return FALSE;
}
void
gui_editor_goto_line (GUIEditor * self, gint ln)
{
gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER(self->buffer), &(self->iter), (ln -1));
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER(self->buffer), &(self->iter));
gtk_text_buffer_move_mark (GTK_TEXT_BUFFER(self->buffer), self->mark, &(self->iter));
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW(self->widget), self->mark);
}
void
ide_highlight_engine_rebuild (IdeHighlightEngine *self)
{
IDE_ENTRY;
g_return_if_fail (IDE_IS_HIGHLIGHT_ENGINE (self));
if (self->buffer != NULL)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (self->buffer);
GtkTextIter begin;
GtkTextIter end;
gtk_text_buffer_get_bounds (buffer, &begin, &end);
gtk_text_buffer_move_mark (buffer, self->invalid_begin, &begin);
gtk_text_buffer_move_mark (buffer, self->invalid_end, &end);
ide_highlight_engine_queue_work (self);
}
IDE_EXIT;
}
gboolean gglk_text_can_scroll(GglkText *tb)
{
GtkTextIter enditer;
/* Move the endmark to the end of the buffer. If it must be moved
to get back onscreen, then the window might by scrollable. */
gtk_text_buffer_get_end_iter(tb->buffer, &enditer);
gtk_text_buffer_move_mark(tb->buffer, tb->endmark, &enditer);
if(gtk_text_view_move_mark_onscreen(GTK_TEXT_VIEW(tb), tb->endmark))
return TRUE;
return FALSE;
}
/**
* ide_highlight_engine_invalidate:
* @self: An #IdeHighlightEngine.
* @begin: the beginning of the range to invalidate
* @end: the end of the range to invalidate
*
* This function will extend the invalidated range of the buffer to include
* the range of @begin to @end.
*
* The highlighter will be queued to interactively update the invalidated
* region.
*
* Updating the invalidated region of the buffer may take some time, as it is
* important that the highlighter does not block for more than 1-2 milliseconds
* to avoid dropping frames.
*/
void
ide_highlight_engine_invalidate (IdeHighlightEngine *self,
const GtkTextIter *begin,
const GtkTextIter *end)
{
GtkTextBuffer *buffer;
GtkTextIter mark_begin;
GtkTextIter mark_end;
IDE_ENTRY;
g_return_if_fail (IDE_IS_HIGHLIGHT_ENGINE (self));
g_return_if_fail (begin != NULL);
g_return_if_fail (end != NULL);
g_return_if_fail (gtk_text_iter_get_buffer (begin) == GTK_TEXT_BUFFER (self->buffer));
g_return_if_fail (gtk_text_iter_get_buffer (end) == GTK_TEXT_BUFFER (self->buffer));
buffer = GTK_TEXT_BUFFER (self->buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &mark_begin, self->invalid_begin);
gtk_text_buffer_get_iter_at_mark (buffer, &mark_end, self->invalid_end);
if (gtk_text_iter_equal (&mark_begin, &mark_end))
{
gtk_text_buffer_move_mark (buffer, self->invalid_begin, begin);
gtk_text_buffer_move_mark (buffer, self->invalid_end, end);
}
else
{
if (gtk_text_iter_compare (begin, &mark_begin) < 0)
gtk_text_buffer_move_mark (buffer, self->invalid_begin, begin);
if (gtk_text_iter_compare (end, &mark_end) > 0)
gtk_text_buffer_move_mark (buffer, self->invalid_end, end);
}
ide_highlight_engine_queue_work (self);
IDE_EXIT;
}
static void
insert_text_after (GtkTextBuffer *buffer, GtkTextIter *iter,
gchar *text, gint len, GeditAutomaticSpellChecker *spell)
{
GtkTextIter start;
/* we need to check a range of text. */
gtk_text_buffer_get_iter_at_mark (buffer, &start, spell->mark_insert_start);
check_range (spell, start, *iter, FALSE);
gtk_text_buffer_move_mark (buffer, spell->mark_insert_end, iter);
}
static gchar *
get_word_at_iter (GscProviderDevhelp *devhelp,
GtkTextIter *iter)
{
GtkTextIter start = *iter;
gint line = gtk_text_iter_get_line (iter);
gboolean went_back = TRUE;
GtkTextMark *mark;
if (!gtk_text_iter_backward_char (&start))
{
return NULL;
}
while (went_back &&
line == gtk_text_iter_get_line (&start) &&
is_word_char (gtk_text_iter_get_char (&start)))
{
went_back = gtk_text_iter_backward_char (&start);
}
if (went_back)
{
gtk_text_iter_forward_char (&start);
}
if (gtk_text_iter_equal (iter, &start))
{
return NULL;
}
mark = gtk_text_buffer_get_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME);
if (mark)
{
gtk_text_buffer_move_mark (gtk_text_iter_get_buffer (iter),
mark,
&start);
}
else
{
mark = gtk_text_buffer_create_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME,
&start,
TRUE);
}
return gtk_text_iter_get_text (&start, iter);
}
static void
parasite_python_shell_write_prompt(GtkWidget *python_shell)
{
ParasitePythonShellPrivate *priv = PARASITE_PYTHON_SHELL(python_shell)->priv;
GtkTextBuffer *buffer =
gtk_text_view_get_buffer(GTK_TEXT_VIEW(priv->textview));
GtkTextIter iter;
const char *prompt = (priv->pending_command == NULL ? ">>> " : "... ");
parasite_python_shell_append_text(PARASITE_PYTHON_SHELL(python_shell),
prompt, "prompt");
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_move_mark(buffer, priv->line_start_mark, &iter);
}
/* Scroll to the bottom of the buffer.
*/
static gboolean
scroll_to_bottom (GtkTextView *textview)
{
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextMark *mark;
char *spaces;
static int count;
buffer = gtk_text_view_get_buffer (textview);
/* Get end iterator */
gtk_text_buffer_get_end_iter (buffer, &iter);
/* and insert some text at it, the iter will be revalidated
* after insertion to point to the end of inserted text
*/
spaces = g_strnfill (count++, ' ');
gtk_text_buffer_insert (buffer, &iter, "\n", -1);
gtk_text_buffer_insert (buffer, &iter, spaces, -1);
gtk_text_buffer_insert (buffer, &iter,
"Scroll to bottom scroll to bottom scroll "
"to bottom scroll to bottom",
-1);
g_free (spaces);
/* Move the iterator to the beginning of line, so we don't scroll
* in horizontal direction
*/
gtk_text_iter_set_line_offset (&iter, 0);
/* and place the mark at iter. the mark will stay there after we
* insert some text at the end because it has right gravity.
*/
mark = gtk_text_buffer_get_mark (buffer, "scroll");
gtk_text_buffer_move_mark (buffer, mark, &iter);
/* Scroll the mark onscreen.
*/
gtk_text_view_scroll_mark_onscreen (textview, mark);
/* Shift text back if we got enough to the right.
*/
if (count > 40)
count = 0;
return TRUE;
}
static void
ide_xml_highlighter_cursor_moved_cb (GtkTextBuffer *buffer,
GtkTextIter *iter,
IdeXmlHighlighter *self)
{
g_assert (IDE_IS_HIGHLIGHTER (self));
g_assert (GTK_IS_TEXT_BUFFER (buffer) && self->buffer == buffer);
if (self->highlight_timeout != 0)
g_source_remove (self->highlight_timeout);
gtk_text_buffer_move_mark (buffer, self->iter_mark, iter);
self->highlight_timeout = g_timeout_add (HIGHLIGH_TIMEOUT_MSEC,
ide_xml_highlighter_highlight_timeout_handler,
self);
}
/* Go to the start of the current checked word so that
* we can re-check it again, change of language for example
*/
gboolean
gbp_spell_navigator_goto_word_start (GbpSpellNavigator *self)
{
GtkTextIter start;
g_assert (GBP_IS_SPELL_NAVIGATOR (self));
if (self->word_start != NULL)
{
gtk_text_buffer_get_iter_at_mark (self->buffer, &start, self->word_start);
gtk_text_buffer_move_mark (self->buffer, self->word_end, &start);
return TRUE;
}
return FALSE;
}
static void help_window_scroll(GtkWidget *text, const gchar *key)
{
gchar *needle;
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextIter start, end;
if (!text || !key) return;
needle = g_strdup_printf("[section:%s]", key);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
if (gtk_text_iter_forward_search(&iter, needle, GTK_TEXT_SEARCH_TEXT_ONLY,
&start, &end, NULL))
{
gint line;
GtkTextMark *mark;
line = gtk_text_iter_get_line(&start);
gtk_text_buffer_get_iter_at_line_offset(buffer, &iter, line, 0);
gtk_text_buffer_place_cursor(buffer, &iter);
#if 0
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(text), &iter, 0.0, TRUE, 0, 0);
#endif
/* apparently only scroll_to_mark works when the textview is not visible yet */
/* if mark exists, move it instead of creating one for every scroll */
mark = gtk_text_buffer_get_mark(buffer, SCROLL_MARKNAME);
if (mark)
{
gtk_text_buffer_move_mark(buffer, mark, &iter);
}
else
{
mark = gtk_text_buffer_create_mark(buffer, SCROLL_MARKNAME, &iter, FALSE);
}
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(text), mark, 0.0, TRUE, 0, 0);
}
g_free(needle);
}
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);
}
/* 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;
}
static void
on_end_user_action (GtkTextBuffer *buffer,
InsertData *data)
{
GSList *item;
if (--data->user_action > 0)
{
return;
}
/* Remove trackers */
for (item = data->trackers; item; item = g_slist_next (item))
{
InsertTracker *tracker = item->data;
GtkTextIter curloc;
GtkTextIter newloc;
/* Move the category to the line where the mark now is */
gtk_text_buffer_get_iter_at_mark (buffer,
&curloc,
GTK_TEXT_MARK (tracker->bookmark));
gtk_text_buffer_get_iter_at_mark (buffer,
&newloc,
tracker->mark);
if (gtk_text_iter_get_line (&curloc) != gtk_text_iter_get_line (&newloc))
{
gtk_text_iter_set_line_offset (&newloc, 0);
gtk_text_buffer_move_mark (buffer,
GTK_TEXT_MARK (tracker->bookmark),
&newloc);
}
gtk_text_buffer_delete_mark (buffer, tracker->mark);
g_slice_free (InsertTracker, tracker);
}
g_slist_free (data->trackers);
data->trackers = NULL;
}
void
hybrid_chat_textview_notify(GtkWidget *textview, const gchar *text, gint type)
{
GtkTextBuffer *recv_tb;
GtkTextIter end_iter;
GtkTextIter stop_iter;
GtkTextIter start_iter;
GtkTextMark *mark;
recv_tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_end_iter(recv_tb, &end_iter);
gtk_text_view_backward_display_line(GTK_TEXT_VIEW(textview), &end_iter);
gtk_text_buffer_get_end_iter(recv_tb, &stop_iter);
gtk_text_buffer_get_start_iter(recv_tb, &start_iter);
/* first line */
if (gtk_text_iter_equal(&end_iter, &stop_iter)) {
gtk_text_buffer_delete(recv_tb, &start_iter, &stop_iter);
} else {
gtk_text_buffer_delete(recv_tb, &end_iter, &stop_iter);
if (!gtk_text_iter_equal(&start_iter, &end_iter)) {
gtk_text_buffer_insert(recv_tb, &end_iter, "\n", -1);
}
}
gtk_text_buffer_get_end_iter(recv_tb, &end_iter);
if (type == MSG_NOTIFICATION_INPUT) {
gtk_text_buffer_insert_with_tags_by_name(recv_tb, &end_iter,
text, strlen(text), "grey", "small", "wrap", NULL);
}
mark = gtk_text_buffer_get_mark(recv_tb, "scroll");
gtk_text_buffer_move_mark(recv_tb, mark, &end_iter);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(textview), mark);
}
