void indent_multi_line_indent(GtkTextBuffer *buffer) { GtkTextIter start_iter, end_iter, iter; gint start_line, end_line, i; gboolean pos; 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); for (i = start_line; i < end_line; i++) { gtk_text_buffer_get_iter_at_line(buffer, &iter, i); gtk_text_buffer_place_cursor(buffer, &iter); g_signal_emit_by_name(G_OBJECT(buffer), "begin-user-action"); gtk_text_buffer_insert(buffer, &iter, "\t", 1); g_signal_emit_by_name(G_OBJECT(buffer), "end-user-action"); undo_set_sequency(TRUE); } 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); } }
//================================================================ int GUI_edi_InsFile (MemObj *mo, char *fnam) { //================================================================ /// GUI_edi_InsFile insert file at curPos, make text selected // see also ED_add_File // was GUI_Ed_Ins_f GtkTextMark *mk1; GtkTextIter it1, it2; long fSiz, cPos1; void *fBuf; // set GUI_ed1_view GUI_ed1_buff if(mo) { // for internal call: mo=NULL if(GUI_ed1_decode(mo)) return -1; } // get file -> fBuf MEM_alloc_file (&fBuf, &fSiz, fnam); UTX_str_file (fBuf, &fSiz, fnam); if(fSiz < 1) { TX_Print("GUI_Ed_Ins_f E001 |%s|",fnam); return -1; } // printf("fBuf=|%s|\n",(char*)fBuf); // // get get iters for "insert" & "selection_bound" // gtk_text_buffer_get_selection_bounds (wTx->text, &it1, &it2); // // insert at iterPos // gtk_text_buffer_insert (wTx->text, &it1, txbuf, -1); // get iter it1 at CurPos mk1 = gtk_text_buffer_get_mark (GUI_ed1_buff, "insert"); // iter at CurPos gtk_text_buffer_get_iter_at_mark (GUI_ed1_buff, &it1, mk1); cPos1 = gtk_text_iter_get_offset (&it1); // insert text txbuf at curpos; gtk_text_buffer_insert_at_cursor (GUI_ed1_buff, fBuf, fSiz); // get iter it2 at new CurPos mk1 = gtk_text_buffer_get_mark (GUI_ed1_buff, "insert"); gtk_text_buffer_get_iter_at_mark (GUI_ed1_buff, &it2, mk1); // set to old curPos it1 gtk_text_buffer_get_iter_at_offset (GUI_ed1_buff, &it1, cPos1); gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1); // select region curPos - it2 gtk_text_buffer_move_mark_by_name (GUI_ed1_buff, "selection_bound", &it2); return 0; }
//================================================================ int GUI_edi_sel__ (MemObj *mo, long von, long bis) { //================================================================ /// \code /// select_region from-curPos to-curPos /// if(from-curPos < 0) - unsect all ! /// \endcode GtkTextIter it1; GtkTextMark *mk1; // printf("GUI_edi_sel__ %d %d\n",von,bis); if(mo) { // for internal call: mo=NULL if(GUI_ed1_decode(mo)) return -1; } // get iter from offset gtk_text_buffer_get_iter_at_offset (GUI_ed1_buff, &it1, von); // move "insert" & "selection_bound"-marks gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1); // get iter from offset gtk_text_buffer_get_iter_at_offset (GUI_ed1_buff, &it1, bis); // set end - mark gtk_text_buffer_move_mark_by_name (GUI_ed1_buff, "selection_bound", &it1); return 0; }
//================================================================ int GUI_edi_setLnr (MemObj *mo, long lNr) { //================================================================ GtkTextIter it1; // printf("GUI_edi_setLnr %ld\n",lNr); --lNr; // first line = 1 // 2012-07-13 // set GUI_ed1_view GUI_ed1_buff if(mo) { // for internal call: mo=NULL if(GUI_ed1_decode(mo)) return -1; } // set iter from lNr if(lNr == gtk_text_buffer_get_line_count (GUI_ed1_buff)) { gtk_text_buffer_get_end_iter (GUI_ed1_buff, &it1); } else { gtk_text_buffer_get_iter_at_line (GUI_ed1_buff, &it1, lNr); } // moves the "insert" and "selection_bound" marks simultaneously gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1); // scroll & focus GUI_edi_scroll_s (NULL); return 0; }
void view_command_line(const gchar *text, const gchar *title, const gchar *seek, gboolean seek_after) { GtkTextIter start, end; gtk_window_set_title(GTK_WINDOW(command_dialog), title ? title : _("GDB Command")); gtk_widget_grab_focus(command_view); if (text) { const gchar *pos = seek ? strstr(text, seek) : NULL; GtkTextIter iter; gtk_text_buffer_set_text(command_text, text, -1); gtk_text_buffer_get_iter_at_offset(command_text, &iter, g_utf8_strlen(text, pos ? pos + strlen(seek) * seek_after - text : -1)); gtk_text_buffer_place_cursor(command_text, &iter); } on_command_text_changed(command_text, NULL); command_line_update_state(debug_state()); gtk_text_buffer_get_start_iter(command_text, &start); gtk_text_buffer_get_end_iter(command_text, &end); gtk_text_buffer_select_range(command_text, &start, &end); gtk_combo_box_set_active_iter(command_history, NULL); gtk_dialog_run(GTK_DIALOG(command_dialog)); }
static void wrap_line (GtkTextBuffer *buffer, GtkTextIter *iter, gchar *text, gint count, gpointer data) { gint chars = gtk_text_iter_get_chars_in_line (iter); if ( chars > DOC_LINE_LENGTH ) { GtkTextIter line_fold = *iter; GtkTextIter cursor; gtk_text_iter_set_line_offset (&line_fold, DOC_LINE_LENGTH); gtk_text_buffer_insert (buffer, &line_fold, "\r\n", 2); cursor = line_fold; gtk_text_iter_forward_to_line_end (&cursor); gtk_text_buffer_place_cursor (buffer, &cursor); } }
void ctk_help_set_page(CtkHelp *ctk_help, GtkTextBuffer *buffer) { GtkTextBuffer *b; GtkTextIter iter; GtkTextView *view; GtkTextMark *mark; if (buffer) { b = buffer; } else { b = ctk_help->default_help; } view = GTK_TEXT_VIEW(ctk_help->text_viewer); /* set the buffer in the TextView */ gtk_text_view_set_buffer(view, b); /* ensure that the top of the buffer is displayed */ gtk_text_buffer_get_start_iter(b, &iter); mark = gtk_text_buffer_create_mark(b, NULL, &iter, TRUE); gtk_text_view_scroll_to_mark(view, mark, 0.0, TRUE, 0.0, 0.0); gtk_text_buffer_place_cursor(b, &iter); }
static void lsv_show_message(const char *message, LibBalsaSourceViewerInfo * lsvi, gboolean escape) { GtkTextBuffer *buffer; GtkTextIter start; gchar *tmp; buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(lsvi->text)); gtk_text_buffer_set_text(buffer, "", 0); if (escape) tmp = g_strescape(message, "\n“"); else { tmp = g_strdup(message); libbalsa_utf8_sanitize(&tmp, FALSE, NULL); } if (tmp) { gtk_text_buffer_insert_at_cursor(buffer, tmp, -1); g_free(tmp); } gtk_text_buffer_get_start_iter(buffer, &start); gtk_text_buffer_place_cursor(buffer, &start); }
/** * \fn void open_file_(BrailleMusicEditor *editor, const gchar *path) * \brief This function actually opens a file in the editor's textview. * \param editor The GUI structure. * \param path the file path. */ void open_file_(BrailleMusicEditor *editor, const gchar *path) { GtkTextBuffer *buffer; GtkTextIter start; GtkTextIter end; FILE *file; gchar read[1024]; buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview)); if(path == NULL) return; file = fopen(path,"r"); open_error(editor->window, file, "Can't open the file : \n%s", path); //save the current file path editor->filename = (gchar *)path; gtk_text_buffer_get_start_iter(buffer, &start); gtk_text_buffer_get_end_iter(buffer, &end); gtk_text_buffer_delete(buffer, &start, &end); while(fgets(read, 1024, file)){ gtk_text_buffer_get_end_iter(buffer, &end); gtk_text_buffer_insert(buffer, &end, read, -1); } fclose(file); gtk_text_buffer_get_start_iter(buffer, &start); gtk_text_buffer_place_cursor(buffer, &start); }
//========================================================================== int GUI_edi_setCpos (MemObj *mo, long cpos) { //========================================================================== /// \code /// set to curPos and view text at curPos /// cpos -1L is end of file /// \endcode GtkTextIter it1; // printf("GUI_edi_setCpos %ld\n",cpos); // set GUI_ed1_view GUI_ed1_buff if(mo) { // for internal call: mo=NULL if(GUI_ed1_decode(mo)) return -1; } // set iter from cpos gtk_text_buffer_get_iter_at_offset (GUI_ed1_buff, &it1, cpos); // moves the "insert" and "selection_bound" marks simultaneously gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1); // scroll & focus GUI_edi_scroll_s (NULL); return 1; }
/* If @line is bigger than the lines of the document, the cursor is moved * to the last line and FALSE is returned. */ gboolean gedit_document_goto_line (GeditDocument *doc, gint line) { gboolean ret = TRUE; guint line_count; GtkTextIter iter; gedit_debug (DEBUG_DOCUMENT); g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE); g_return_val_if_fail (line >= -1, FALSE); line_count = gtk_text_buffer_get_line_count (GTK_TEXT_BUFFER (doc)); if (line >= line_count) { ret = FALSE; gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &iter); } else { gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (doc), &iter, line); } gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc), &iter); return ret; }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkTextAreaPeer_select (JNIEnv *env, jobject obj, jint start, jint end) { void *ptr; GtkWidget *text = NULL; GtkTextBuffer *buf; GtkTextIter iter; gdk_threads_enter (); ptr = NSA_GET_PTR (env, obj); text = gtk_bin_get_child (GTK_BIN (ptr)); buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text)); gtk_text_buffer_get_iter_at_offset (buf, &iter, start); /* quickly move both 'insert' and 'selection_bound' to the same position */ gtk_text_buffer_place_cursor (buf, &iter); gtk_text_buffer_get_iter_at_offset (buf, &iter, end); gtk_text_buffer_move_mark_by_name (buf, "selection_bound", &iter); gdk_threads_leave (); }
static void menu_evaluate_modify(const gchar *expr, const char *value, const gchar *title, gint hb_mode, gint mr_mode, const char *prefix) { gchar *display = parse_get_display_from_7bit(value, hb_mode, mr_mode); gchar *text = g_strdup_printf("%s = %s", expr, display ? display : ""); GtkTextIter iter; g_free(display); gtk_window_set_title(GTK_WINDOW(modify_dialog), title); gtk_widget_grab_focus(modify_value); gtk_text_buffer_set_text(modify_text, text, -1); g_free(text); gtk_text_buffer_get_iter_at_offset(modify_text, &iter, g_utf8_strlen(expr, -1) + 3); gtk_text_buffer_place_cursor(modify_text, &iter); modify_dialog_update_state(debug_state()); if (gtk_dialog_run(GTK_DIALOG(modify_dialog)) == GTK_RESPONSE_ACCEPT) { text = utils_text_buffer_get_text(modify_text, -1); utils_strchrepl(text, '\n', ' '); if (validate_column(text, TRUE)) { char *locale = utils_get_locale_from_display(text, hb_mode); debug_send_format(F, "%s-gdb-set var %s", prefix ? prefix : "", locale); g_free(locale); } g_free(text); } }
gboolean undo_redo_real(GtkTextBuffer *buffer) { GtkTextIter start_iter, end_iter; UndoInfo *ri; if (g_list_length(redo_list)) { // undo_block_signal(buffer); ri = g_list_last(redo_list)->data; gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, ri->start); switch (ri->command) { case INS: gtk_text_buffer_insert(buffer, &start_iter, ri->str, -1); break; default: gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, ri->end); gtk_text_buffer_delete(buffer, &start_iter, &end_iter); } undo_list = g_list_append(undo_list, ri); redo_list = g_list_delete_link(redo_list, g_list_last(redo_list)); DV(g_print("cb_edit_redo: undo left = %d, redo left = %d\n", g_list_length(undo_list), g_list_length(redo_list))); // undo_unblock_signal(buffer); if (ri->seq) { undo_set_sequency(TRUE); return TRUE; } if (!g_list_length(redo_list)) gtk_widget_set_sensitive(redo_w, FALSE); gtk_widget_set_sensitive(undo_w, TRUE); gtk_text_buffer_place_cursor(buffer, &start_iter); scroll_to_cursor(buffer, 0.05); } undo_check_modified_step(buffer); return FALSE; }
void SourceView::goToLine (int lineNumber) { GtkTextIter iter; gtk_text_buffer_get_iter_at_line(GTK_TEXT_BUFFER(_buffer), &iter, lineNumber); gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(_buffer), &iter); gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(_view), gtk_text_buffer_get_insert(GTK_TEXT_BUFFER(_buffer))); }
/** * \fn void external_link_catch(GtkWidget *w, GObject *link) * \brief This function catch the signal when a clic is made on a note. * \param w The widget which triggered the call. * \param link ev_link_action. * \param editor The GUI structure. */ void external_link_catch(GtkWidget *widget, GObject *link, BrailleMusicEditor *editor) { EvLinkAction *l = EV_LINK_ACTION(link); ev_view_copy_link_address(EV_VIEW(widget), l); //get line:column link const gchar * lc = ev_link_action_get_uri(l); int line, column; int i = 0; char c = ' ', temp[2048]; while(c != ':' || i >= strlen(lc)) { c = lc[i]; temp[i] = c; i++; } temp[i+1]='\0'; line = atoi(temp); line--; column = atoi(lc+i); GtkTextIter it; GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview)); if(gtk_text_buffer_get_line_count(buffer) < line ) { line = 0; column = 0; } gtk_text_buffer_get_iter_at_line(buffer, &it, line); while(column >0 && !gtk_text_iter_ends_line(&it)) { gtk_text_iter_forward_char(&it); column--; } gtk_widget_grab_focus(editor->textview); gtk_text_buffer_place_cursor(buffer, &it); gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(editor->textview), &it, 0.0, FALSE, 0.5, 0.5); }
void gTextArea::setPosition(int vl) { GtkTextIter *iter = getIterAt(); gtk_text_iter_set_offset(iter, vl); gtk_text_buffer_place_cursor(_buffer, iter); ensureVisible(); }
void pTextEdit::setCursorPosition(unsigned position) { GtkTextMark *mark = gtk_text_buffer_get_mark(textBuffer, "insert"); GtkTextIter iter; gtk_text_buffer_get_end_iter(textBuffer, &iter); gtk_text_iter_set_offset(&iter, min(position, gtk_text_iter_get_offset(&iter))); gtk_text_buffer_place_cursor(textBuffer, &iter); gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(subWidget), mark); }
static void console_insert_prompt (GtkTextBuffer *buf, GtkTextIter *iter, const char *prompt) { gtk_text_buffer_insert_with_tags_by_name(buf, iter, prompt, -1, "redtext", NULL); gtk_text_buffer_place_cursor(buf, iter); }
static void help_window_load_text(GtkWidget *text, const gchar *path) { gchar *pathl; FILE *f; gchar s_buf[1024]; GtkTextBuffer *buffer; GtkTextIter iter; GtkTextIter start, end; if (!text || !path) return; buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)); gtk_text_buffer_get_bounds(buffer, &start, &end); gtk_text_buffer_delete(buffer, &start, &end); gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0); pathl = path_from_utf8(path); f = fopen(pathl, "r"); g_free(pathl); if (!f) { gchar *buf; buf = g_strdup_printf(_("Unable to load:\n%s"), path); gtk_text_buffer_insert(buffer, &iter, buf, -1); g_free(buf); } else { while (fgets(s_buf, sizeof(s_buf), f)) { gchar *buf; gint l; l = strlen(s_buf); if (!g_utf8_validate(s_buf, l, NULL)) { buf = g_locale_to_utf8(s_buf, l, NULL, NULL, NULL); if (!buf) buf = g_strdup("\n"); } else { buf = NULL; } gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, (buf) ? buf : s_buf, -1, "monospace", NULL); g_free(buf); } fclose(f); } gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0); gtk_text_buffer_place_cursor(buffer, &iter); gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(text), &iter, 0.0, TRUE, 0, 0); }
void sg_set_cursor(GtkWidget *w, int position) { GtkTextIter pos; GtkTextBuffer *buf; buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w)); gtk_text_buffer_get_iter_at_offset(buf, &pos, position - 1); gtk_text_buffer_place_cursor(buf, &pos); gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(w), gtk_text_buffer_get_insert(buf)); }
void set_buffer(){ gtk_source_buffer_begin_not_undoable_action(GTK_SOURCE_BUFFER(mBuff)); gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mBuff),content,-1); g_free(content); gtk_source_buffer_end_not_undoable_action(GTK_SOURCE_BUFFER(mBuff)); gtk_text_buffer_set_modified(GTK_TEXT_BUFFER(mBuff),FALSE); GtkTextIter iter; gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(mBuff),&iter); gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(mBuff),&iter); }
/** * gb_view_source_goto_start: * @buffer: A #GtkTextBuffer. * * Moves the cursor to the beginning of @buffer. */ static void gb_view_source_goto_start (GtkTextBuffer *buffer) { GtkTextIter iter; g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer)); gtk_text_buffer_get_start_iter(buffer, &iter); gtk_text_buffer_place_cursor(buffer, &iter); }
/* compose_scroll_to_offset */ void compose_scroll_to_offset(Compose * compose, int offset) { GtkTextBuffer * buffer; GtkTextIter iter; buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(compose->view)); gtk_text_buffer_get_iter_at_offset(buffer, &iter, offset); gtk_text_buffer_place_cursor(buffer, &iter); gtk_text_view_place_cursor_onscreen(GTK_TEXT_VIEW(compose->view)); }
/* * 'Search Backward' */ void av_editor_search_backward(const av_editor *editor) { GtkTextIter iter_search_start, iter_search_end; GtkTextIter iter_match_start, iter_match_end; GtkTextIter iter_end; GtkTextSearchFlags flags_search; gchar *text_search = NULL; gboolean found = FALSE; gboolean status = FALSE; g_return_if_fail(editor != NULL && editor->textbuf != NULL); status = gtk_text_buffer_get_selection_bounds(GTK_TEXT_BUFFER(editor->textbuf), &iter_search_start, &iter_search_end); g_return_if_fail(status == TRUE); text_search = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(editor->textbuf), &iter_search_start, &iter_search_end, FALSE); g_return_if_fail(text_search != NULL); iter_end = iter_search_start; flags_search = GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY; found = editor_search_backward(editor, text_search, flags_search, NULL, &iter_end, &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 backward: %s: not found\n", __func__, text_search); } }
void run_dialog_jump_to(GtkWidget *textview) { GtkWidget *dialog; GtkWidget *button; GtkWidget *table; GtkWidget *label; GtkWidget *spinner; GtkAdjustment *spinner_adj; GtkTextIter iter; gint num, max_num; GtkTextBuffer *textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); gtk_text_buffer_get_iter_at_mark(textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer)); num = gtk_text_iter_get_line(&iter) + 1; gtk_text_buffer_get_end_iter(textbuffer, &iter); max_num = gtk_text_iter_get_line(&iter) + 1; dialog = gtk_dialog_new_with_buttons(_("Jump To"), GTK_WINDOW(gtk_widget_get_toplevel(textview)), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); button = create_button_with_stock_image(_("_Jump"), GTK_STOCK_JUMP_TO); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button, GTK_RESPONSE_OK); table = gtk_table_new(1, 2, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 8); gtk_container_set_border_width (GTK_CONTAINER(table), 8); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic(_("_Line number:")); spinner_adj = (GtkAdjustment *) gtk_adjustment_new(num, 1, max_num, 1, 1, 0); spinner = gtk_spin_button_new(spinner_adj, 1, 0); gtk_entry_set_width_chars(GTK_ENTRY(spinner), 8); gtk_label_set_mnemonic_widget(GTK_LABEL(label), spinner); gtk_entry_set_activates_default(GTK_ENTRY(spinner), TRUE); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), spinner, 1, 2, 0, 1); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_widget_show_all(dialog); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { gtk_text_buffer_get_iter_at_line(textbuffer, &iter, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spinner)) - 1); gtk_text_buffer_place_cursor(textbuffer, &iter); // gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview), &iter, 0.1, FALSE, 0.5, 0.5); scroll_to_cursor(textbuffer, 0.25); } gtk_widget_destroy (dialog); }
static void hide_search_widget (GeditViewFrame *frame, gboolean cancel) { GtkTextBuffer *buffer; if (frame->priv->disable_popdown) { return; } g_signal_handler_block (frame->priv->search_entry, frame->priv->search_entry_focus_out_id); if (frame->priv->view_scroll_event_id != 0) { g_signal_handler_disconnect (frame->priv->view, frame->priv->view_scroll_event_id); frame->priv->view_scroll_event_id = 0; } if (frame->priv->typeselect_flush_timeout != 0) { g_source_remove (frame->priv->typeselect_flush_timeout); frame->priv->typeselect_flush_timeout = 0; } /* To hide the slider we just set the animation-state property */ g_object_set (G_OBJECT (frame->priv->slider), "animation-state", GEDIT_THEATRICS_ANIMATION_STATE_INTENDING_TO_GO, NULL); if (cancel) { GtkTextBuffer *buffer; GtkTextIter iter; buffer = GTK_TEXT_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (frame->priv->view))); gtk_text_buffer_get_iter_at_mark (buffer, &iter, frame->priv->start_mark); gtk_text_buffer_place_cursor (buffer, &iter); gedit_view_scroll_to_cursor (GEDIT_VIEW (frame->priv->view)); } buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (frame->priv->view)); gtk_text_buffer_delete_mark (buffer, frame->priv->start_mark); /* Make sure the view is the one who has the focus when we destroy the search widget */ gtk_widget_grab_focus (frame->priv->view); g_signal_handler_unblock (frame->priv->search_entry, frame->priv->search_entry_focus_out_id); }
void gTextArea::undo() { gTextAreaAction *action; GtkTextIter start, stop; if (!_undo_stack) return; begin(); _undo_in_progress = true; action = _undo_stack; _undo_stack = _undo_stack->next; action->prev = NULL; action->next = _redo_stack; if (_redo_stack) _redo_stack->prev = action; _redo_stack = action; if (action->type == ACTION_INSERT) { gtk_text_buffer_get_iter_at_offset(_buffer, &start, action->start); gtk_text_buffer_get_iter_at_offset(_buffer, &stop, action->start + action->length); gtk_text_buffer_delete(_buffer, &start, &stop); gtk_text_buffer_place_cursor(_buffer, &start); } else if (action->type == ACTION_DELETE) { gtk_text_buffer_get_iter_at_offset(_buffer, &start, action->start); gtk_text_buffer_insert(_buffer, &start, action->text->str, action->text->len); gtk_text_buffer_get_iter_at_offset(_buffer, &stop, action->end); if (action->delete_key_used) gtk_text_buffer_place_cursor(_buffer, &start); else gtk_text_buffer_place_cursor(_buffer, &stop); } end(); ensureVisible(); _undo_in_progress = false; }
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); } }
/* 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); }