Changeset 892 for libcaca/trunk/cpp


Ignore:
Timestamp:
Apr 26, 2006, 12:04:02 PM (14 years ago)
Author:
Jean-Yves Lamoureux
Message:
  • Updated C++ bindings, should be coding-style-correction-proof, or at least a bit better than before. Not tested at all.
Location:
libcaca/trunk/cpp
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/cpp/cpptest.cpp

    r827 r892  
    5454    try {
    5555        qq = new Cucul();
    56     } 
     56    }
    5757    catch (int e) {
    5858        cerr << "Error while initializing cucul (" << e << ")" << endl;
    5959        return -1;
    6060    }
    61    
     61
    6262    try {
    6363        kk = new Caca(qq);
     
    7171
    7272    while(!kk->get_event(ev.CACA_EVENT_KEY_PRESS, &ev, 0)) {
    73        
     73
    7474        /* Draw pig */
    75         qq->set_color(CUCUL_COLOR_LIGHTMAGENTA, CUCUL_COLOR_BLACK);
    76        
     75        qq->setColor(CUCUL_COLOR_LIGHTMAGENTA, CUCUL_COLOR_BLACK);
     76
    7777        for(int i = 0; pig[i]; i++)
    78             qq->putstr(x, y+i, (char*)pig[i]);
    79        
     78            qq->putStr(x, y+i, (char*)pig[i]);
     79
    8080        /* printf works */
    81         qq->set_color(CUCUL_COLOR_LIGHTBLUE, CUCUL_COLOR_BLACK); 
    82         qq->printf(30,15, "Powered by libcaca %s", VERSION);
    83        
     81        qq->setColor(CUCUL_COLOR_LIGHTBLUE, CUCUL_COLOR_BLACK);
     82        qq->Printf(30,15, "Powered by libcaca %s", VERSION);
     83
    8484        /* Blit */
    8585        kk->display();
     
    8888        y+=iy;
    8989
    90         if(x>=(qq->get_width()-35)  || x<0 )
     90        if(x>=(qq->getWidth()-35)  || x<0 )
    9191            ix=-ix;
    92         if(y>=(qq->get_height()-15)   || y<0 )
     92        if(y>=(qq->getHeight()-15)   || y<0 )
    9393            iy=-iy;
    9494
  • libcaca/trunk/cpp/cucul++.cpp

    r838 r892  
    2424#include "cucul++.h"
    2525
    26 Cucul::Cucul() 
     26Cucul::Cucul()
    2727{
    2828    cv = cucul_create_canvas(0, 0);
     
    3131}
    3232
    33 Cucul::Cucul(int width, int height) 
     33Cucul::Cucul(int width, int height)
    3434{
    3535    cv = cucul_create_canvas(width, height);
     
    3737}
    3838
    39 Cucul::~Cucul() 
     39Cucul::~Cucul()
    4040{
    4141    if(cv)
     
    4848}
    4949
    50 void Cucul::set_size(unsigned int width, unsigned int height)
     50void Cucul::setSize(unsigned int width, unsigned int height)
    5151{
    5252    cucul_set_canvas_size(cv, width, height);
    5353}
    5454
    55 unsigned int Cucul::get_width(void)
     55unsigned int Cucul::getWidth(void)
    5656{
    5757    return cucul_get_canvas_width(cv);
    5858}
    5959
    60 unsigned int Cucul::get_height(void)
     60unsigned int Cucul::getHeight(void)
    6161{
    6262    return cucul_get_canvas_height(cv);
    6363}
    6464
    65 void Cucul::set_color(unsigned int f, unsigned int b)
     65void Cucul::setColor(unsigned int f, unsigned int b)
    6666{
    6767    cucul_set_color(cv, f, b);
    6868}
    6969
    70 char const * Cucul::get_color_name(unsigned int color)
     70char const * Cucul::getColorName(unsigned int color)
    7171{
    7272    return cucul_get_color_name(color);
    7373}
    7474
    75 void Cucul::putchar(int x, int y, char ch)
     75void Cucul::putChar(int x, int y, char ch)
    7676{
    7777    cucul_putchar(cv, x, y, ch);
    7878}
    7979
    80 void Cucul::putstr(int x, int y, char *str)
     80void Cucul::putStr(int x, int y, char *str)
    8181{
    8282    cucul_putstr(cv, x, y, str);
    8383}
    8484
    85 void Cucul::printf(int x, int y, char const * format,...)
     85void Cucul::Printf(int x, int y, char const * format,...)
    8686{
    8787    char tmp[BUFSIZ];
     
    9191    va_start(args, format);
    9292#if defined(HAVE_VSNPRINTF)
    93     vsnprintf(buf, get_width() - x + 1, format, args);
     93    vsnprintf(buf, getWidth() - x + 1, format, args);
    9494#else
    9595    vsprintf(buf, format, args);
    9696#endif
    97     buf[get_width() - x] = '\0';
     97    buf[getWidth() - x] = '\0';
    9898    va_end(args);
    9999
    100     putstr(x, y, buf);
    101 }
    102 
    103 void Cucul::clear(void)
     100    putStr(x, y, buf);
     101}
     102
     103void Cucul::Clear(void)
    104104{
    105105    cucul_clear_canvas(cv);
    106106}
    107107
    108 void Cucul::blit(int x, int y, Cucul* c1, Cucul* c2)
     108void Cucul::Blit(int x, int y, Cucul* c1, Cucul* c2)
    109109{
    110110    cucul_blit(cv, x, y, c1->get_cucul_canvas_t(), c2->get_cucul_canvas_t());
    111111}
    112112
    113 void Cucul::invert()
     113void Cucul::Invert()
    114114{
    115115    cucul_invert(cv);
    116116}
    117117
    118 void Cucul::flip()
     118void Cucul::Flip()
    119119{
    120120    cucul_flip(cv);
    121121}
    122122
    123 void Cucul::flop()
     123void Cucul::Flop()
    124124{
    125125    cucul_flop(cv);
    126126}
    127127
    128 void Cucul::rotate()
     128void Cucul::Rotate()
    129129{
    130130    cucul_rotate(cv);
    131131}
    132132
    133 void Cucul::draw_line(int x1, int y1, int x2, int y2, char const *ch)
     133void Cucul::drawLine(int x1, int y1, int x2, int y2, char const *ch)
    134134{
    135135    cucul_draw_line(cv, x1, y1, x2, y2, ch);
    136136}
    137  
    138 void Cucul::draw_polyline(int const x[], int const y[], int f, char const *ch)
     137
     138void Cucul::drawPolyline(int const x[], int const y[], int f, char const *ch)
    139139{
    140140    cucul_draw_polyline(cv, x, y, f, ch);
    141141}
    142  
    143 void Cucul::draw_thin_line(int x1, int y1, int x2, int y2)
     142
     143void Cucul::drawThinLine(int x1, int y1, int x2, int y2)
    144144{
    145145    cucul_draw_thin_line(cv, x1, y1, x2, y2);
    146146}
    147147
    148 void Cucul::draw_thin_polyline(int const x[], int const y[], int f)
     148void Cucul::drawThinPolyline(int const x[], int const y[], int f)
    149149{
    150150    cucul_draw_thin_polyline(cv, x, y, f);
    151151}
    152  
    153 void Cucul::draw_circle(int x, int y, int d, char const *ch)
     152
     153void Cucul::drawCircle(int x, int y, int d, char const *ch)
    154154{
    155155    cucul_draw_circle(cv, x, y, d, ch);
    156156}
    157157
    158 void Cucul::draw_ellipse(int x, int y, int d1, int d2, char const *ch)
     158void Cucul::drawEllipse(int x, int y, int d1, int d2, char const *ch)
    159159{
    160160    cucul_draw_ellipse(cv, x, y, d1, d2, ch);
    161161}
    162162
    163 void Cucul::draw_thin_ellipse(int x, int y, int d1, int d2)
     163void Cucul::drawThinEllipse(int x, int y, int d1, int d2)
    164164{
    165165    cucul_draw_thin_ellipse(cv, x, y, d1, d2);
    166166}
    167167
    168 void Cucul::fill_ellipse(int x, int y, int d1, int d2, char const *ch)
     168void Cucul::fillEllipse(int x, int y, int d1, int d2, char const *ch)
    169169{
    170170    cucul_fill_ellipse(cv, x, y, d1, d2, ch);
    171171}
    172172
    173 void Cucul::draw_box(int x, int y, int w, int h, char const *ch)
     173void Cucul::drawBox(int x, int y, int w, int h, char const *ch)
    174174{
    175175    cucul_draw_box(cv, x, y, w, h, ch);
    176176}
    177  
    178 void Cucul::draw_thin_box(int x, int y, int w, int h)
     177
     178void Cucul::drawThinBox(int x, int y, int w, int h)
    179179{
    180180    cucul_draw_thin_box(cv, x, y, w, h);
    181181}
    182182
    183 void Cucul::fill_box(int x, int y, int w, int h, char const *ch)
     183void Cucul::fillBox(int x, int y, int w, int h, char const *ch)
    184184{
    185185    cucul_fill_box(cv, x, y, w, h, ch);
    186186}
    187187
    188 void Cucul::draw_triangle(int x1, int y1, int x2, int y2, int x3, int y3, char const *ch)
     188void Cucul::drawTriangle(int x1, int y1, int x2, int y2, int x3, int y3, char const *ch)
    189189{
    190190    cucul_draw_triangle(cv, x1, y1, x2, y2, x3, y3, ch);
    191191}
    192192
    193 void Cucul::draw_thin_triangle(int x1, int y1, int x2, int y2, int x3, int y3)
     193void Cucul::drawThinTriangle(int x1, int y1, int x2, int y2, int x3, int y3)
    194194{
    195195    cucul_draw_thin_triangle(cv, x1, y1, x2, y2, x3, y3);
    196196}
    197197
    198 void Cucul::fill_triangle(int x1, int y1, int x2, int y2, int x3, int y3, const char *ch)
     198void Cucul::fillTriangle(int x1, int y1, int x2, int y2, int x3, int y3, const char *ch)
    199199{
    200200    cucul_fill_triangle(cv, x1, y1, x2, y2, x3, y3, ch);
    201201}
    202202
    203 int Cucul::rand(int min, int max)
     203int Cucul::Rand(int min, int max)
    204204{
    205205    return cucul_rand(min, max);
    206206}
    207207
    208 Cucul::Dither * Cucul::create_dither(unsigned int v1, unsigned int v2, unsigned int v3, unsigned int v4, unsigned int v5, unsigned int v6, unsigned int v7, unsigned int v8)
    209 {
    210     Cucul::Dither *d = new Dither();
    211     d->dither = cucul_create_dither(v1, v2, v3, v4, v5, v6, v7, v8);
    212     return d;
    213 }
    214 
    215 void Cucul::set_dither_palette(Cucul::Dither *d, unsigned int r[], unsigned int g[], unsigned int b[], unsigned int a[])
    216 {
    217     cucul_set_dither_palette(d->dither, r, g, b, a);
    218 }
    219 
    220 void Cucul::set_dither_brightness(Cucul::Dither *d, float f)
    221 {
    222     cucul_set_dither_brightness(d->dither, f);
    223 }
    224 
    225 void Cucul::set_dither_gamma(Cucul::Dither *d, float f)
    226 {
    227     cucul_set_dither_gamma(d->dither, f);
    228 }
    229 
    230 void Cucul::set_dither_contrast(Cucul::Dither *d, float f)
    231 {
    232     cucul_set_dither_contrast(d->dither, f);
    233 }
    234 
    235 void Cucul::set_dither_invert(Cucul::Dither *d, int i)
    236 {
    237     cucul_set_dither_invert(d->dither, i);
    238 }
    239 
    240 void Cucul::set_dither_antialias(Cucul::Dither *d, char const *cv)
    241 {
    242     cucul_set_dither_antialias(d->dither, cv);
    243 }
    244  
    245 char const *const * Cucul::get_dither_antialias_list(Cucul::Dither const *d)
    246 {
    247     return cucul_get_dither_antialias_list(d->dither);
    248 }
    249 
    250 void Cucul::set_dither_color(Cucul::Dither *d, char const *cv)
    251 {
    252     cucul_set_dither_color(d->dither, cv);
    253 }
    254 
    255 char const *const * Cucul::get_dither_color_list(Cucul::Dither const *d)
    256 {
    257     return cucul_get_dither_color_list(d->dither);
    258 }
    259  
    260 void Cucul::set_dither_charset(Cucul::Dither *d, char const *cv)
    261 {
    262     cucul_set_dither_charset(d->dither, cv);
    263 }
    264 
    265 char const *const * Cucul::get_dither_charset_list(Cucul::Dither const *d)
    266 {
    267     return cucul_get_dither_charset_list(d->dither);
    268 }
    269  
    270 void Cucul::set_dither_mode(Cucul::Dither *d, char const *cv)
    271 {
    272     cucul_set_dither_mode(d->dither, cv);
    273 }
    274 
    275 char const *const * Cucul::get_dither_mode_list(Cucul::Dither const *d)
    276 {
    277     return cucul_get_dither_mode_list(d->dither);
    278 }
    279 
    280 void Cucul::dither_bitmap(int x, int y, int w, int h,  Cucul::Dither const *d, void *v)
    281 {
    282     cucul_dither_bitmap(cv, x, y, w, h, d->dither, v);
    283 }
    284 
    285 void Cucul::free_dither(Cucul::Dither *d)
    286 {
    287     cucul_free_dither(d->dither);
    288 }
    289 
    290 Cucul::Font * Cucul::load_font(void const *s, unsigned int v)
    291 {
    292     Cucul::Font *f = new Cucul::Font();
    293     f->font = cucul_load_font(s, v);
    294     return f;
    295 }
    296 
    297 char const *const * Cucul::get_font_list(void)
     208Dither::Dither(unsigned int v1, unsigned int v2, unsigned int v3, unsigned int v4, unsigned int v5, unsigned int v6, unsigned int v7, unsigned int v8)
     209{
     210    dither = cucul_create_dither(v1, v2, v3, v4, v5, v6, v7, v8);
     211}
     212Dither::~Dither()
     213{
     214    cucul_free_dither(dither);
     215}
     216
     217void Dither::setPalette(unsigned int r[], unsigned int g[], unsigned int b[], unsigned int a[])
     218{
     219    cucul_set_dither_palette(dither, r, g, b, a);
     220}
     221
     222void Dither::setBrightness(float f)
     223{
     224    cucul_set_dither_brightness(dither, f);
     225}
     226
     227void Dither::setGamma(float f)
     228{
     229    cucul_set_dither_gamma(dither, f);
     230}
     231
     232void Dither::setContrast(float f)
     233{
     234    cucul_set_dither_contrast(dither, f);
     235}
     236
     237void Dither::setInvert(int i)
     238{
     239    cucul_set_dither_invert(dither, i);
     240}
     241
     242void Dither::setAntialias(char const *cv)
     243{
     244    cucul_set_dither_antialias(dither, cv);
     245}
     246
     247char const *const * Dither::getAntialiasList()
     248{
     249    return cucul_get_dither_antialias_list(dither);
     250}
     251
     252void Dither::setColor(char const *cv)
     253{
     254    cucul_set_dither_color(dither, cv);
     255}
     256
     257char const *const * Dither::getColorList()
     258{
     259    return cucul_get_dither_color_list(dither);
     260}
     261
     262void Dither::setCharset(char const *cv)
     263{
     264    cucul_set_dither_charset(dither, cv);
     265}
     266
     267char const *const * Dither::getCharsetList()
     268{
     269    return cucul_get_dither_charset_list(dither);
     270}
     271
     272void Dither::setMode(char const *cv)
     273{
     274    cucul_set_dither_mode(dither, cv);
     275}
     276
     277char const *const * Dither::getModeList(void)
     278{
     279    return cucul_get_dither_mode_list(dither);
     280}
     281
     282void Dither::Bitmap(Cucul *cv, int x, int y, int w, int h, void *v)
     283{
     284    cucul_dither_bitmap(cv->get_cucul_canvas_t(), x, y, w, h, dither, v);
     285}
     286
     287Font::Font(void const *s, unsigned int v)
     288{
     289    font = cucul_load_font(s, v);
     290}
     291
     292char const *const * Font::getList(void)
    298293{
    299294    return cucul_get_font_list();
    300295}
    301296
    302 unsigned int Cucul::get_font_width(Cucul::Font *f)
    303 {
    304     return cucul_get_font_width(f->font);
    305 }
    306 
    307 unsigned int Cucul::get_font_height(Cucul::Font *f)
    308 {
    309     return cucul_get_font_height(f->font);
    310 }
    311 
    312 void Cucul::render_canvas(Cucul::Font *f, unsigned char *buf, unsigned int x, unsigned int y, unsigned int w)
    313 {
    314     cucul_render_canvas(cv, f->font, buf, x, y, w);
    315 }
    316 
    317 void Cucul::free_font(Cucul::Font *f)
    318 {
    319     cucul_free_font(f->font);
    320 }
    321 
    322 Cucul::Buffer * Cucul::export_canvas(char const *buf)
    323 {
    324     Cucul::Buffer *b = new Cucul::Buffer();
    325     b->buffer = cucul_export_canvas(cv, buf);
    326     return b;
    327 }
    328 
    329 char const *const * Cucul::get_export_list(void)
     297unsigned int Font::getWidth()
     298{
     299    return cucul_get_font_width(font);
     300}
     301
     302unsigned int Font::getHeight()
     303{
     304    return cucul_get_font_height(font);
     305}
     306
     307void Font::renderCanvas(Cucul *cv, unsigned char *buf, unsigned int x, unsigned int y, unsigned int w)
     308{
     309    cucul_render_canvas(cv->get_cucul_canvas_t(), font, buf, x, y, w);
     310}
     311
     312Font::~Font()
     313{
     314    cucul_free_font(font);
     315}
     316
     317Buffer::Buffer(Cucul *cv, char const *buf)
     318{
     319    buffer = cucul_export_canvas(cv->get_cucul_canvas_t(), buf);
     320}
     321
     322char const *const * Buffer::getExportList(void)
    330323{
    331324    return cucul_get_export_list();
  • libcaca/trunk/cpp/cucul++.h

    r838 r892  
    2626#include <cucul.h>
    2727
     28
     29class Cucul;
     30
     31/* Ugly, I know */
     32class Font
     33{
     34 public:
     35    ~Font();
     36    Font(void const *, unsigned int);
     37    char const *const * getList(void);
     38    unsigned int getWidth();
     39    unsigned int getHeight();
     40    void renderCanvas(Cucul *, unsigned char *, unsigned int, unsigned int, unsigned int);
     41
     42 private:
     43    cucul_font *font;
     44
     45};
     46
     47class Dither
     48{
     49 public:
     50    Dither(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int);
     51    ~Dither();
     52
     53    void setPalette(unsigned int r[], unsigned int g[], unsigned int b[], unsigned int a[]);
     54    void setBrightness(float);
     55    void setGamma(float);
     56    void setContrast(float);
     57    void setInvert(int);
     58    void setAntialias(char const *);
     59    char const *const * getAntialiasList();
     60    void setColor(char const *);
     61    char const *const * getColorList();
     62    void setCharset(char const *);
     63    char const *const * getCharsetList();
     64    void setMode(char const *);
     65    char const *const * getModeList();
     66    void Bitmap(Cucul *, int, int, int, int, void *);
     67
     68 private:
     69    cucul_dither *dither;
     70
     71};
     72
     73class Buffer
     74{
     75 public:
     76    Buffer(Cucul *cv, char const *);
     77    ~Buffer();
     78    char const *const * getExportList(void);
     79
     80 private:
     81    cucul_buffer *buffer;
     82};
     83
     84
    2885class Cucul
    2986{
    3087    friend class Caca;
     88    friend class Dither;
     89    friend class Font;
     90    friend class Buffer;
    3191  public:
    3292    Cucul();
     
    3494    ~Cucul();
    3595
    36     /* Ugly, I know */
    37     class Font
    38     {
    39         friend class Cucul;
    40       protected:
    41         cucul_font *font;
    42     };
    43 
    44     class Dither
    45     {
    46         friend class Cucul;
    47       protected:
    48         cucul_dither *dither;
    49     };
    50 
    51     class Buffer
    52     {
    53         friend class Cucul;
    54       protected:
    55         cucul_buffer *buffer;
    56     };
    57 
    58     void set_size(unsigned int w, unsigned int h);
    59     unsigned int get_width(void);
    60     unsigned int get_height(void);
    61     void set_color(unsigned int f, unsigned int b);
    62     char const * get_color_name(unsigned int color);
    63     void printf(int x , int y , char const * format,...);
    64     void putchar(int x, int y, char ch);
    65     void putstr(int x, int y, char *str);
    66     void clear(void);
    67     void blit(int, int, Cucul* c1, Cucul* c2);
    68     void invert();
    69     void flip();
    70     void flop();
    71     void rotate();
    72     void draw_line(int, int, int, int, char const *);
    73     void draw_polyline(int const x[], int const y[], int, char const *);
    74     void draw_thin_line(int, int, int, int);
    75     void draw_thin_polyline(int const x[], int const y[], int);
    76     void draw_circle(int, int, int, char const *);
    77     void draw_ellipse(int, int, int, int, char const *);
    78     void draw_thin_ellipse(int, int, int, int);
    79     void fill_ellipse(int, int, int, int, char const *);
    80     void draw_box(int, int, int, int, char const *);
    81     void draw_thin_box(int, int, int, int);
    82     void fill_box(int, int, int, int, char const *);
    83     void draw_triangle(int, int, int, int, int, int, char const *);
    84     void draw_thin_triangle(int, int, int, int, int, int);
    85     void fill_triangle(int, int, int, int, int, int, char const *);
    86     int rand(int, int);
    87     Dither * create_dither(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int);
    88     void set_dither_palette(Cucul::Dither *, unsigned int r[], unsigned int g[], unsigned int b[], unsigned int a[]);
    89     void set_dither_brightness(Cucul::Dither *, float);
    90     void set_dither_gamma(Cucul::Dither *, float);
    91     void set_dither_contrast(Cucul::Dither *, float);
    92     void set_dither_invert(Cucul::Dither *, int);
    93     void set_dither_antialias(Cucul::Dither *, char const *);
    94     char const *const * get_dither_antialias_list(Cucul::Dither const *);
    95     void set_dither_color(Cucul::Dither *, char const *);
    96     char const *const * get_dither_color_list(Cucul::Dither const *);
    97     void set_dither_charset(Cucul::Dither *, char const *);
    98     char const *const * get_dither_charset_list(Cucul::Dither const *);
    99     void set_dither_mode(Cucul::Dither *, char const *);
    100     char const *const * get_dither_mode_list(Cucul::Dither const *);
    101     void dither_bitmap(int, int, int, int, Cucul::Dither const *, void *);
    102     void free_dither(Cucul::Dither *);
    103     Font * load_font(void const *, unsigned int);
    104     char const *const * get_font_list(void);
    105     unsigned int get_font_width(Font *);
    106     unsigned int get_font_height(Font *);
    107     void render_canvas(Font *, unsigned char *, unsigned int, unsigned int, unsigned int);
    108     void free_font(Font *);
    109     Buffer * export_canvas(char const *);
    110     char const *const * get_export_list(void);
     96    void setSize(unsigned int w, unsigned int h);
     97    unsigned int getWidth(void);
     98    unsigned int getHeight(void);
     99    void setColor(unsigned int f, unsigned int b);
     100    char const * getColorName(unsigned int color);
     101    void Printf(int x , int y , char const * format,...);
     102    void putChar(int x, int y, char ch);
     103    void putStr(int x, int y, char *str);
     104    void Clear(void);
     105    void Blit(int, int, Cucul* c1, Cucul* c2);
     106    void Invert();
     107    void Flip();
     108    void Flop();
     109    void Rotate();
     110    void drawLine(int, int, int, int, char const *);
     111    void drawPolyline(int const x[], int const y[], int, char const *);
     112    void drawThinLine(int, int, int, int);
     113    void drawThinPolyline(int const x[], int const y[], int);
     114    void drawCircle(int, int, int, char const *);
     115    void drawEllipse(int, int, int, int, char const *);
     116    void drawThinEllipse(int, int, int, int);
     117    void fillEllipse(int, int, int, int, char const *);
     118    void drawBox(int, int, int, int, char const *);
     119    void drawThinBox(int, int, int, int);
     120    void fillBox(int, int, int, int, char const *);
     121    void drawTriangle(int, int, int, int, int, int, char const *);
     122    void drawThinTriangle(int, int, int, int, int, int);
     123    void fillTriangle(int, int, int, int, int, int, char const *);
     124    int Rand(int, int);
    111125
    112126  protected:
Note: See TracChangeset for help on using the changeset viewer.