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