index 39ebc17d1d2fb7f0f0c20e2b75eff179332ad141..fef2fcc0c1f4653ba54b02a3a3dff92cd079ce11 100644 (file)
#include <libnr/nr-convex-hull.h>
#include "prefs-utils.h"
+// Tiles are a way to minimize the number of redraws, eliminating too small redraws.
+// The canvas stores a 2D array of ints, each representing a TILE_SIZExTILE_SIZE pixels tile.
+// If any part of it is dirtied, the entire tile is dirtied (its int is nonzero) and repainted.
+#define TILE_SIZE 32
+
enum {
RENDERMODE_NORMAL,
RENDERMODE_NOAA,
@@ -739,11 +744,16 @@ sp_canvas_group_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned i
}
}
- NR::Rect const &bounds = corners.bounds();
- item->x1 = bounds.min()[NR::X];
- item->y1 = bounds.min()[NR::Y];
- item->x2 = bounds.max()[NR::X];
- item->y2 = bounds.max()[NR::Y];
+ NR::Maybe<NR::Rect> const bounds = corners.bounds();
+ if (bounds) {
+ item->x1 = bounds->min()[NR::X];
+ item->y1 = bounds->min()[NR::Y];
+ item->x2 = bounds->max()[NR::X];
+ item->y2 = bounds->max()[NR::Y];
+ } else {
+ // FIXME ?
+ item->x1 = item->x2 = item->y1 = item->y2 = 0;
+ }
}
/**
canvas->forced_redraw_limit = -1;
canvas->slowest_buffer = 0;
+
+ canvas->is_scrolling = false;
+
}
/**
@@ -1552,7 +1565,13 @@ sp_canvas_paint_single_buffer (SPCanvas *canvas, int x0, int y0, int x1, int y1,
x1 - x0, y1 - y0);
} else {
/*
- CAIRO FIXME: after SPCanvasBuf is made 32bpp throughout, this rgb_draw below can be replaced with:
+// CAIRO FIXME: after SPCanvasBuf is made 32bpp throughout, this rgb_draw below can be replaced with the below.
+// Why this must not be done currently:
+// - all canvas items (handles, nodes etc) paint themselves assuming 24bpp
+// - cairo assumes bgra, but we have rgba, so r and b get swapped (until we paint all with cairo too)
+// - it does not seem to be any faster; in fact since with 32bpp, buf contains less pixels,
+// we need more bufs to paint a given area and as a result it's even a bit slower
+
cairo_surface_t* cst = cairo_image_surface_create_for_data (
buf.buf,
CAIRO_FORMAT_RGB24, // unpacked, i.e. 32 bits! one byte is unused
@@ -1562,7 +1581,6 @@ sp_canvas_paint_single_buffer (SPCanvas *canvas, int x0, int y0, int x1, int y1,
cairo_t *ct = gdk_cairo_create(SP_CANVAS_WINDOW (canvas));
cairo_set_source_surface (ct, cst, x0 - canvas->x0, y0 - canvas->y0);
cairo_paint (ct);
-
cairo_destroy (ct);
cairo_surface_finish (cst);
cairo_surface_destroy (cst);
@@ -1692,8 +1710,23 @@ sp_canvas_paint_rect_internal (SPCanvas *canvas, NRRectL *rect, NR::ICoord *x_ab
dy1 = MIN (dy1, draw_y2);
}
+ // SMOOTH SCROLLING: if we are scrolling, process pending events even before doing any rendering.
+ // This allows for scrolling smoothly without hiccups. Any accumulated redraws will be made
+ // when scrolling stops. The scrolling flag is set by sp_canvas_scroll_to for each scroll and zeroed
+ // here for each redraw, to ensure it never gets stuck.
+
// OPTIMIZATION IDEA: if drawing is really slow (as measured by canvas->slowest
- // buffer), process some events even BEFORE we do any buffers?
+ // buffer), do the same - process some events even before we paint any buffers
+
+ if (canvas->is_scrolling) {
+ while (Gtk::Main::events_pending()) { // process any events
+ Gtk::Main::iteration(false);
+ }
+ canvas->is_scrolling = false;
+ if (this_count != canvas->redraw_count) { // if there was redraw,
+ return 1; // interrupt this one
+ }
+ }
// Paint one buffer; measure how long it takes.
g_get_current_time (&tstart);
int const canvas_x1 = canvas->x0 + widget->allocation.width;
int const canvas_y1 = canvas->y0 + widget->allocation.height;
- NRRectL topaint;
- topaint.x0 = topaint.y0 = topaint.x1 = topaint.y1 = 0;
+ bool dirty = false;
- for (int j=canvas->tTop&(~3);j<canvas->tBottom;j+=4) {
- for (int i=canvas->tLeft&(~3);i<canvas->tRight;i+=4) {
- int mode=0;
-
- int pl=i+1,pr=i,pt=j+4,pb=j;
- for (int l=MAX(j,canvas->tTop);l<MIN(j+4,canvas->tBottom);l++) {
- for (int k=MAX(i,canvas->tLeft);k<MIN(i+4,canvas->tRight);k++) {
- if ( canvas->tiles[(k-canvas->tLeft)+(l-canvas->tTop)*canvas->tileH] ) {
- mode|=1<<((k-i)+(l-j)*4);
- if ( k < pl ) pl=k;
- if ( k+1 > pr ) pr=k+1;
- if ( l < pt ) pt=l;
- if ( l+1 > pb ) pb=l+1;
- }
- canvas->tiles[(k-canvas->tLeft)+(l-canvas->tTop)*canvas->tileH]=0;
- }
- }
-
- if ( mode ) {
- NRRectL tile;
- tile.x0 = MAX (pl*32, canvas->x0);
- tile.y0 = MAX (pt*32, canvas->y0);
- tile.x1 = MIN (pr*32, canvas_x1);
- tile.y1 = MIN (pb*32, canvas_y1);
- if ((tile.x0 < tile.x1) && (tile.y0 < tile.y1)) {
- nr_rect_l_union (&topaint, &topaint, &tile);
- }
+ int pl = canvas->tRight, pr = canvas->tLeft, pt = canvas->tBottom, pb = canvas->tTop; // start with "inverted" tile rect
+
+ for (int j=canvas->tTop; j<canvas->tBottom; j++) {
+ for (int i=canvas->tLeft; i<canvas->tRight; i++) {
+
+ int tile_index = (i - canvas->tLeft) + (j - canvas->tTop)*canvas->tileH;
+ if ( canvas->tiles[tile_index] ) { // if this tile is dirtied (nonzero)
+ dirty = true;
+ // make (pl..pr)x(pt..pb) the minimal rect covering all dirtied tiles
+ if ( i < pl ) pl = i;
+ if ( i+1 > pr ) pr = i+1;
+ if ( j < pt ) pt = j;
+ if ( j+1 > pb ) pb = j+1;
}
+
+ canvas->tiles[tile_index] = 0; // undirty this tile
}
}
canvas->need_redraw = FALSE;
- sp_canvas_paint_rect (canvas, topaint.x0, topaint.y0, topaint.x1, topaint.y1);
+
+ if ( dirty ) {
+ NRRectL topaint;
+ topaint.x0 = MAX (pl*TILE_SIZE, canvas->x0);
+ topaint.y0 = MAX (pt*TILE_SIZE, canvas->y0);
+ topaint.x1 = MIN (pr*TILE_SIZE, canvas_x1);
+ topaint.y1 = MIN (pb*TILE_SIZE, canvas_y1);
+ if ((topaint.x0 < topaint.x1) && (topaint.y0 < topaint.y1)) {
+ sp_canvas_paint_rect (canvas, topaint.x0, topaint.y0, topaint.x1, topaint.y1);
+ }
+ }
return TRUE;
}
* Scrolls canvas to specific position.
*/
void
-sp_canvas_scroll_to (SPCanvas *canvas, double cx, double cy, unsigned int clear)
+sp_canvas_scroll_to (SPCanvas *canvas, double cx, double cy, unsigned int clear, bool is_scrolling)
{
g_return_if_fail (canvas != NULL);
g_return_if_fail (SP_IS_CANVAS (canvas));
@@ -2150,27 +2180,14 @@ sp_canvas_scroll_to (SPCanvas *canvas, double cx, double cy, unsigned int clear)
canvas->x0 = ix;
canvas->y0 = iy;
- sp_canvas_resize_tiles(canvas,canvas->x0,canvas->y0,canvas->x0+canvas->widget.allocation.width,canvas->y0+canvas->widget.allocation.height);
+ sp_canvas_resize_tiles (canvas, canvas->x0, canvas->y0, canvas->x0+canvas->widget.allocation.width, canvas->y0+canvas->widget.allocation.height);
if (!clear) {
// scrolling without zoom; redraw only the newly exposed areas
if ((dx != 0) || (dy != 0)) {
- int width, height;
- width = canvas->widget.allocation.width;
- height = canvas->widget.allocation.height;
+ canvas->is_scrolling = is_scrolling;
if (GTK_WIDGET_REALIZED (canvas)) {
gdk_window_scroll (SP_CANVAS_WINDOW (canvas), -dx, -dy);
- gdk_window_process_updates (SP_CANVAS_WINDOW (canvas), TRUE);
- }
- if (dx < 0) {
- sp_canvas_request_redraw (canvas, ix + 0, iy + 0, ix - dx, iy + height);
- } else if (dx > 0) {
- sp_canvas_request_redraw (canvas, ix + width - dx, iy + 0, ix + width, iy + height);
- }
- if (dy < 0) {
- sp_canvas_request_redraw (canvas, ix + 0, iy + 0, ix + width, iy - dy);
- } else if (dy > 0) {
- sp_canvas_request_redraw (canvas, ix + 0, iy + height - dy, ix + width, iy + height);
}
}
} else {
@@ -2301,7 +2318,7 @@ bool sp_canvas_world_pt_inside_window(SPCanvas const *canvas, NR::Point const &w
}
/**
- * Return canvas window coordinates as NRRect.
+ * Return canvas window coordinates as NR::Rect.
*/
NR::Rect SPCanvas::getViewbox() const
{
inline int sp_canvas_tile_floor(int x)
{
- return (x&(~31))/32;
+ return (x & (~(TILE_SIZE - 1))) / TILE_SIZE;
}
inline int sp_canvas_tile_ceil(int x)
{
- return ((x+31)&(~31))/32;
+ return ((x + (TILE_SIZE - 1)) & (~(TILE_SIZE - 1))) / TILE_SIZE;
}
/**
- * Helper that changes tile size for canvas redraw.
+ * Helper that allocates a new tile array for the canvas, copying overlapping tiles from the old array
*/
void sp_canvas_resize_tiles(SPCanvas* canvas,int nl,int nt,int nr,int nb)
{
int tr=sp_canvas_tile_ceil(nr);
int tb=sp_canvas_tile_ceil(nb);
- int nh=tr-tl,nv=tb-tt;
- uint8_t* ntiles=(uint8_t*)g_malloc(nh*nv*sizeof(uint8_t));
- for (int i=tl;i<tr;i++) {
- for (int j=tt;j<tb;j++) {
- int ind=(i-tl)+(j-tt)*nh;
+ int nh = tr-tl, nv = tb-tt;
+ uint8_t* ntiles = (uint8_t*)g_malloc(nh*nv*sizeof(uint8_t));
+ for (int i=tl; i<tr; i++) {
+ for (int j=tt; j<tb; j++) {
+ int ind = (i-tl) + (j-tt)*nh;
if ( i >= canvas->tLeft && i < canvas->tRight && j >= canvas->tTop && j < canvas->tBottom ) {
- ntiles[ind]=canvas->tiles[(i-canvas->tLeft)+(j-canvas->tTop)*canvas->tileH];
+ ntiles[ind]=canvas->tiles[(i-canvas->tLeft)+(j-canvas->tTop)*canvas->tileH]; // copy from the old tile
} else {
- ntiles[ind]=0;
+ ntiles[ind]=0; // newly exposed areas get 0
}
}
}
}
/**
- * Helper that marks specific canvas rectangle for redraw.
+ * Helper that marks specific canvas rectangle for redraw by dirtying its tiles
*/
void sp_canvas_dirty_rect(SPCanvas* canvas,int nl,int nt,int nr,int nb)
{
canvas->need_redraw = TRUE;
- for (int i=tl;i<tr;i++) {
- for (int j=tt;j<tb;j++) {
- canvas->tiles[(i-canvas->tLeft)+(j-canvas->tTop)*canvas->tileH]=1;
+ for (int i=tl; i<tr; i++) {
+ for (int j=tt; j<tb; j++) {
+ canvas->tiles[(i-canvas->tLeft)+(j-canvas->tTop)*canvas->tileH] = 1;
}
}
}