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)); } }