Change the dirty rectangle API so that it can handle several rectangles. The

inner implementation still only handles one dirty rectangle, but this way
we can prepare supporting applictions for the future.

caca/Makefile.am

@@ -23,6 +23,7 @@ libcaca_la_SOURCES = \
 	caca0.c \
 	caca0.h \
 	canvas.c \
+	dirty.c \
 	string.c \
         legacy.c \
         transform.c \

caca/caca.h

@@ -220,10 +220,6 @@ __extern char const * caca_get_version(void);
  *
  *  @{ */
 #define CACA_MAGIC_FULLWIDTH 0x000ffffe /**< Used to indicate that the previous character was a fullwidth glyph. */
-__extern int caca_get_dirty_rectangle(caca_canvas_t *, int *, int *,
-                                      int *, int *);
-__extern int caca_add_dirty_rectangle(caca_canvas_t *, int, int, int, int);
-__extern int caca_set_dirty_rectangle(caca_canvas_t *, int, int, int, int);
 __extern int caca_gotoxy(caca_canvas_t *, int, int);
 __extern int caca_get_cursor_x(caca_canvas_t const *);
 __extern int caca_get_cursor_y(caca_canvas_t const *);
@@ -240,6 +236,18 @@ __extern int caca_blit(caca_canvas_t *, int, int, caca_canvas_t const *,
 __extern int caca_set_canvas_boundaries(caca_canvas_t *, int, int, int, int);
 /*  @} */
 
+/** \defgroup caca_dirty libcaca dirty rectangle manipulation
+ *
+ *  These functions manipulate dirty rectangles for optimised blitting.
+ *  @{ */
+__extern int caca_get_dirty_rectangle_count(caca_canvas_t *);
+__extern int caca_get_dirty_rectangle(caca_canvas_t *, int, int *, int *,
+                                      int *, int *);
+__extern int caca_add_dirty_rectangle(caca_canvas_t *, int, int, int, int);
+__extern int caca_remove_dirty_rectangle(caca_canvas_t *, int, int, int, int);
+__extern int caca_clear_dirty_rectangle_list(caca_canvas_t *);
+/*  @} */
+
 /** \defgroup caca_transform libcaca canvas transformation
  *
  *  These functions perform horizontal and vertical canvas flipping.

caca/canvas.c

@@ -298,133 +298,6 @@ uint8_t const * caca_get_canvas_attrs(caca_canvas_t const *cv)
     return (uint8_t const *)cv->attrs;
 }
 
-/** \brief Get a canvas's dirty rectangle.
- *
- *  Get the canvas's dirty rectangle coordinates. The dirty rectangle is
- *  the smallest area containing all the cells that have changed since it
- *  was last reset.
- *
- *  The dirty rectangle is used internally by display drivers to optimise
- *  rendering by avoiding to redraw the whole screen. Once the display driver
- *  has rendered the canvas, it resets the dirty rectangle.
- *
- *  Values such that \b xmin > \b xmax or \b ymin > \b ymax indicate that
- *  the dirty rectangle is empty. It means that the canvas's contents have
- *  not changed since the dirty rectangle was last reset.
- *
- *  FIXME: having only one dirty rectangle instead of a list of rectangles
- *  is a severe limitation, but the potential gain does not yet look to be
- *  worth the implementation complexity of a multiple-rectangle scheme.
- *
- *  This function never fails.
- *
- *  \param cv A libcaca canvas.
- *  \param xmin A pointer to an integer where the leftmost edge of the
- *              dirty rectangle will be stored.
- *  \param ymin A pointer to an integer where the topmost edge of the
- *              dirty rectangle will be stored.
- *  \param xmax A pointer to an integer where the rightmost edge of the
- *              dirty rectangle will be stored.
- *  \param ymax A pointer to an integer where the bottommost edge of the
- *              dirty rectangle will be stored.
- *  \return This function always returns 0.
- */
-int caca_get_dirty_rectangle(caca_canvas_t *cv, int *xmin, int *ymin,
-                             int *xmax, int *ymax)
-{
-    *xmin = cv->dirty_xmin;
-    *xmax = cv->dirty_xmax;
-    *ymin = cv->dirty_ymin;
-    *ymax = cv->dirty_ymax;
-
-    return 0;
-}
-
-/** \brief Add a dirty rectangle to the canvas's dirty rectangle.
- *
- *  Add an invalidating zone to the canvas's dirty rectangle. For more
- *  information about the dirty rectangle, see caca_get_dirty_rectangle().
- *
- *  This function may be useful to force refresh of a given zone of the
- *  canvas even if the dirty rectangle tracking indicates that it is
- *  unchanged.
- *
- *  Values such that \b xmin > \b xmax or \b ymin > \b ymax indicate that
- *  the dirty rectangle is empty. They will be silently ignored.
- *
- *  This function never fails.
- *
- *  \param cv A libcaca canvas.
- *  \param xmin The leftmost edge of the additional dirty rectangle.
- *  \param ymin The topmost edge of the additional dirty rectangle.
- *  \param xmax The rightmost edge of the additional dirty rectangle.
- *  \param ymax The bottommost edge of the additional dirty rectangle.
- *  \return This function always returns 0.
- */
-int caca_add_dirty_rectangle(caca_canvas_t *cv, int xmin, int ymin,
-                             int xmax, int ymax)
-{
-    /* Ignore empty rectangles. */
-    if(xmin > xmax || ymin > ymax)
-        return 0;
-
-    /* Ignore out-of-bounds rectangles. */
-    if(xmax < 0 || xmin >= cv->width || ymax < 0 || ymin >= cv->height)
-        return 0;
-
-    if(xmin < cv->dirty_xmin)
-        cv->dirty_xmin = xmin;
-
-    if(xmax > cv->dirty_xmax)
-        cv->dirty_xmax = xmax;
-
-    if(ymin < cv->dirty_ymin)
-        cv->dirty_ymin = ymin;
-
-    if(ymax > cv->dirty_ymax)
-        cv->dirty_ymax = ymax;
-
-    return 0;
-}
-
-/** \brief Set a canvas's dirty rectangle.
- *
- *  Set the canvas's dirty rectangle coordinates. For more information
- *  about the dirty rectangle, see caca_get_dirty_rectangle().
- *
- *  Values such that \b xmin > \b xmax or \b ymin > \b ymax indicate that
- *  the dirty rectangle is empty.
- *
- *  This function never fails.
- *
- *  \param cv A libcaca canvas.
- *  \param xmin The leftmost edge of the desired dirty rectangle.
- *  \param ymin The topmost edge of the desired dirty rectangle.
- *  \param xmax The rightmost edge of the desired dirty rectangle.
- *  \param ymax The bottommost edge of the desired dirty rectangle.
- *  \return This function always returns 0.
- */
-int caca_set_dirty_rectangle(caca_canvas_t *cv, int xmin, int ymin,
-                             int xmax, int ymax)
-{
-    /* Normalise values indicating an empty or out-of-bounds rectangle. */
-    if(xmin > xmax || ymin > ymax ||
-        xmax < 0 || xmin >= cv->width || ymax < 0 || ymin >= cv->height)
-    {
-        xmin = cv->width;
-        xmax = -1;
-        ymin = cv->height;
-        ymax = -1;
-    }
-
-    cv->dirty_xmin = xmin;
-    cv->dirty_xmax = xmax;
-    cv->dirty_ymin = ymin;
-    cv->dirty_ymax = ymax;
-
-    return 0;
-}
-
 /** \brief Free a \e libcaca canvas.
  *
  *  Free all resources allocated by caca_create_canvas(). The canvas

caca/dirty.c

@@ -0,0 +1,215 @@
+/*
+ *  libcaca       Colour ASCII-Art library
+ *  Copyright (c) 2002-2009 Sam Hocevar <sam@hocevar.net>
+ *                All Rights Reserved
+ *
+ *  $Id$
+ *
+ *  This library is free software. It comes without any warranty, to
+ *  the extent permitted by applicable law. You can redistribute it
+ *  and/or modify it under the terms of the Do What The Fuck You Want
+ *  To Public License, Version 2, as published by Sam Hocevar. See
+ *  http://sam.zoy.org/wtfpl/COPYING for more details.
+ */
+
+/*
+ *  This file contains the dirty rectangle handling functions.
+ */
+
+#include "config.h"
+
+#if !defined(__KERNEL__)
+#   include <stdio.h>
+#endif
+
+#include "caca.h"
+#include "caca_internals.h"
+
+/** \brief Get the number of dirty rectangles in the canvas.
+ *
+ *  Get the number of dirty rectangles in a canvas. Dirty rectangles are
+ *  areas that contain cells that have changed since the last reset.
+ *
+ *  The dirty rectangles are used internally by display drivers to optimise
+ *  rendering by avoiding to redraw the whole screen. Once the display driver
+ *  has rendered the canvas, it resets the dirty rectangle list.
+ *
+ *  Dirty rectangles are guaranteed not to overlap.
+ *
+ *  This function never fails.
+ *
+ *  \param cv A libcaca canvas.
+ *  \return The number of dirty rectangles in the given canvas.
+ */
+int caca_get_dirty_rectangle_count(caca_canvas_t *cv)
+{
+    /* Ignore empty rectangles. */
+    if(cv->dirty_xmin > cv->dirty_xmax || cv->dirty_ymin > cv->dirty_ymax)
+        return 0;
+
+    /* Ignore out-of-bounds rectangles. */
+    if(cv->dirty_xmax < 0 || cv->dirty_xmin >= cv->width
+        || cv->dirty_ymax < 0 || cv->dirty_ymin >= cv->height)
+        return 0;
+
+    return 1;
+}
+
+/** \brief Get a canvas's dirty rectangle.
+ *
+ *  Get the canvas's given dirty rectangle coordinates. The index must be
+ *  within the dirty rectangle count. See caca_get_dirty_rectangle_count()
+ *  for how to compute this count.
+ *
+ *  If an error occurs, no coordinates are written in the pointer arguments,
+ *  -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Specified rectangle index is out of bounds.
+ *
+ *  \param cv A libcaca canvas.
+ *  \param index The requested rectangle index.
+ *  \param xmin A pointer to an integer where the leftmost edge of the
+ *              dirty rectangle will be stored.
+ *  \param ymin A pointer to an integer where the topmost edge of the
+ *              dirty rectangle will be stored.
+ *  \param xmax A pointer to an integer where the rightmost edge of the
+ *              dirty rectangle will be stored.
+ *  \param ymax A pointer to an integer where the bottommost edge of the
+ *              dirty rectangle will be stored.
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int caca_get_dirty_rectangle(caca_canvas_t *cv, int index,
+                             int *xmin, int *ymin, int *xmax, int *ymax)
+{
+    /* For now, index can only be zero, and if the dirty rectangle is
+     * empty, we don't return anything. */
+    if(index < 0 || index > 0
+        || cv->dirty_xmin > cv->dirty_xmax || cv->dirty_ymin > cv->dirty_ymax
+        || cv->dirty_xmax < 0 || cv->dirty_xmin >= cv->width
+        || cv->dirty_ymax < 0 || cv->dirty_ymin >= cv->height)
+    {
+        seterrno(EINVAL);
+        return -1;
+    }
+
+    /* Normalise dirty rectangle so that the values can be directly used. */
+    if(cv->dirty_xmin < 0)
+        cv->dirty_xmin = 0;
+
+    if(cv->dirty_xmax > cv->width - 1)
+        cv->dirty_xmax = cv->width - 1;
+
+    if(cv->dirty_ymin < 0)
+        cv->dirty_ymin = 0;
+
+    if(cv->dirty_ymax > cv->height - 1)
+        cv->dirty_ymax = cv->height - 1;
+
+    *xmin = cv->dirty_xmin;
+    *xmax = cv->dirty_xmax;
+    *ymin = cv->dirty_ymin;
+    *ymax = cv->dirty_ymax;
+
+    return 0;
+}
+
+/** \brief Add an area to the canvas's dirty rectangle list.
+ *
+ *  Add an invalidating zone to the canvas's dirty rectangle list. For more
+ *  information about the dirty rectangles, see caca_get_dirty_rectangle().
+ *
+ *  This function may be useful to force refresh of a given zone of the
+ *  canvas even if the dirty rectangle tracking indicates that it is
+ *  unchanged. This may happen if the canvas contents were somewhat
+ *  directly modified.
+ *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Specified rectangle coordinates are out of bounds.
+ *
+ *  \param cv A libcaca canvas.
+ *  \param xmin The leftmost edge of the additional dirty rectangle.
+ *  \param ymin The topmost edge of the additional dirty rectangle.
+ *  \param xmax The rightmost edge of the additional dirty rectangle.
+ *  \param ymax The bottommost edge of the additional dirty rectangle.
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int caca_add_dirty_rectangle(caca_canvas_t *cv, int xmin, int ymin,
+                             int xmax, int ymax)
+{
+    /* Ignore empty and out-of-bounds rectangles */
+    if(xmin > xmax || ymin > ymax
+        || xmax < 0 || xmin >= cv->width || ymax < 0 || ymin >= cv->height)
+    {
+        seterrno(EINVAL);
+        return -1;
+    }
+
+    if(xmin < cv->dirty_xmin)
+        cv->dirty_xmin = xmin;
+
+    if(xmax > cv->dirty_xmax)
+        cv->dirty_xmax = xmax;
+
+    if(ymin < cv->dirty_ymin)
+        cv->dirty_ymin = ymin;
+
+    if(ymax > cv->dirty_ymax)
+        cv->dirty_ymax = ymax;
+
+    return 0;
+}
+
+/** \brief Remove an area from the dirty rectangle list.
+ *
+ *  Mark a cell area in the canvas as not dirty. For more information about
+ *  the dirty rectangles, see caca_get_dirty_rectangle().
+ *
+ *  Values such that \b xmin > \b xmax or \b ymin > \b ymax indicate that
+ *  the dirty rectangle is empty. They will be silently ignored.
+ *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Specified rectangle coordinates are out of bounds.
+ *
+ *  \param cv A libcaca canvas.
+ *  \param xmin The leftmost edge of the clean rectangle.
+ *  \param ymin The topmost edge of the clean rectangle.
+ *  \param xmax The rightmost edge of the clean rectangle.
+ *  \param ymax The bottommost edge of the clean rectangle.
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int caca_remove_dirty_rectangle(caca_canvas_t *cv, int xmin, int ymin,
+                                int xmax, int ymax)
+{
+    /* Ignore empty and out-of-bounds rectangles */
+    if(xmin > xmax || ymin > ymax
+        || xmax < 0 || xmin >= cv->width || ymax < 0 || ymin >= cv->height)
+    {
+        seterrno(EINVAL);
+        return -1;
+    }
+
+    /* FIXME: implement this function. It's OK to have it do nothing,
+     * since we take a conservative approach in dirty rectangle handling,
+     * but we ought to help the rendering eventually. */
+
+    return 0;
+}
+
+/** \brief Clear a canvas's dirty rectangle list.
+ *
+ *  Empty the canvas's dirty rectangle list.
+ *
+ *  This function never fails.
+ *
+ *  \param cv A libcaca canvas.
+ *  \return This function always returns 0.
+ */
+int caca_clear_dirty_rectangle_list(caca_canvas_t *cv)
+{
+    cv->dirty_xmin = cv->width;
+    cv->dirty_xmax = -1;
+    cv->dirty_ymin = cv->height;
+    cv->dirty_ymax = -1;
+
+    return 0;
+}
+

