Ignore:
Timestamp:
Nov 25, 2007, 3:12:01 PM (12 years ago)
Author:
Sam Hocevar
Message:
  • Introduce cucul_get_canvas_chars() and cucul_get_canvas_attrs() to avoid direct cv->chars and cv->attrs access by display drivers.
Location:
libcaca/trunk/caca
Files:
12 edited

Legend:

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

    r2055 r2056  
    3434
    3535#include "cucul.h"
    36 #include "cucul_internals.h"
    3736#include "caca.h"
    3837#include "caca_internals.h"
     
    130129
    131130    /* Mouse position */
    132     dp->mouse.x = dp->cv->width / 2;
    133     dp->mouse.y = dp->cv->height / 2;
     131    dp->mouse.x = cucul_get_canvas_width(dp->cv) / 2;
     132    dp->mouse.y = cucul_get_canvas_height(dp->cv) / 2;
    134133
    135134    /* Resize events */
  • libcaca/trunk/caca/driver_cocoa.m

    r2055 r2056  
    2424#import <Cocoa/Cocoa.h>
    2525
     26#include "cucul.h"
    2627#include "caca.h"
    2728#include "caca_internals.h"
    28 #include "cucul.h"
    29 #include "cucul_internals.h"
    3029
    3130//#define COCOA_DEBUG
     
    197196- (void)resizeIfNeeded:(caca_display_t *)dp
    198197{
    199     if(   _w != dp->cv->width || _h != dp->cv->height
    200        || !_attrs || !_bkg_rects || !_bkg_colors)
     198    if(_w != cucul_get_canvas_width(dp->cv)
     199        || _h != cucul_get_canvas_height(dp->cv)
     200        || !_attrs || !_bkg_rects || !_bkg_colors)
    201201    {
    202202        debug_log(@"%s resize to %ux%u", _cmd, _w, _h);
    203203       
    204         _w = dp->cv->width;
    205         _h = dp->cv->height;
     204        _w = cucul_get_canvas_width(dp->cv);
     205        _h = cucul_get_canvas_height(dp->cv);
    206206
    207207        if(_attrs)
     
    217217        _bkg_colors = malloc(_w * _h * sizeof(NSColor*));
    218218
    219         [[self window] setContentSize: NSMakeSize(dp->cv->width * _font_rect.size.width,
    220                                                   dp->cv->height * _font_rect.size.height)];
     219        [[self window] setContentSize: NSMakeSize(cucul_get_canvas_width(dp->cv) * _font_rect.size.width,
     220                                                  cucul_get_canvas_height(dp->cv) * _font_rect.size.height)];
    221221    }
    222222}
     
    229229    {
    230230        _chars = _attrs + _w * _h;
    231         memcpy(_attrs, dp->cv->attrs, _w * _h * sizeof(uint32_t));
    232         memcpy(_chars, dp->cv->chars, _w * _h * sizeof(uint32_t));
     231        memcpy(_attrs, cucul_get_canvas_attrs(dp->cv),
     232               _w * _h * sizeof(uint32_t));
     233        memcpy(_chars, cucul_get_canvas_chars(dp->cv),
     234               _w * _h * sizeof(uint32_t));
    233235
    234236        [self setNeedsDisplay:TRUE];
     
    571573    NSRect fontRect = [font boundingRectForFont];
    572574    fontRect = NSMakeRect(0, 0, ceilf(fontRect.size.width), ceilf(fontRect.size.height));
    573     NSRect windowRect = NSMakeRect(20, 20, dp->cv->width * fontRect.size.width,
    574                                            dp->cv->height * fontRect.size.height);
     575    NSRect windowRect = NSMakeRect(20, 20, cucul_get_canvas_width(dp->cv) * fontRect.size.width,
     576                                           cucul_get_canvas_height(dp->cv) * fontRect.size.height);
    575577    convert_NSRect(&windowRect);
    576578
     
    825827static int cocoa_init_graphics(caca_display_t *dp)
    826828{
    827     debug_log(@"%s dp->cv: %ux%u", __PRETTY_FUNCTION__,
    828               dp->cv->width, dp->cv->height);
     829    unsigned int width = cucul_get_canvas_width(dp->cv);
     830    unsigned int height = cucul_get_canvas_height(dp->cv);
     831
     832    debug_log(@"%s dp->cv: %ux%u", __PRETTY_FUNCTION__, width, height);
    829833
    830834    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
     
    834838        return -1;
    835839
    836     unsigned int width = dp->cv->width, height = dp->cv->height;
    837840    dp->resize.allow = 1;
    838841    cucul_set_canvas_size(dp->cv, width ? width : 80, height ? height : 32);
     
    856859{
    857860    debug_log(@"%s dp->cv: %ux%u", __PRETTY_FUNCTION__,
    858               dp->cv->width, dp->cv->height);
     861              cucul_get_canvas_width(dp->cv), cucul_get_canvas_height(dp->cv));
    859862
    860863    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
     
    956959{
    957960    debug_log(@"%s", __PRETTY_FUNCTION__);
    958     dp->resize.w = dp->cv->width;
    959     dp->resize.h = dp->cv->height;
     961    dp->resize.w = cucul_get_canvas_width(dp->cv);
     962    dp->resize.h = cucul_get_canvas_height(dp->cv);
    960963}
    961964
  • libcaca/trunk/caca/driver_conio.c

    r2055 r2056  
    3030#include <stdlib.h>
    3131
     32#include "cucul.h"
    3233#include "caca.h"
    3334#include "caca_internals.h"
    34 #include "cucul.h"
    35 #include "cucul_internals.h"
    3635
    3736struct driver_private
     
    7271    textcolor((enum COLORS)WHITE);
    7372    textbackground((enum COLORS)BLACK);
    74     gotoxy(dp->cv->width, dp->cv->height);
     73    gotoxy(cucul_get_canvas_width(dp->cv), cucul_get_canvas_height(dp->cv));
    7574    cputs("\r\n");
    7675    _setcursortype(_NORMALCURSOR);
     
    9089{
    9190    /* Fallback to a 6x10 font */
    92     return dp->cv->width * 6;
     91    return cucul_get_canvas_width(dp->cv) * 6;
    9392}
    9493
     
    9695{
    9796    /* Fallback to a 6x10 font */
    98     return dp->cv->height * 10;
     97    return cucul_get_canvas_height(dp->cv) * 10;
    9998}
    10099
     
    102101{
    103102    char *screen = dp->drv.p->screen;
    104     uint32_t *attrs = dp->cv->attrs;
    105     uint32_t *chars = dp->cv->chars;
     103    uint32_t const *chars = (uint32_t const *)cucul_get_canvas_chars(dp->cv);
     104    uint32_t const *attrs = (uint32_t const *)cucul_get_canvas_attrs(dp->cv);
     105    unsigned int width = cucul_get_canvas_width(dp->cv);
     106    unsigned int height = cucul_get_canvas_height(dp->cv);
    106107    unsigned int n;
    107108
    108     for(n = dp->cv->height * dp->cv->width; n--; )
     109    for(n = height * width; n--; )
    109110    {
    110111        char ch = cucul_utf32_to_cp437(*chars++);
     
    130131{
    131132    /* We know nothing about our window */
    132     dp->resize.w = dp->cv->width;
    133     dp->resize.h = dp->cv->height;
     133    dp->resize.w = cucul_get_canvas_width(dp->cv);
     134    dp->resize.h = cucul_get_canvas_height(dp->cv);
    134135}
    135136
  • libcaca/trunk/caca/driver_gl.c

    r2055 r2056  
    3737#include <stdio.h>
    3838
     39#include "cucul.h"
     40#include "cucul_internals.h"
    3941#include "caca.h"
    4042#include "caca_internals.h"
    41 #include "cucul.h"
    42 #include "cucul_internals.h"
    43 
    4443
    4544/*
     
    9089    char *argv[2] = { "", NULL };
    9190    char const * const * fonts;
    92     unsigned int width = dp->cv->width, height = dp->cv->height;
     91    unsigned int width = cucul_get_canvas_width(dp->cv);
     92    unsigned int height = cucul_get_canvas_height(dp->cv);
    9393    int argc = 1;
    9494
     
    124124    dp->drv.p->font_height = cucul_get_font_height(dp->drv.p->f);
    125125
    126     dp->drv.p->width = dp->cv->width * dp->drv.p->font_width;
    127     dp->drv.p->height = dp->cv->height * dp->drv.p->font_height;
     126    dp->drv.p->width = cucul_get_canvas_width(dp->cv) * dp->drv.p->font_width;
     127    dp->drv.p->height = cucul_get_canvas_height(dp->cv) * dp->drv.p->font_height;
    128128
    129129#ifdef HAVE_GLUTCLOSEFUNC
     
    212212static void gl_display(caca_display_t *dp)
    213213{
     214    uint32_t const *cvchars = (uint32_t const *)cucul_get_canvas_chars(dp->cv);
     215    uint32_t const *cvattrs = (uint32_t const *)cucul_get_canvas_attrs(dp->cv);
     216    unsigned int width = cucul_get_canvas_width(dp->cv);
    214217    unsigned int x, y, line;
    215218
     
    220223    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height)
    221224    {
    222         uint32_t *attrs = dp->cv->attrs + line * dp->cv->width;
     225        uint32_t const *attrs = cvattrs + line * width;
    223226
    224227        /* FIXME: optimise using stride */
     
    250253    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height, line++)
    251254    {
    252         uint32_t *attrs = dp->cv->attrs + line * dp->cv->width;
    253         uint32_t *chars = dp->cv->chars + line * dp->cv->width;
     255        uint32_t const *attrs = cvattrs + line * width;
     256        uint32_t const *chars = cvchars + line * width;
    254257
    255258        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width, attrs++)
     
    345348    {
    346349        ev->type = CACA_EVENT_RESIZE;
    347         ev->data.resize.w = dp->cv->width;
    348         ev->data.resize.h = dp->cv->height;
     350        ev->data.resize.w = cucul_get_canvas_width(dp->cv);
     351        ev->data.resize.h = cucul_get_canvas_height(dp->cv);
    349352        return 1;
    350353    }
  • libcaca/trunk/caca/driver_ncurses.c

    r2055 r2056  
    5252#endif
    5353
     54#include "cucul.h"
    5455#include "caca.h"
    5556#include "caca_internals.h"
    56 #include "cucul.h"
    57 #include "cucul_internals.h"
    5857
    5958/*
     
    332331{
    333332    /* Fallback to a 6x10 font */
    334     return dp->cv->width * 6;
     333    return cucul_get_canvas_width(dp->cv) * 6;
    335334}
    336335
     
    338337{
    339338    /* Fallback to a 6x10 font */
    340     return dp->cv->height * 10;
     339    return cucul_get_canvas_height(dp->cv) * 10;
    341340}
    342341
    343342static void ncurses_display(caca_display_t *dp)
    344343{
     344    uint32_t const *cvchars = (uint32_t const *)cucul_get_canvas_chars(dp->cv);
     345    uint32_t const *cvattrs = (uint32_t const *)cucul_get_canvas_attrs(dp->cv);
     346    unsigned int width = cucul_get_canvas_width(dp->cv);
     347    unsigned int height = cucul_get_canvas_height(dp->cv);
    345348    int x, y;
    346     uint32_t *attrs = dp->cv->attrs;
    347     uint32_t *chars = dp->cv->chars;
    348     for(y = 0; y < (int)dp->cv->height; y++)
     349
     350    for(y = 0; y < (int)height; y++)
    349351    {
    350352        move(y, 0);
    351         for(x = dp->cv->width; x--; )
     353        for(x = width; x--; )
    352354        {
    353             attrset(dp->drv.p->attr[cucul_attr_to_ansi(*attrs++)]);
    354             ncurses_write_utf32(*chars++);
     355            attrset(dp->drv.p->attr[cucul_attr_to_ansi(*cvattrs++)]);
     356            ncurses_write_utf32(*cvchars++);
    355357        }
    356358    }
     
    383385
    384386    /* Fallback */
    385     dp->resize.w = dp->cv->width;
    386     dp->resize.h = dp->cv->height;
     387    dp->resize.w = cucul_get_canvas_width(dp->cv);
     388    dp->resize.h = cucul_get_canvas_height(dp->cv);
    387389}
    388390
  • libcaca/trunk/caca/driver_raw.c

    r2055 r2056  
    2525#include <stdlib.h>
    2626
     27#include "cucul.h"
    2728#include "caca.h"
    2829#include "caca_internals.h"
    29 #include "cucul.h"
    30 #include "cucul_internals.h"
    3130
    3231static int raw_init_graphics(caca_display_t *dp)
    3332{
    34     unsigned int width = dp->cv->width, height = dp->cv->height;
     33    unsigned int width = cucul_get_canvas_width(dp->cv);
     34    unsigned int height = cucul_get_canvas_height(dp->cv);
    3535    char const *geometry;
    3636
  • libcaca/trunk/caca/driver_slang.c

    r2055 r2056  
    3535#endif
    3636
     37#include "cucul.h"
    3738#include "caca.h"
    3839#include "caca_internals.h"
    39 #include "cucul.h"
    40 #include "cucul_internals.h"
    4140
    4241/*
     
    199198{
    200199    /* Fallback to a 6x10 font */
    201     return dp->cv->width * 6;
     200    return cucul_get_canvas_width(dp->cv) * 6;
    202201}
    203202
     
    205204{
    206205    /* Fallback to a 6x10 font */
    207     return dp->cv->height * 10;
     206    return cucul_get_canvas_height(dp->cv) * 10;
    208207}
    209208
    210209static void slang_display(caca_display_t *dp)
    211210{
     211    uint32_t const *cvchars = (uint32_t const *)cucul_get_canvas_chars(dp->cv);
     212    uint32_t const *cvattrs = (uint32_t const *)cucul_get_canvas_attrs(dp->cv);
     213    unsigned int width = cucul_get_canvas_width(dp->cv);
     214    unsigned int height = cucul_get_canvas_height(dp->cv);
    212215    int x, y;
    213     uint32_t *attrs = dp->cv->attrs;
    214     uint32_t *chars = dp->cv->chars;
    215     for(y = 0; y < (int)dp->cv->height; y++)
     216
     217    for(y = 0; y < (int)height; y++)
    216218    {
    217219        SLsmg_gotorc(y, 0);
    218         for(x = dp->cv->width; x--; )
     220        for(x = width; x--; )
    219221        {
    220             uint32_t ch = *chars++;
     222            uint32_t ch = *cvchars++;
    221223
    222224#if defined(OPTIMISE_SLANG_PALETTE)
     
    227229             * bright backgrounds, it's just fucked up. */
    228230#if 0
    229             uint8_t fgcolor = cucul_attr_to_ansi_fg(*attrs);
    230             uint8_t bgcolor = cucul_attr_to_ansi_bg(*attrs);
     231            uint8_t fgcolor = cucul_attr_to_ansi_fg(*cvattrs);
     232            uint8_t bgcolor = cucul_attr_to_ansi_bg(*cvattrs);
    231233
    232234            if(fgcolor >= 0x10)
     
    247249                SLsmg_set_color(slang_assoc[fgcolor + 16 * bgcolor]);
    248250                SLsmg_write_char(' ');
    249                 attrs++;
     251                cvattrs++;
    250252            }
    251253            else
    252254#endif
    253255            {
    254                 SLsmg_set_color(slang_assoc[cucul_attr_to_ansi(*attrs++)]);
     256                SLsmg_set_color(slang_assoc[cucul_attr_to_ansi(*cvattrs++)]);
    255257                slang_write_utf32(ch);
    256258            }
    257259#else
    258             SLsmg_set_color(cucul_attr_to_ansi(*attrs++));
     260            SLsmg_set_color(cucul_attr_to_ansi(*cvattrs++));
    259261            slang_write_utf32(ch);
    260262#endif
     
    271273    dp->resize.h = SLtt_Screen_Rows;
    272274
    273     if(dp->resize.w != dp->cv->width || dp->resize.h != dp->cv->height)
     275    if(dp->resize.w != cucul_get_canvas_width(dp->cv)
     276        || dp->resize.h != cucul_get_canvas_height(dp->cv))
    274277        SLsmg_reinit_smg();
    275278}
  • libcaca/trunk/caca/driver_vga.c

    r2055 r2056  
    2222#if defined(USE_VGA)
    2323
     24#include "cucul.h"
    2425#include "caca.h"
    2526#include "caca_internals.h"
    26 #include "cucul.h"
    27 #include "cucul_internals.h"
    2827
    2928/* Address of the VGA screen */
     
    119118{
    120119    char *screen = (char *)(intptr_t)0x000b8000;
    121     uint32_t *attrs = dp->cv->attrs;
    122     uint32_t *chars = dp->cv->chars;
     120    uint32_t const *cvchars = (uint32_t const *)cucul_get_canvas_chars(dp->cv);
     121    uint32_t const *cvattrs = (uint32_t const *)cucul_get_canvas_attrs(dp->cv);
     122    unsigned int width = cucul_get_canvas_width(dp->cv);
     123    unsigned int height = cucul_get_canvas_height(dp->cv);
    123124    int n;
    124125
    125     for(n = dp->cv->height * dp->cv->width; n--; )
     126    for(n = height * width; n--; )
    126127    {
    127         char ch = cucul_utf32_to_cp437(*chars++);
    128         if(n && *chars == CUCUL_MAGIC_FULLWIDTH)
     128        char ch = cucul_utf32_to_cp437(*cvchars++);
     129        if(n && *cvchars == CUCUL_MAGIC_FULLWIDTH)
    129130        {
    130131            *screen++ = '[';
    131             *screen++ = cucul_attr_to_ansi(*attrs++);
     132            *screen++ = cucul_attr_to_ansi(*cvattrs++);
    132133            ch = ']';
    133             chars++;
     134            cvchars++;
    134135            n--;
    135136        }
    136137        *screen++ = ch;
    137         *screen++ = cucul_attr_to_ansi(*attrs++);
     138        *screen++ = cucul_attr_to_ansi(*cvattrs++);
    138139    }
    139140}
     
    142143{
    143144    /* We know nothing about our window */
    144     dp->resize.w = dp->cv->width;
    145     dp->resize.h = dp->cv->height;
     145    dp->resize.w = cucul_get_canvas_width(dp->cv);
     146    dp->resize.h = cucul_get_canvas_height(dp->cv);
    146147}
    147148
  • libcaca/trunk/caca/driver_win32.c

    r2055 r2056  
    2727#include <stdio.h>
    2828
     29#include "cucul.h"
    2930#include "caca.h"
    3031#include "caca_internals.h"
    31 #include "cucul.h"
    32 #include "cucul_internals.h"
    3332
    3433/*
     
    8584static int win32_init_graphics(caca_display_t *dp)
    8685{
     86    unsigned int width = cucul_get_canvas_width(dp->cv);
     87    unsigned int height = cucul_get_canvas_height(dp->cv);
    8788    CONSOLE_SCREEN_BUFFER_INFO csbi;
    8889    SMALL_RECT rect;
     
    114115
    115116    /* Set the new console size */
    116     size.X = dp->cv->width ? dp->cv->width : 80;
    117     size.Y = dp->cv->height ? dp->cv->height : 25;
     117    size.X = width ? width : 80;
     118    size.Y = height ? height : 25;
    118119    SetConsoleScreenBufferSize(dp->drv.p->screen, size);
    119120
    120121    rect.Left = rect.Top = 0;
    121     rect.Right = dp->cv->width - 1;
    122     rect.Bottom = dp->cv->height - 1;
     122    rect.Right = size.X - 1;
     123    rect.Bottom = size.Y - 1;
    123124    SetConsoleWindowInfo(dp->drv.p->screen, TRUE, &rect);
    124125
     
    131132                          csbi.srWindow.Right - csbi.srWindow.Left + 1,
    132133                          csbi.srWindow.Bottom - csbi.srWindow.Top + 1);
     134    width = cucul_get_canvas_width(dp->cv);
     135    height = cucul_get_canvas_height(dp->cv);
    133136    dp->resize.allow = 0;
    134137
     
    142145    SetConsoleActiveScreenBuffer(dp->drv.p->screen);
    143146
    144     dp->drv.p->buffer = malloc(dp->cv->width * dp->cv->height
     147    dp->drv.p->buffer = malloc(width * height
    145148                               * sizeof(CHAR_INFO));
    146149    if(dp->drv.p->buffer == NULL)
     
    179182
    180183    /* Fallback to a 6x10 font */
    181     return dp->cv->width * 6;
     184    return cucul_get_canvas_width(dp->cv) * 6;
    182185}
    183186
     
    187190
    188191    /* Fallback to a 6x10 font */
    189     return dp->cv->height * 10;
     192    return cucul_get_canvas_height(dp->cv) * 10;
    190193}
    191194
     
    195198    SMALL_RECT rect;
    196199    CHAR_INFO *buffer = dp->drv.p->buffer;
    197     uint32_t *attrs = dp->cv->attrs;
    198     uint32_t *chars = dp->cv->chars;
     200    uint32_t const *cvchars = (uint32_t const *)cucul_get_canvas_chars(dp->cv);
     201    uint32_t const *cvattrs = (uint32_t const *)cucul_get_canvas_attrs(dp->cv);
     202    unsigned int width = cucul_get_canvas_width(dp->cv);
     203    unsigned int height = cucul_get_canvas_height(dp->cv);
    199204    unsigned int n;
    200205
    201206    /* Render everything to our screen buffer */
    202     for(n = dp->cv->height * dp->cv->width; n--; )
     207    for(n = height * width; n--; )
    203208    {
    204         uint32_t ch = *chars++;
    205         uint8_t fg = cucul_attr_to_ansi_fg(*attrs);
    206         uint8_t bg = cucul_attr_to_ansi_bg(*attrs);
     209        uint32_t ch = *cvchars++;
     210        uint8_t fg = cucul_attr_to_ansi_fg(*cvattrs);
     211        uint8_t bg = cucul_attr_to_ansi_bg(*cvattrs);
    207212
    208213#if 0
     
    212217            dp->drv.p->buffer[i].Char.AsciiChar = ' ';
    213218#else
    214         if(n && *chars == CUCUL_MAGIC_FULLWIDTH)
     219        if(n && *cvchars == CUCUL_MAGIC_FULLWIDTH)
    215220            ;
    216221        else if(ch > 0x00000020 && ch < 0x00010000)
     
    222227        buffer->Attributes = win32_fg_palette[fg < 0x10 ? fg : CUCUL_LIGHTGRAY]
    223228                              | win32_bg_palette[bg < 0x10 ? bg : CUCUL_BLACK];
    224         attrs++;
     229        cvattrs++;
    225230        buffer++;
    226231    }
    227232
    228233    /* Blit the screen buffer */
    229     size.X = dp->cv->width;
    230     size.Y = dp->cv->height;
     234    size.X = width;
     235    size.Y = height;
    231236    pos.X = pos.Y = 0;
    232237    rect.Left = rect.Top = 0;
    233     rect.Right = dp->cv->width - 1;
    234     rect.Bottom = dp->cv->height - 1;
     238    rect.Right = width - 1;
     239    rect.Bottom = height - 1;
    235240#if 0
    236241    WriteConsoleOutput(dp->drv.p->screen, dp->drv.p->buffer, size, pos, &rect);
     
    243248{
    244249    /* FIXME: I don't know what to do here. */
    245     dp->resize.w = dp->cv->width;
    246     dp->resize.h = dp->cv->height;
     250    dp->resize.w = cucul_get_canvas_width(dp->cv);
     251    dp->resize.h = cucul_get_canvas_height(dp->cv);
    247252}
    248253
  • libcaca/trunk/caca/driver_x11.c

    r2055 r2056  
    3434#include <string.h>
    3535
     36#include "cucul.h"
     37#include "cucul_internals.h"
    3638#include "caca.h"
    3739#include "caca_internals.h"
    38 #include "cucul.h"
    39 #include "cucul_internals.h"
    4040
    4141/*
     
    7878    char const *fonts[] = { NULL, "8x13bold", "fixed" }, **parser;
    7979    char const *geometry;
    80     unsigned int width = dp->cv->width, height = dp->cv->height;
     80    unsigned int width = cucul_get_canvas_width(dp->cv);
     81    unsigned int height = cucul_get_canvas_height(dp->cv);
    8182    int i;
    8283
     
    9192    dp->resize.allow = 1;
    9293    cucul_set_canvas_size(dp->cv, width ? width : 80, height ? height : 32);
     94    width = cucul_get_canvas_width(dp->cv);
     95    height = cucul_get_canvas_height(dp->cv);
    9396    dp->resize.allow = 0;
    9497
     
    193196    dp->drv.p->window =
    194197        XCreateWindow(dp->drv.p->dpy, DefaultRootWindow(dp->drv.p->dpy), 0, 0,
    195                       dp->cv->width * dp->drv.p->font_width,
    196                       dp->cv->height * dp->drv.p->font_height,
     198                      width * dp->drv.p->font_width,
     199                      height * dp->drv.p->font_height,
    197200                      0, 0, InputOutput, 0,
    198201                      CWBackingStore | CWBackPixel | CWEventMask,
     
    241244
    242245    dp->drv.p->pixmap = XCreatePixmap(dp->drv.p->dpy, dp->drv.p->window,
    243                                    dp->cv->width * dp->drv.p->font_width,
    244                                    dp->cv->height * dp->drv.p->font_height,
    245                                    DefaultDepth(dp->drv.p->dpy,
    246                                             DefaultScreen(dp->drv.p->dpy)));
     246                                      width * dp->drv.p->font_width,
     247                                      height * dp->drv.p->font_height,
     248                                      DefaultDepth(dp->drv.p->dpy,
     249                                      DefaultScreen(dp->drv.p->dpy)));
    247250    dp->drv.p->pointer = None;
    248251
     
    279282static unsigned int x11_get_display_width(caca_display_t const *dp)
    280283{
    281     return dp->cv->width * dp->drv.p->font_width;
     284    return cucul_get_canvas_width(dp->cv) * dp->drv.p->font_width;
    282285}
    283286
    284287static unsigned int x11_get_display_height(caca_display_t const *dp)
    285288{
    286     return dp->cv->height * dp->drv.p->font_height;
     289    return cucul_get_canvas_height(dp->cv) * dp->drv.p->font_height;
    287290}
    288291
    289292static void x11_display(caca_display_t *dp)
    290293{
     294    uint32_t const *cvchars = (uint32_t const *)cucul_get_canvas_chars(dp->cv);
     295    uint32_t const *cvattrs = (uint32_t const *)cucul_get_canvas_attrs(dp->cv);
     296    unsigned int width = cucul_get_canvas_width(dp->cv);
     297    unsigned int height = cucul_get_canvas_height(dp->cv);
    291298    unsigned int x, y, len;
    292299
    293300    /* First draw the background colours. Splitting the process in two
    294301     * loops like this is actually slightly faster. */
    295     for(y = 0; y < dp->cv->height; y++)
    296     {
    297         for(x = 0; x < dp->cv->width; x += len)
    298         {
    299             uint32_t *attrs = dp->cv->attrs + x + y * dp->cv->width;
     302    for(y = 0; y < height; y++)
     303    {
     304        for(x = 0; x < width; x += len)
     305        {
     306            uint32_t const *attrs = cvattrs + x + y * width;
    300307            uint16_t bg = _cucul_attr_to_rgb12bg(*attrs);
    301308
    302309            len = 1;
    303             while(x + len < dp->cv->width
     310            while(x + len < width
    304311                   && _cucul_attr_to_rgb12bg(attrs[len]) == bg)
    305312                len++;
     
    316323
    317324    /* Then print the foreground characters */
    318     for(y = 0; y < dp->cv->height; y++)
     325    for(y = 0; y < height; y++)
    319326    {
    320327        unsigned int yoff = (y + 1) * dp->drv.p->font_height
    321328                                    - dp->drv.p->font_offset;
    322         uint32_t *chars = dp->cv->chars + y * dp->cv->width;
    323         uint32_t *attrs = dp->cv->attrs + y * dp->cv->width;
    324 
    325         for(x = 0; x < dp->cv->width; x++, chars++, attrs++)
     329        uint32_t const *chars = cvchars + y * width;
     330        uint32_t const *attrs = cvattrs + y * width;
     331
     332        for(x = 0; x < width; x++, chars++, attrs++)
    326333        {
    327334            XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
     
    349356    XCopyArea(dp->drv.p->dpy, dp->drv.p->pixmap, dp->drv.p->window,
    350357              dp->drv.p->gc, 0, 0,
    351               dp->cv->width * dp->drv.p->font_width,
    352               dp->cv->height * dp->drv.p->font_height,
     358              width * dp->drv.p->font_width,
     359              height * dp->drv.p->font_height,
    353360              0, 0);
    354361    XFlush(dp->drv.p->dpy);
     
    374381static int x11_get_event(caca_display_t *dp, caca_privevent_t *ev)
    375382{
     383    unsigned int width = cucul_get_canvas_width(dp->cv);
     384    unsigned int height = cucul_get_canvas_height(dp->cv);
    376385    XEvent xevent;
    377386    char key;
     
    387396            XCopyArea(dp->drv.p->dpy, dp->drv.p->pixmap,
    388397                      dp->drv.p->window, dp->drv.p->gc, 0, 0,
    389                       dp->cv->width * dp->drv.p->font_width,
    390                       dp->cv->height * dp->drv.p->font_height, 0, 0);
     398                      width * dp->drv.p->font_width,
     399                      height * dp->drv.p->font_height, 0, 0);
    391400            continue;
    392401        }
     
    402411                  / dp->drv.p->font_height;
    403412
    404             if(!w || !h || (w == dp->cv->width && h == dp->cv->height))
     413            if(!w || !h || (w == width && h == height))
    405414                continue;
    406415
     
    418427            unsigned int newy = xevent.xmotion.y / dp->drv.p->font_height;
    419428
    420             if(newx >= dp->cv->width)
    421                 newx = dp->cv->width - 1;
    422             if(newy >= dp->cv->height)
    423                 newy = dp->cv->height - 1;
     429            if(newx >= width)
     430                newx = width - 1;
     431            if(newy >= height)
     432                newy = height - 1;
    424433
    425434            if(dp->mouse.x == newx && dp->mouse.y == newy)
  • libcaca/trunk/caca/event.c

    r2049 r2056  
    2626
    2727#include "cucul.h"
    28 #include "cucul_internals.h"
    2928#include "caca.h"
    3029#include "caca_internals.h"
     
    132131unsigned int caca_get_mouse_x(caca_display_t const *dp)
    133132{
    134     if(dp->mouse.x >= dp->cv->width)
    135         return dp->cv->width - 1;
     133    unsigned int width = cucul_get_canvas_width(dp->cv);
     134
     135    if(dp->mouse.x >= width)
     136        return width - 1;
    136137
    137138    return dp->mouse.x;
     
    152153unsigned int caca_get_mouse_y(caca_display_t const *dp)
    153154{
    154     if(dp->mouse.y >= dp->cv->height)
    155         return dp->cv->height - 1;
     155    unsigned int height = cucul_get_canvas_height(dp->cv);
     156
     157    if(dp->mouse.y >= height)
     158        return height - 1;
    156159
    157160    return dp->mouse.y;
     
    334337        _caca_handle_resize(dp);
    335338        ev->type = CACA_EVENT_RESIZE;
    336         ev->data.resize.w = dp->cv->width;
    337         ev->data.resize.h = dp->cv->height;
     339        ev->data.resize.w = cucul_get_canvas_width(dp->cv);
     340        ev->data.resize.h = cucul_get_canvas_height(dp->cv);
    338341        return 1;
    339342    }
  • libcaca/trunk/caca/graphics.c

    r2055 r2056  
    2626#endif
    2727
     28#include "cucul.h"
    2829#include "caca.h"
    2930#include "caca_internals.h"
    30 #include "cucul.h"
    31 #include "cucul_internals.h"
    3231
    3332/** \brief Set the display title.
     
    238237
    239238    /* Tell libcucul we changed size */
    240     if(dp->resize.w != dp->cv->width || dp->resize.h != dp->cv->height)
     239    if(dp->resize.w != cucul_get_canvas_width(dp->cv)
     240        || dp->resize.h != cucul_get_canvas_height(dp->cv))
    241241    {
    242242        dp->resize.allow = 1;
Note: See TracChangeset for help on using the changeset viewer.