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