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 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 ide_source_view_movements_last_line (Movement *mv) { GtkTextBuffer *buffer; buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self)); gtk_text_buffer_get_end_iter (buffer, &mv->insert); gtk_text_iter_set_line_offset (&mv->insert, 0); if (mv->count) { gint line; line = gtk_text_iter_get_line (&mv->insert) - mv->count; gtk_text_iter_set_line (&mv->insert, MAX (0, line)); } }
int gTextArea::toPosition(int line,int col) { GtkTextIter iter; if (line < 0) line=0; if (col < 0) col=0; gtk_text_buffer_get_end_iter(_buffer, &iter); if (line > gtk_text_iter_get_line(&iter)) line = gtk_text_iter_get_line(&iter); gtk_text_iter_set_line(&iter, line); if (col > gtk_text_iter_get_line_offset(&iter)) col = gtk_text_iter_get_line_offset(&iter); gtk_text_iter_set_line_offset(&iter, col); return gtk_text_iter_get_offset(&iter); }
static void ide_source_view_movements_nth_line (Movement *mv) { GtkTextBuffer *buffer; buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self)); if (mv->count < 1) gtk_text_buffer_get_end_iter (buffer, &mv->insert); else gtk_text_iter_set_line (&mv->insert, mv->count - 1); gtk_text_iter_set_line_offset (&mv->insert, 0); while (!gtk_text_iter_ends_line (&mv->insert) && g_unichar_isspace (gtk_text_iter_get_char (&mv->insert))) if (!gtk_text_iter_forward_char (&mv->insert)) break; }
void gTextArea::setLine(int vl) { int col = column(); GtkTextIter *iter = getIterAt(); if (vl < 0) { setPosition(0); return; } else if (vl >= gtk_text_buffer_get_line_count(_buffer)) { setPosition(length()); return; } gtk_text_iter_set_line(iter, vl); if (gtk_text_iter_get_chars_in_line(iter) <= col) col = gtk_text_iter_get_chars_in_line(iter) - 1; gtk_text_iter_set_line_offset(iter, col); gtk_text_buffer_place_cursor(_buffer, iter); ensureVisible(); }
void Show_Code(BYTE *disas_addr, gboolean force) { BYTE *p, *isabreak; int line, i, pc_line, pc_row, scrollto, win_offset; unsigned int disas_addr_line; char whole_buffer[CODE_LIST_LENGTH*48]; char br_char, pc_char; WORD code_ptr; BYTE *Start_Code_List; GtkTextIter aniter; GtkTextMark *mark; GdkRectangle coderect; gint winx, winy; int vbuf_start, vbuf_end, disas_buff_line; disas_addr_line = codelines[disas_addr - ram]; /* get line from disas addr */ printf("P1: disas_addr_line=%d force=%d buff_lines_start=%ld buff_lines_end=%ld\n", disas_addr_line, force, buff_lines_start, buff_lines_start + CODE_LIST_LENGTH); /* * (1) If 'disas_addr_line' is not in the text buffer rebuild the text buffer. * If 'force' is set, do it anyway. */ if (disas_addr_line < buff_lines_start || disas_addr_line > buff_lines_start + CODE_LIST_LENGTH || force) { buff_lines_start = disas_addr_line - BACKUP_LINES; if (buff_lines_start < 0) buff_lines_start = 0; code_ptr = 0; /* scan the codelines table */ while (codelines[code_ptr] != buff_lines_start) /*..for the new start addr */ code_ptr++; Start_Code_List = code_ptr + ram; /* set disass start addr */ p = Start_Code_List; /* tmp pointer for disass */ whole_buffer[0] = 0; /* rewind to start */ printf("Starting disassembly from %04X (line=%d) PC=%04X (line=%d)\n", (p - ram), disas_addr_line, (PC - ram), codelines[PC - ram]); for (line = 0; line < CODE_LIST_LENGTH; line++) { Disass_Str[0] = 0; isabreak = 0; /* zero if no break */ if ((((BYTE)(*p)) & 0xff) == BREAK_OP) /* possible breakpoint? */ for (i = 0; i < SBSIZE; i++) /* scan all BPs */ if (soft[i].sb_adr == (p - ram)) /* BP here? */ { isabreak = p; /* mark the BP address */ *p = soft[i].sb_oldopc; /* restore the opcode */ } sprintf(tstr, "%04X: ", /* put addr etc @ SOL */ (WORD)(p - ram)); strcat(whole_buffer, tstr); disass(&p, p - ram); /* get Opcode and Disass */ /* DEBUG: show buffered line number and code line number */ sprintf(tstr, "%02d %03d ", line, disas_addr_line + line); strcat(whole_buffer, tstr); if (show_opcodes) /* machine code display? */ { strcat(whole_buffer, Opcode_Str); /* yes - add it */ strcat(whole_buffer, " "); /* and a separator */ } strcat(whole_buffer, Disass_Str); /* add the disas string */ if (isabreak) /* breakpoint to restore? */ *isabreak = BREAK_OP; } gtk_text_buffer_set_text( /* show buffer in the win */ code_textbuffer, whole_buffer, -1); } /* END OF (1) */ /* * At this point we know that disas_addr_line is within the text buffer. * * Now we check to see if it is within the visible lines. * * If not we need to scroll the window so that disas_addr_line is in * the middle of the visible lines. */ /* Find the limits of the visible lines, upper and lower. */ gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(codetext), &coderect); // printf("coderect1: x=%d y=%d width=%d height=%d\n", // coderect.x, coderect.y, coderect.width, coderect.height); 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) - 1; // printf("visible (modified): start=%d end=%d\n", vbuf_start, vbuf_end); /* Is the target line NOT in the visible window? */ disas_buff_line = disas_addr_line - buff_lines_start; // printf("Checking for %d between %d and %d\n", // disas_buff_line, vbuf_start, vbuf_end); if ( !(disas_buff_line >= vbuf_start && disas_buff_line <= vbuf_end ) ) { if (disas_buff_line <= vbuf_start) /* backing up or down? */ { scrollto = disas_buff_line - BACKUP_LINES; if (scrollto < 0) scrollto = 0; } else scrollto = disas_buff_line + BACKUP_LINES; // printf("scrolling to %d\n", scrollto); gtk_text_buffer_get_end_iter(code_textbuffer, &aniter); gtk_text_iter_set_line(&aniter, scrollto); mark = gtk_text_buffer_create_mark(code_textbuffer, NULL, &aniter, FALSE); gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(codetext), mark, 0.0, FALSE, 0.0, 0.0); } // printf("p1: dch\n"); do_code_highlights(); }
static void ide_source_view_movements_previous_line (Movement *mv) { GtkTextBuffer *buffer; gboolean has_selection; guint line; guint offset = 0; buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self)); /* check for linewise */ has_selection = !gtk_text_iter_equal (&mv->insert, &mv->selection) || !mv->exclusive; line = gtk_text_iter_get_line (&mv->insert); if ((*mv->target_offset) > 0) offset = *mv->target_offset; if (line == 0) return; /* * If we have a whole line selected (from say `V`), then we need to swap the cursor and * selection. This feels to me like a slight bit of a hack. There may be cause to actually have * a selection mode and know the type of selection (line vs individual characters). */ if (is_single_line_selection (&mv->insert, &mv->selection)) { if (gtk_text_iter_compare (&mv->insert, &mv->selection) > 0) gtk_text_iter_order (&mv->insert, &mv->selection); gtk_text_iter_set_line (&mv->insert, gtk_text_iter_get_line (&mv->insert) - 1); select_range (mv, &mv->insert, &mv->selection); ensure_anchor_selected (mv); return; } if (is_single_char_selection (&mv->insert, &mv->selection)) { if (gtk_text_iter_compare (&mv->insert, &mv->selection) > 0) { if (offset) --offset; *mv->target_offset = offset; } } gtk_text_buffer_get_iter_at_line (buffer, &mv->insert, line - 1); if ((line - 1) == gtk_text_iter_get_line (&mv->insert)) { for (; offset; offset--) if (!gtk_text_iter_ends_line (&mv->insert)) if (!gtk_text_iter_forward_char (&mv->insert)) break; if (has_selection) { if (gtk_text_iter_equal (&mv->insert, &mv->selection)) gtk_text_iter_backward_char (&mv->insert); select_range (mv, &mv->insert, &mv->selection); ensure_anchor_selected (mv); } else gtk_text_buffer_select_range (buffer, &mv->insert, &mv->insert); } /* make sure selection/insert are up to date */ if (!gtk_text_buffer_get_has_selection (buffer)) mv->selection = mv->insert; }
static void ide_source_view_movements_first_line (Movement *mv) { gtk_text_iter_set_line (&mv->insert, mv->count); gtk_text_iter_set_line_offset (&mv->insert, 0); }