caca/driver/slang.c

@@ -222,59 +222,61 @@ static void slang_display(caca_display_t *dp)
 {
     uint32_t const *cvchars = (uint32_t const *)caca_get_canvas_chars(dp->cv);
     uint32_t const *cvattrs = (uint32_t const *)caca_get_canvas_attrs(dp->cv);
-    int x, y;
-    int xmin, ymin, xmax, ymax;
+    int x, y, i;
 
-    caca_get_dirty_rectangle(dp->cv, &xmin, &ymin, &xmax, &ymax);
-    if(xmin > xmax || ymin > ymax)
-        return;
-
-    for(y = ymin; y <= ymax; y++)
+    for(i = 0; i < caca_get_dirty_rectangle_count(dp->cv); i++)
     {
-        SLsmg_gotorc(y, 0);
-        for(x = xmax; x >= xmin; x--)
+        int xmin, ymin, xmax, ymax;
+
+        caca_get_dirty_rectangle(dp->cv, i, &xmin, &ymin, &xmax, &ymax);
+
+        for(y = ymin; y <= ymax; y++)
         {
-            uint32_t ch = *cvchars++;
+            SLsmg_gotorc(y, 0);
+            for(x = xmax; x >= xmin; x--)
+            {
+                uint32_t ch = *cvchars++;
 
 #if defined(OPTIMISE_SLANG_PALETTE)
-            /* If foreground == background, just don't use this colour
-             * pair, and print a space instead of the real character.
-             * XXX: disabled, because I can't remember what it was
-             * here for, and in cases where SLang does not render
-             * bright backgrounds, it's just fucked up. */
+                /* If foreground == background, just don't use this colour
+                 * pair, and print a space instead of the real character. */
+                /* XXX: disabled, because I can't remember what it was
+                 * here for, and in cases where SLang does not render
+                 * bright backgrounds, it's just fucked up. */
 #if 0
-            uint8_t fgcolor = caca_attr_to_ansi_fg(*cvattrs);
-            uint8_t bgcolor = caca_attr_to_ansi_bg(*cvattrs);
-
-            if(fgcolor >= 0x10)
-                fgcolor = CACA_LIGHTGRAY;
-
-            if(bgcolor >= 0x10)
-                bgcolor = CACA_BLACK; /* FIXME: handle transparency */
-
-            if(fgcolor == bgcolor)
-            {
-                if(fgcolor == CACA_BLACK)
-                    fgcolor = CACA_WHITE;
-                else if(fgcolor == CACA_WHITE
-                         || fgcolor <= CACA_LIGHTGRAY)
-                    fgcolor = CACA_BLACK;
+                uint8_t fgcolor = caca_attr_to_ansi_fg(*cvattrs);
+                uint8_t bgcolor = caca_attr_to_ansi_bg(*cvattrs);
+
+                if(fgcolor >= 0x10)
+                    fgcolor = CACA_LIGHTGRAY;
+
+                if(bgcolor >= 0x10)
+                    bgcolor = CACA_BLACK; /* FIXME: handle transparency */
+
+                if(fgcolor == bgcolor)
+                {
+                    if(fgcolor == CACA_BLACK)
+                        fgcolor = CACA_WHITE;
+                    else if(fgcolor == CACA_WHITE
+                             || fgcolor <= CACA_LIGHTGRAY)
+                        fgcolor = CACA_BLACK;
+                    else
+                        fgcolor = CACA_WHITE;
+                    SLsmg_set_color(slang_assoc[fgcolor + 16 * bgcolor]);
+                    SLsmg_write_char(' ');
+                    cvattrs++;
+                }
                 else
-                    fgcolor = CACA_WHITE;
-                SLsmg_set_color(slang_assoc[fgcolor + 16 * bgcolor]);
-                SLsmg_write_char(' ');
-                cvattrs++;
-            }
-            else
 #endif
-            {
-                SLsmg_set_color(slang_assoc[caca_attr_to_ansi(*cvattrs++)]);
-                slang_write_utf32(ch);
-            }
+                {
+                    SLsmg_set_color(slang_assoc[caca_attr_to_ansi(*cvattrs++)]);
+                    slang_write_utf32(ch);
+                }
 #else
-            SLsmg_set_color(caca_attr_to_ansi(*cvattrs++));
-            slang_write_utf32(ch);
+                SLsmg_set_color(caca_attr_to_ansi(*cvattrs++));
+                slang_write_utf32(ch);
 #endif
+            }
         }
     }
     SLsmg_gotorc(caca_get_cursor_y(dp->cv), caca_get_cursor_x(dp->cv));

caca/driver/x11.c

@@ -293,58 +293,61 @@ static void x11_display(caca_display_t *dp)
     uint32_t const *cvattrs = (uint32_t const *)caca_get_canvas_attrs(dp->cv);
     int width = caca_get_canvas_width(dp->cv);
     int height = caca_get_canvas_height(dp->cv);
-    int x, y, len;
-    int xmin, ymin, xmax, ymax;
+    int x, y, i, len;
 
-    caca_get_dirty_rectangle(dp->cv, &xmin, &ymin, &xmax, &ymax);
-    if(xmin > xmax || ymin > ymax)
-        return;
-
-    /* First draw the background colours. Splitting the process in two
-     * loops like this is actually slightly faster. */
-    for(y = ymin; y <= ymax; y++)
+    for(i = 0; i < caca_get_dirty_rectangle_count(dp->cv); i++)
     {
-        for(x = xmin; x <= xmax; x += len)
+        int xmin, ymin, xmax, ymax;
+
+        caca_get_dirty_rectangle(dp->cv, i, &xmin, &ymin, &xmax, &ymax);
+
+        /* First draw the background colours. Splitting the process in two
+         * loops like this is actually slightly faster. */
+        for(y = ymin; y <= ymax; y++)
         {
-            uint32_t const *attrs = cvattrs + x + y * width;
-            uint16_t bg = caca_attr_to_rgb12_bg(*attrs);
-
-            len = 1;
-            while(x + len < width
-                   && caca_attr_to_rgb12_bg(attrs[len]) == bg)
-                len++;
-
-            XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
-                           dp->drv.p->colors[bg]);
-            XFillRectangle(dp->drv.p->dpy, dp->drv.p->pixmap, dp->drv.p->gc,
-                           x * dp->drv.p->font_width,
-                           y * dp->drv.p->font_height,
-                           len * dp->drv.p->font_width,
-                           dp->drv.p->font_height);
+            for(x = xmin; x <= xmax; x += len)
+            {
+                uint32_t const *attrs = cvattrs + x + y * width;
+                uint16_t bg = caca_attr_to_rgb12_bg(*attrs);
+
+                len = 1;
+                while(x + len < width
+                       && caca_attr_to_rgb12_bg(attrs[len]) == bg)
+                    len++;
+
+                XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
+                               dp->drv.p->colors[bg]);
+                XFillRectangle(dp->drv.p->dpy, dp->drv.p->pixmap,
+                               dp->drv.p->gc,
+                               x * dp->drv.p->font_width,
+                               y * dp->drv.p->font_height,
+                               len * dp->drv.p->font_width,
+                               dp->drv.p->font_height);
+            }
         }
