Changeset 3494 for libcaca/trunk


Ignore:
Timestamp:
May 21, 2009, 10:55:13 PM (11 years ago)
Author:
Sam Hocevar
Message:

Change the dirty rectangle API once again so that calling applications get
a more natural (x,y,w,h) 4-tuple to handle.

Location:
libcaca/trunk
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/caca/attr.c

    r3450 r3494  
    11/*
    22 *  libcaca       Colour ASCII-Art library
    3  *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2009 Sam Hocevar <sam@hocevar.net>
    44 *                All Rights Reserved
    55 *
     
    157157    }
    158158
    159     caca_add_dirty_rectangle(cv, xmin, y, xmax, y);
     159    caca_add_dirty_rect(cv, xmin, y, xmax - xmin + 1, 1);
    160160
    161161    return 0;
  • libcaca/trunk/caca/caca.h

    r3470 r3494  
    11/*
    22 *  libcaca       Colour ASCII-Art library
    3  *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2009 Sam Hocevar <sam@hocevar.net>
    44 *                All Rights Reserved
    55 *
     
    1515/** \file caca.h
    1616 *  \version \$Id$
    17  *  \author Sam Hocevar <sam@zoy.org>
     17 *  \author Sam Hocevar <sam@hocevar.net>
    1818 *  \brief The \e libcaca public header.
    1919 *
     
    241241 *  These functions manipulate dirty rectangles for optimised blitting.
    242242 *  @{ */
    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 *);
     243__extern int caca_get_dirty_rect_count(caca_canvas_t *);
     244__extern int caca_get_dirty_rect(caca_canvas_t *, int, int *, int *,
     245                                 int *, int *);
     246__extern int caca_add_dirty_rect(caca_canvas_t *, int, int, int, int);
     247__extern int caca_remove_dirty_rect(caca_canvas_t *, int, int, int, int);
     248__extern int caca_clear_dirty_rect_list(caca_canvas_t *);
    249249/*  @} */
    250250
  • libcaca/trunk/caca/canvas.c

    r3471 r3494  
    11/*
    22 *  libcaca       Colour ASCII-Art library
    3  *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2009 Sam Hocevar <sam@hocevar.net>
    44 *                All Rights Reserved
    55 *
     
    427427        }
    428428
    429         caca_add_dirty_rectangle(cv, old_width, 0, width - 1, old_height - 1);
     429        caca_add_dirty_rect(cv, old_width, 0, width - old_width, old_height);
    430430    }
    431431    else
     
    468468        }
    469469
    470         caca_add_dirty_rectangle(cv, 0, old_height, old_width - 1, height - 1);
     470        caca_add_dirty_rect(cv, 0, old_height, old_width, height - old_height);
    471471    }
    472472
     
    475475     * but in case the API changes later, we make sure this is handled. */
    476476    if(width > old_width && height > old_height)
    477         caca_add_dirty_rectangle(cv, old_width, old_height,
    478                                  width - 1, height - 1);
     477        caca_add_dirty_rect(cv, old_width, old_height,
     478                            width - old_width, height - old_height);
    479479
    480480    /* Step 4: if new area is smaller, resize memory area now. */
  • libcaca/trunk/caca/dirty.c

    r3484 r3494  
    4242 *  \return The number of dirty rectangles in the given canvas.
    4343 */
    44 int caca_get_dirty_rectangle_count(caca_canvas_t *cv)
     44int caca_get_dirty_rect_count(caca_canvas_t *cv)
    4545{
    4646    return cv->ndirty;
     
    5050 *
    5151 *  Get the canvas's given dirty rectangle coordinates. The index must be
    52  *  within the dirty rectangle count. See caca_get_dirty_rectangle_count()
     52 *  within the dirty rectangle count. See caca_get_dirty_rect_count()
    5353 *  for how to compute this count.
    5454 *
     
    5959 *  \param cv A libcaca canvas.
    6060 *  \param r The requested rectangle index.
    61  *  \param xmin A pointer to an integer where the leftmost edge of the
    62  *              dirty rectangle will be stored.
    63  *  \param ymin A pointer to an integer where the topmost edge of the
    64  *              dirty rectangle will be stored.
    65  *  \param xmax A pointer to an integer where the rightmost edge of the
    66  *              dirty rectangle will be stored.
    67  *  \param ymax A pointer to an integer where the bottommost edge of the
    68  *              dirty rectangle will be stored.
     61 *  \param x A pointer to an integer where the leftmost edge of the
     62 *           dirty rectangle will be stored.
     63 *  \param y A pointer to an integer where the topmost edge of the
     64 *           dirty rectangle will be stored.
     65 *  \param width A pointer to an integer where the width of the
     66 *               dirty rectangle will be stored.
     67 *  \param height A pointer to an integer where the height of the
     68 *                dirty rectangle will be stored.
    6969 *  \return 0 in case of success, -1 if an error occurred.
    7070 */
    71 int caca_get_dirty_rectangle(caca_canvas_t *cv, int r,
    72                              int *xmin, int *ymin, int *xmax, int *ymax)
     71int caca_get_dirty_rect(caca_canvas_t *cv, int r,
     72                        int *x, int *y, int *width, int *height)
    7373{
    7474    if(r < 0 || r >= cv->ndirty)
     
    9191        cv->dirty_ymax = cv->height - 1;
    9292
    93     *xmin = cv->dirty_xmin;
    94     *xmax = cv->dirty_xmax;
    95     *ymin = cv->dirty_ymin;
    96     *ymax = cv->dirty_ymax;
     93    *x = cv->dirty_xmin;
     94    *y = cv->dirty_ymin;
     95    *width = cv->dirty_xmax - cv->dirty_xmin + 1;
     96    *height = cv->dirty_ymax - cv->dirty_ymin + 1;
    9797
    9898    return 0;
     
    102102 *
    103103 *  Add an invalidating zone to the canvas's dirty rectangle list. For more
    104  *  information about the dirty rectangles, see caca_get_dirty_rectangle().
     104 *  information about the dirty rectangles, see caca_get_dirty_rect().
    105105 *
    106106 *  This function may be useful to force refresh of a given zone of the
     
    113113 *
    114114 *  \param cv A libcaca canvas.
    115  *  \param xmin The leftmost edge of the additional dirty rectangle.
    116  *  \param ymin The topmost edge of the additional dirty rectangle.
    117  *  \param xmax The rightmost edge of the additional dirty rectangle.
    118  *  \param ymax The bottommost edge of the additional dirty rectangle.
     115 *  \param x The leftmost edge of the additional dirty rectangle.
     116 *  \param y The topmost edge of the additional dirty rectangle.
     117 *  \param width The width of the additional dirty rectangle.
     118 *  \param height The height of the additional dirty rectangle.
    119119 *  \return 0 in case of success, -1 if an error occurred.
    120120 */
    121 int caca_add_dirty_rectangle(caca_canvas_t *cv, int xmin, int ymin,
    122                              int xmax, int ymax)
     121int caca_add_dirty_rect(caca_canvas_t *cv, int x, int y,
     122                             int width, int height)
    123123{
    124124    /* Ignore empty and out-of-bounds rectangles */
    125     if(xmin > xmax || ymin > ymax
    126         || xmax < 0 || xmin >= cv->width || ymax < 0 || ymin >= cv->height)
     125    if(width <= 0 || height <= 0 || x + width <= 0 || x >= cv->width
     126        || y + height <= 0 || y >= cv->height)
    127127    {
    128128        seterrno(EINVAL);
     
    133133    {
    134134        cv->ndirty = 1;
    135         cv->dirty_xmin = xmin;
    136         cv->dirty_xmax = xmax;
    137         cv->dirty_ymin = ymin;
    138         cv->dirty_ymax = ymax;
     135        cv->dirty_xmin = x;
     136        cv->dirty_xmax = x + width - 1;
     137        cv->dirty_ymin = y;
     138        cv->dirty_ymax = y + height - 1;
    139139    }
    140140    else
    141141    {
    142         if(xmin < cv->dirty_xmin)
    143             cv->dirty_xmin = xmin;
    144         if(xmax > cv->dirty_xmax)
    145             cv->dirty_xmax = xmax;
    146         if(ymin < cv->dirty_ymin)
    147             cv->dirty_ymin = ymin;
    148         if(ymax > cv->dirty_ymax)
    149             cv->dirty_ymax = ymax;
     142        if(x < cv->dirty_xmin)
     143            cv->dirty_xmin = x;
     144        if(x + width - 1 > cv->dirty_xmax)
     145            cv->dirty_xmax = x + width - 1;
     146        if(y < cv->dirty_ymin)
     147            cv->dirty_ymin = y;
     148        if(y + height - 1 > cv->dirty_ymax)
     149            cv->dirty_ymax = y + height - 1;
    150150    }
    151151
     
    156156 *
    157157 *  Mark a cell area in the canvas as not dirty. For more information about
    158  *  the dirty rectangles, see caca_get_dirty_rectangle().
     158 *  the dirty rectangles, see caca_get_dirty_rect().
    159159 *
    160160 *  Values such that \b xmin > \b xmax or \b ymin > \b ymax indicate that
     
    165165 *
    166166 *  \param cv A libcaca canvas.
    167  *  \param xmin The leftmost edge of the clean rectangle.
    168  *  \param ymin The topmost edge of the clean rectangle.
    169  *  \param xmax The rightmost edge of the clean rectangle.
    170  *  \param ymax The bottommost edge of the clean rectangle.
     167 *  \param x The leftmost edge of the clean rectangle.
     168 *  \param y The topmost edge of the clean rectangle.
     169 *  \param width The width of the clean rectangle.
     170 *  \param height The height of the clean rectangle.
    171171 *  \return 0 in case of success, -1 if an error occurred.
    172172 */
    173 int caca_remove_dirty_rectangle(caca_canvas_t *cv, int xmin, int ymin,
    174                                 int xmax, int ymax)
     173int caca_remove_dirty_rect(caca_canvas_t *cv, int x, int y,
     174                           int width, int height)
    175175{
    176176    /* Ignore empty and out-of-bounds rectangles */
    177     if(xmin > xmax || ymin > ymax
    178         || xmax < 0 || xmin >= cv->width || ymax < 0 || ymin >= cv->height)
     177    if(width <= 0 || height <= 0 || x + width <= 0 || x >= cv->width
     178        || y + height <= 0 || y >= cv->height)
    179179    {
    180180        seterrno(EINVAL);
     
    198198 *  \return This function always returns 0.
    199199 */
    200 int caca_clear_dirty_rectangle_list(caca_canvas_t *cv)
     200int caca_clear_dirty_rect_list(caca_canvas_t *cv)
    201201{
    202202    cv->ndirty = 0;
  • libcaca/trunk/caca/driver/ncurses.c

    r3489 r3494  
    348348    int x, y, i;
    349349
    350     for(i = 0; i < caca_get_dirty_rectangle_count(dp->cv); i++)
     350    for(i = 0; i < caca_get_dirty_rect_count(dp->cv); i++)
    351351    {
    352352        uint32_t const *cvchars, *cvattrs;
    353         int xmin, ymin, xmax, ymax;
    354 
    355         caca_get_dirty_rectangle(dp->cv, i, &xmin, &ymin, &xmax, &ymax);
     353        int dx, dy, dw, dh;
     354
     355        caca_get_dirty_rect(dp->cv, i, &dx, &dy, &dw, &dh);
    356356
    357357        cvchars = (uint32_t const *)caca_get_canvas_chars(dp->cv)
    358                     + xmin + ymin * dp->cv->width;
     358                    + dx + dy * dp->cv->width;
    359359        cvattrs = (uint32_t const *)caca_get_canvas_attrs(dp->cv)
    360                     + xmin + ymin * dp->cv->width;
    361 
    362         for(y = ymin; y <= ymax; y++)
     360                    + dx + dy * dp->cv->width;
     361
     362        for(y = dy; y < dy + dh; y++)
    363363        {
    364             move(y, xmin);
    365             for(x = xmin; x <= xmax; x++)
     364            move(y, dx);
     365            for(x = dx; x < dx + dw; x++)
    366366            {
    367367                attrset(dp->drv.p->attr[caca_attr_to_ansi(*cvattrs++)]);
     
    369369            }
    370370
    371             cvchars += dp->cv->width - (xmax - xmin) - 1;
    372             cvattrs += dp->cv->width - (xmax - xmin) - 1;
     371            cvchars += dp->cv->width - dw;
     372            cvattrs += dp->cv->width - dw;
    373373        }
    374374    }
  • libcaca/trunk/caca/driver/slang.c

    r3480 r3494  
    11/*
    22 *  libcaca       Colour ASCII-Art library
    3  *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2009 Sam Hocevar <sam@hocevar.net>
    44 *                All Rights Reserved
    55 *
     
    223223    int x, y, i;
    224224
    225     for(i = 0; i < caca_get_dirty_rectangle_count(dp->cv); i++)
     225    for(i = 0; i < caca_get_dirty_rect_count(dp->cv); i++)
    226226    {
    227227        uint32_t const *cvchars, *cvattrs;
    228         int xmin, ymin, xmax, ymax;
    229 
    230         caca_get_dirty_rectangle(dp->cv, i, &xmin, &ymin, &xmax, &ymax);
     228        int dx, dy, dw, dh;
     229
     230        caca_get_dirty_rect(dp->cv, i, &dx, &dy, &dw, &dh);
    231231
    232232        cvchars = (uint32_t const *)caca_get_canvas_chars(dp->cv)
    233                     + xmin + ymin * dp->cv->width;
     233                    + dx + dy * dp->cv->width;
    234234        cvattrs = (uint32_t const *)caca_get_canvas_attrs(dp->cv)
    235                     + xmin + ymin * dp->cv->width;
    236 
    237         for(y = ymin; y <= ymax; y++)
     235                    + dx + dy * dp->cv->width;
     236
     237        for(y = dy; y < dy + dh; y++)
    238238        {
    239             SLsmg_gotorc(y, xmin);
    240             for(x = xmin; x <= xmax; x++)
     239            SLsmg_gotorc(y, dx);
     240            for(x = dx; x < dx + dw; x++)
    241241            {
    242242                uint32_t ch = *cvchars++;
     
    283283            }
    284284
    285             cvchars += dp->cv->width - (xmax - xmin) - 1;
    286             cvattrs += dp->cv->width - (xmax - xmin) - 1;
     285            cvchars += dp->cv->width - dw;
     286            cvattrs += dp->cv->width - dw;
    287287        }
    288288    }
  • libcaca/trunk/caca/driver/vga.c

    r3489 r3494  
    121121        char *screen = (char *)(intptr_t)0x000b8000;
    122122        uint32_t const *cvchars, *cvattrs;
    123         int xmin, ymin, xmax, ymax;
     123        int dx, dy, dw, dh;
    124124
    125         caca_get_dirty_rectangle(dp->cv, i, &xmin, &ymin, &xmax, &ymax);
     125        caca_get_dirty_rect(dp->cv, i, &dx, &dy, &dw, &dh);
    126126
    127127        cvchars = (uint32_t const *)caca_get_canvas_chars(dp->cv)
    128                     + xmin + ymin * dp->cv->width;
     128                    + dx + dy * dp->cv->width;
    129129        cvattrs = (uint32_t const *)caca_get_canvas_attrs(dp->cv)
    130                     + xmin + ymin * dp->cv->width;
     130                    + dx + dy * dp->cv->width;
    131131
    132         screen += ymin * dp->cv->width + xmin;
     132        screen += dy * dp->cv->width + dx;
    133133
    134         for(y = ymin; y <= ymax; y++)
     134        for(y = dy; y < dy + dh; y++)
    135135        {
    136             for(x = xmin; x <= xmax; x++)
     136            for(x = dx; x < dx + dw; x++)
    137137            {
    138138                char ch = caca_utf32_to_cp437(*cvchars++);
    139                 if(x < xmax && *cvchars == CACA_MAGIC_FULLWIDTH)
     139                if(x < dx + dw - 1 && *cvchars == CACA_MAGIC_FULLWIDTH)
    140140                {
    141141                    *screen++ = '[';
     
    149149            }
    150150
    151             cvchars += dp->cv->width - (xmax - xmin) - 1;
    152             cvattrs += dp->cv->width - (xmax - xmin) - 1;
    153             screen += 2 * (dp->cv->width - (xmax - xmin) - 1);
     151            cvchars += dp->cv->width - dw;
     152            cvattrs += dp->cv->width - dw;
     153            screen += 2 * (dp->cv->width - dw);
    154154        }
    155155    }
  • libcaca/trunk/caca/driver/x11.c

    r3480 r3494  
    11/*
    22 *  libcaca       Colour ASCII-Art library
    3  *  Copyright (c) 2002-2007 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2009 Sam Hocevar <sam@hocevar.net>
    44 *                2007 Ben Wiley Sittler <bsittler@gmail.com>
    55 *                All Rights Reserved
     
    296296    int x, y, i, len;
    297297
    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);
     298    for(i = 0; i < caca_get_dirty_rect_count(dp->cv); i++)
     299    {
     300        int dx, dy, dw, dh;
     301
     302        caca_get_dirty_rect(dp->cv, i, &dx, &dy, &dw, &dh);
    303303
    304304        /* First draw the background colours. Splitting the process in two
    305305         * loops like this is actually slightly faster. */
    306         for(y = ymin; y <= ymax; y++)
    307         {
    308             for(x = xmin; x <= xmax; x += len)
     306        for(y = dy; y < dy + dh; y++)
     307        {
     308            for(x = dx; x < dx + dw; x += len)
    309309            {
    310310                uint32_t const *attrs = cvattrs + x + y * width;
     
    328328
    329329        /* Then print the foreground characters */
    330         for(y = ymin; y <= ymax; y++)
     330        for(y = dy; y < dy + dh; y++)
    331331        {
    332332            int yoff = (y + 1) * dp->drv.p->font_height
    333333                                        - dp->drv.p->font_offset;
    334             uint32_t const *chars = cvchars + xmin + y * width;
    335             uint32_t const *attrs = cvattrs + xmin + y * width;
    336 
    337             for(x = xmin; x <= xmax; x++, chars++, attrs++)
     334            uint32_t const *chars = cvchars + dx + y * width;
     335            uint32_t const *attrs = cvattrs + dx + y * width;
     336
     337            for(x = dx; x < dx + dw; x++, chars++, attrs++)
    338338            {
    339339                XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
  • libcaca/trunk/caca/frame.c

    r3470 r3494  
    11/*
    22 *  libcaca       Colour ASCII-Art library
    3  *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2009 Sam Hocevar <sam@hocevar.net>
    44 *                All Rights Reserved
    55 *
     
    7373    _caca_load_frame_info(cv);
    7474
    75     caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     75    caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    7676
    7777    return 0;
     
    237237        cv->frame = 0;
    238238        _caca_load_frame_info(cv);
    239         caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     239        caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    240240    }
    241241
  • libcaca/trunk/caca/graphics.c

    r3470 r3494  
    11/*
    22 *  libcaca       Colour ASCII-Art library
    3  *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2009 Sam Hocevar <sam@hocevar.net>
    44 *                All Rights Reserved
    55 *
     
    156156
    157157    /* Invalidate the dirty rectangle */
    158     caca_clear_dirty_rectangle_list(dp->cv);
     158    caca_clear_dirty_rect_list(dp->cv);
    159159
    160160    /* Once the display is finished, we can ack resizes */
  • libcaca/trunk/caca/string.c

    r3470 r3494  
    11/*
    22 *  libcaca       Colour ASCII-Art library
    3  *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2009 Sam Hocevar <sam@hocevar.net>
    44 *                All Rights Reserved
    55 *
     
    177177    }
    178178
    179     caca_add_dirty_rectangle(cv, xmin, y, xmax, y);
     179    caca_add_dirty_rect(cv, xmin, y, xmax - xmin + 1, 1);
    180180
    181181    curchar[0] = ch;
     
    323323    }
    324324
    325     caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     325    caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    326326
    327327    return 0;
     
    462462    }
    463463
    464     caca_add_dirty_rectangle(dst, starti + x - bleed_left, startj + y,
    465                              endi + x - 1 + bleed_right, endj + y - 1);
     464    caca_add_dirty_rect(dst, starti + x - bleed_left, startj + y,
     465                        endi - starti + bleed_left + bleed_right,
     466                        endj - startj);
    466467
    467468    return 0;
     
    529530
    530531    /* FIXME: this may be optimised somewhat */
    531     caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     532    caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    532533
    533534    return 0;
  • libcaca/trunk/caca/transform.c

    r3470 r3494  
    11/*
    22 *  libcaca       Colour ASCII-Art library
    3  *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2009 Sam Hocevar <sam@hocevar.net>
    44 *                All Rights Reserved
    55 *
     
    5555    }
    5656
    57     caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     57    caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    5858
    5959    return 0;
     
    116116    }
    117117
    118     caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     118    caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    119119
    120120    return 0;
     
    163163    }
    164164
    165     caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     165    caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    166166
    167167    return 0;
     
    222222    }
    223223
    224     caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     224    caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    225225
    226226    return 0;
     
    341341    _caca_load_frame_info(cv);
    342342
    343     caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     343    caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    344344
    345345    return 0;
     
    460460    _caca_load_frame_info(cv);
    461461
    462     caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     462    caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    463463
    464464    return 0;
     
    553553    _caca_load_frame_info(cv);
    554554
    555     caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     555    caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    556556
    557557    return 0;
     
    646646    _caca_load_frame_info(cv);
    647647
    648     caca_add_dirty_rectangle(cv, 0, 0, cv->width - 1, cv->height - 1);
     648    caca_add_dirty_rect(cv, 0, 0, cv->width, cv->height);
    649649
    650650    return 0;
  • libcaca/trunk/tests/dirty.cpp

    r3470 r3494  
    11/*
    22 *  caca-test     testsuite program for libcaca
    3  *  Copyright (c) 2009 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2009 Sam Hocevar <sam@hocevar.net>
    44 *                All Rights Reserved
    55 *
     
    3939    {
    4040        caca_canvas_t *cv;
    41         int i, xmin, xmax, ymin, ymax;
     41        int i, dx, dy, dw, dh;
    4242
    4343        /* Check that the dirty rectangle contains the whole canvas
    4444         * upon creation. */
    4545        cv = caca_create_canvas(WIDTH, HEIGHT);
    46         i = caca_get_dirty_rectangle_count(cv);
     46        i = caca_get_dirty_rect_count(cv);
    4747        CPPUNIT_ASSERT_EQUAL(i, 1);
    4848
    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);
     49        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     50        CPPUNIT_ASSERT_EQUAL(dx, 0);
     51        CPPUNIT_ASSERT_EQUAL(dy, 0);
     52        CPPUNIT_ASSERT_EQUAL(dw, caca_get_canvas_width(cv));
     53        CPPUNIT_ASSERT_EQUAL(dh, caca_get_canvas_height(cv));
    5454
    5555        /* Invalidate the dirty rectangle and check that it stays so. */
    56         caca_clear_dirty_rectangle_list(cv);
    57         i = caca_get_dirty_rectangle_count(cv);
     56        caca_clear_dirty_rect_list(cv);
     57        i = caca_get_dirty_rect_count(cv);
    5858        CPPUNIT_ASSERT_EQUAL(i, 0);
    5959
     
    6464    {
    6565        caca_canvas_t *cv;
    66         int i, xmin, xmax, ymin, ymax;
     66        int i, dx, dy, dw, dh;
    6767
    6868        cv = caca_create_canvas(WIDTH, HEIGHT);
    6969
    70         caca_clear_dirty_rectangle_list(cv);
     70        caca_clear_dirty_rect_list(cv);
    7171        caca_put_char(cv, 7, 3, 'x');
    72         i = caca_get_dirty_rectangle_count(cv);
     72        i = caca_get_dirty_rect_count(cv);
    7373        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);
     74        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     75        CPPUNIT_ASSERT_EQUAL(dx, 7);
     76        CPPUNIT_ASSERT_EQUAL(dy, 3);
     77        CPPUNIT_ASSERT_EQUAL(dw, 1);
     78        CPPUNIT_ASSERT_EQUAL(dh, 1);
    7979
    8080        caca_clear_canvas(cv);
    81         caca_clear_dirty_rectangle_list(cv);
     81        caca_clear_dirty_rect_list(cv);
    8282        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    83         i = caca_get_dirty_rectangle_count(cv);
     83        i = caca_get_dirty_rect_count(cv);
    8484        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);
     85        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     86        CPPUNIT_ASSERT_EQUAL(dx, 7);
     87        CPPUNIT_ASSERT_EQUAL(dy, 3);
     88        CPPUNIT_ASSERT_EQUAL(dw, 2);
     89        CPPUNIT_ASSERT_EQUAL(dh, 1);
    9090
    9191        caca_clear_canvas(cv);
    9292        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    93         caca_clear_dirty_rectangle_list(cv);
     93        caca_clear_dirty_rect_list(cv);
    9494        caca_put_char(cv, 7, 3, 'x');
    95         i = caca_get_dirty_rectangle_count(cv);
     95        i = caca_get_dirty_rect_count(cv);
    9696        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);
     97        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     98        CPPUNIT_ASSERT_EQUAL(dx, 7);
     99        CPPUNIT_ASSERT_EQUAL(dy, 3);
     100        CPPUNIT_ASSERT_EQUAL(dw, 2);
     101        CPPUNIT_ASSERT_EQUAL(dh, 1);
    102102
    103103        caca_clear_canvas(cv);
    104104        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    105         caca_clear_dirty_rectangle_list(cv);
     105        caca_clear_dirty_rect_list(cv);
    106106        caca_put_char(cv, 8, 3, 'x');
    107         i = caca_get_dirty_rectangle_count(cv);
     107        i = caca_get_dirty_rect_count(cv);
    108108        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);
     109        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     110        CPPUNIT_ASSERT_EQUAL(dx, 7);
     111        CPPUNIT_ASSERT_EQUAL(dy, 3);
     112        CPPUNIT_ASSERT_EQUAL(dw, 2);
     113        CPPUNIT_ASSERT_EQUAL(dh, 1);
    114114
    115115        caca_clear_canvas(cv);
    116116        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    117         caca_clear_dirty_rectangle_list(cv);
     117        caca_clear_dirty_rect_list(cv);
    118118        caca_put_char(cv, 6, 3, 0x2f06 /* ⼆ */);
    119         i = caca_get_dirty_rectangle_count(cv);
     119        i = caca_get_dirty_rect_count(cv);
    120120        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);
     121        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     122        CPPUNIT_ASSERT_EQUAL(dx, 6);
     123        CPPUNIT_ASSERT_EQUAL(dy, 3);
     124        CPPUNIT_ASSERT_EQUAL(dw, 3);
     125        CPPUNIT_ASSERT_EQUAL(dh, 1);
    126126
    127127        caca_clear_canvas(cv);
    128128        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    129         caca_clear_dirty_rectangle_list(cv);
     129        caca_clear_dirty_rect_list(cv);
    130130        caca_put_char(cv, 8, 3, 0x2f06 /* ⼆ */);
    131         i = caca_get_dirty_rectangle_count(cv);
     131        i = caca_get_dirty_rect_count(cv);
    132132        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);
     133        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     134        CPPUNIT_ASSERT_EQUAL(dx, 7);
     135        CPPUNIT_ASSERT_EQUAL(dy, 3);
     136        CPPUNIT_ASSERT_EQUAL(dw, 3);
     137        CPPUNIT_ASSERT_EQUAL(dh, 1);
    138138    }
    139139
Note: See TracChangeset for help on using the changeset viewer.