Changeset 3470 for libcaca/trunk


Ignore:
Timestamp:
May 19, 2009, 2:51:47 AM (10 years ago)
Author:
Sam Hocevar
Message:

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.

Location:
libcaca/trunk
Files:
1 added
11 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/caca/Makefile.am

    r3323 r3470  
    2424        caca0.h \
    2525        canvas.c \
     26        dirty.c \
    2627        string.c \
    2728        legacy.c \
  • libcaca/trunk/caca/caca.h

    r3443 r3470  
    221221 *  @{ */
    222222#define CACA_MAGIC_FULLWIDTH 0x000ffffe /**< Used to indicate that the previous character was a fullwidth glyph. */
    223 __extern int caca_get_dirty_rectangle(caca_canvas_t *, int *, int *,
    224                                       int *, int *);
    225 __extern int caca_add_dirty_rectangle(caca_canvas_t *, int, int, int, int);
    226 __extern int caca_set_dirty_rectangle(caca_canvas_t *, int, int, int, int);
    227223__extern int caca_gotoxy(caca_canvas_t *, int, int);
    228224__extern int caca_get_cursor_x(caca_canvas_t const *);
     
    239235                       caca_canvas_t const *);
    240236__extern int caca_set_canvas_boundaries(caca_canvas_t *, int, int, int, int);
     237/*  @} */
     238
     239/** \defgroup caca_dirty libcaca dirty rectangle manipulation
     240 *
     241 *  These functions manipulate dirty rectangles for optimised blitting.
     242 *  @{ */
     243__extern int caca_get_dirty_rectangle_count(caca_canvas_t *);
     244__extern int caca_get_dirty_rectangle(caca_canvas_t *, int, int *, int *,
     245                                      int *, int *);
     246__extern int caca_add_dirty_rectangle(caca_canvas_t *, int, int, int, int);
     247__extern int caca_remove_dirty_rectangle(caca_canvas_t *, int, int, int, int);
     248__extern int caca_clear_dirty_rectangle_list(caca_canvas_t *);
    241249/*  @} */
    242250
  • libcaca/trunk/caca/canvas.c

    r3450 r3470  
    297297{
    298298    return (uint8_t const *)cv->attrs;
    299 }
    300 
    301 /** \brief Get a canvas's dirty rectangle.
    302  *
    303  *  Get the canvas's dirty rectangle coordinates. The dirty rectangle is
    304  *  the smallest area containing all the cells that have changed since it
    305  *  was last reset.
    306  *
    307  *  The dirty rectangle is used internally by display drivers to optimise
    308  *  rendering by avoiding to redraw the whole screen. Once the display driver
    309  *  has rendered the canvas, it resets the dirty rectangle.
    310  *
    311  *  Values such that \b xmin > \b xmax or \b ymin > \b ymax indicate that
    312  *  the dirty rectangle is empty. It means that the canvas's contents have
    313  *  not changed since the dirty rectangle was last reset.
    314  *
    315  *  FIXME: having only one dirty rectangle instead of a list of rectangles
    316  *  is a severe limitation, but the potential gain does not yet look to be
    317  *  worth the implementation complexity of a multiple-rectangle scheme.
    318  *
    319  *  This function never fails.
    320  *
    321  *  \param cv A libcaca canvas.
    322  *  \param xmin A pointer to an integer where the leftmost edge of the
    323  *              dirty rectangle will be stored.
    324  *  \param ymin A pointer to an integer where the topmost edge of the
    325  *              dirty rectangle will be stored.
    326  *  \param xmax A pointer to an integer where the rightmost edge of the
    327  *              dirty rectangle will be stored.
    328  *  \param ymax A pointer to an integer where the bottommost edge of the
    329  *              dirty rectangle will be stored.
    330  *  \return This function always returns 0.
    331  */
    332 int caca_get_dirty_rectangle(caca_canvas_t *cv, int *xmin, int *ymin,
    333                              int *xmax, int *ymax)
    334 {
    335     *xmin = cv->dirty_xmin;
    336     *xmax = cv->dirty_xmax;
    337     *ymin = cv->dirty_ymin;
    338     *ymax = cv->dirty_ymax;
    339 
    340     return 0;
    341 }
    342 
    343 /** \brief Add a dirty rectangle to the canvas's dirty rectangle.
    344  *
    345  *  Add an invalidating zone to the canvas's dirty rectangle. For more
    346  *  information about the dirty rectangle, see caca_get_dirty_rectangle().
    347  *
    348  *  This function may be useful to force refresh of a given zone of the
    349  *  canvas even if the dirty rectangle tracking indicates that it is
    350  *  unchanged.
    351  *
    352  *  Values such that \b xmin > \b xmax or \b ymin > \b ymax indicate that
    353  *  the dirty rectangle is empty. They will be silently ignored.
    354  *
    355  *  This function never fails.
    356  *
    357  *  \param cv A libcaca canvas.
    358  *  \param xmin The leftmost edge of the additional dirty rectangle.
    359  *  \param ymin The topmost edge of the additional dirty rectangle.
    360  *  \param xmax The rightmost edge of the additional dirty rectangle.
    361  *  \param ymax The bottommost edge of the additional dirty rectangle.
    362  *  \return This function always returns 0.
    363  */
    364 int caca_add_dirty_rectangle(caca_canvas_t *cv, int xmin, int ymin,
    365                              int xmax, int ymax)
    366 {
    367     /* Ignore empty rectangles. */
    368     if(xmin > xmax || ymin > ymax)
    369         return 0;
    370 
    371     /* Ignore out-of-bounds rectangles. */
    372     if(xmax < 0 || xmin >= cv->width || ymax < 0 || ymin >= cv->height)
    373         return 0;
    374 
    375     if(xmin < cv->dirty_xmin)
    376         cv->dirty_xmin = xmin;
    377 
    378     if(xmax > cv->dirty_xmax)
    379         cv->dirty_xmax = xmax;
    380 
    381     if(ymin < cv->dirty_ymin)
    382         cv->dirty_ymin = ymin;
    383 
    384     if(ymax > cv->dirty_ymax)
    385         cv->dirty_ymax = ymax;
    386 
    387     return 0;
    388 }
    389 
    390 /** \brief Set a canvas's dirty rectangle.
    391  *
    392  *  Set the canvas's dirty rectangle coordinates. For more information
    393  *  about the dirty rectangle, see caca_get_dirty_rectangle().
    394  *
    395  *  Values such that \b xmin > \b xmax or \b ymin > \b ymax indicate that
    396  *  the dirty rectangle is empty.
    397  *
    398  *  This function never fails.
    399  *
    400  *  \param cv A libcaca canvas.
    401  *  \param xmin The leftmost edge of the desired dirty rectangle.
    402  *  \param ymin The topmost edge of the desired dirty rectangle.
    403  *  \param xmax The rightmost edge of the desired dirty rectangle.
    404  *  \param ymax The bottommost edge of the desired dirty rectangle.
    405  *  \return This function always returns 0.
    406  */
    407 int caca_set_dirty_rectangle(caca_canvas_t *cv, int xmin, int ymin,
    408                              int xmax, int ymax)
    409 {
    410     /* Normalise values indicating an empty or out-of-bounds rectangle. */
    411     if(xmin > xmax || ymin > ymax ||
    412         xmax < 0 || xmin >= cv->width || ymax < 0 || ymin >= cv->height)
    413     {
    414         xmin = cv->width;
    415         xmax = -1;
    416         ymin = cv->height;
    417         ymax = -1;
    418     }
    419 
    420     cv->dirty_xmin = xmin;
    421     cv->dirty_xmax = xmax;
    422     cv->dirty_ymin = ymin;
    423     cv->dirty_ymax = ymax;
    424 
    425     return 0;
    426299}
    427300
  • libcaca/trunk/caca/driver/slang.c

    r3469 r3470  
    223223    uint32_t const *cvchars = (uint32_t const *)caca_get_canvas_chars(dp->cv);
    224224    uint32_t const *cvattrs = (uint32_t const *)caca_get_canvas_attrs(dp->cv);
    225     int x, y;
    226     int xmin, ymin, xmax, ymax;
    227 
    228     caca_get_dirty_rectangle(dp->cv, &xmin, &ymin, &xmax, &ymax);
    229     if(xmin > xmax || ymin > ymax)
    230         return;
    231 
    232     for(y = ymin; y <= ymax; y++)
    233     {
    234         SLsmg_gotorc(y, 0);
    235         for(x = xmax; x >= xmin; x--)
     225    int x, y, i;
     226
     227    for(i = 0; i < caca_get_dirty_rectangle_count(dp->cv); i++)
     228    {
     229        int xmin, ymin, xmax, ymax;
     230
     231        caca_get_dirty_rectangle(dp->cv, i, &xmin, &ymin, &xmax, &ymax);
     232
     233        for(y = ymin; y <= ymax; y++)
    236234        {
    237             uint32_t ch = *cvchars++;
     235            SLsmg_gotorc(y, 0);
     236            for(x = xmax; x >= xmin; x--)
     237            {
     238                uint32_t ch = *cvchars++;
    238239
    239240#if defined(OPTIMISE_SLANG_PALETTE)
    240             /* If foreground == background, just don't use this colour
    241              * pair, and print a space instead of the real character.
    242              * XXX: disabled, because I can't remember what it was
    243              * here for, and in cases where SLang does not render
    244              * bright backgrounds, it's just fucked up. */
     241                /* If foreground == background, just don't use this colour
     242                 * pair, and print a space instead of the real character. */
     243                /* XXX: disabled, because I can't remember what it was
     244                 * here for, and in cases where SLang does not render
     245                 * bright backgrounds, it's just fucked up. */
    245246#if 0
    246             uint8_t fgcolor = caca_attr_to_ansi_fg(*cvattrs);
    247             uint8_t bgcolor = caca_attr_to_ansi_bg(*cvattrs);
    248 
    249             if(fgcolor >= 0x10)
    250                 fgcolor = CACA_LIGHTGRAY;
    251 
    252             if(bgcolor >= 0x10)
    253                 bgcolor = CACA_BLACK; /* FIXME: handle transparency */
    254 
    255             if(fgcolor == bgcolor)
    256             {
    257                 if(fgcolor == CACA_BLACK)
    258                     fgcolor = CACA_WHITE;
    259                 else if(fgcolor == CACA_WHITE
    260                          || fgcolor <= CACA_LIGHTGRAY)
    261                     fgcolor = CACA_BLACK;
     247                uint8_t fgcolor = caca_attr_to_ansi_fg(*cvattrs);
     248                uint8_t bgcolor = caca_attr_to_ansi_bg(*cvattrs);
     249
     250                if(fgcolor >= 0x10)
     251                    fgcolor = CACA_LIGHTGRAY;
     252
     253                if(bgcolor >= 0x10)
     254                    bgcolor = CACA_BLACK; /* FIXME: handle transparency */
     255
     256                if(fgcolor == bgcolor)
     257                {
     258                    if(fgcolor == CACA_BLACK)
     259                        fgcolor = CACA_WHITE;
     260                    else if(fgcolor == CACA_WHITE
     261                             || fgcolor <= CACA_LIGHTGRAY)
     262                        fgcolor = CACA_BLACK;
     263                    else
     264                        fgcolor = CACA_WHITE;
     265                    SLsmg_set_color(slang_assoc[fgcolor + 16 * bgcolor]);
     266                    SLsmg_write_char(' ');
     267                    cvattrs++;
     268                }
    262269                else
    263                     fgcolor = CACA_WHITE;
    264                 SLsmg_set_color(slang_assoc[fgcolor + 16 * bgcolor]);
    265                 SLsmg_write_char(' ');
    266                 cvattrs++;
     270#endif
     271                {
     272                    SLsmg_set_color(slang_assoc[caca_attr_to_ansi(*cvattrs++)]);
     273                    slang_write_utf32(ch);
     274                }
     275#else
     276                SLsmg_set_color(caca_attr_to_ansi(*cvattrs++));
     277                slang_write_utf32(ch);
     278#endif
    267279            }
    268             else
    269 #endif
    270             {
    271                 SLsmg_set_color(slang_assoc[caca_attr_to_ansi(*cvattrs++)]);
    272                 slang_write_utf32(ch);
    273             }
    274 #else
    275             SLsmg_set_color(caca_attr_to_ansi(*cvattrs++));
    276             slang_write_utf32(ch);
    277 #endif
    278280        }
    279281    }
  • libcaca/trunk/caca/driver/x11.c

    r3468 r3470  
    294294    int width = caca_get_canvas_width(dp->cv);
    295295    int height = caca_get_canvas_height(dp->cv);
    296     int x, y, len;
    297     int xmin, ymin, xmax, ymax;
    298 
    299     caca_get_dirty_rectangle(dp->cv, &xmin, &ymin, &xmax, &ymax);
    300     if(xmin > xmax || ymin > ymax)
    301         return;
    302 
    303     /* First draw the background colours. Splitting the process in two
    304      * loops like this is actually slightly faster. */
    305     for(y = ymin; y <= ymax; y++)
    306     {
    307         for(x = xmin; x <= xmax; x += len)
    308         {
    309             uint32_t const *attrs = cvattrs + x + y * width;
    310             uint16_t bg = caca_attr_to_rgb12_bg(*attrs);
    311 
    312             len = 1;
    313             while(x + len < width
    314                    && caca_attr_to_rgb12_bg(attrs[len]) == bg)
    315                 len++;
    316 
    317             XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
    318                            dp->drv.p->colors[bg]);
    319             XFillRectangle(dp->drv.p->dpy, dp->drv.p->pixmap, dp->drv.p->gc,
    320                            x * dp->drv.p->font_width,
    321                            y * dp->drv.p->font_height,
    322                            len * dp->drv.p->font_width,
    323                            dp->drv.p->font_height);
    324         }
    325     }
    326 
    327     /* Then print the foreground characters */
    328     for(y = ymin; y <= ymax; y++)
    329     {
    330         int yoff = (y + 1) * dp->drv.p->font_height
    331                                     - dp->drv.p->font_offset;
    332         uint32_t const *chars = cvchars + y * width;
    333         uint32_t const *attrs = cvattrs + y * width;
    334 
    335         for(x = xmin; x <= xmax; x++, chars++, attrs++)
    336         {
    337             XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
     296    int x, y, i, len;
     297
     298    for(i = 0; i < caca_get_dirty_rectangle_count(dp->cv); i++)
     299    {
     300        int xmin, ymin, xmax, ymax;
     301
     302        caca_get_dirty_rectangle(dp->cv, i, &xmin, &ymin, &xmax, &ymax);
     303
     304        /* First draw the background colours. Splitting the process in two
     305         * loops like this is actually slightly faster. */
     306        for(y = ymin; y <= ymax; y++)
     307        {
     308            for(x = xmin; x <= xmax; x += len)
     309            {
     310                uint32_t const *attrs = cvattrs + x + y * width;
     311                uint16_t bg = caca_attr_to_rgb12_bg(*attrs);
     312
     313                len = 1;
     314                while(x + len < width
     315                       && caca_attr_to_rgb12_bg(attrs[len]) == bg)
     316                    len++;
     317
     318                XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
     319                               dp->drv.p->colors[bg]);
     320                XFillRectangle(dp->drv.p->dpy, dp->drv.p->pixmap,
     321                               dp->drv.p->gc,
     322                               x * dp->drv.p->font_width,
     323                               y * dp->drv.p->font_height,
     324                               len * dp->drv.p->font_width,
     325                               dp->drv.p->font_height);
     326            }
     327        }
     328
     329        /* Then print the foreground characters */
     330        for(y = ymin; y <= ymax; y++)
     331        {
     332            int yoff = (y + 1) * dp->drv.p->font_height
     333                                        - dp->drv.p->font_offset;
     334            uint32_t const *chars = cvchars + y * width;
     335            uint32_t const *attrs = cvattrs + y * width;
     336
     337            for(x = xmin; x <= xmax; x++, chars++, attrs++)
     338            {
     339                XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
    338340                           dp->drv.p->colors[caca_attr_to_rgb12_fg(*attrs)]);
    339341
    340             x11_put_glyph(dp, x * dp->drv.p->font_width,
    341                           y * dp->drv.p->font_height, yoff,
    342                           dp->drv.p->font_width, dp->drv.p->font_height,
    343                           *attrs, *chars);
    344         }
    345     }
    346 
    347     /* Print the cursor if necessary */
     342                x11_put_glyph(dp, x * dp->drv.p->font_width,
     343                              y * dp->drv.p->font_height, yoff,
     344                              dp->drv.p->font_width, dp->drv.p->font_height,
     345                              *attrs, *chars);
     346            }
     347        }
     348    }
     349
     350    /* Print the cursor if necessary. FIXME: handle dirty rectangles! */
    348351    if(dp->drv.p->cursor_flags)
    349352    {
  • libcaca/trunk/caca/frame.c

    r3448 r3470  
    7373    _caca_load_frame_info(cv);
    7474
    75     caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     75    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    7676
    7777    return 0;
     
    237237        cv->frame = 0;
    238238        _caca_load_frame_info(cv);
    239         caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     239        caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    240240    }
    241241
  • libcaca/trunk/caca/graphics.c

    r3448 r3470  
    156156
    157157    /* Invalidate the dirty rectangle */
    158     caca_set_dirty_rectangle(dp->cv, -1, -1, -1, -1);
     158    caca_clear_dirty_rectangle_list(dp->cv);
    159159
    160160    /* Once the display is finished, we can ack resizes */
  • libcaca/trunk/caca/libcaca.vcproj

    r3452 r3470  
    418418                </File>
    419419                <File
     420                        RelativePath=".\dirty.c"
     421                        >
     422                </File>
     423                <File
    420424                        RelativePath=".\dither.c"
    421425                        >
  • libcaca/trunk/caca/string.c

    r3450 r3470  
    323323    }
    324324
    325     caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     325    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    326326
    327327    return 0;
     
    529529
    530530    /* FIXME: this may be optimised somewhat */
    531     caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     531    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    532532
    533533    return 0;
  • libcaca/trunk/caca/transform.c

    r3448 r3470  
    5555    }
    5656
    57     caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     57    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    5858
    5959    return 0;
     
    116116    }
    117117
    118     caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     118    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    119119
    120120    return 0;
     
    163163    }
    164164
    165     caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     165    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    166166
    167167    return 0;
     
    222222    }
    223223
    224     caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     224    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    225225
    226226    return 0;
     
    341341    _caca_load_frame_info(cv);
    342342
    343     caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     343    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    344344
    345345    return 0;
     
    460460    _caca_load_frame_info(cv);
    461461
    462     caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     462    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    463463
    464464    return 0;
     
    553553    _caca_load_frame_info(cv);
    554554
    555     caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     555    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    556556
    557557    return 0;
     
    646646    _caca_load_frame_info(cv);
    647647
    648     caca_set_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     648    caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
    649649
    650650    return 0;
  • libcaca/trunk/tests/dirty.cpp

    r3449 r3470  
    3939    {
    4040        caca_canvas_t *cv;
    41         int xmin, xmax, ymin, ymax;
     41        int i, xmin, xmax, ymin, ymax;
    4242
    4343        /* Check that the dirty rectangle contains the whole canvas
    4444         * upon creation. */
    4545        cv = caca_create_canvas(WIDTH, HEIGHT);
    46         caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
    47         CPPUNIT_ASSERT(xmin <= 0);
    48         CPPUNIT_ASSERT(ymin <= 0);
    49         CPPUNIT_ASSERT(xmax >= caca_get_canvas_width(cv) - 1);
    50         CPPUNIT_ASSERT(ymax >= caca_get_canvas_height(cv) - 1);
     46        i = caca_get_dirty_rectangle_count(cv);
     47        CPPUNIT_ASSERT_EQUAL(i, 1);
     48
     49        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
     50        CPPUNIT_ASSERT_EQUAL(xmin, 0);
     51        CPPUNIT_ASSERT_EQUAL(ymin, 0);
     52        CPPUNIT_ASSERT_EQUAL(xmax, caca_get_canvas_width(cv) - 1);
     53        CPPUNIT_ASSERT_EQUAL(ymax, caca_get_canvas_height(cv) - 1);
    5154
    5255        /* Invalidate the dirty rectangle and check that it stays so. */
    53         caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
    54         caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
    55         CPPUNIT_ASSERT(xmin > xmax || ymin > ymax);
     56        caca_clear_dirty_rectangle_list(cv);
     57        i = caca_get_dirty_rectangle_count(cv);
     58        CPPUNIT_ASSERT_EQUAL(i, 0);
    5659
    5760        caca_free_canvas(cv);
     
    6164    {
    6265        caca_canvas_t *cv;
    63         int xmin, xmax, ymin, ymax;
     66        int i, xmin, xmax, ymin, ymax;
    6467
    6568        cv = caca_create_canvas(WIDTH, HEIGHT);
    6669
    67         caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
     70        caca_clear_dirty_rectangle_list(cv);
    6871        caca_put_char(cv, 7, 3, 'x');
    69         caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
    70         CPPUNIT_ASSERT(xmin <= 7);
    71         CPPUNIT_ASSERT(ymin <= 3);
    72         CPPUNIT_ASSERT(xmax >= 7);
    73         CPPUNIT_ASSERT(ymax >= 3);
     72        i = caca_get_dirty_rectangle_count(cv);
     73        CPPUNIT_ASSERT_EQUAL(i, 1);
     74        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
     75        CPPUNIT_ASSERT_EQUAL(xmin, 7);
     76        CPPUNIT_ASSERT_EQUAL(ymin, 3);
     77        CPPUNIT_ASSERT_EQUAL(xmax, 7);
     78        CPPUNIT_ASSERT_EQUAL(ymax, 3);
    7479
    7580        caca_clear_canvas(cv);
    76         caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
     81        caca_clear_dirty_rectangle_list(cv);
    7782        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    78         caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
    79         CPPUNIT_ASSERT(xmin <= 7);
    80         CPPUNIT_ASSERT(ymin <= 3);
    81         CPPUNIT_ASSERT(xmax >= 8);
    82         CPPUNIT_ASSERT(ymax >= 3);
     83        i = caca_get_dirty_rectangle_count(cv);
     84        CPPUNIT_ASSERT_EQUAL(i, 1);
     85        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
     86        CPPUNIT_ASSERT_EQUAL(xmin, 7);
     87        CPPUNIT_ASSERT_EQUAL(ymin, 3);
     88        CPPUNIT_ASSERT_EQUAL(xmax, 8);
     89        CPPUNIT_ASSERT_EQUAL(ymax, 3);
    8390
    8491        caca_clear_canvas(cv);
    8592        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    86         caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
     93        caca_clear_dirty_rectangle_list(cv);
    8794        caca_put_char(cv, 7, 3, 'x');
    88         caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
    89         CPPUNIT_ASSERT(xmin <= 7);
    90         CPPUNIT_ASSERT(ymin <= 3);
    91         CPPUNIT_ASSERT(xmax >= 8);
    92         CPPUNIT_ASSERT(ymax >= 3);
     95        i = caca_get_dirty_rectangle_count(cv);
     96        CPPUNIT_ASSERT_EQUAL(i, 1);
     97        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
     98        CPPUNIT_ASSERT_EQUAL(xmin, 7);
     99        CPPUNIT_ASSERT_EQUAL(ymin, 3);
     100        CPPUNIT_ASSERT_EQUAL(xmax, 8);
     101        CPPUNIT_ASSERT_EQUAL(ymax, 3);
    93102
    94103        caca_clear_canvas(cv);
    95104        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    96         caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
     105        caca_clear_dirty_rectangle_list(cv);
    97106        caca_put_char(cv, 8, 3, 'x');
    98         caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
    99         CPPUNIT_ASSERT(xmin <= 7);
    100         CPPUNIT_ASSERT(ymin <= 3);
    101         CPPUNIT_ASSERT(xmax >= 8);
    102         CPPUNIT_ASSERT(ymax >= 3);
     107        i = caca_get_dirty_rectangle_count(cv);
     108        CPPUNIT_ASSERT_EQUAL(i, 1);
     109        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
     110        CPPUNIT_ASSERT_EQUAL(xmin, 7);
     111        CPPUNIT_ASSERT_EQUAL(ymin, 3);
     112        CPPUNIT_ASSERT_EQUAL(xmax, 8);
     113        CPPUNIT_ASSERT_EQUAL(ymax, 3);
    103114
    104115        caca_clear_canvas(cv);
    105116        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    106         caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
     117        caca_clear_dirty_rectangle_list(cv);
    107118        caca_put_char(cv, 6, 3, 0x2f06 /* ⼆ */);
    108         caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
    109         CPPUNIT_ASSERT(xmin <= 6);
    110         CPPUNIT_ASSERT(ymin <= 3);
    111         CPPUNIT_ASSERT(xmax >= 8);
    112         CPPUNIT_ASSERT(ymax >= 3);
     119        i = caca_get_dirty_rectangle_count(cv);
     120        CPPUNIT_ASSERT_EQUAL(i, 1);
     121        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
     122        CPPUNIT_ASSERT_EQUAL(xmin, 6);
     123        CPPUNIT_ASSERT_EQUAL(ymin, 3);
     124        CPPUNIT_ASSERT_EQUAL(xmax, 8);
     125        CPPUNIT_ASSERT_EQUAL(ymax, 3);
    113126
    114127        caca_clear_canvas(cv);
    115128        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    116         caca_set_dirty_rectangle(cv, -1, -1, -1, -1);
     129        caca_clear_dirty_rectangle_list(cv);
    117130        caca_put_char(cv, 8, 3, 0x2f06 /* ⼆ */);
    118         caca_get_dirty_rectangle(cv, &xmin, &ymin, &xmax, &ymax);
    119         CPPUNIT_ASSERT(xmin <= 7);
    120         CPPUNIT_ASSERT(ymin <= 3);
    121         CPPUNIT_ASSERT(xmax >= 9);
    122         CPPUNIT_ASSERT(ymax >= 3);
     131        i = caca_get_dirty_rectangle_count(cv);
     132        CPPUNIT_ASSERT_EQUAL(i, 1);
     133        caca_get_dirty_rectangle(cv, 0, &xmin, &ymin, &xmax, &ymax);
     134        CPPUNIT_ASSERT_EQUAL(xmin, 7);
     135        CPPUNIT_ASSERT_EQUAL(ymin, 3);
     136        CPPUNIT_ASSERT_EQUAL(xmax, 9);
     137        CPPUNIT_ASSERT_EQUAL(ymax, 3);
    123138    }
    124139
Note: See TracChangeset for help on using the changeset viewer.