static void
dma_sparse_view_update_adjustement (DmaSparseView *view)
{
PangoLayout *layout;
GdkRectangle text_area;
int height;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW (view), &text_area);
layout = gtk_widget_create_pango_layout (GTK_WIDGET(view), "0123456789ABCDEFGHIJKLMNOPQRSTUVWWYZ,");
pango_layout_get_pixel_size(layout, NULL, &height);
g_object_unref (G_OBJECT (layout));
view->priv->line_by_page = text_area.height / height;
view->priv->char_by_line = 8;
if (view->priv->vadjustment != NULL)
{
GtkAdjustment *vadj = view->priv->vadjustment;
gdouble step_increment, page_size;
step_increment = view->priv->char_by_line;
page_size = (view->priv->line_by_page - 1) * step_increment;
gtk_adjustment_set_step_increment (vadj, step_increment);
gtk_adjustment_set_page_size (vadj, page_size);
gtk_adjustment_set_page_increment (vadj, page_size * 0.9);
gtk_adjustment_changed (vadj);
}
}
static void
timestamp_display(PurpleConversation *conv, time_t then, time_t now)
{
PidginConversation *gtk_conv = PIDGIN_CONVERSATION(conv);
GtkWidget *imhtml = gtk_conv->imhtml;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(imhtml));
GtkTextIter iter;
const char *mdate;
int y, height;
GdkRectangle rect;
/* display timestamp */
mdate = purple_utf8_strftime(then == 0 ? "%H:%M" : "\n%H:%M",
localtime(&now));
gtk_text_buffer_get_end_iter(buffer, &iter);
if (gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "TIMESTAMP") == NULL)
gtk_text_buffer_create_tag(buffer, "TIMESTAMP",
"foreground", "#888888", "justification", GTK_JUSTIFY_CENTER,
"weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, mdate,
strlen(mdate), "TIMESTAMP", NULL);
/* scroll view if necessary */
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(imhtml), &rect);
gtk_text_view_get_line_yrange(
GTK_TEXT_VIEW(imhtml), &iter, &y, &height);
if (((y + height) - (rect.y + rect.height)) > height &&
gtk_text_buffer_get_char_count(buffer)) {
gboolean smooth = purple_prefs_get_bool(
PIDGIN_PREFS_ROOT "/conversations/use_smooth_scrolling");
gtk_imhtml_scroll_to_end(GTK_IMHTML(imhtml), smooth);
}
}
static VALUE
textview_get_visible_rect(VALUE self)
{
GdkRectangle rect;
gtk_text_view_get_visible_rect(_SELF(self), &rect);
return BOXED2RVAL(&rect, GDK_TYPE_RECTANGLE);
}
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");
}
gint gtk_mate_view_last_visible_line (GtkMateView* self) {
GdkRectangle rect = {0};
gint bufy;
GtkTextIter iter = {0};
gint line;
g_return_val_if_fail (self != NULL, 0);
gtk_text_view_get_visible_rect ((GtkTextView*) self, &rect);
bufy = rect.y + rect.height;
gtk_text_view_get_line_at_y ((GtkTextView*) self, &iter, bufy, NULL);
line = gtk_text_iter_get_line (&iter);
return line;
}
void src_view___::scroll2__(GtkTextIter* ti) {
gtk_text_buffer_place_cursor(buf2__(), ti);
GtkTextIter i1,i2;
gtk_text_buffer_get_selection_bounds (buf2__(), &i1,&i2);
GdkRectangle rect;
gtk_text_view_get_visible_rect (handle2__(), &rect);
int y = -1;
int height = -1;
gtk_text_view_get_line_yrange (handle2__(), &i1, &y, &height);
if (y < rect.y + rect.height + 16)
gtk_text_view_scroll_to_mark (handle2__(), gtk_text_buffer_get_insert(buf2__()), 0, false, 0, 0);
}
static void bmark_popup_menu_goto_lcb(GtkWidget * widget, gpointer user_data)
{
Tbmark *b;
GtkTextIter it;
if (!user_data)
return;
b = get_current_bmark(BFWIN(user_data));
if (!b)
return;
if (b->filepath && !b->doc) {
/* check if that document _is_ open */
Tdocument *tmpdoc;
GList *doclist = return_allwindows_documentlist();
tmpdoc = documentlist_return_document_from_filename(doclist, b->filepath);
g_list_free(doclist);
if (tmpdoc == NULL) {
if (!g_file_test(b->filepath, G_FILE_TEST_EXISTS)) {
gchar *string = g_strdup_printf(_("Could not find the file \"%s\"."), b->filepath);
error_dialog(BFWIN(user_data)->main_window, string,
_("This bookmark is set in a file that no longer exists."));
g_free(string);
return;
}
tmpdoc = doc_new_with_file(BFWIN(user_data), b->filepath, FALSE, TRUE);
}
/* now I have to check all bookmarks */
bmark_set_for_doc(tmpdoc);
}
if (b->doc) {
GdkRectangle visirect;
GtkTextIter visi_so, visi_eo;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(b->doc->view),&visirect);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(b->doc->view), &visi_so, visirect.x, visirect.y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(b->doc->view), &visi_eo, visirect.x + visirect.width, visirect.y + visirect.height);
gtk_text_buffer_get_iter_at_mark(b->doc->buffer, &it, b->mark);
gtk_text_buffer_place_cursor(b->doc->buffer, &it);
if (!gtk_text_iter_in_range(&it,&visi_so,&visi_eo)) {
DEBUG_MSG("bmark_popup_menu_goto_lcb, cursor NOT visible!\n");
/* gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(b->doc->view), b->mark); */
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(b->doc->view),b->mark,0.0,
TRUE,0.5,0.5);
}
if (b->doc != BFWIN(user_data)->current_document)
switch_to_document_by_pointer(BFWIN(user_data), b->doc);
gtk_widget_grab_focus(b->doc->view);
}
}
void scroll_mainview_up(){
GtkTextIter iter;
GdkRectangle rect;
gint distance;
gint i;
LOG(LOG_DEBUG, "IN : scroll_mainview_up()");
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(main_view), &rect);
distance = rect.height - scroll_margin;
if(bsmooth_scroll == TRUE){
for(i=0 ; i < scroll_step; i ++){
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(main_view),
&iter,
rect.x,
rect.y - (distance / scroll_step)*(i+1));
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(main_view),
&iter,
0.0,
TRUE,
0.0, 0.0);
#ifdef __WIN32__
Sleep(scroll_time / scroll_step / 1000);
#else
usleep(scroll_time / scroll_step);
#endif
}
} else {
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(main_view),
&iter,
rect.x,
rect.y - distance);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(main_view),
&iter,
0.0,
TRUE,
0.0, 0.0);
}
LOG(LOG_DEBUG, "OUT : scroll_mainview_up()");
}
static int
imhtml_expose_cb(GtkWidget *widget, GdkEventExpose *event, PidginConversation *gtkconv)
{
int y, last_y, offset;
GdkRectangle visible_rect;
GtkTextIter iter;
GdkRectangle buf;
int pad;
PurpleConversation *conv = gtkconv->active_conv;
PurpleConversationType type = purple_conversation_get_type(conv);
if ((type == PURPLE_CONV_TYPE_CHAT && !purple_prefs_get_bool(PREF_CHATS)) ||
(type == PURPLE_CONV_TYPE_IM && !purple_prefs_get_bool(PREF_IMS)))
return FALSE;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(widget), &visible_rect);
offset = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "markerline"));
if (offset)
{
gtk_text_buffer_get_iter_at_offset(gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget)),
&iter, offset);
gtk_text_view_get_iter_location(GTK_TEXT_VIEW(widget), &iter, &buf);
last_y = buf.y + buf.height;
pad = (gtk_text_view_get_pixels_below_lines(GTK_TEXT_VIEW(widget)) +
gtk_text_view_get_pixels_above_lines(GTK_TEXT_VIEW(widget))) / 2;
last_y += pad;
}
else
last_y = 0;
gtk_text_view_buffer_to_window_coords(GTK_TEXT_VIEW(widget), GTK_TEXT_WINDOW_TEXT,
0, last_y, 0, &y);
if (y >= event->area.y)
{
GdkColor red = {0, 0xffff, 0, 0};
GdkGC *gc = gdk_gc_new(GDK_DRAWABLE(event->window));
gdk_gc_set_rgb_fg_color(gc, &red);
gdk_draw_line(event->window, gc,
0, y, visible_rect.width, y);
g_object_unref(G_OBJECT(gc));
}
return FALSE;
}
static void
update_scrubber_position (GtkSourceMap *map)
{
GtkSourceMapPrivate *priv;
GtkTextIter iter;
GdkRectangle visible_area;
GdkRectangle iter_area;
GdkRectangle scrubber_area;
GtkAllocation alloc;
GtkAllocation view_alloc;
gint child_height;
gint view_height;
gint y;
priv = gtk_source_map_get_instance_private (map);
if (priv->view == NULL)
{
return;
}
gtk_widget_get_allocation (GTK_WIDGET (priv->view), &view_alloc);
gtk_widget_get_allocation (GTK_WIDGET (map), &alloc);
gtk_widget_get_preferred_height (GTK_WIDGET (priv->view), NULL, &view_height);
gtk_widget_get_preferred_height (GTK_WIDGET (priv->child_view), NULL, &child_height);
gtk_text_view_get_visible_rect (GTK_TEXT_VIEW (priv->view), &visible_area);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (priv->view), &iter,
visible_area.x, visible_area.y);
gtk_text_view_get_iter_location (GTK_TEXT_VIEW (priv->child_view), &iter, &iter_area);
gtk_text_view_buffer_to_window_coords (GTK_TEXT_VIEW (priv->child_view),
GTK_TEXT_WINDOW_WIDGET,
iter_area.x, iter_area.y,
NULL, &y);
scrubber_area.x = 0;
scrubber_area.width = alloc.width;
scrubber_area.y = y;
scrubber_area.height = (gdouble)view_alloc.height / (gdouble)view_height * (gdouble)child_height;
if (memcmp (&scrubber_area, &priv->scrubber_area, sizeof scrubber_area) != 0)
{
priv->scrubber_area = scrubber_area;
gtk_widget_queue_draw (GTK_WIDGET (map));
}
}
static void
paint_widget_icons (GcrDisplayView *self, cairo_t *cr)
{
GHashTableIter hit;
GtkTextView *view;
GdkRectangle visible;
GdkRectangle location;
GcrDisplayItem *item;
gpointer value;
GtkTextIter iter;
view = GTK_TEXT_VIEW (self);
gtk_text_view_get_visible_rect (view, &visible);
g_hash_table_iter_init (&hit, self->pv->items);
while (g_hash_table_iter_next (&hit, NULL, &value)) {
item = value;
if (item->pixbuf == NULL)
continue;
gtk_text_buffer_get_iter_at_mark (self->pv->buffer, &iter, item->beginning);
gtk_text_view_get_iter_location (view, &iter, &location);
location.height = gdk_pixbuf_get_height (item->pixbuf);
location.width = gdk_pixbuf_get_width (item->pixbuf);
location.x = visible.width - location.width - ICON_MARGIN;
if (!gdk_rectangle_intersect (&visible, &location, NULL))
continue;
gtk_text_view_buffer_to_window_coords (view, GTK_TEXT_WINDOW_TEXT,
location.x, location.y,
&location.x, &location.y);
cairo_save (cr);
gdk_cairo_set_source_pixbuf (cr, item->pixbuf, location.x, location.y);
cairo_rectangle (cr, location.x, location.y, location.width, location.height);
cairo_fill (cr);
cairo_restore (cr);
}
}
static gint
get_last_visible_line_number (GtkSourceGutterRendererLines *lines)
{
GtkTextView *view;
GdkRectangle visible_rect;
GtkTextIter iter;
view = gtk_source_gutter_renderer_get_view (GTK_SOURCE_GUTTER_RENDERER (lines));
gtk_text_view_get_visible_rect (view, &visible_rect);
gtk_text_view_get_line_at_y (view,
&iter,
visible_rect.y + visible_rect.height,
NULL);
gtk_text_iter_forward_line (&iter);
return gtk_text_iter_get_line (&iter);
}
void
gb_source_view_move_next_match (GbSourceView *view)
{
GtkTextBuffer *buffer;
GdkRectangle rect;
GtkTextIter iter;
GtkTextTag *search_tag;
gboolean wrapped = FALSE;
g_return_if_fail(GB_IS_SOURCE_VIEW(view));
/*
* TODO: Track current match, so move next match jumps past it next time.
*/
search_tag = gb_source_view_ref_search_tag(view);
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(view), &rect);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(view),
&iter, rect.x, rect.y);
again:
if (!gtk_text_iter_begins_tag(&iter, search_tag)) {
if (gtk_text_iter_forward_to_tag_toggle(&iter, search_tag)) {
if (!gtk_text_iter_begins_tag(&iter, search_tag)) {
gtk_text_iter_backward_to_tag_toggle(&iter, search_tag);
}
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(view), &iter,
0.25, FALSE, 0, 0);
goto cleanup;
}
if (!wrapped) {
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
gtk_text_buffer_get_start_iter(buffer, &iter);
wrapped = TRUE;
goto again;
}
}
cleanup:
g_object_unref(search_tag);
}
static void
snapshot_background (GtkWidget *widget,
GtkSnapshot *snapshot)
{
GdkRectangle visible_rect;
gtk_text_view_get_visible_rect (GTK_TEXT_VIEW (widget), &visible_rect);
gtk_snapshot_append_color (snapshot,
&(GdkRGBA) { CHECK_DARK, CHECK_DARK, CHECK_DARK, 1.0 },
&GRAPHENE_RECT_INIT(visible_rect.x, visible_rect.y, visible_rect.width, visible_rect.height));
gtk_snapshot_push_repeat (snapshot,
&GRAPHENE_RECT_INIT(visible_rect.x, visible_rect.y, visible_rect.width, visible_rect.height),
&GRAPHENE_RECT_INIT(visible_rect.x, visible_rect.y, CHECK_SIZE * 2, CHECK_SIZE * 2));
gtk_snapshot_append_color (snapshot,
&(GdkRGBA) { CHECK_LIGHT, CHECK_LIGHT, CHECK_LIGHT, 1.0 },
&GRAPHENE_RECT_INIT(visible_rect.x, visible_rect.y, CHECK_SIZE, CHECK_SIZE));
gtk_snapshot_append_color (snapshot,
&(GdkRGBA) { CHECK_LIGHT, CHECK_LIGHT, CHECK_LIGHT, 1.0 },
&GRAPHENE_RECT_INIT(visible_rect.x + CHECK_SIZE, visible_rect.y + CHECK_SIZE, CHECK_SIZE, CHECK_SIZE));
gtk_snapshot_pop (snapshot);
}
CAMLprim value ml_gtk_text_view_get_visible_rect (value tv)
{
GdkRectangle res;
gtk_text_view_get_visible_rect(GtkTextView_val(tv), &res);
return Val_copy(res);
}
// append a string to the WarlockView
// string needs to be valid UTF-8, and gets mangled, sorry.
static void
view_append (WarlockView *view, WString *string)
{
GtkTextIter iter;
GtkTextBuffer *buffer;
GtkTextIter start, end;
GList *list_current;
GdkRectangle rect;
int y, height;
gboolean scroll;
g_assert (view != NULL);
buffer = view->text_buffer;
list_current = NULL;
// Get the end of the buffer
gtk_text_buffer_get_end_iter (buffer, &iter);
// test if we should scroll
gtk_text_view_get_visible_rect (GTK_TEXT_VIEW (view->text_view), &rect);
gtk_text_view_get_line_yrange (GTK_TEXT_VIEW(view->text_view), &iter,
&y, &height);
if(((y + height) - (rect.y + rect.height)) > height){
scroll = FALSE;
} else {
scroll = TRUE;
}
// highlighting stuff
highlight_match (string);
// FIXME the following lines should be done through hooks
// script stuff
script_match_string (string->string->str);
// log it
warlock_log (string->string->str);
// Put the mark there that will stay in the same place when we insert
// text as a reference for highlighting
gtk_text_buffer_move_mark (buffer, view->mark, &iter);
gtk_text_buffer_insert (buffer, &iter, string->string->str, -1);
// markup the buffer with the tags from our string
for (list_current = string->highlights; list_current != NULL;
list_current = list_current->next) {
WHighlight *tmp = list_current->data;
debug ("tag: %s offset: %d length: %d\n", tmp->tag_name,
tmp->offset, tmp->length);
gtk_text_buffer_get_iter_at_mark (buffer, &start, view->mark);
gtk_text_iter_forward_chars (&start, tmp->offset);
end = start;
gtk_text_iter_forward_chars (&end, tmp->length);
gtk_text_buffer_apply_tag_by_name (buffer, tmp->tag_name,
&start, &end);
}
if (scroll) {
// scroll the end mark on the screen.
gtk_text_iter_set_line_offset (&iter, 0);
gtk_text_buffer_move_mark (buffer, view->mark, &iter);
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view->text_view),
view->mark, 0, TRUE, 1.0, 0.0);
}
// Cut off beginning lines that don't fit in the buffer.
warlock_view_trim (view);
if (view == main_view)
prompting = FALSE;
}
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 gboolean cb_key_press_event(GtkWidget *view, GdkEventKey *event)
{
GtkTextBuffer *buffer;
GtkTextMark *mark;
GtkTextIter iter;
GdkRectangle prev_rect;
if (check_preedit(view))
return FALSE;
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);
gtk_text_view_get_iter_location(GTK_TEXT_VIEW(view), &iter, &prev_rect);
keyval = 0;
//g_print("key-press-event: 0x%X\n", event->keyval);
switch (event->keyval) {
case GDK_Up: // Try [Shift]+[Down]. it works bad.
case GDK_Down:
if (gtk_text_view_move_mark_onscreen(GTK_TEXT_VIEW(view), mark)) {
GdkRectangle iter_rect;
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
gtk_text_view_get_iter_location(GTK_TEXT_VIEW(view), &iter, &iter_rect);
if (iter_rect.y < prev_rect.y) {
gtk_text_view_get_line_at_y(GTK_TEXT_VIEW(view), &iter,
iter_rect.y - iter_rect.height, NULL);
gtk_text_buffer_move_mark(buffer, mark, &iter);
}
if (!(event->state & GDK_SHIFT_MASK)) {
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
gtk_text_buffer_place_cursor(buffer, &iter);
}
return TRUE;
}
break;
case GDK_Page_Up:
case GDK_Page_Down:
if (gtk_text_view_move_mark_onscreen(GTK_TEXT_VIEW(view), mark)) {
GdkRectangle visible_rect, iter_rect;
gint pos = 0;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(view), &visible_rect);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
gtk_text_view_get_iter_location(GTK_TEXT_VIEW(view), &iter, &iter_rect);
if (iter_rect.y < prev_rect.y)
pos = 1;
if (event->keyval == GDK_Page_Up)
gtk_text_view_get_line_at_y(GTK_TEXT_VIEW(view), &iter,
iter_rect.y - visible_rect.height + iter_rect.height, NULL);
else
gtk_text_view_get_line_at_y(GTK_TEXT_VIEW(view), &iter,
iter_rect.y + visible_rect.height - iter_rect.height, NULL);
gtk_text_buffer_move_mark(buffer, mark, &iter);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(view),
mark, 0, TRUE, 0, pos);
if (!(event->state & GDK_SHIFT_MASK)) {
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
gtk_text_buffer_place_cursor(GTK_TEXT_VIEW(view)->buffer, &iter);
}
return TRUE;
}
break;
case GDK_Return:
if (indent_get_state()) {
indent_real(view);
return TRUE;
}
break;
case GDK_Tab:
if (event->state & GDK_CONTROL_MASK) {
indent_toggle_tab_width(view);
return TRUE;
}
case GDK_ISO_Left_Tab:
if (event->state & GDK_SHIFT_MASK)
indent_multi_line_unindent(GTK_TEXT_VIEW(view)->buffer);
else if (!check_selection_bound(GTK_TEXT_VIEW(view)->buffer))
break;
else
indent_multi_line_indent(GTK_TEXT_VIEW(view)->buffer);
return TRUE;
}
keyval = event->keyval;
if ((event->state & GDK_CONTROL_MASK)
|| (event->keyval == GDK_Control_L)
|| (event->keyval == GDK_Control_R)) {
keyval = keyval + 0x10000;
//g_print("=================================================\n");
}
return FALSE;
}
/*
* Append a line of text to the buffer
*/
void html_text_buffer_append(GtkTextView *text_view, char *txt, int ignore)
{
gchar *text = convert_to_utf8(txt);
GtkTextIter iter;
GtkTextMark *insert_mark;
GdkRectangle iter_loc;
GdkRectangle visible_rect;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(text_view);
if (strcasestr(text, "<br>")) {
char *c = text;
while ((c = strchr(text, '\n')) != 0)
*c = ' ';
while ((c = strchr(text, '\r')) != 0)
*c = ' ';
} else if (strchr(text, '\r')) {
char *c = text;
if (strchr(text, '\n')) {
while ((c = strchr(c, '\r')) != 0)
*c = ' ';
} else {
while ((c = strchr(c, '\r')) != 0)
*c = '\n';
}
}
gtk_text_buffer_get_end_iter(buffer, &iter);
insert_mark = gtk_text_buffer_get_mark(buffer, "real_end_mark");
if (insert_mark) {
GtkTextIter del;
gtk_text_buffer_get_iter_at_mark(buffer, &del, insert_mark);
gtk_text_buffer_delete(buffer, &del, &iter);
gtk_text_buffer_get_end_iter(buffer, &iter);
}
else
insert_mark = gtk_text_buffer_create_mark(buffer,
"real_end_mark", &iter, TRUE);
/* Decide first if we want to scroll the text to the end or not */
gtk_text_view_get_iter_location(text_view, &iter, &iter_loc);
gtk_text_view_get_visible_rect(text_view, &visible_rect);
gtk_text_buffer_insert(buffer, &iter, text, -1);
parse_html(text_view, *insert_mark, ignore);
if (iter_loc.y <= visible_rect.y + visible_rect.height) {
GtkTextMark *end_mark;
gtk_text_buffer_get_end_iter(buffer, &iter);
end_mark = gtk_text_buffer_create_mark(buffer, NULL, &iter,
TRUE);
gtk_text_view_scroll_mark_onscreen(text_view, end_mark);
gtk_text_buffer_delete_mark(buffer, end_mark);
}
if (!(ignore & HTML_IGNORE_END))
gtk_text_buffer_delete_mark(buffer, insert_mark);
g_free(text);
}
static void
ide_source_view_movements_move_page (Movement *mv)
{
GtkTextView *text_view = (GtkTextView *)mv->self;
GtkTextBuffer *buffer;
GtkTextMark *mark;
GdkRectangle rect;
GtkTextIter iter_top;
GtkTextIter iter_bottom;
GtkTextIter scroll_iter;
gint scrolloff;
gint half_page;
gint line_top;
gint line_bottom;
gtk_text_view_get_visible_rect (text_view, &rect);
gtk_text_view_get_iter_at_location (text_view, &iter_top, rect.x, rect.y);
gtk_text_view_get_iter_at_location (text_view, &iter_bottom,
rect.x + rect.width,
rect.y + rect.height);
buffer = gtk_text_view_get_buffer (text_view);
line_top = gtk_text_iter_get_line (&iter_top);
line_bottom = gtk_text_iter_get_line (&iter_bottom);
half_page = MAX (1, (line_bottom - line_top) / 2);
scrolloff = MIN (ide_source_view_get_scroll_offset (mv->self), half_page);
switch ((int)mv->type)
{
case IDE_SOURCE_VIEW_MOVEMENT_HALF_PAGE_UP:
ide_source_view_movements_scroll_by_lines (mv, -half_page);
gtk_text_iter_backward_lines (&mv->insert, half_page);
break;
case IDE_SOURCE_VIEW_MOVEMENT_HALF_PAGE_DOWN:
ide_source_view_movements_scroll_by_lines (mv, half_page);
gtk_text_iter_forward_lines (&mv->insert, half_page);
break;
case IDE_SOURCE_VIEW_MOVEMENT_PAGE_UP:
gtk_text_buffer_get_iter_at_line (buffer, &mv->insert, MAX (0, line_top - scrolloff));
text_iter_forward_to_nonspace_captive (&mv->insert);
ide_source_view_movements_select_range (mv);
mark = _ide_source_view_get_scroll_mark (mv->self);
gtk_text_buffer_get_iter_at_line (buffer, &scroll_iter, line_top);
gtk_text_buffer_move_mark (buffer, mark, &scroll_iter);
gtk_text_view_scroll_to_mark (text_view, mark, 0.0, TRUE, 1.0, 1.0);
mv->ignore_select = TRUE;
mv->ignore_scroll_to_insert = TRUE;
break;
case IDE_SOURCE_VIEW_MOVEMENT_PAGE_DOWN:
gtk_text_buffer_get_iter_at_line (buffer, &mv->insert, line_bottom + scrolloff);
text_iter_forward_to_nonspace_captive (&mv->insert);
ide_source_view_movements_select_range (mv);
mark = _ide_source_view_get_scroll_mark (mv->self);
gtk_text_buffer_get_iter_at_line (buffer, &scroll_iter, line_bottom);
gtk_text_buffer_move_mark (buffer, mark, &scroll_iter);
gtk_text_view_scroll_to_mark (text_view, mark, 0.0, TRUE, 1.0, 0.0);
mv->ignore_select = TRUE;
mv->ignore_scroll_to_insert = TRUE;
break;
default:
g_assert_not_reached();
}
}
