Ignore:
Timestamp:
Apr 18, 2006, 5:11:25 PM (14 years ago)
Author:
Sam Hocevar
Message:
  • Renamed caca_t into caca_display_t.
  • Renamed canvas handle variables from "c" to "cv". Eh ouais mon gros.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/cucul/cucul.c

    r810 r811  
    4444cucul_canvas_t * cucul_create(unsigned int width, unsigned int height)
    4545{
    46     cucul_canvas_t *c = malloc(sizeof(cucul_canvas_t));
    47 
    48     c->refcount = 0;
    49 
    50     c->fgcolor = CUCUL_COLOR_LIGHTGRAY;
    51     c->bgcolor = CUCUL_COLOR_BLACK;
    52 
    53     c->width = c->height = 0;
    54     c->chars = NULL;
    55     c->attr = NULL;
    56     c->empty_line = c->scratch_line = NULL;
     46    cucul_canvas_t *cv = malloc(sizeof(cucul_canvas_t));
     47
     48    cv->refcount = 0;
     49
     50    cv->fgcolor = CUCUL_COLOR_LIGHTGRAY;
     51    cv->bgcolor = CUCUL_COLOR_BLACK;
     52
     53    cv->width = cv->height = 0;
     54    cv->chars = NULL;
     55    cv->attr = NULL;
     56    cv->empty_line = cv->scratch_line = NULL;
    5757
    5858    /* Initialise to a default size. 80x32 is arbitrary but matches AAlib's
     
    6060     * a different size. */
    6161    if(width && height)
    62         _cucul_set_size(c, width, height);
     62        _cucul_set_size(cv, width, height);
    6363    else
    64         _cucul_set_size(c, 80, 32);
     64        _cucul_set_size(cv, 80, 32);
    6565
    6666    if(_cucul_init_dither())
    6767    {
    68         free(c);
    69         return NULL;
    70     }
    71 
    72     return c;
     68        free(cv);
     69        return NULL;
     70    }
     71
     72    return cv;
    7373}
    7474
     
    8484cucul_canvas_t *cucul_load(void *data, unsigned int size)
    8585{
    86     cucul_canvas_t *c;
     86    cucul_canvas_t *cv;
    8787    uint8_t *buf = (uint8_t *)data;
    8888    unsigned int width, height, n;
     
    109109        return NULL;
    110110
    111     c = cucul_create(width, height);
    112 
    113     if(!c)
     111    cv = cucul_create(width, height);
     112
     113    if(!cv)
    114114        return NULL;
    115115
    116116    for(n = height * width; n--; )
    117117    {
    118         c->chars[n] = ((uint32_t)buf[12 + 8 * n] << 24)
     118        cv->chars[n] = ((uint32_t)buf[12 + 8 * n] << 24)
    119119                     | ((uint32_t)buf[13 + 8 * n] << 16)
    120120                     | ((uint32_t)buf[14 + 8 * n] << 8)
    121121                     | (uint32_t)buf[15 + 8 * n];
    122         c->attr[n] = ((uint32_t)buf[16 + 8 * n] << 24)
     122        cv->attr[n] = ((uint32_t)buf[16 + 8 * n] << 24)
    123123                    | ((uint32_t)buf[17 + 8 * n] << 16)
    124124                    | ((uint32_t)buf[18 + 8 * n] << 8)
     
    126126    }
    127127
    128     return c;
     128    return cv;
    129129}
    130130
     
    144144 *  for more about this.
    145145 *
    146  *  \param c A libcucul canvas
     146 *  \param cv A libcucul canvas
    147147 *  \param width The desired canvas width
    148148 *  \param height The desired canvas height
    149149 */
    150 void cucul_set_size(cucul_canvas_t *c, unsigned int width, unsigned int height)
    151 {
    152     if(c->refcount)
     150void cucul_set_size(cucul_canvas_t *cv, unsigned int width, unsigned int height)
     151{
     152    if(cv->refcount)
    153153        return;
    154154
    155     _cucul_set_size(c, width, height);
     155    _cucul_set_size(cv, width, height);
    156156}
    157157
     
    160160 *  This function returns the current canvas width, in character cells.
    161161 *
    162  *  \param c A libcucul canvas
     162 *  \param cv A libcucul canvas
    163163 *  \return The canvas width.
    164164 */
    165 unsigned int cucul_get_width(cucul_canvas_t *c)
    166 {
    167     return c->width;
     165unsigned int cucul_get_width(cucul_canvas_t *cv)
     166{
     167    return cv->width;
    168168}
    169169
     
    172172 *  This function returns the current canvas height, in character cells.
    173173 *
    174  *  \param c A libcucul canvas
     174 *  \param cv A libcucul canvas
    175175 *  \return The canvas height.
    176176 */
    177 unsigned int cucul_get_height(cucul_canvas_t *c)
    178 {
    179     return c->height;
     177unsigned int cucul_get_height(cucul_canvas_t *cv)
     178{
     179    return cv->height;
    180180}
    181181
     
    222222 *  unless a new call to cucul_create() is done.
    223223 *
    224  *  \param c A libcucul canvas
    225  */
    226 void cucul_free(cucul_canvas_t *c)
     224 *  \param cv A libcucul canvas
     225 */
     226void cucul_free(cucul_canvas_t *cv)
    227227{
    228228    _cucul_end_dither();
    229229
    230     free(c->empty_line);
    231     free(c->scratch_line);
    232 
    233     free(c->chars);
    234     free(c->attr);
    235 
    236     free(c);
     230    free(cv->empty_line);
     231    free(cv->scratch_line);
     232
     233    free(cv->chars);
     234    free(cv->attr);
     235
     236    free(cv);
    237237}
    238238
     
    291291 */
    292292
    293 void _cucul_set_size(cucul_canvas_t *c, unsigned int width, unsigned int height)
     293void _cucul_set_size(cucul_canvas_t *cv, unsigned int width,
     294                                         unsigned int height)
    294295{
    295296    unsigned int x, y, old_width, old_height, new_size, old_size;
    296297
    297     old_width = c->width;
    298     old_height = c->height;
     298    old_width = cv->width;
     299    old_height = cv->height;
    299300    old_size = old_width * old_height;
    300301
    301     c->width = width;
    302     c->height = height;
     302    cv->width = width;
     303    cv->height = height;
    303304    new_size = width * height;
    304305
     
    306307    if(new_size > old_size)
    307308    {
    308         c->chars = realloc(c->chars, new_size * sizeof(uint32_t));
    309         c->attr = realloc(c->attr, new_size * sizeof(uint32_t));
     309        cv->chars = realloc(cv->chars, new_size * sizeof(uint32_t));
     310        cv->attr = realloc(cv->attr, new_size * sizeof(uint32_t));
    310311    }
    311312
     
    325326            for(x = old_width; x--; )
    326327            {
    327                 c->chars[y * width + x] = c->chars[y * old_width + x];
    328                 c->attr[y * width + x] = c->attr[y * old_width + x];
     328                cv->chars[y * width + x] = cv->chars[y * old_width + x];
     329                cv->attr[y * width + x] = cv->attr[y * old_width + x];
    329330            }
    330331
    331332            /* Zero the end of the line */
    332333            for(x = width - old_width; x--; )
    333                 c->chars[y * width + old_width + x] = (uint32_t)' ';
    334             memset(c->attr + y * width + old_width, 0,
     334                cv->chars[y * width + old_width + x] = (uint32_t)' ';
     335            memset(cv->attr + y * width + old_width, 0,
    335336                   (width - old_width) * 4);
    336337        }
     
    346347            for(x = 0; x < width; x++)
    347348            {
    348                 c->chars[y * width + x] = c->chars[y * old_width + x];
    349                 c->attr[y * width + x] = c->attr[y * old_width + x];
     349                cv->chars[y * width + x] = cv->chars[y * old_width + x];
     350                cv->attr[y * width + x] = cv->attr[y * old_width + x];
    350351            }
    351352        }
     
    357358        /* Zero the bottom of the screen */
    358359        for(x = (height - old_height) * width; x--; )
    359             c->chars[old_height * width + x] = (uint32_t)' ';
    360         memset(c->attr + old_height * width, 0,
     360            cv->chars[old_height * width + x] = (uint32_t)' ';
     361        memset(cv->attr + old_height * width, 0,
    361362               (height - old_height) * width * 4);
    362363    }
     
    365366    if(new_size <= old_size)
    366367    {
    367         c->chars = realloc(c->chars, new_size * sizeof(uint32_t));
    368         c->attr = realloc(c->attr, new_size * sizeof(uint32_t));
     368        cv->chars = realloc(cv->chars, new_size * sizeof(uint32_t));
     369        cv->attr = realloc(cv->attr, new_size * sizeof(uint32_t));
    369370    }
    370371
     
    372373    if(width != old_width)
    373374    {
    374         c->empty_line = realloc(c->empty_line, width + 1);
    375         memset(c->empty_line, ' ', width);
    376         c->empty_line[width] = '\0';
    377 
    378         c->scratch_line = realloc(c->scratch_line, width + 1);
    379     }
    380 }
    381 
     375        cv->empty_line = realloc(cv->empty_line, width + 1);
     376        memset(cv->empty_line, ' ', width);
     377        cv->empty_line[width] = '\0';
     378
     379        cv->scratch_line = realloc(cv->scratch_line, width + 1);
     380    }
     381}
     382
Note: See TracChangeset for help on using the changeset viewer.