-    }
-
-    /* Then print the foreground characters */
-    for(y = ymin; y <= ymax; y++)
-    {
-        int yoff = (y + 1) * dp->drv.p->font_height
-                                    - dp->drv.p->font_offset;
-        uint32_t const *chars = cvchars + y * width;
-        uint32_t const *attrs = cvattrs + y * width;
 
-        for(x = xmin; x <= xmax; x++, chars++, attrs++)
+        /* Then print the foreground characters */
+        for(y = ymin; y <= ymax; y++)
         {
-            XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
+            int yoff = (y + 1) * dp->drv.p->font_height
+                                        - dp->drv.p->font_offset;
+            uint32_t const *chars = cvchars + y * width;
+            uint32_t const *attrs = cvattrs + y * width;
+
+            for(x = xmin; x <= xmax; x++, chars++, attrs++)
+            {
+                XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
                            dp->drv.p->colors[caca_attr_to_rgb12_fg(*attrs)]);
 
-            x11_put_glyph(dp, x * dp->drv.p->font_width,
-                          y * dp->drv.p->font_height, yoff,
-                          dp->drv.p->font_width, dp->drv.p->font_height,
-                          *attrs, *chars);
+                x11_put_glyph(dp, x * dp->drv.p->font_width,
+                              y * dp->drv.p->font_height, yoff,
+                              dp->drv.p->font_width, dp->drv.p->font_height,
+                              *attrs, *chars);
+            }
         }
     }
 
-    /* Print the cursor if necessary */
+    /* Print the cursor if necessary. FIXME: handle dirty rectangles! */
     if(dp->drv.p->cursor_flags)
     {
         XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,

caca/frame.c

@@ -72,7 +72,7 @@ int caca_set_frame(caca_canvas_t *cv, int id)
     cv->frame = id;
     _caca_load_frame_info(cv);
 
-    caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
 
     return 0;
 }
@@ -236,7 +236,7 @@ int caca_free_frame(caca_canvas_t *cv, int id)
     {
         cv->frame = 0;
         _caca_load_frame_info(cv);
-        caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+        caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     }
 
     return 0;

caca/graphics.c

@@ -155,7 +155,7 @@ int caca_refresh_display(caca_display_t *dp)
     dp->drv.display(dp);
 
     /* Invalidate the dirty rectangle */
-    caca_set_dirty_rectangle(dp->cv, -1, -1, -1, -1);
+    caca_clear_dirty_rectangle_list(dp->cv);
 
     /* Once the display is finished, we can ack resizes */
     if(dp->resize.resized)

caca/libcaca.vcproj

@@ -416,6 +416,10 @@
 			RelativePath=".\driver\conio.c"
 			>
 		</File>
+		<File
+			RelativePath=".\dirty.c"
+			>
+		</File>
 		<File
 			RelativePath=".\dither.c"
 			>

caca/string.c

@@ -322,7 +322,7 @@ int caca_clear_canvas(caca_canvas_t *cv)
         cv->attrs[n] = attr;
     }
 
-    caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
 
     return 0;
 }
@@ -528,7 +528,7 @@ int caca_set_canvas_boundaries(caca_canvas_t *cv, int x, int y, int w, int h)
     _caca_load_frame_info(cv);
 
     /* FIXME: this may be optimised somewhat */
-    caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
 
     return 0;
 }

caca/transform.c

@@ -54,7 +54,7 @@ int caca_invert(caca_canvas_t *cv)
         attrs++;
     }
 
-    caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
 
     return 0;
 }
@@ -115,7 +115,7 @@ int caca_flip(caca_canvas_t *cv)
         }
     }
 
-    caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
 
     return 0;
 }
@@ -162,7 +162,7 @@ int caca_flop(caca_canvas_t *cv)
             *ctop = flopchar(*ctop);
     }
 
-    caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
 
     return 0;
 }
@@ -221,7 +221,7 @@ int caca_rotate_180(caca_canvas_t *cv)
         }
     }
 
-    caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
 
     return 0;
 }
@@ -340,7 +340,7 @@ int caca_rotate_left(caca_canvas_t *cv)
     /* Reset the current frame shortcuts */
     _caca_load_frame_info(cv);
 
-    caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
 
     return 0;
 }
@@ -459,7 +459,7 @@ int caca_rotate_right(caca_canvas_t *cv)
     /* Reset the current frame shortcuts */
     _caca_load_frame_info(cv);
 
-    caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
 
     return 0;
 }
@@ -552,7 +552,7 @@ int caca_stretch_left(caca_canvas_t *cv)
     /* Reset the current frame shortcuts */
     _caca_load_frame_info(cv);
 
-    caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
 
     return 0;
 }
@@ -645,7 +645,7 @@ int caca_stretch_right(caca_canvas_t *cv)
     /* Reset the current frame shortcuts */
     _caca_load_frame_info(cv);
 
-    caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
+    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
 
     return 0;
 }

tests/dirty.cpp

@@ -38,21 +38,24 @@ public:
     void test_create()
     {
         caca_canvas_t *cv;
-        int xmin, xmax, ymin, ymax;
+        int i, xmin, xmax, ymin, ymax;
 
         /* Check that the dirty rectangle contains the whole canvas
          * upon creation. */
         cv = caca_create_canvas(WIDTH, HEIGHT);
-        caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
-        CPPUNIT_ASSERT(xmin <= 0);
-        CPPUNIT_ASSERT(ymin <= 0);
-        CPPUNIT_ASSERT(xmax >= caca_get_canvas_width(cv) - 1);
-        CPPUNIT_ASSERT(ymax >= caca_get_canvas_height(cv) - 1);
+        i = caca_get_dirty_rectangle_count(cv);
+        CPPUNIT_ASSERT_EQUAL(i, 1);
+
+        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
+        CPPUNIT_ASSERT_EQUAL(xmin, 0);
+        CPPUNIT_ASSERT_EQUAL(ymin, 0);
+        CPPUNIT_ASSERT_EQUAL(xmax, caca_get_canvas_width(cv) - 1);
+        CPPUNIT_ASSERT_EQUAL(ymax, caca_get_canvas_height(cv) - 1);
 
         /* Invalidate the dirty rectangle and check that it stays so. */
-        caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
-        caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
-        CPPUNIT_ASSERT(xmin > xmax || ymin > ymax);
+        caca_clear_dirty_rectangle_list(cv);
+        i = caca_get_dirty_rectangle_count(cv);
+        CPPUNIT_ASSERT_EQUAL(i, 0);
 
         caca_free_canvas(cv);
     }
