sp-canvas.cpp revision 1c08f6f5db209751a0e337ffd4c9b2dd850e5c7f
/** \file
* Port of GnomeCanvas for Inkscape needs
*
* Authors:
* Federico Mena <federico@nuclecu.unam.mx>
* Raph Levien <raph@gimp.org>
* Lauris Kaplinski <lauris@kaplinski.com>
* fred
* bbyak
*
* Copyright (C) 1998 The Free Software Foundation
* Copyright (C) 2002-2006 authors
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <gtkmm.h>
#include "helper/sp-marshal.h"
#include <helper/recthull.h>
#include "display-forward.h"
#include "display/sp-canvas.h"
#include "display/sp-canvas-group.h"
#include "preferences.h"
#include "inkscape.h"
#include "sodipodi-ctrlrect.h"
#include "cms-system.h"
#include "display/rendermode.h"
#include "display/cairo-utils.h"
#include "debug/gdk-event-latency-tracker.h"
#include "desktop.h"
#include "sp-namedview.h"
// gtk_check_version returns non-NULL on failure
static bool const HAS_BROKEN_MOTION_HINTS =
// Define this to visualize the regions to be redrawn
//#define DEBUG_REDRAW 1;
// 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 16
enum {
};
/**
* A group of Items.
*/
struct SPCanvasGroup {
};
/**
* The SPCanvasGroup vtable.
*/
struct SPCanvasGroupClass {
};
/**
* The SPCanvas vtable.
*/
struct SPCanvasClass {
};
/* SPCanvasItem */
enum {ITEM_EVENT, ITEM_LAST_SIGNAL};
enum {PROP_0, PROP_VISIBLE};
static void sp_canvas_item_construct (SPCanvasItem *item, SPCanvasGroup *parent, gchar const *first_arg_name, va_list args);
/**
* Registers the SPCanvasItem class with Glib and returns its type number.
*/
sp_canvas_item_get_type (void)
{
if (!type) {
sizeof (SPCanvasItemClass),
sizeof (SPCanvasItem),
0,
};
}
return type;
}
/**
* Initializes the SPCanvasItem vtable and the "event" signal.
*/
static void
{
G_TYPE_BOOLEAN, 1,
}
/**
* Callback for initialization of SPCanvasItem.
*/
static void
{
// TODO items should not be visible on creation - this causes kludges with items
// that should be initially invisible; examples of such items: node handles, the CtrlRect
// used for rubberbanding, path outline, etc.
}
/**
* Constructs new SPCanvasItem on SPCanvasGroup.
*/
{
return item;
}
/**
* Sets up the newly created SPCanvasItem.
*
* We make it static for encapsulation reasons since it was nowhere used.
*/
static void
sp_canvas_item_construct (SPCanvasItem *item, SPCanvasGroup *parent, gchar const *first_arg_name, va_list args)
{
}
/**
* Helper function that requests redraw only if item's visible flag is set.
*/
static void
{
sp_canvas_request_redraw (item->canvas, (int)(item->x1), (int)(item->y1), (int)(item->x2 + 1), (int)(item->y2 + 1));
}
}
}
/**
* Callback that removes item from all referers and destroys it.
*/
static void
{
// Hack: if this is a ctrlrect, move it to 0,0;
// this redraws only the stroke of the rect to be deleted,
// avoiding redraw of the entire area
if (SP_IS_CTRLRECT(item)) {
} else {
}
}
}
}
}
}
/**
* Helper function to update item and its children.
*
* NB! affine is parent2canvas.
*/
static void
{
/* Apply the child item's transform */
/* apply object flags to child flags */
}
}
/**
* Helper function to invoke the point method of the item.
*
* The argument x, y should be in the parent's item-relative coordinate
* system. This routine applies the inverse of the item's transform,
* maintaining the affine invariant.
*/
static double
{
}
/**
* Makes the item's affine transformation matrix be equal to the specified
* matrix.
*
* @item: A canvas item.
* @affine: An affine transformation matrix.
*/
void
{
} else {
}
}
}
/**
* Convenience function to reorder items in a group's child list.
*
* This puts the specified link after the "before" link.
*/
static void
{
return;
} else {
}
} else {
return;
else {
}
else
}
}
/**
* Raises the item in its parent's stack by the specified number of positions.
*
* \param item A canvas item.
* \param positions Number of steps to raise the item.
*
* If the number of positions is greater than the distance to the top of the
* stack, then the item is put at the top.
*/
void
{
g_return_if_fail (positions >= 0);
return;
if (!before)
}
/**
* Lowers the item in its parent's stack by the specified number of positions.
*
* \param item A canvas item.
* \param positions Number of steps to lower the item.
*
* If the number of positions is greater than the distance to the bottom of the
* stack, then the item is put at the bottom.
**/
void
{
return;
else
}
bool
{
}
/**
* Sets visible flag on item and requests a redraw.
*/
void
{
return;
sp_canvas_request_redraw (item->canvas, (int)(item->x1), (int)(item->y1), (int)(item->x2 + 1), (int)(item->y2 + 1));
}
}
/**
* Clears visible flag on item and requests a redraw.
*/
void
{
return;
sp_canvas_request_redraw (item->canvas, (int)item->x1, (int)item->y1, (int)(item->x2 + 1), (int)(item->y2 + 1));
}
}
/**
* Grab item under cursor.
*
* \pre !canvas->grabbed_item && item->flags & SP_CANVAS_ITEM_VISIBLE
*/
int
{
return -1;
// This test disallows grabbing events by an invisible item, which may be useful
// sometimes. An example is the hidden control point used for the selector component,
// where it is used for object selection and rubberbanding. There seems to be nothing
// preventing this except this test, so I removed it.
// -- Krzysztof Kosiński, 2009.08.12
//if (!(item->flags & SP_CANVAS_ITEM_VISIBLE))
// return -1;
if (HAS_BROKEN_MOTION_HINTS) {
}
/* fixme: Top hack (Lauris) */
/* fixme: If we add key masks to event mask, Gdk will abort (Lauris) */
/* fixme: But Canvas actualle does get key events, so all we need is routing these here */
return 0;
}
/**
* Ungrabs the item, which must have been grabbed in the canvas, and ungrabs the
* mouse.
*
* \param item A canvas item that holds a grab.
* \param etime The timestamp for ungrabbing the mouse.
*/
void
{
return;
}
/**
* Returns the product of all transformation matrices from the root item down
* to the item.
*/
{
while (item) {
}
return affine;
}
/**
* Helper that returns true iff item is descendant of parent.
*/
{
while (item) {
return true;
}
return false;
}
/**
* Focus canvas, and item under cursor if it is not already focussed.
*/
void
{
if (focused_item) {
}
if (focused_item) {
}
}
/**
* Requests that the canvas queue an update for the specified item.
*
* To be used only by item implementations.
*/
void
{
return;
/* Recurse up the tree */
} else {
/* Have reached the top of the tree, make sure the update call gets scheduled. */
}
}
/**
* Returns position of item in group.
*/
{
}
/* SPCanvasGroup */
static void sp_canvas_group_update (SPCanvasItem *item, Geom::Affine const &affine, unsigned int flags);
static double sp_canvas_group_point (SPCanvasItem *item, Geom::Point p, SPCanvasItem **actual_item);
static void sp_canvas_group_visible_area_changed (SPCanvasItem *item, Geom::IntRect const &old_area, Geom::IntRect const &new_area);
static SPCanvasItemClass *group_parent_class;
/**
* Registers SPCanvasGroup class with Gtk and returns its type number.
*/
{
if (!type) {
sizeof(SPCanvasGroupClass),
0, // base_init
0, // base_finalize
0, // class_finalize
0, // class_data
sizeof(SPCanvasGroup),
0, // n_preallocs
0 // value_table
};
type = g_type_register_static(sp_canvas_item_get_type(), "SPCanvasGroup", &info, static_cast<GTypeFlags>(0));
}
return type;
}
/**
* Class initialization function for SPCanvasGroupClass
*/
static void
{
}
/**
* Callback. Empty.
*/
static void
{
/* Nothing here */
}
/**
* Callback that destroys all items in group and calls group's virtual
* destroy() function.
*/
static void
{
while (list) {
}
}
/**
* Update handler for canvas groups
*/
static void
{
bool empty=true;
if (empty) {
empty = false;
} else {
}
}
}
if (bounds) {
} else {
// FIXME ?
}
}
/**
* Point handler for canvas groups.
*/
static double
{
double const x = p[Geom::X];
double const y = p[Geom::Y];
double best = 0.0;
*actual_item = NULL;
double dist = 0.0;
int has_point;
} else
// This metric should be improved, because in case of (partly) overlapping items we will now
// always select the last one that has been added to the group. We could instead select the one
// of which the center is the closest, for example. One can then move to the center
// of the item to be focused, and have that one selected. Of course this will only work if the
// centers are not coincident, but at least it's better than what we have now.
// See the extensive comment in Inkscape::SelTrans::_updateHandles()
}
}
}
return best;
}
/**
* Renders all visible canvas group items in buf rectangle.
*/
static void
{
}
}
}
}
static void
sp_canvas_group_visible_area_changed (SPCanvasItem *item, Geom::IntRect const &old_area, Geom::IntRect const &new_area)
{
}
}
}
/**
* Adds an item to a canvas group.
*/
static void
{
} else {
}
}
/**
* Removes an item from a canvas group
*/
static void
{
/* Unparent the child */
/* Remove it from the list */
break;
}
}
}
/* SPCanvas */
static GtkWidgetClass *canvas_parent_class;
/**
* Registers the SPCanvas class if necessary, and returns the type ID
* associated to it.
*
* \return The type ID of the SPCanvas class.
**/
GType sp_canvas_get_type(void)
{
if (!type) {
sizeof(SPCanvasClass),
0, // base_init
0, // base_finalize
0, // class_finalize
0, // class_data
sizeof(SPCanvas),
0, // n_preallocs
0 // value_table
};
}
return type;
}
/**
* Class initialization function for SPCanvasClass.
*/
static void
{
}
/**
* Callback: object initialization for SPCanvas.
*/
static void
{
/* Create the root item as a special case */
// See comment at in sp-canvas.h.
canvas->gen_all_enter_events = false;
canvas->drawing_disabled = false;
canvas->forced_redraw_count = 0;
#if ENABLE_LCMS
canvas->enable_cms_display_adj = false;
#endif // ENABLE_LCMS
canvas->is_scrolling = false;
}
/**
* Convenience function to remove the idle handler of a canvas.
*/
static void
{
}
}
/*
* Removes the transient state of the canvas (idle handler, grabs).
*/
static void
{
/* We turn off the need_redraw flag, since if the canvas is mapped again
* it will request a redraw anyways. We do not turn off the need_update
* flag, though, because updates are not queued when the canvas remaps
* itself.
*/
if (canvas->need_redraw) {
}
if (canvas->grabbed_item) {
}
}
/**
* Destroy handler for SPCanvas.
*/
static void
{
}
}
//g_warning("Event latency reached %f sec (%1.4f)", *latency, tracker.getSkew());
}
}
/**
* Returns new canvas as widget.
*/
sp_canvas_new_aa (void)
{
}
/**
* The canvas widget's realize callback.
*/
static void
{
0 : GDK_POINTER_MOTION_HINT_MASK ) |
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
}
/**
* The canvas widget's unrealize callback.
*/
static void
{
}
/**
* The canvas widget's size_request callback.
*/
static void
{
}
/**
* The canvas widget's size_allocate callback.
*/
static void
{
/* Schedule redraw of new region */
sp_canvas_resize_tiles(canvas,canvas->x0,canvas->y0,canvas->x0+allocation->width,canvas->y0+allocation->height);
0,
}
0,
}
if (gtk_widget_get_realized (widget)) {
}
}
/**
* Helper that emits an event for an item in the canvas, be it the current
* item, grabbed item, or focused item, as appropriate.
*/
static int
{
if (canvas->grabbed_item) {
case GDK_ENTER_NOTIFY:
break;
case GDK_LEAVE_NOTIFY:
break;
case GDK_MOTION_NOTIFY:
break;
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
break;
case GDK_BUTTON_RELEASE:
break;
case GDK_KEY_PRESS:
break;
case GDK_KEY_RELEASE:
break;
case GDK_SCROLL:
mask = GDK_SCROLL;
break;
default:
mask = 0;
break;
}
}
/* Convert to world coordinates -- we have two cases because of different
* offsets of the fields in the event structures.
*/
case GDK_ENTER_NOTIFY:
case GDK_LEAVE_NOTIFY:
break;
case GDK_MOTION_NOTIFY:
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
break;
default:
break;
}
/* Choose where we send the event */
/* canvas->current_item becomes NULL in some cases under Win32
** (e.g. if the pointer leaves the window). So this is a hack that
** Lauris applied to SP to get around the problem.
*/
} else {
// Make sure that current_item is up-to-date. If a snap indicator was just deleted, then
// sp_canvas_item_dispose has been called and there is no current_item specified. We need
// that though because otherwise we don't know where to send this event to, leading to a
// lost event. We can't wait for idle events to have current_item updated, we need it now!
// Otherwise, scrolling when hovering above a pre-snap indicator won't work (for example)
// See this bug report: https://bugs.launchpad.net/inkscape/+bug/522335/comments/8
// To avoid side effects, we'll only do this for scroll events, because this is the
// only thing we want to fix here. An example of a reported side effect is that
// otherwise selection of nodes in the node editor by dragging a rectangle using a
// tablet will break
}
}
if (canvas->focused_item &&
}
/* The event is propagated up the hierarchy (for if someone connected to
* a group instead of a leaf event), and emission is stopped if a
* handler returns TRUE, just like for GtkWidget events.
*/
}
return finished;
}
/**
* Helper that re-picks the current item in the canvas, based on the event's
*/
static int
{
int button_down = 0;
double x, y;
if (!canvas->root) // canvas may have already be destroyed by closing desktop durring interrupted display!
return FALSE;
if (canvas->gen_all_enter_events == false) {
// If a button is down, we'll perform enter and leave events on the
// current item, but not enter on any other item. This is more or
// less like X pointer grabbing for canvas items.
//
}
/* Save the event in the canvas. This is used to synthesize enter and
* leave events in case the current item changes. It is also used to
* re-pick the current item if the current one gets deleted. Also,
* synthesize an enter event.
*/
/* these fields have the same offsets in both types of events */
/* these fields don't have the same offsets in both types of events */
} else {
}
} else {
}
}
/* Don't do anything else if this is a recursive call */
/* LeaveNotify means that there is no current item, so we don't look for one */
/* these fields don't have the same offsets in both types of events */
} else {
}
/* world coords */
/* find the closest item */
} else {
}
} else {
}
return retval; /* current item did not change */
}
/* Synthesize events for old and new current items */
&& !canvas->left_grabbed_item) {
}
if (canvas->gen_all_enter_events == false) {
// new_current_item may have been set to NULL during the call to
// emit_event() above
return retval;
}
}
/* Handle the rest of cases */
}
return retval;
}
/**
* Button event handler for the canvas.
*/
static gint
{
/* dispatch normally regardless of the event's window if an item
has a pointer grab in effect */
if (!canvas->grabbed_item &&
return retval;
int mask;
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
default:
mask = 0;
}
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
/* Pick the current item as if the button were not pressed, and
* then process the event.
*/
break;
case GDK_BUTTON_RELEASE:
/* Process the event as if the button were pressed, then repick
* after the button has been released
*/
break;
default:
}
return retval;
}
/**
* Scroll event handler for the canvas.
*
* \todo FIXME: generate motion events to re-select items.
*/
static gint
{
}
}
/**
* Motion event handler for the canvas.
*/
static int
{
int status;
return FALSE;
return FALSE;
}
return status;
}
static void sp_canvas_paint_single_buffer(SPCanvas *canvas, int x0, int y0, int x1, int y1, int draw_x1, int draw_y1, int draw_x2, int draw_y2, int /*sw*/)
{
// Mark the region clean
buf.buf_rowstride = 0;
//buf.ct = gdk_cairo_create(widget->window);
// create temporary surface
//cairo_translate(buf.ct, -x0, -y0);
// fix coordinates, clip all drawing to the tile and clear the background
//cairo_translate(buf.ct, x0 - canvas->x0, y0 - canvas->y0);
//cairo_rectangle(buf.ct, 0, 0, x1 - x0, y1 - y0);
//cairo_set_line_width(buf.ct, 3);
//cairo_set_source_rgba(buf.ct, 1.0, 0.0, 0.0, 0.1);
//cairo_stroke_preserve(buf.ct);
//cairo_clip(buf.ct);
//cairo_rectangle(buf.ct, 0, 0, x1 - x0, y1 - y0);
}
// output to X
#if ENABLE_LCMS
if (canvas->enable_cms_display_adj) {
cmsHTRANSFORM transf = 0;
if ( fromDisplay ) {
} else {
}
if (transf) {
for (int i=0; i<h; ++i) {
}
}
}
#endif // ENABLE_LCMS
//cairo_surface_t *cst = cairo_get_target(buf.ct);
//cairo_destroy (buf.ct);
//cairo_surface_finish (cst);
//cairo_surface_destroy (cst);
}
struct PaintRectSetup {
int max_pixels;
};
/**
* Paint the given rect, recursively subdividing the region until it is the size of a single
* buffer.
*
* @return true if the drawing completes
*/
static int
{
// Allow only very fast buffers to be run together;
// as soon as the total redraw time exceeds 1ms, cancel;
// this returns control to the idle loop and allows Inkscape to process user input
// (potentially interrupting the redraw); as soon as Inkscape has some more idle time,
// it will get back and finish painting what remains to paint.
if (elapsed > 1000) {
// Interrupting redraw isn't always good.
// For example, when you drag one node of a big path, only the buffer containing
// the mouse cursor will be redrawn again and again, and the rest of the path
// will remain stale because Inkscape never has enough idle time to redraw all
// of the screen. To work around this, such operations set a forced_redraw_limit > 0.
// If this limit is set, and if we have aborted redraw more times than is allowed,
// interrupting is blocked and we're forced to redraw full screen once
// (after which we can again interrupt forced_redraw_limit times).
}
return false;
}
}
// Find the optimal buffer dimensions
return 0;
// We are small enough
/*GdkRectangle r;
r.x = this_rect.x0 - setup->canvas->x0;
r.y = this_rect.y0 - setup->canvas->y0;
r.width = this_rect.x1 - this_rect.x0;
r.height = this_rect.y1 - this_rect.y0;
GdkWindow *window = GTK_WIDGET(setup->canvas)->window;
gdk_window_begin_paint_rect(window, &r);*/
//gdk_window_end_paint(window);
return 1;
}
/*
This test determines the redraw strategy:
bw < bh (strips mode) splits across the smaller dimension of the rect and therefore (on
horizontally-stretched windows) results in redrawing in horizontal strips (from cursor point, in
both directions if the cursor is in the middle). This is traditional for Inkscape since old days,
and seems to be faster for drawings with many smaller objects at zoom-out.
bw > bh (chunks mode) splits across the larger dimension of the rect and therefore paints in
almost-square chunks, again from the cursor point. It's sometimes faster for drawings with few slow
(e.g. blurred) objects crossing the entire screen. It also appears to be somewhat psychologically
faster.
The default for now is the strips mode.
*/
// to correctly calculate the mean of two ints, we need to sum them into a larger int type
// Make sure that mid lies on a tile boundary
// Always paint towards the mouse first
} else {
}
} else {
// to correctly calculate the mean of two ints, we need to sum them into a larger int type
// Make sure that mid lies on a tile boundary
// Always paint towards the mouse first
} else {
}
}
}
/**
* Helper that draws a specific rectangular part of the canvas.
*
* @return true if the rectangle painting succeeds.
*/
static bool
{
// Clip rect-to-draw by the current visible area
// Save the mouse location
gint x, y;
// use 256K as a compromise to not slow down gradients
// 256K is the cached buffer and we need 4 channels
} else {
// paths only, so 1M works faster
// 1M is the cached buffer and we need 4 channels
}
// Start the clock
// Go
}
/**
* Force a full redraw after a specified number of interrupted redraws
*/
void
canvas->forced_redraw_count = 0;
}
/**
* End forced full redraw requests
*/
void
}
/**
* The canvas widget's expose callback.
*/
static gint
{
if (!gtk_widget_is_drawable (widget) ||
return FALSE;
int n_rects;
for (int i = 0; i < n_rects; i++) {
}
if (n_rects > 0)
return FALSE;
}
/**
* The canvas widget's keypress callback.
*/
static gint
{
}
/**
* Crossing event handler for the canvas.
*/
static gint
{
return FALSE;
}
/**
* Focus in handler for the canvas.
*/
static gint
{
if (canvas->focused_item) {
} else {
return FALSE;
}
}
/**
* Focus out handler for the canvas.
*/
static gint
{
if (canvas->focused_item)
else
return FALSE;
}
/**
* Helper that repaints the areas in the canvas that need it.
*
* @return true if all the dirty parts have been redrawn
*/
static int
{
if (canvas->need_update) {
}
if (!canvas->need_redraw)
return TRUE;
}
}
}
// Aborted
return FALSE;
};
}
}
// we've had a full unaborted redraw, reset the full redraw counter
canvas->forced_redraw_count = 0;
}
return TRUE;
}
/**
* Helper that invokes update, paint, and repick on canvas.
*/
static int
{
if (!canvas->root) // canvas may have already be destroyed by closing desktop during interrupted display!
return TRUE;
if (canvas->drawing_disabled)
return TRUE;
/* Cause the update if necessary */
if (canvas->need_update) {
}
/* Paint if able to */
}
/* Pick new current item */
while (canvas->need_repick) {
}
return TRUE;
}
/**
* Idle handler for the canvas that deals with pending updates and redraws.
*/
static gint
{
if (ret) {
/* Reset idle id */
}
return !ret;
}
/**
* Convenience function to add an idle handler to a canvas.
*/
static void
{
return;
}
/**
* Returns the root group of the specified canvas.
*/
{
}
/**
* Scrolls canvas to specific position (cx and cy are measured in screen pixels)
*/
void
{
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
}
}
} else {
// scrolling as part of zoom; do nothing here - the next do_update will perform full redraw
}
}
/**
* Updates canvas if necessary.
*/
void
{
if (!(canvas->need_update ||
return;
}
/**
* Update callback for canvas widget.
*/
static void
{
}
/**
* Forces redraw of rectangular canvas area.
*/
void
{
}
/**
* Sets world coordinates from win and canvas.
*/
void sp_canvas_window_to_world(SPCanvas const *canvas, double winx, double winy, double *worldx, double *worldy)
{
}
/**
* Sets win coordinates from world and canvas.
*/
void sp_canvas_world_to_window(SPCanvas const *canvas, double worldx, double worldy, double *winx, double *winy)
{
}
/**
* Converts point from win to world coordinates.
*/
{
}
/**
* Converts point from world to win coordinates.
*/
{
}
/**
* Returns true if point given in world coordinates is inside window.
*/
{
}
/**
* Return canvas window coordinates as Geom::Rect.
*/
{
GtkWidget const *w = GTK_WIDGET(this);
}
/**
* Return canvas window coordinates as integer rectangle.
*/
{
GtkWidget const *w = GTK_WIDGET(this);
return ret;
}
inline int sp_canvas_tile_floor(int x)
{
}
inline int sp_canvas_tile_ceil(int x)
{
}
/**
* Helper that allocates a new tile array for the canvas, copying overlapping tiles from the old array
*/
{
return;
}
ntiles[ind]=canvas->tiles[(i-canvas->tLeft)+(j-canvas->tTop)*canvas->tileH]; // copy from the old tile
} else {
}
}
}
}
/*
* Helper that queues a canvas rectangle for redraw
*/
}
/**
* Helper that marks specific canvas rectangle as clean (val == 0) or dirty (otherwise)
*/
{
return;
}
if ( tl >= canvas->tRight || tr <= canvas->tLeft || tt >= canvas->tBottom || tb <= canvas->tTop ) return;
}
}
}
/*
Local Variables:
mode:c++
c-file-style:"stroustrup"
c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
indent-tabs-mode:nil
fill-column:99
End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :