gboolean
gtksnippets_inplaceparser_deactivate(GtkSnippetsInPlaceParser *self)
{
if (!self->priv->active)
return FALSE;
g_signal_handlers_disconnect_by_func(self->priv->view,view_key_press_cb,self);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(self->priv->view);
g_signal_handlers_disconnect_by_func(buffer,view_insert_text_cb,self);
g_signal_handlers_disconnect_by_func(buffer,buffer_mark_set_cb,self);
GtkTextIter start,end;
gtk_text_buffer_get_start_iter(buffer,&start);
gtk_text_buffer_get_end_iter(buffer,&end);
if (self->priv->var_tag!=NULL)
{
gtk_text_buffer_remove_tag_by_name(buffer,
VAR_TAG_NAME,
&start,
&end);
}
if (self->priv->var_tag_error != NULL)
{
gtk_text_buffer_remove_tag_by_name(buffer,
VAR_ERROR_TAG_NAME,
&start,
&end);
}
/*
If we set the vars to NULL they don't disappear in the GtkTextView
self->priv->var_tag = NULL;
self->priv->var_tag_error = NULL;
*/
GList *lista = self->priv->vars;
if (lista!=NULL)
{
do{
g_object_unref(GTKSNIPPETS_GTV_VAR(lista->data));
lista = g_list_next(lista);
}while(lista!=NULL);
}
g_list_free(self->priv->vars);
gtk_text_buffer_delete_mark_by_name(buffer,SNIPPET_START_MARK);
gtk_text_buffer_delete_mark_by_name(buffer,SNIPPET_END_MARK);
self->priv->vars = NULL;
self->priv->active = FALSE;
self->priv->active_var_pos = NULL;
self->priv->moving = FALSE;
/*The cursor variable frees its mark*/
self->priv->end_position_mark = NULL;
gsnippets_func_manager_unregister_func("cursor");
g_signal_emit (G_OBJECT (self), signals[PARSER_END], 0);
return TRUE;
}
gboolean key_pressed(GtkWidget * window,
GdkEventKey* event, GtkTextBuffer *buffer) {
GtkTextIter start_sel, end_sel;
GtkTextIter start_find, end_find;
GtkTextIter start_match, end_match;
gboolean selected;
gchar *text;
if ((event->type == GDK_KEY_PRESS) &&
(event->state & GDK_CONTROL_MASK)) {
switch (event->keyval)
{
case GDK_m :
selected = gtk_text_buffer_get_selection_bounds(buffer,
&start_sel, &end_sel);
if (selected) {
gtk_text_buffer_get_start_iter(buffer, &start_find);
gtk_text_buffer_get_end_iter(buffer, &end_find);
gtk_text_buffer_remove_tag_by_name(buffer, "gray_bg",
&start_find, &end_find);
text = (char *) gtk_text_buffer_get_text(buffer, &start_sel,
&end_sel, FALSE);
while ( gtk_text_iter_forward_search(&start_find, text,
GTK_TEXT_SEARCH_TEXT_ONLY |
GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start_match, &end_match, NULL) ) {
gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg",
&start_match, &end_match);
int offset = gtk_text_iter_get_offset(&end_match);
gtk_text_buffer_get_iter_at_offset(buffer,
&start_find, offset);
}
g_free(text);
}
break;
case GDK_r:
gtk_text_buffer_get_start_iter(buffer, &start_find);
gtk_text_buffer_get_end_iter(buffer, &end_find);
gtk_text_buffer_remove_tag_by_name(buffer, "gray_bg",
&start_find, &end_find);
break;
}
}
return FALSE;
}
void gglk_text_line_input_end(GglkText *tb)
{
GtkTextIter b, e;
tb->line_maxlen = 0;
/* Disable signal handlers */
if(tb->cursor_handler)
g_signal_handler_disconnect(tb->buffer, tb->cursor_handler);
if(tb->update_handler)
g_signal_handler_disconnect(tb->buffer, tb->update_handler);
tb->cursor_handler = 0;
tb->update_handler = 0;
/* Remove end marker */
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->endedit);
gtk_text_buffer_get_end_iter(tb->buffer, &e);
gtk_text_buffer_delete(tb->buffer, &b, &e);
/* Set text to be non-editable */
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_get_end_iter(tb->buffer, &e);
gtk_text_buffer_remove_tag_by_name(tb->buffer, "editable", &b, &e);
gtk_text_buffer_get_end_iter(tb->buffer, &tb->iter);
}
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;
}
}
/*******************************************************************************
* Advance the cursor n positions on the tutor text view
*/
gint
cursor_advance (gint n)
{
gint i;
gboolean cursor_out_screen;
GtkWidget *wg;
GtkTextBuffer *buf;
GtkTextIter new_start;
GtkTextIter old_start;
GtkTextIter end;
GtkTextMark *mark;
wg = get_wg ("text_tutor");
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (wg));
/* Get current position for the iter old_start */
gtk_text_buffer_get_iter_at_mark (buf, &new_start, gtk_text_buffer_get_insert (buf));
old_start = new_start;
/* Get new position for the iter new_start */
if (n > 0)
for (i = 0; i < n && gtk_text_iter_forward_cursor_position (&new_start); i++);
else
for (i = 0; i > n && gtk_text_iter_backward_cursor_position (&new_start); i--);
/* Move cursor blinking */
end = new_start;
gtk_text_iter_forward_char (&end);
gtk_text_buffer_apply_tag_by_name (buf, "cursor_blink", &new_start, &end);
end = old_start;
gtk_text_iter_forward_char (&end);
gtk_text_buffer_remove_tag_by_name (buf, "cursor_blink", &old_start, &end);
/* Move cursor */
gtk_text_buffer_place_cursor (buf, &new_start);
/* Check need for auto-scrolling */
if (i == n)
{
end = new_start;
gtk_text_iter_forward_line (&end);
mark = gtk_text_buffer_create_mark (buf, "aux", &end, FALSE);
cursor_out_screen = gtk_text_view_move_mark_onscreen (GTK_TEXT_VIEW (wg), mark);
if (cursor_out_screen)
{
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (wg),
gtk_text_buffer_get_insert (buf), 0.0, TRUE, 0.5, 0.12);
}
}
return (i);
}
void
highlight_add_tag (GtkTextBuffer *buffer, GtkTextIter *startitr,
gint offset, gint len, gchar *tag)
{
/* Apply highlighting. */
gint start_offset;
gint end_offset;
GtkTextIter start, end;
start_offset = gtk_text_iter_get_offset (startitr) + offset;
end_offset = start_offset + len;
gtk_text_buffer_get_iter_at_offset (buffer, &start, start_offset);
gtk_text_buffer_get_iter_at_offset (buffer, &end, end_offset);
/* If needed tag is a error style, we shouldn't delete other tags. */
if (g_strcmp0 (tag, CODE_TAG_ERROR) != 0) {
gtk_text_buffer_remove_tag_by_name (buffer, CODE_TAG_PREPROCESSOR, &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, CODE_TAG_KEYWORD, &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, CODE_TAG_CONSTANT, &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, CODE_TAG_STRING, &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, CODE_TAG_COMMENT, &start, &end);
}
gtk_text_buffer_apply_tag_by_name (buffer, tag, &start, &end);
}
static void
clear_fortune_text (FishApplet *fish)
{
GtkTextIter begin, end;
gtk_text_buffer_get_iter_at_offset (fish->fortune_buffer, &begin, 0);
gtk_text_buffer_get_iter_at_offset (fish->fortune_buffer, &end, -1);
gtk_text_buffer_delete (fish->fortune_buffer, &begin, &end);
gtk_text_buffer_remove_tag_by_name (fish->fortune_buffer,
"monospace_tag", &begin, &end);
/* insert an empty line */
insert_fortune_text (fish, "\n");
}
void EditorActionChangeCharacterStyle::change_styles (const vector <ustring>& old_ones, const vector <ustring>& new_ones)
{
// Remove old styles and apply new ones.
for (gint i = 0; i < length; i++) {
GtkTextIter startiter, enditer;
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &startiter, offset + i);
enditer = startiter;
gtk_text_iter_forward_char (&enditer);
if (!old_ones[i].empty()) {
gtk_text_buffer_remove_tag_by_name (paragraph->textbuffer, old_ones[i].c_str(), &startiter, &enditer);
}
if (!new_ones[i].empty()) {
gtk_text_buffer_apply_tag_by_name (paragraph->textbuffer, new_ones[i].c_str(), &startiter, &enditer);
}
}
}
/**********************************************************************
* Turns off the cursor immediately
*/
void
cursor_switch_off ()
{
GtkTextView *wg_text;
GtkTextBuffer *buf;
GtkTextIter start;
GtkTextIter end;
wg_text = GTK_TEXT_VIEW (get_wg ("text_tutor"));
buf = gtk_text_view_get_buffer (wg_text);
gtk_text_buffer_get_iter_at_mark (buf, &start, gtk_text_buffer_get_insert (buf));
gtk_text_buffer_get_iter_at_mark (buf, &end, gtk_text_buffer_get_insert (buf));
gtk_text_iter_forward_char (&end);
if (tutor_get_correcting ())
gtk_text_buffer_apply_tag_by_name (buf, "cursor_blink", &start, &end);
else
gtk_text_buffer_remove_tag_by_name (buf, "cursor_blink", &start, &end);
}
// Koloruje słowa nie ze słownika na czerwono
static void ColorMistakes (GtkMenuItem *item, gpointer data) {
GtkTextIter start, end, buffEnd;
gtk_text_buffer_get_start_iter(editor_buf, &end);
//Teraz sztuczką przesuwamy końcowy iterator na koniec ostatniego słowa
gtk_text_buffer_get_end_iter(editor_buf, &buffEnd);
gtk_text_iter_backward_word_start(&buffEnd);
gtk_text_iter_forward_word_end(&buffEnd);
gtk_text_buffer_create_tag(editor_buf, "red_fg",
"foreground", "red",
"weight", PANGO_WEIGHT_BOLD, NULL);
// Aktualizacja słownika
if(update_actual_dict() < 0)
return;
start = end;
while (!gtk_text_iter_equal(&end, &buffEnd)) {
// Inkrementacja zmiennych
gtk_text_iter_forward_word_end(&end);
start = end;
gtk_text_iter_backward_word_start(&start);
// Usuwamy etykietkę ze słowa jeśli jest
gtk_text_buffer_remove_tag_by_name(editor_buf, "red_fg",
&start, &end);
// Separujemy słowo
char* word = gtk_text_iter_get_text(&start, &end);
gunichar* wword = g_utf8_to_ucs4_fast(word, -1, NULL);
// Jeśli znaleziono w słowniku to kolorujemy
if(!dictionary_find(dict, (const wchar_t*)wword))
gtk_text_buffer_apply_tag_by_name(editor_buf, "red_fg",
&start, &end);
g_free(word);
}
}
static void
markup_text (GtkTextBuffer *buffer)
{
GtkTextIter start, end;
gchar *text;
gint i;
regmatch_t pmatch[2];
gboolean any;
const gchar *str;
gint offset = 0;
g_return_if_fail (buffer != NULL);
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
gtk_text_buffer_remove_tag_by_name (buffer, E_BUFFER_TAGGER_LINK_TAG, &start, &end);
text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
str = text;
any = TRUE;
while (any) {
any = FALSE;
for (i = 0; i < G_N_ELEMENTS (mim); i++) {
if (mim[i].preg && !regexec (mim[i].preg, str, 2, pmatch, 0)) {
gtk_text_buffer_get_iter_at_offset (buffer, &start, offset + pmatch[0].rm_so);
gtk_text_buffer_get_iter_at_offset (buffer, &end, offset + pmatch[0].rm_eo);
gtk_text_buffer_apply_tag_by_name (buffer, E_BUFFER_TAGGER_LINK_TAG, &start, &end);
any = TRUE;
str += pmatch[0].rm_eo;
offset += pmatch[0].rm_eo;
break;
}
}
}
g_free (text);
}
static void
hide_search_bar (TextSearch *tsearch)
{
GtkTextIter start, end;
GtkTextBuffer *buffer;
/* clean all previous search result */
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tsearch->priv->view));
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, "search", &start, &end);
if (tsearch->priv->search_marks) {
GList *list;
for (list = tsearch->priv->search_marks; list; list = list->next)
gtk_text_buffer_delete_mark (buffer, GTK_TEXT_MARK (list->data));
g_list_free (tsearch->priv->search_marks);
tsearch->priv->search_marks = NULL;
}
tsearch->priv->current_mark = NULL;
gtk_widget_hide (GTK_WIDGET (tsearch));
}
static void about_textview_uri_update(GtkWidget *textview, gint x, gint y)
{
GtkTextBuffer *buffer;
GtkTextIter start_iter, end_iter;
gchar *uri = NULL;
gboolean same;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
if (x != -1 && y != -1) {
gint bx, by;
GtkTextIter iter;
GSList *tags;
GSList *cur;
gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(textview),
GTK_TEXT_WINDOW_WIDGET,
x, y, &bx, &by);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(textview),
&iter, bx, by);
tags = gtk_text_iter_get_tags(&iter);
for (cur = tags; cur != NULL; cur = cur->next) {
GtkTextTag *tag = cur->data;
char *name;
g_object_get(G_OBJECT(tag), "name", &name, NULL);
if (strcmp(name, "link") == 0
&& get_tag_range(&iter, tag, &start_iter, &end_iter)) {
uri = gtk_text_iter_get_text(&start_iter, &end_iter);
}
g_free(name);
if (uri) {
break;
}
}
g_slist_free(tags);
}
/* compare previous hovered link and this one
(here links must be unique in text buffer otherwise ClickableText structures should be
used as in textview.c) */
same = (uri != NULL && uri_hover != NULL
&& strcmp((char*)uri, (char*)uri_hover) == 0);
if (same == FALSE) {
GdkWindow *window;
if (uri_hover) {
gtk_text_buffer_remove_tag_by_name(buffer,
"link-hover",
&uri_hover_start_iter,
&uri_hover_end_iter);
}
uri_hover = uri;
if (uri) {
uri_hover_start_iter = start_iter;
uri_hover_end_iter = end_iter;
gtk_text_buffer_apply_tag_by_name(buffer,
"link-hover",
&start_iter,
&end_iter);
}
window = gtk_text_view_get_window(GTK_TEXT_VIEW(textview),
GTK_TEXT_WINDOW_TEXT);
if (!hand_cursor)
hand_cursor = gdk_cursor_new(GDK_HAND2);
if (!text_cursor)
text_cursor = gdk_cursor_new(GDK_XTERM);
gdk_window_set_cursor(window, uri ? hand_cursor : text_cursor);
}
}
static void
search_text_changed_cb (GtkEntry *entry, TextSearch *tsearch)
{
GtkTextIter iter, siter, end;
GtkTextBuffer *buffer;
const gchar *search_text, *sptr;
gboolean sensitive;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tsearch->priv->view));
/* clean all previous search result */
gtk_text_buffer_get_bounds (buffer, &iter, &end);
gtk_text_buffer_remove_tag_by_name (buffer, "search", &iter, &end);
tsearch->priv->current_mark = NULL;
if (tsearch->priv->search_marks) {
GList *list;
for (list = tsearch->priv->search_marks; list; list = list->next)
gtk_text_buffer_delete_mark (buffer, GTK_TEXT_MARK (list->data));
g_list_free (tsearch->priv->search_marks);
tsearch->priv->search_marks = NULL;
}
gtk_text_buffer_get_start_iter (buffer, &iter);
search_text = gtk_entry_get_text (entry);
if (!search_text || !*search_text)
return;
sensitive = gtk_toggle_button_get_active (tsearch->priv->search_sensitive);
while (1) {
gboolean high = TRUE;
siter = iter;
sptr = search_text;
/* search for @search_text starting from the @siter position */
while (1) {
gunichar c1, c2;
c1 = gtk_text_iter_get_char (&siter);
c2 = g_utf8_get_char (sptr);
if (!sensitive) {
c1 = g_unichar_tolower (c1);
c2 = g_unichar_tolower (c2);
}
if (c1 != c2) {
high = FALSE;
break;
}
sptr = g_utf8_find_next_char (sptr, NULL);
if (!sptr || !*sptr)
break;
if (! gtk_text_iter_forward_char (&siter)) {
high = FALSE;
break;
}
}
if (high) {
if (gtk_text_iter_forward_char (&siter)) {
GtkTextMark *mark;
gtk_text_buffer_apply_tag_by_name (buffer, "search", &iter, &siter);
mark = gtk_text_buffer_create_mark (buffer, NULL, &iter, FALSE);
tsearch->priv->search_marks = g_list_prepend (tsearch->priv->search_marks,
mark);
}
iter = siter;
}
else {
if (! gtk_text_iter_forward_char (&iter))
break;
}
}
if (tsearch->priv->search_marks) {
tsearch->priv->search_marks = g_list_reverse (tsearch->priv->search_marks);
tsearch->priv->current_mark = tsearch->priv->search_marks;
gtk_text_view_scroll_mark_onscreen (tsearch->priv->view,
GTK_TEXT_MARK (tsearch->priv->current_mark->data));
}
}