@@ -60,66 +63,78 @@ public:
     void test_put_char()
     {
         caca_canvas_t *cv;
-        int xmin, xmax, ymin, ymax;
+        int i, xmin, xmax, ymin, ymax;
 
         cv = caca_create_canvas(WIDTH, HEIGHT);
 
-        caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
+        caca_clear_dirty_rectangle_list(cv);
         caca_put_char(cv, 7, 3, 'x');
-        caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
-        CPPUNIT_ASSERT(xmin <= 7);
-        CPPUNIT_ASSERT(ymin <= 3);
-        CPPUNIT_ASSERT(xmax >= 7);
-        CPPUNIT_ASSERT(ymax >= 3);
+        i = caca_get_dirty_rectangle_count(cv);
+        CPPUNIT_ASSERT_EQUAL(i, 1);
+        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
+        CPPUNIT_ASSERT_EQUAL(xmin, 7);
+        CPPUNIT_ASSERT_EQUAL(ymin, 3);
+        CPPUNIT_ASSERT_EQUAL(xmax, 7);
+        CPPUNIT_ASSERT_EQUAL(ymax, 3);
 
         caca_clear_canvas(cv);
-        caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
+        caca_clear_dirty_rectangle_list(cv);
         caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
-        caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
-        CPPUNIT_ASSERT(xmin <= 7);
-        CPPUNIT_ASSERT(ymin <= 3);
-        CPPUNIT_ASSERT(xmax >= 8);
-        CPPUNIT_ASSERT(ymax >= 3);
+        i = caca_get_dirty_rectangle_count(cv);
+        CPPUNIT_ASSERT_EQUAL(i, 1);
+        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
+        CPPUNIT_ASSERT_EQUAL(xmin, 7);
+        CPPUNIT_ASSERT_EQUAL(ymin, 3);
+        CPPUNIT_ASSERT_EQUAL(xmax, 8);
+        CPPUNIT_ASSERT_EQUAL(ymax, 3);
 
         caca_clear_canvas(cv);
         caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
-        caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
+        caca_clear_dirty_rectangle_list(cv);
         caca_put_char(cv, 7, 3, 'x');
-        caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
-        CPPUNIT_ASSERT(xmin <= 7);
-        CPPUNIT_ASSERT(ymin <= 3);
-        CPPUNIT_ASSERT(xmax >= 8);
-        CPPUNIT_ASSERT(ymax >= 3);
+        i = caca_get_dirty_rectangle_count(cv);
+        CPPUNIT_ASSERT_EQUAL(i, 1);
+        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
+        CPPUNIT_ASSERT_EQUAL(xmin, 7);
+        CPPUNIT_ASSERT_EQUAL(ymin, 3);
+        CPPUNIT_ASSERT_EQUAL(xmax, 8);
+        CPPUNIT_ASSERT_EQUAL(ymax, 3);
 
         caca_clear_canvas(cv);
         caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
-        caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
+        caca_clear_dirty_rectangle_list(cv);
         caca_put_char(cv, 8, 3, 'x');
-        caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
-        CPPUNIT_ASSERT(xmin <= 7);
-        CPPUNIT_ASSERT(ymin <= 3);
-        CPPUNIT_ASSERT(xmax >= 8);
-        CPPUNIT_ASSERT(ymax >= 3);
+        i = caca_get_dirty_rectangle_count(cv);
+        CPPUNIT_ASSERT_EQUAL(i, 1);
+        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
+        CPPUNIT_ASSERT_EQUAL(xmin, 7);
+        CPPUNIT_ASSERT_EQUAL(ymin, 3);
+        CPPUNIT_ASSERT_EQUAL(xmax, 8);
+        CPPUNIT_ASSERT_EQUAL(ymax, 3);
 
         caca_clear_canvas(cv);
         caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
-        caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
+        caca_clear_dirty_rectangle_list(cv);
         caca_put_char(cv, 6, 3, 0x2f06 /* ⼆ */);
-        caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
-        CPPUNIT_ASSERT(xmin <= 6);
-        CPPUNIT_ASSERT(ymin <= 3);
-        CPPUNIT_ASSERT(xmax >= 8);
-        CPPUNIT_ASSERT(ymax >= 3);
+        i = caca_get_dirty_rectangle_count(cv);
+        CPPUNIT_ASSERT_EQUAL(i, 1);
+        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
+        CPPUNIT_ASSERT_EQUAL(xmin, 6);
+        CPPUNIT_ASSERT_EQUAL(ymin, 3);
+        CPPUNIT_ASSERT_EQUAL(xmax, 8);
+        CPPUNIT_ASSERT_EQUAL(ymax, 3);
 
         caca_clear_canvas(cv);
         caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
-        caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
+        caca_clear_dirty_rectangle_list(cv);
         caca_put_char(cv, 8, 3, 0x2f06 /* ⼆ */);
-        caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
-        CPPUNIT_ASSERT(xmin <= 7);
-        CPPUNIT_ASSERT(ymin <= 3);
-        CPPUNIT_ASSERT(xmax >= 9);
-        CPPUNIT_ASSERT(ymax >= 3);
+        i = caca_get_dirty_rectangle_count(cv);
+        CPPUNIT_ASSERT_EQUAL(i, 1);
+        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
+        CPPUNIT_ASSERT_EQUAL(xmin, 7);
+        CPPUNIT_ASSERT_EQUAL(ymin, 3);
+        CPPUNIT_ASSERT_EQUAL(xmax, 9);
+        CPPUNIT_ASSERT_EQUAL(ymax, 3);
     }
 
 private: