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