/* Format->Indent */ void action_indent(GtkAction *action, I7Document *document) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER(i7_document_get_buffer(document)); /* Shift the selected lines in the buffer one tab to the right */ /* Adapted from gtksourceview.c */ GtkTextIter start, end; gtk_text_buffer_get_selection_bounds(buffer, &start, &end); /* Find out which lines to indent */ gint start_line = gtk_text_iter_get_line(&start); gint end_line = gtk_text_iter_get_line(&end); gint i; /* if the end of the selection is before the first character on a line, don't indent it */ if((gtk_text_iter_get_visible_line_offset(&end) == 0) && (end_line > start_line)) end_line--; /* Treat it as one single undo action */ gtk_text_buffer_begin_user_action(buffer); for(i = start_line; i <= end_line; i++) { GtkTextIter iter; gtk_text_buffer_get_iter_at_line(buffer, &iter, i); /* don't add indentation on empty lines */ if(gtk_text_iter_ends_line(&iter)) continue; gtk_text_buffer_insert(buffer, &iter, "\t", -1); } gtk_text_buffer_end_user_action(buffer); }
/* Format->Unindent */ void action_unindent(GtkAction *action, I7Document *document) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER(i7_document_get_buffer(document)); /* Shift the selected lines in the buffer one tab to the left */ /* Adapted from gtksourceview.c */ GtkTextIter start, end; gtk_text_buffer_get_selection_bounds(buffer, &start, &end); /* Find out which lines to unindent */ gint start_line = gtk_text_iter_get_line(&start); gint end_line = gtk_text_iter_get_line(&end); gint i; /* if the end of the selection is before the first character on a line, don't unindent it */ if((gtk_text_iter_get_visible_line_offset(&end) == 0) && (end_line > start_line)) end_line--; /* Treat it as one single undo action */ gtk_text_buffer_begin_user_action(buffer); for(i = start_line; i <= end_line; i++) { GtkTextIter iter, iter2; gtk_text_buffer_get_iter_at_line(buffer, &iter, i); if(gtk_text_iter_get_char(&iter) == '\t') { iter2 = iter; gtk_text_iter_forward_char(&iter2); gtk_text_buffer_delete(buffer, &iter, &iter2); } } gtk_text_buffer_end_user_action(buffer); }
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); } }
void dump_code_vars() { int i; GtkTextIter aniter; GtkTextMark *mark; GdkRectangle coderect; int vbuf_start, vbuf_end; printf("+++ CODE +++\n"); printf("selected_code_line=%d, Selected_Code_Addr=%04X, Code_Selected=%d\n", selected_code_line, Selected_Code_Addr, Code_Selected); printf("ram=%04X, SP=%04X, PC=%04X\n", (WORD)ram, (WORD)(STACK - ram), (WORD)(PC - ram)); do_break("\n"); // printf("Codeline table\n"); // for (i = 0; i < 4; i++) // printf("addr=%04X line=%d\n", i, codelines[i]); gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(codetext), &coderect); gtk_text_view_get_line_at_y(GTK_TEXT_VIEW(codetext), &aniter, coderect.y, NULL); vbuf_start = gtk_text_iter_get_line(&aniter); gtk_text_view_get_line_at_y(GTK_TEXT_VIEW(codetext), &aniter, coderect.y+coderect.height, NULL); vbuf_end = gtk_text_iter_get_line(&aniter); printf("coderect: x=%d y=%d width=%d height=%d\n", coderect.x, coderect.y, coderect.width, coderect.height); printf("visible: start=%d end=%d\n", vbuf_start, vbuf_end); printf("--- CODE ---\n"); }
static void gb_vim_do_substitute (GtkTextBuffer *buffer, GtkTextIter *begin, GtkTextIter *end, const gchar *search_text, const gchar *replace_text, gboolean is_global, gboolean should_search_all_lines) { GtkTextIter begin_tmp; GtkTextIter end_tmp; GtkTextMark *last_line; GtkTextIter *current_line; GtkTextMark *end_mark; GtkTextMark *insert; g_assert (search_text); g_assert (replace_text); g_assert ((!begin && !end) || (begin && end)); insert = gtk_text_buffer_get_insert (buffer); if (!begin) { if (should_search_all_lines) gtk_text_buffer_get_start_iter (buffer, &begin_tmp); else gtk_text_buffer_get_iter_at_mark (buffer, &begin_tmp, insert); begin = &begin_tmp; } if (!end) { if (should_search_all_lines) gtk_text_buffer_get_end_iter (buffer, &end_tmp); else gtk_text_buffer_get_iter_at_mark (buffer, &end_tmp, insert); end = &end_tmp; } current_line = begin; last_line = gtk_text_buffer_create_mark (buffer, NULL, current_line, FALSE); end_mark = gtk_text_buffer_create_mark (buffer, NULL, end, FALSE); for (guint line = gtk_text_iter_get_line (current_line); line <= gtk_text_iter_get_line (end); line++) { gb_vim_do_substitute_line (buffer, current_line, search_text, replace_text, is_global); gtk_text_buffer_get_iter_at_mark (buffer, current_line, last_line); gtk_text_buffer_get_iter_at_mark (buffer, end, end_mark); gtk_text_iter_set_line (current_line, line + 1); } gtk_text_buffer_delete_mark (buffer, last_line); gtk_text_buffer_delete_mark (buffer, end_mark); }
static void gbp_retab_editor_page_addin_action (GSimpleAction *action, GVariant *variant, gpointer user_data) { GbpRetabEditorPageAddin *self = user_data; IdeSourceView *source_view; GtkTextBuffer *buffer; IdeCompletion *completion; guint tab_width; gint start_line; gint end_line; gint indent; GtkTextIter begin; GtkTextIter end; gboolean editable; gboolean to_spaces; g_assert (GBP_IS_RETAB_EDITOR_PAGE_ADDIN (self)); g_assert (G_IS_SIMPLE_ACTION (action)); buffer = GTK_TEXT_BUFFER (ide_editor_page_get_buffer (self->editor_view)); source_view = ide_editor_page_get_view (self->editor_view); g_assert (IDE_IS_SOURCE_VIEW (source_view)); editable = gtk_text_view_get_editable (GTK_TEXT_VIEW (source_view)); completion = ide_source_view_get_completion (IDE_SOURCE_VIEW (source_view)); tab_width = gtk_source_view_get_tab_width(GTK_SOURCE_VIEW (source_view)); to_spaces = gtk_source_view_get_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW (source_view)); if (!editable) return; gtk_text_buffer_get_selection_bounds (buffer, &begin, &end); gtk_text_iter_order (&begin, &end); if (!gtk_text_iter_equal (&begin, &end) && gtk_text_iter_starts_line (&end)) gtk_text_iter_backward_char (&end); start_line = gtk_text_iter_get_line (&begin); end_line = gtk_text_iter_get_line (&end); ide_completion_block_interactive (completion); gtk_text_buffer_begin_user_action (buffer); for (gint line = start_line; line <= end_line; ++line) { indent = get_buffer_range_indent (buffer, line, to_spaces); if (indent > 0) gbp_retab_editor_page_addin_retab (buffer, line, tab_width, indent, to_spaces); } gtk_text_buffer_end_user_action (buffer); ide_completion_unblock_interactive (completion); }
//! //! @brief Pagination algorithm to calculate how many pages are needed //! @param operation Unused GtkPrintOperation //! @param context Pointer co a GtkPrintContext to draw on //! @param page_nr Integer of the current page number being draw //! @param data Painter to a PageInfo struct to use for information //! @return Return true when pagination finishes //! @sa _done() _begin_print() draw() _begin_print() //! static gboolean _paginate (GtkPrintOperation *operation, GtkPrintContext *context, GwPrintData *data ) { printf("paginate!\n"); //Declarations GwPageInfo *page; GwPageInfo *prev_page; GList *iter; GtkTextIter end_bound; GtkTextIter start_bound; GtkTextView *view; GtkTextBuffer *buffer; //Initializations view = gw_searchwindow_get_current_textview (data->window); buffer = gtk_text_view_get_buffer (view); //Get the draw bounds if (gtk_text_buffer_get_has_selection (buffer)) { gtk_text_buffer_get_selection_bounds (buffer, &start_bound, &end_bound); } else { gtk_text_buffer_get_start_iter (buffer, &start_bound); gtk_text_buffer_get_end_iter (buffer, &end_bound); } //Create the first page if (data->pages == NULL) { page = gw_pageinfo_new (start_bound, end_bound); _draw_page_results (context, page, data); data->pages = g_list_append (data->pages, page); return FALSE; } iter = g_list_last (data->pages); prev_page = GW_PAGEINFO (iter->data); //Finish paginating if (gtk_text_iter_get_line (&(prev_page->end)) == gtk_text_iter_get_line (&end_bound)) { gtk_print_operation_set_n_pages (operation, g_list_length (data->pages)); return TRUE; } //Add another page page = gw_pageinfo_new (prev_page->end, end_bound); _draw_page_results (context, page, data); data->pages = g_list_append (data->pages, page); return FALSE; }
/* Always process start and end by init_boudaries before */ static GHashTable * gbp_spell_navigator_count_words (GbpSpellNavigator *self, GtkTextIter *start, GtkTextIter *end) { GHashTable *table; GtkSourceRegion *words_count_region; WordsCountState *state; GtkTextIter start_subregion; GtkTextIter end_subregion; gint line_start; gint line_end; gint nb_subregion; g_assert (GBP_IS_SPELL_NAVIGATOR (self)); g_assert (start != NULL); g_assert (end != NULL); words_count_region = gtk_source_region_new (self->buffer); line_start = gtk_text_iter_get_line (start); line_end = gtk_text_iter_get_line (end); nb_subregion = (line_end - line_start + 1) / SPELLCHECKER_SUBREGION_LENGTH; if (nb_subregion > 1) { for (gint i = 0; i < nb_subregion; ++i) { line_end = line_start + SPELLCHECKER_SUBREGION_LENGTH - 1; gtk_text_buffer_get_iter_at_line_offset (self->buffer, &start_subregion, line_start, 0); gtk_text_buffer_get_iter_at_line_offset (self->buffer, &end_subregion, line_end, 0); if (!gtk_text_iter_ends_line (&end_subregion)) gtk_text_iter_forward_to_line_end (&end_subregion); gtk_source_region_add_subregion (words_count_region, &start_subregion, &end_subregion); line_start = line_end + 1; } } gtk_text_buffer_get_iter_at_line_offset (self->buffer, &start_subregion, line_start, 0); gtk_source_region_add_subregion (words_count_region, &start_subregion, end); table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); state = g_slice_new0 (WordsCountState); state->navigator = g_object_ref (self); state->words_count_region = words_count_region; gtk_source_region_get_start_region_iter (words_count_region, &state->iter); g_idle_add_full (G_PRIORITY_LOW, (GSourceFunc)gbp_spell_navigator_words_count_cb, state, (GDestroyNotify)words_count_state_free); return table; }
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); }
/* TODO: can we make this function faster? when adding bookmarks from a search this function uses a lot of time, perhaps that can be improved */ static Tbmark *bmark_get_bmark_at_line(Tdocument *doc, gint offset) { GtkTextIter sit, eit; GtkTreeIter tmpiter; gint linenum; gtk_text_buffer_get_iter_at_offset(doc->buffer,&sit,offset); linenum = gtk_text_iter_get_line(&sit); eit = sit; gtk_text_iter_set_line_offset(&sit, 0); gtk_text_iter_forward_to_line_end(&eit); #ifdef DEBUG { gchar *tmp = gtk_text_buffer_get_text(doc->buffer, &sit,&eit,FALSE); DEBUG_MSG("bmark_get_bmark_at_line, searching bookmarks at line %d between offsets %d - %d --> '%s'\n",linenum,gtk_text_iter_get_offset(&sit),gtk_text_iter_get_offset(&eit),tmp); g_free(tmp); } #endif /* check for existing bookmark in this place */ if (DOCUMENT(doc)->bmark_parent) { GtkTextIter testit; Tbmark *m, *m2; m = bmark_find_bookmark_before_offset(BFWIN(doc->bfwin), offset, doc->bmark_parent); if (m == NULL) { DEBUG_MSG("bmark_get_bmark_at_line, m=NULL, get first child\n"); if (gtk_tree_model_iter_children(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter,doc->bmark_parent)) { gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN, &m2, -1); gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m2->mark); if (gtk_text_iter_get_line(&testit) == linenum) { return m2; } } } else { gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m->mark); DEBUG_MSG("bmark_get_bmark_at_line, m=%p, has linenum=%d\n",m,gtk_text_iter_get_line(&testit)); if (gtk_text_iter_get_line(&testit) == linenum) { return m; } tmpiter = m->iter; if (gtk_tree_model_iter_next(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore),&tmpiter)) { gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN, &m2, -1); gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m2->mark); if (gtk_text_iter_get_line(&testit) == linenum) { return m2; } } } DEBUG_MSG("bmark_get_bmark_at_line, nothing found at this line, return NULL\n"); return NULL; } DEBUG_MSG("bmark_get_bmark_at_line, no existing bookmark found, return NULL\n"); return NULL; }
//選択された範囲の行を全てインデントする void set_indent_all(void) { int line_start, line_end, i; GtkTextIter start, end; gtk_text_buffer_get_selection_bounds(GTK_TEXT_BUFFER(buffer), &start, &end); line_start = gtk_text_iter_get_line(&start); line_end = gtk_text_iter_get_line(&end); for (i = line_start; i <= line_end; i++) { int depth = get_indent_depth(i - 1); set_indent_depth(i, depth); } }
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 gb_vim_do_substitute_line (GtkTextBuffer *buffer, GtkTextIter *begin, const gchar *search_text, const gchar *replace_text, gboolean is_global) { GtkSourceSearchContext *search_context; GtkSourceSearchSettings *search_settings; GtkTextIter match_begin; GtkTextIter match_end; gboolean has_wrapped = FALSE; GError *error = NULL; gint line_number; g_assert(buffer); g_assert(begin); g_assert(search_text); g_assert(replace_text); search_settings = gtk_source_search_settings_new (); search_context = gtk_source_search_context_new (GTK_SOURCE_BUFFER (buffer), search_settings); line_number = gtk_text_iter_get_line(begin); gtk_text_iter_set_line_offset(begin, 0); gtk_source_search_settings_set_search_text (search_settings, search_text); gtk_source_search_settings_set_case_sensitive (search_settings, TRUE); while (gtk_source_search_context_forward (search_context, begin, &match_begin, &match_end, &has_wrapped) && !has_wrapped) { if (gtk_text_iter_get_line (&match_end) != line_number) break; if (!gtk_source_search_context_replace (search_context, &match_begin, &match_end, replace_text, -1, &error)) { g_warning ("%s", error->message); g_clear_error (&error); break; } *begin = match_end; if (!is_global) break; } g_clear_object (&search_settings); g_clear_object (&search_context); }
static gboolean is_single_line_selection (const GtkTextIter *begin, const GtkTextIter *end) { if (gtk_text_iter_compare (begin, end) < 0) return ((gtk_text_iter_get_line_offset (begin) == 0) && (gtk_text_iter_get_line_offset (end) == 0) && ((gtk_text_iter_get_line (begin) + 1) == gtk_text_iter_get_line (end))); else return ((gtk_text_iter_get_line_offset (begin) == 0) && (gtk_text_iter_get_line_offset (end) == 0) && ((gtk_text_iter_get_line (end) + 1) == gtk_text_iter_get_line (begin))); }
static std::vector<LineInfo> getLinesInfo(GtkTextView* textView, int height) { std::vector<LineInfo> linesInfo; int y1 = 0; int y2 = height; gtk_text_view_window_to_buffer_coords(textView, GTK_TEXT_WINDOW_LEFT, 0, y1, NULL, &y1); gtk_text_view_window_to_buffer_coords(textView, GTK_TEXT_WINDOW_LEFT, 0, y2, NULL, &y2); GtkTextIter iter; gtk_text_view_get_line_at_y(textView, &iter, y1, NULL); while(!gtk_text_iter_is_end(&iter)) { int y, height; gtk_text_view_get_line_yrange(textView, &iter, &y, &height); int line = gtk_text_iter_get_line(&iter); linesInfo.push_back(LineInfo(line+1, y)); if((y + height) >= y2) { break; } gtk_text_iter_forward_line(&iter); } if(linesInfo.size() == 0) { linesInfo.push_back(LineInfo(1, 1)); } return linesInfo; }
gint gui_editor_get_line (GUIEditor * self) { gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER(self->buffer), &(self->iter), self->mark); return gtk_text_iter_get_line (&(self->iter)); }
static void buffer_insert_text_after_cb (GbpGitBufferChangeMonitor *self, GtkTextIter *location, gchar *text, gint len, IdeBuffer *buffer) { guint line; g_assert (GBP_IS_GIT_BUFFER_CHANGE_MONITOR (self)); g_assert (location != NULL); g_assert (text != NULL); g_assert (IDE_IS_BUFFER (buffer)); /* * We need to recalculate the diff when text is inserted if: * * 1) A newline is included in the text. * 2) The line currently has flags of NONE. * * Technically we need to do it on every change to be more correct, but that * wastes a lot of power. So instead, we'll be a bit lazy about it here and * pick up the other changes on a much more conservative timeout */ line = gtk_text_iter_get_line (location); if (self->cache == NULL || NULL != memmem (text, len, "\n", 1) || !line_cache_get_mark (self->cache, line)) gbp_git_buffer_change_monitor_queue_update (self, FAST); }
void moveBMsForPage(pageStruct *page,unsigned dowhat) { unsigned thisid; unsigned len; bookMarksNew *bookmarkdata; GtkTextIter newiter; if(page!=NULL) { thisid=page->pageID; if(newBookMarksList!=NULL) { len=g_list_length(newBookMarksList); for(unsigned j=0;j<len;j++) { bookmarkdata=(bookMarksNew*)g_list_nth_data (newBookMarksList,j); if(bookmarkdata->pageID==thisid) { switch(dowhat) { case 0: gtk_text_buffer_get_iter_at_line_offset((GtkTextBuffer*)page->buffer,&newiter,bookmarkdata->line,0); gtk_text_buffer_move_mark_by_name((GtkTextBuffer*)page->buffer,bookmarkdata->markName,&newiter); break; case 1: gtk_text_buffer_get_iter_at_mark((GtkTextBuffer*)page->buffer,&newiter,(GtkTextMark*)bookmarkdata->mark); bookmarkdata->line=gtk_text_iter_get_line(&newiter); break; } } } } } }
static void gb_view_source_notify_cursor (GbViewSource *source, GParamSpec *pspec, GtkTextBuffer *buffer) { GbViewSourcePrivate *priv; GtkTextIter iter; guint col; guint line; guint position; gchar *s; g_return_if_fail(GB_IS_VIEW_SOURCE(source)); g_return_if_fail(pspec != NULL); g_return_if_fail(GTK_SOURCE_IS_BUFFER(buffer)); priv = source->priv; g_object_get(buffer, "cursor-position", &position, NULL); gtk_text_buffer_get_iter_at_offset(buffer, &iter, position); line = gtk_text_iter_get_line(&iter); col = gtk_source_view_get_visual_column(GTK_SOURCE_VIEW(priv->source1), &iter); s = g_strdup_printf(_("Line %d, Column %d"), line + 1, col + 1); g_object_set(priv->pos_label, "label", s, NULL); g_free(s); }
static void update_statusbar (GtkTextBuffer *buffer, GtkStatusbar *statusbar) { gchar *msg; gint row, col; gint count; GtkTextIter iter; /* clear any previous message, underflow is allowed */ gtk_statusbar_pop (statusbar, 0); count = gtk_text_buffer_get_char_count (buffer); 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 ("Cursor at row %d column %d - %d chars in document", row, col, count); gtk_statusbar_push (statusbar, 0, msg); g_free (msg); }
static void wikipad_document_notify_cursor_position (GtkTextBuffer *buffer, GParamSpec *pspec, WikipadDocument *document) { GtkTextIter iter; gint line, column, selection; gint tab_size; g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer)); g_return_if_fail (WIKIPAD_IS_DOCUMENT (document)); /* get the current iter position */ gtk_text_buffer_get_iter_at_mark (buffer, &iter, gtk_text_buffer_get_insert (buffer)); /* get the current line number */ line = gtk_text_iter_get_line (&iter) + 1; /* get the tab size */ tab_size = WIKIPAD_SETTING_GET_INT (TAB_WIDTH); /* get the column */ column = wikipad_util_get_real_line_offset (&iter, tab_size); /* get length of the selection */ selection = wikipad_view_get_selection_length (document->textview, NULL); /* emit the signal */ g_signal_emit (G_OBJECT (document), document_signals[CURSOR_CHANGED], 0, line, column, selection); }
static void ide_line_change_gutter_renderer_draw (GtkSourceGutterRenderer *renderer, cairo_t *cr, GdkRectangle *bg_area, GdkRectangle *cell_area, GtkTextIter *begin, GtkTextIter *end, GtkSourceGutterRendererState state) { IdeLineChangeGutterRenderer *self = (IdeLineChangeGutterRenderer *)renderer; guint line; g_assert (IDE_IS_LINE_CHANGE_GUTTER_RENDERER (self)); g_assert (cr != NULL); g_assert (bg_area != NULL); g_assert (cell_area != NULL); g_assert (begin != NULL); g_assert (end != NULL); if (self->lines == NULL) return; line = gtk_text_iter_get_line (begin); if ((line - self->begin_line) < self->lines->len) { LineInfo *info = &g_array_index (self->lines, LineInfo, line - self->begin_line); if (IS_LINE_CHANGE (info)) draw_line_change (self, cr, cell_area, info, state); } }
static void ide_source_view_movements_line_percentage (Movement *mv) { GtkTextBuffer *buffer; GtkTextIter end; guint end_line; buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self)); gtk_text_buffer_get_end_iter (buffer, &end); end_line = gtk_text_iter_get_line (&end); if (!mv->count) { gtk_text_iter_set_line (&mv->insert, 0); } else { guint line; mv->count = MAX (1, mv->count); line = (float)end_line * (mv->count / 100.0); gtk_text_iter_set_line (&mv->insert, line); } mv->count = 0; ide_source_view_movements_first_nonspace_char (mv); }
static void update_statusbar (void) { gchar *msg; gint row, col; GtkTextIter iter; const char *print_str; gtk_statusbar_pop (GTK_STATUSBAR (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); print_str = ""; if (active_prints) { GtkPrintOperation *op = active_prints->data; print_str = gtk_print_operation_get_status_string (op); } msg = g_strdup_printf ("%d, %d%s %s", row, col, file_changed?" - Modified":"", print_str); gtk_statusbar_push (GTK_STATUSBAR (statusbar), 0, msg); g_free (msg); }
static IdeBufferLineChange ide_git_buffer_change_monitor_get_change (IdeBufferChangeMonitor *monitor, const GtkTextIter *iter) { IdeGitBufferChangeMonitor *self = (IdeGitBufferChangeMonitor *)monitor; gpointer key; gpointer value; g_return_val_if_fail (IDE_IS_GIT_BUFFER_CHANGE_MONITOR (self), IDE_BUFFER_LINE_CHANGE_NONE); g_return_val_if_fail (iter, IDE_BUFFER_LINE_CHANGE_NONE); if (!self->state) { /* * If the file is within the working directory, synthesize line addition. */ if (self->is_child_of_workdir) return IDE_BUFFER_LINE_CHANGE_ADDED; return IDE_BUFFER_LINE_CHANGE_NONE; } key = GINT_TO_POINTER (gtk_text_iter_get_line (iter) + 1); value = g_hash_table_lookup (self->state, key); return GPOINTER_TO_INT (value); }
/****** 'text_tags' function *************************************************/ gint text_tags(GtkTextBuffer *buffer, const gchar *text) { GtkTextTag *tag; GtkTextIter start, match_end, match_start; gtk_text_buffer_get_iter_at_line_offset(buffer, &start, char_line, char_line_offset); if(gtk_text_iter_forward_search(&start, text, GTK_TEXT_SEARCH_CASE_INSENSITIVE, &match_start, &match_end, NULL)) { tag = gtk_text_buffer_create_tag(buffer, NULL, "font", "italic 12", "weight", 650, "underline", PANGO_UNDERLINE_SINGLE, NULL); gtk_text_buffer_apply_tag(buffer, tag, &match_start, &match_end); char_line = gtk_text_iter_get_line(&match_end); char_line_offset = gtk_text_iter_get_line_offset(&match_end); return 0; } else { return -1; } }
static void gutter_renderer_query_data (GtkSourceGutterRenderer *renderer, GtkTextIter *start, GtkTextIter *end, GtkSourceGutterRendererState state) { GtkSourceGutterRendererLines *lines = GTK_SOURCE_GUTTER_RENDERER_LINES (renderer); gchar text[24]; gint line; gint len; gboolean current_line; line = gtk_text_iter_get_line (start) + 1; current_line = (state & GTK_SOURCE_GUTTER_RENDERER_STATE_CURSOR) && lines->priv->cursor_visible; if (current_line) { len = g_snprintf (text, sizeof text, "<b>%d</b>", line); } else { len = g_snprintf (text, sizeof text, "%d", line); } gtk_source_gutter_renderer_text_set_markup (GTK_SOURCE_GUTTER_RENDERER_TEXT (renderer), text, len); }
gboolean gglk_text_mouse(GtkTextTag *unused, GObject *object, GdkEvent *event, GtkTextIter *iter, gpointer user_data) { GglkText *tb; int x = gtk_text_iter_get_line_offset(iter); int y = gtk_text_iter_get_line(iter); if(!IS_GGLK_TEXT(object)) return FALSE; tb = GGLK_TEXT(object); if(event->type == GDK_BUTTON_PRESS) { tb->click_x = x; tb->click_y = y; } else if(event->type == GDK_BUTTON_RELEASE) { if(tb->click_x == x && tb->click_y == y) g_signal_emit(tb, gglk_text_signals[MOUSE_SIGNAL], 0, x, y); } else if(event->type == GDK_2BUTTON_PRESS && user_data) { int hyperval = GPOINTER_TO_INT(user_data); g_signal_emit(tb, gglk_text_signals[HYPER_SIGNAL], 0, hyperval); return TRUE; } return FALSE; }
static void position_save (Position *pos, const GtkTextIter *iter) { pos->line = gtk_text_iter_get_line (iter); pos->line_offset = gtk_text_iter_get_line_offset (iter); }
/* 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); }