Ignore:
Timestamp:
Apr 20, 2011, 12:39:27 AM (12 years ago)
Author:
Sam Hocevar
Message:

imlib: use vec2i for image::size and unroll all necessary changes
everywhere else in the code.

Location:
abuse/trunk/src/imlib
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/src/imlib/Makefile.am

    r510 r512  
    3030    $(NULL)
    3131
    32 INCLUDES = -I$(srcdir) $(SDL_CFLAGS)
     32INCLUDES = -I$(srcdir) -I$(srcdir)/.. $(SDL_CFLAGS)
    3333
    3434CPPFLAGS = @CPPFLAGS@ -DNO_CHECK
  • abuse/trunk/src/imlib/filesel.cpp

    r494 r512  
    1010
    1111#include "config.h"
     12
     13#include "common.h"
    1214
    1315#include "filesel.h"
  • abuse/trunk/src/imlib/filter.cpp

    r494 r512  
    1111#include "config.h"
    1212
     13#include "common.h"
     14
    1315#include "image.h"
    1416#include "macs.h"
     
    8486  CONDITION(im,"null image passed in filter::apply\n");
    8587  im->lock();
    86   for (y=im->height()-1; y>=0; y--)
     88  for (y=im->Size().y-1; y>=0; y--)
    8789  {
    8890    c=im->scan_line(y);
    89     for (x=im->width()-1; x>=0; x--)
     91    for (x=im->Size().x-1; x>=0; x--)
    9092    {
    9193      CONDITION((unsigned) c[x]<nc,"not enough filter colors");
     
    179181{
    180182    short cx1, cy1, cx2, cy2, x1 = 0, y1 = 0,
    181           x2 = im->width() - 1, y2 = im->height() - 1;
     183          x2 = im->Size().x - 1, y2 = im->Size().y - 1;
    182184    screen->get_clip(cx1,cy1,cx2,cy2);
    183185
  • abuse/trunk/src/imlib/fonts.cpp

    r494 r512  
    1313#include <ctype.h>
    1414
     15#include "common.h"
     16
    1517#include "fonts.h"
    1618
     
    1820{ fntpat=font_pattern;
    1921  let=letters;
    20   tl=(let->width()+1)/32;
    21   th=(let->height()+1)/8;
     22  tl=(let->Size().x+1)/32;
     23  th=(let->Size().y+1)/8;
    2224}
    2325
     
    6062JCFont::JCFont(image *letters)
    6163{
    62   tl=(letters->width()+1)/32;
    63   th=(letters->height()+1)/8;
     64  tl=(letters->Size().x+1)/32;
     65  th=(letters->Size().y+1)/8;
    6466
    6567  image tmp(tl,th);
  • abuse/trunk/src/imlib/guistat.cpp

    r494 r512  
    1212
    1313#include <string.h>
     14
     15#include "common.h"
    1416
    1517#include "input.h"
  • abuse/trunk/src/imlib/image.cpp

    r494 r512  
    1818#endif
    1919#include <stdlib.h>
     20
     21#include "common.h"
    2022
    2123#include "image.h"
     
    9193{
    9294  delete_page();
    93   w=new_width;
    94   h=new_height;
     95  size = vec2i(new_width, new_height);
    9596  make_page(new_width, new_height, page);
    9697}
     
    120121uint8_t image::pixel(int16_t x, int16_t y)
    121122{
    122   CONDITION(x>=0 && x<width() && y>=0 && y<height(),
     123  CONDITION(x>=0 && x<size.x && y>=0 && y<size.y,
    123124     "image::pixel Bad pixel xy");
    124125  return (*(scan_line(y)+x));
     
    127128void image::putpixel(int16_t x, int16_t y, char color)
    128129{
    129   CONDITION(x>=0 && x<width() && y>=0 && y<height(),
     130  CONDITION(x>=0 && x<size.x && y>=0 && y<size.y,
    130131     "image::putpixel Bad pixel xy");
    131132  if (special)
     
    139140image::image(int16_t width, int16_t height, uint8_t *page_buffer, int16_t create_descriptor)
    140141{
    141   w=width;
    142   h=height;
     142  size = vec2i(width, height);
    143143  if (create_descriptor || page_buffer)
    144144  {
     
    154154image::image(spec_entry *e, bFILE *fp)
    155155{
    156   int16_t i;
    157   fp->seek(e->offset, 0);
    158   w=fp->read_uint16();
    159   h=fp->read_uint16();
    160   special=NULL;
    161   make_page(w, h, NULL);
    162   for (i=0; i<h; i++)
    163     fp->read(scan_line(i), w);
    164   image_list.add_end((linked_node *) this);
     156    int16_t i;
     157    fp->seek(e->offset, 0);
     158    size.x = fp->read_uint16();
     159    size.y = fp->read_uint16();
     160    special = NULL;
     161    make_page(size.x, size.y, NULL);
     162    for (i = 0; i < size.y; i++)
     163        fp->read(scan_line(i), size.x);
     164    image_list.add_end((linked_node *) this);
    165165    _locked = false;
    166166}
     
    168168image::image(bFILE *fp)
    169169{
    170   int16_t i;
    171   w=fp->read_uint16();
    172   h=fp->read_uint16();
    173   special=NULL;
    174   make_page(w, h, NULL);
    175   for (i=0; i<h; i++)
    176     fp->read(scan_line(i), w);
    177   image_list.add_end((linked_node *) this);
     170    int16_t i;
     171    size.x = fp->read_uint16();
     172    size.y = fp->read_uint16();
     173    special = NULL;
     174    make_page(size.x, size.y, NULL);
     175    for (i = 0; i < size.y; i++)
     176        fp->read(scan_line(i), size.x);
     177    image_list.add_end((linked_node *) this);
    178178    _locked = false;
    179179}
     
    237237
    238238    lock();
    239     for(co = 0, i = height() - 1; i >= 0; i--)
     239    for(co = 0, i = size.y - 1; i >= 0; i--)
    240240    {
    241241        c = scan_line(i);
    242         for(j = width() - 1; j >= 0; j--, c++)
     242        for(j = size.x - 1; j >= 0; j--, c++)
    243243            if(*c != background) co++;
    244244    }
     
    262262    }
    263263    else
    264         for(i = height() - 1; i >= 0; i--)
    265             memset(scan_line(i), color, width());
    266     add_dirty(0, 0, width() - 1, height() - 1);
     264        for(i = size.y - 1; i >= 0; i--)
     265            memset(scan_line(i), color, size.x);
     266    add_dirty(0, 0, size.x - 1, size.y - 1);
    267267    unlock();
    268268}
     
    275275
    276276    lock();
    277     dat = (uint8_t *)malloc(width());
    278     im = new image(width(), height());
     277    dat = (uint8_t *)malloc(size.x);
     278    im = new image(size.x, size.y);
    279279    im->lock();
    280     for(i = height() - 1; i >= 0; i--)
     280    for(i = size.y - 1; i >= 0; i--)
    281281    {
    282282        c = scan_line(i);
    283         memcpy(dat, c, width());
     283        memcpy(dat, c, size.x);
    284284        c = im->scan_line(i);
    285         memcpy(c, dat, width());
     285        memcpy(c, dat, size.x);
    286286    }
    287287    im->unlock();
     
    443443    if(screen->special)
    444444    {
    445         put_part(screen, x, y, 0, 0, width()-1, height()-1, transparent);
     445        put_part(screen, x, y, 0, 0, size.x-1, size.y-1, transparent);
    446446        return;
    447447    }
    448448
    449     if(x < screen->width() && y < screen->height())
    450     {
    451         xl = width();
    452         if(x + xl > screen->width()) // clip to the border of the screen
    453             xl = screen->width() - x;
    454         yl = height();
    455         if(y + yl > screen->height())
    456             yl = screen->height() - y;
     449    if(x < screen->Size().x && y < screen->Size().y)
     450    {
     451        xl = size.x;
     452        if(x + xl > screen->Size().x) // clip to the border of the screen
     453            xl = screen->Size().x - x;
     454        yl = size.y;
     455        if(y + yl > screen->Size().y)
     456            yl = screen->Size().y - y;
    457457
    458458        int startx = 0, starty = 0;
     
    511511  { if (x1<0) x1=0;
    512512    if (y2<0) y1=0;
    513     if (x2>=screen->width())  x2=screen->width()-1;
    514     if (y2>=screen->height()) y2=screen->height()-1;
    515   }
    516   if (x2<0 || y2<0 || x1>=screen->width() || y1>=screen->height())
     513    if (x2>=screen->Size().x)  x2=screen->Size().x-1;
     514    if (y2>=screen->Size().y) y2=screen->Size().y-1;
     515  }
     516  if (x2<0 || y2<0 || x1>=screen->Size().x || y1>=screen->Size().y)
    517517    return ;
    518518  screen->add_dirty(x1, y1, x2, y2);
    519   w=width();
     519  w=size.x;
    520520  if (align)
    521521  {
    522522    start=x1%w;
    523     starty=y1%height();
     523    starty=y1%size.y;
    524524  }
    525525  else
     
    533533    pg1=screen->scan_line(j);
    534534    pg2=scan_line(starty++);
    535     if (starty>=height()) starty=0;
     535    if (starty>=size.y) starty=0;
    536536    i=x1;
    537537    xx=start;
     
    565565  if (x1<0) { x+=-x1; x1=0; }
    566566  if (y1<0) { y+=-y1; y1=0; }
    567   if (x2>=width()) x2=width()-1;
    568   if (y2>=height()) y2=height()-1;
     567  if (x2>=size.x) x2=size.x-1;
     568  if (y2>=size.y) y2=size.y-1;
    569569  if (x1>x2 || y1>y2) return ;      // return if it was adjusted so that nothing will be put
    570570
     
    628628  CHECK(x1<=x2 && y1<=y2);
    629629
    630   i=x1; x1=width()-x2-1;  // reverse the x locations
    631   x2=width()-i-1;
     630  i=x1; x1=size.x-x2-1;  // reverse the x locations
     631  x2=size.x-i-1;
    632632
    633633  if (x1<0)
     
    649649    { y2=cy2-y+y1; }
    650650  }
    651   else  if (x>screen->width() || y>screen->height() || x+x2<0 || y+y2<0)
     651  else  if (x>screen->Size().x || y>screen->Size().y || x+x2<0 || y+y2<0)
    652652    return ;
    653653
    654   if (x<screen->width() && y<screen->height() && x1<width() && y1<height() &&
     654  if (x<screen->Size().x && y<screen->Size().y && x1<size.x && y1<size.y &&
    655655      x1<=x2 && y1<=y2)
    656656  {
    657     if (x2>=width())
    658       x2=width()-1;
    659     if (y2>=height())
    660       y2=height()-1;
     657    if (x2>=size.x)
     658      x2=size.x-1;
     659    if (y2>=size.y)
     660      y2=size.y-1;
    661661    xl=x2-x1+1;
    662     if (x+xl>screen->width())
    663       xl=screen->width()-x;
     662    if (x+xl>screen->Size().x)
     663      xl=screen->Size().x-x;
    664664    yl=y2-y1+1;
    665     if (y+yl>screen->height())
    666       yl=screen->height()-y;
     665    if (y+yl>screen->Size().y)
     666      yl=screen->Size().y-y;
    667667    screen->add_dirty(x, y, x+xl-1, y+yl-1);
    668668    screen->lock();
     
    709709    { y2=cy2+y1-y; }
    710710  }
    711   else  if (x>screen->width() || y>screen->height() || x+x1<0 || y+y1<0)
     711  else  if (x>screen->Size().x || y>screen->Size().y || x+x1<0 || y+y1<0)
    712712    return ;
    713713
    714   ml=mask->width();
    715   mh=mask->height();
    716   if (x<screen->width() && y<screen->height() && x1<width() && y1<height() &&
     714  ml=mask->Size().x;
     715  mh=mask->Size().y;
     716  if (x<screen->Size().x && y<screen->Size().y && x1<size.x && y1<size.y &&
    717717      maskx<ml && masky<mh && x1<=x2 && y1<=y2)
    718718  {
    719719
    720     if (x2>=width())
    721       x2=width()-1;
    722     if (y2>=height())
    723       y2=height()-1;
     720    if (x2>=size.x)
     721      x2=size.x-1;
     722    if (y2>=size.y)
     723      y2=size.y-1;
    724724    xl=x2-x1+1;
    725     if (x+xl>screen->width())
    726       xl=screen->width()-x-1;
     725    if (x+xl>screen->Size().x)
     726      xl=screen->Size().x-x-1;
    727727    yl=y2-y1+1;
    728     if (y+yl>screen->height())
    729       yl=screen->height()-y-1;
     728    if (y+yl>screen->Size().y)
     729      yl=screen->Size().y-y-1;
    730730    screen->add_dirty(x, y, x+xl-1, y+yl-1);
    731731    screen->lock();
     
    761761  brv=0; bri=0;
    762762  lock();
    763   for (j=0; j<h; j++)
     763  for (j=0; j<size.y; j++)
    764764  {
    765765    p=scan_line(j);
    766     for (i=0; i<w; i++)
     766    for (i=0; i<size.x; i++)
    767767    { pal->get(p[i], r, g, b);
    768768      if ((int32_t)r*(int32_t)g*(int32_t)b>brv)
     
    782782  brv=(int32_t)258*(int32_t)258*(int32_t)258; bri=0;
    783783  lock();
    784   for (j=0; j<h; j++)
     784  for (j=0; j<size.y; j++)
    785785  {
    786786    p=scan_line(j);
    787     for (i=0; i<w; i++)
     787    for (i=0; i<size.x; i++)
    788788    { pal->get(p[i], r, g, b);
    789789      x=(int32_t)r*(int32_t)g*(int32_t)b;
     
    811811    // with no dirty rectangle keeping.
    812812    if(!special)
    813         special = new image_descriptor(width(), height(), 0);
     813        special = new image_descriptor(size.x, size.y, 0);
    814814
    815815    // set the image descriptor what the clip
     
    823823    special->get_clip(x1, y1, x2, y2);
    824824  else
    825   { x1=0; y1=0; x2=width()-1; y2=height()-1; }
     825  { x1=0; y1=0; x2=size.x-1; y2=size.y-1; }
    826826}
    827827
     
    10561056  { if (x1<0) x1=0;
    10571057    if (y1<0) y1=0;
    1058     if (x2>=width())  x2=width()-1;
    1059     if (y2>=height()) y2=height()-1;
    1060   }
    1061   if (x2<0 || y2<0 || x1>=width() || y1>=height() || x2<x1 || y2<y1)
     1058    if (x2>=size.x)  x2=size.x-1;
     1059    if (y2>=size.y) y2=size.y-1;
     1060  }
     1061  if (x2<0 || y2<0 || x1>=size.x || y1>=size.y || x2<x1 || y2<y1)
    10621062    return ;
    10631063  lock();
     
    10811081  { if (x1<0) x1=0;
    10821082    if (y1<0) y1=0;
    1083     if (x2>=width())  x2=width()-1;
    1084     if (y2>=height()) y2=height()-1;
    1085   }
    1086   if (x2<0 || y2<0 || x1>=width() || y1>=height() || x2<x1 || y2<y1)
     1083    if (x2>=size.x)  x2=size.x-1;
     1084    if (y2>=size.y) y2=size.y-1;
     1085  }
     1086  if (x2<0 || y2<0 || x1>=size.x || y1>=size.y || x2<x1 || y2<y1)
    10871087    return ;
    10881088
     
    10941094    for (x=x1; x<=x2; x++, s++)
    10951095      *s=(*s)^color;
    1096     sl+=w;
     1096    sl+=size.x;
    10971097  }
    10981098  unlock();
     
    11061106  int16_t x;
    11071107  uint8_t *sl, *ex, mask, bt, sh;
    1108   ex=(uint8_t *)malloc(width());
     1108  ex=(uint8_t *)malloc(size.x);
    11091109
    11101110  lock();
    11111111  sl=scan_line(line);
    1112   memcpy(ex, sl, width());
     1112  memcpy(ex, sl, size.x);
    11131113  unlock();
    11141114
     
    11171117  else                 {  mask=128+64+32+16; bt=2; }
    11181118
    1119   for (x=0; x<width(); x++)
     1119  for (x=0; x<size.x; x++)
    11201120  { sh=((x%bt)<<(bitsperpixel-1));
    11211121    sl[x]=(ex[x/bt]&(mask>>sh))>>(bt-sh-1);
     
    11351135  uint8_t *sl;
    11361136  lock();
    1137   for (y=height()-1; y>=0; y--)
     1137  for (y=size.y-1; y>=0; y--)
    11381138  {
    11391139    sl=scan_line(y);
    1140     for (i=0, j=y%4, x=width()-1; x>=0; x--)
     1140    for (i=0, j=y%4, x=size.x-1; x>=0; x--)
    11411141    {
    11421142      if (pal->red(sl[x])>dt_matrix[j*4+i])
     
    11621162void image::resize(int16_t new_width, int16_t new_height)
    11631163{
    1164   int old_width=width(), old_height=height();
    1165   uint8_t *im=(uint8_t *)malloc(width()*height());
     1164  int old_width=size.x, old_height=size.y;
     1165  uint8_t *im=(uint8_t *)malloc(size.x*size.y);
    11661166  lock();
    1167   memcpy(im, scan_line(0), width()*height());
     1167  memcpy(im, scan_line(0), size.x*size.y);
    11681168
    11691169  delete_page();
    11701170  make_page(new_width, new_height, NULL);
    1171   w=new_width;      // set the new hieght and width
    1172   h=new_height;
     1171  size = vec2i(new_width, new_height); // set the new height and width
    11731172
    11741173  uint8_t *sl1, *sl2;
     
    11961195{
    11971196  int16_t cx1, cy1, cx2, cy2;
    1198   CHECK(x1>=0 && y1>=0 && x1<x2 && y1<y2 && x2<width() && y2<height());
     1197  CHECK(x1>=0 && y1>=0 && x1<x2 && y1<y2 && x2<size.x && y2<size.y);
    11991198  if (special)
    12001199  {
     
    12281227  d=smoothness*2+1;
    12291228  d=d*d;
    1230   im=new image(width(), height());
    1231   for (i=0; i<width(); i++)
    1232     for (j=0; j<height(); j++)
     1229  im=new image(size.x, size.y);
     1230  for (i=0; i<size.x; i++)
     1231    for (j=0; j<size.y; j++)
    12331232    {
    12341233      for (t=0, k=-smoothness; k<=smoothness; k++)
    12351234    for (l=-smoothness; l<=smoothness; l++)
    1236       if (i+k>smoothness && i+k<width()-smoothness && j+l<height()-smoothness && j+l>smoothness)
     1235      if (i+k>smoothness && i+k<size.x-smoothness && j+l<size.y-smoothness && j+l>smoothness)
    12371236        t+=pixel(i+k, j+l);
    12381237      else t+=pixel(i, j);
     
    12911290        }
    12921291      }
    1293       if (y<height()-1)
     1292      if (y<size.y-1)
    12941293      {
    12951294        above=scan_line(y+1);
     
    13121311          }
    13131312        }
    1314         if (y<height()-1)
     1313        if (y<size.y-1)
    13151314        { below=scan_line(y+1);
    13161315          if (x>0 && below[x-1]!=fcolor && below[x]==fcolor)
     
    13201319        }
    13211320        x++;
    1322       } while (sl[x]==fcolor && x<width());
     1321      } while (sl[x]==fcolor && x<size.x);
    13231322      x--;
    13241323      if (y>0)
     
    13301329        }
    13311330      }
    1332       if (y<height()-1)
     1331      if (y<size.y-1)
    13331332      {
    13341333        above=scan_line(y+1);
     
    14251424void image::flip_x()
    14261425{
    1427   uint8_t *rev=(uint8_t *)malloc(width()), *sl;
     1426  uint8_t *rev=(uint8_t *)malloc(size.x), *sl;
    14281427  CONDITION(rev, "memory allocation");
    14291428  int y, x, i;
     
    14311430  /* FIXME: Abuse Win32 uses RestoreSurface() here instead of locking */
    14321431  lock();
    1433   for (y=0; y<height(); y++)
     1432  for (y=0; y<size.y; y++)
    14341433  { sl=scan_line(y);
    1435     for (i=0, x=width()-1; x>=0; x--, i++)
     1434    for (i=0, x=size.x-1; x>=0; x--, i++)
    14361435      rev[i]=sl[x];
    1437     memcpy(sl, rev, width());
     1436    memcpy(sl, rev, size.x);
    14381437  }
    14391438  unlock();
     
    14431442void image::flip_y()
    14441443{
    1445   uint8_t *rev=(uint8_t *)malloc(width()), *sl;
     1444  uint8_t *rev=(uint8_t *)malloc(size.x), *sl;
    14461445  CONDITION(rev, "memory allocation");
    14471446  int y;
     
    14491448  /* FIXME: Abuse Win32 uses RestoreSurface() here instead of locking */
    14501449  lock();
    1451   for (y=0; y<height()/2; y++)
     1450  for (y=0; y<size.y/2; y++)
    14521451  { sl=scan_line(y);
    1453     memcpy(rev, sl, width());
    1454     memcpy(sl, scan_line(height()-y-1), width());
    1455     memcpy(scan_line(height()-y-1), rev, width());
     1452    memcpy(rev, sl, size.x);
     1453    memcpy(sl, scan_line(size.y-y-1), size.x);
     1454    memcpy(scan_line(size.y-y-1), rev, size.x);
    14561455  }
    14571456  unlock();
     
    14641463  int y, x;
    14651464  lock();
    1466   for (y=0; y<height(); y++)
     1465  for (y=0; y<size.y; y++)
    14671466  {
    14681467    sl=scan_line(y);
    1469     for (x=width(); x; x--, sl++)
     1468    for (x=size.x; x; x--, sl++)
    14701469      if (*sl)
    14711470        *sl=color;
  • abuse/trunk/src/imlib/image.h

    r494 r512  
    119119private:
    120120    uint8_t *data;
    121     int16_t w, h;
     121    vec2i size;
    122122    void make_page(int16_t width, int16_t height, uint8_t *page_buffer);
    123123    void delete_page();
     
    140140    uint8_t *scan_line(int16_t y)
    141141    {
    142         return data + y * w;
     142        return data + y * size.x;
    143143    }
    144144    uint8_t *next_line(int16_t lasty, uint8_t *last_scan)
    145145    {
    146         return last_scan + w;
     146        return last_scan + size.x;
    147147    }
    148148    int32_t total_pixels(uint8_t background=0);
     
    150150    void clear(int16_t color = -1); // -1 is background color
    151151    void to_24bit(palette &pal);
    152     int16_t width()
    153     {
    154         return (int16_t)w;
    155     }
    156     int16_t height()
    157     {
    158         return (int16_t)h;
    159     }
    160     int16_t pitch()
    161     {
    162         return (int16_t)w; // FIXME: for now, pitch == width
    163     }
     152
     153    vec2i Size() const { return size; }
     154    int Pitch() const { return size.x; } // FIXME: for now, pitch == width
     155
    164156    void scroll(int16_t x1, int16_t y1, int16_t x2, int16_t y2,
    165157                int16_t xd, int16_t yd);
  • abuse/trunk/src/imlib/include.cpp

    r494 r512  
    1010
    1111#include "config.h"
     12
     13#include "common.h"
    1214
    1315#include "include.h"
     
    5355      }
    5456    }
    55     fprintf(fp,"unsigned char %s[%d*%d]={\n    ",tmp_name,
    56             im->width(),im->height());
    57     int x,y,max=im->width()*im->height()-1;
    58     for (y=0,i=0; y<im->height(); y++)
    59       for (x=0; x<im->width(); x++,i++)
     57    vec2i size = im->Size();
     58    fprintf(fp,"unsigned char %s[%d*%d]={\n    ",tmp_name, size.x, size.y);
     59    int x,y,max=size.x*size.y-1;
     60    for (y=0,i=0; y<size.y; y++)
     61      for (x=0; x<size.x; x++,i++)
    6062      {
    6163        fprintf(fp,"%d",(int)im->pixel(x,y));
  • abuse/trunk/src/imlib/input.cpp

    r494 r512  
    1212
    1313#include <string.h>
     14
     15#include "common.h"
    1416
    1517#include "input.h"
     
    202204  if (pressed)
    203205  {
    204     x2=x+pressed->width()-1;
    205     y2=y+pressed->height()-1;
     206    x2=x+pressed->Size().x-1;
     207    y2=y+pressed->Size().y-1;
    206208  }
    207209  else
     
    213215    } else
    214216    {
    215       x2=x+6+visual->width();
    216       y2=y+6+visual->height();
     217      x2=x+6+visual->Size().x;
     218      y2=y+6+visual->Size().y;
    217219    }
    218220  }
  • abuse/trunk/src/imlib/jwindow.cpp

    r494 r512  
    1212
    1313#include <string.h>
     14
     15#include "common.h"
    1416
    1517#include "video.h"
     
    314316                                     ifield * fields, char const *name)
    315317{
    316     if(x > screen->width () - 4)
    317         x = screen->width () - 25;
    318     if(y > screen->height () - 4)
    319         y = screen->height () - 10;
     318    if(x > screen->Size().x - 4)
     319        x = screen->Size().x - 25;
     320    if(y > screen->Size().y - 4)
     321        y = screen->Size().y - 10;
    320322
    321323    Jwindow * j = new Jwindow (x, y, l, h, fields, name);
     
    340342
    341343        screen->put_part(mouse_save, 0, 0, mx, my,
    342                          mx + mouse_pic->width() - 1,
    343                          my + mouse_pic->height() - 1);
     344                         mx + mouse_pic->Size().x - 1,
     345                         my + mouse_pic->Size().y - 1);
    344346        mouse_pic->put_image(screen, mx, my, 1);
    345347    }
     
    361363        {
    362364            p->screen->put_part(mouse_save, 0, 0, mx - p->x, my - p->y,
    363                                 mx - p->x + mouse_pic->width() - 1,
    364                                 my - p->y + mouse_pic->height() - 1);
     365                                mx - p->x + mouse_pic->Size().x - 1,
     366                                my - p->y + mouse_pic->Size().y - 1);
    365367            if(has_mouse())
    366368                mouse_pic->put_image(p->screen, mx - p->x, my - p->y, 1);
     
    529531    {
    530532      screen->bar (top_border(), 1,
    531                     top_border() + fnt->width () * strlen (_name) + 1,
     533                    top_border() + fnt->width() * strlen (_name) + 1,
    532534                    top_border() - 2, med);
    533535      fnt->put_string (screen, top_border() + 1, 1, _name, low);
  • abuse/trunk/src/imlib/palette.cpp

    r494 r512  
    1212
    1313#include <math.h>
     14
     15#include "common.h"
    1416
    1517#include "palette.h"
  • abuse/trunk/src/imlib/pcxread.cpp

    r494 r512  
    1010
    1111#include "config.h"
     12
     13#include "common.h"
    1214
    1315#include "pcxread.h"
     
    6062  PCX_header.xmin=0;
    6163  PCX_header.ymin=0;
    62   PCX_header.xmax=im->width()-1;
    63   PCX_header.ymax=im->height()-1;
     64  PCX_header.xmax=im->Size().x-1;
     65  PCX_header.ymax=im->Size().y-1;
    6466  PCX_header.hres=320;
    6567  PCX_header.vres=200;
    6668  PCX_header.reserved=0;
    6769  PCX_header.color_planes=1;
    68   PCX_header.bytes_per_line=im->width();
     70  PCX_header.bytes_per_line=im->Size().x;
    6971  PCX_header.palette_type=0;
    7072  memset(PCX_header.filter,0,58);
     
    7880  int y,run_length,x;
    7981  unsigned char *sl,code;
    80   for (y=0; y<im->height(); y++)
     82  for (y=0; y<im->Size().y; y++)
    8183  {
    8284    sl=im->scan_line(y);
    83     for (x=0; x<im->width(); )
     85    for (x=0; x<im->Size().x; )
    8486    {
    8587      run_length=1;
    86       while (x+run_length<im->width() && sl[x]==sl[x+run_length])
     88      while (x+run_length<im->Size().x && sl[x]==sl[x+run_length])
    8789        run_length++;
    8890      if (run_length==1 && sl[x]<64)
  • abuse/trunk/src/imlib/pmenu.cpp

    r494 r512  
    1313#include <string.h>
    1414
     15#include "common.h"
     16
    1517#include "pmenu.h"
    1618
     
    285287{
    286288  if (p->xp!=-1) return p->xp;
    287   int w=bar->screen->width();
     289  int w=bar->screen->Size().x;
    288290
    289291
     
    376378  mx-=bar->x;
    377379  my-=bar->y;
    378   if (mx<0 || my<0 || mx>=bar->screen->width() || my>=bar->screen->height()) return NULL;
     380  if (mx<0 || my<0 || mx>=bar->screen->Size().x || my>=bar->screen->Size().y) return NULL;
    379381  else
    380382  {
  • abuse/trunk/src/imlib/scroller.cpp

    r494 r512  
    1010
    1111#include "config.h"
     12
     13#include "common.h"
    1214
    1315#include "scroller.h"
     
    492494    screen->get_clip(cx1,cy1,cx2,cy2);
    493495    screen->set_clip(x,y,x+l-1,y+h-1);
    494     int tw=(l+tex->width()-1)/tex->width();
    495     int th=(h+tex->height()-1)/tex->height();
     496    int tw=(l+tex->Size().x-1)/tex->Size().x;
     497    int th=(h+tex->Size().y-1)/tex->Size().y;
    496498    int dy=y;
    497     for (int j=0; j<th; j++,dy+=tex->height())
    498       for (int i=0,dx=x; i<tw; i++,dx+=tex->width())
     499    for (int j=0; j<th; j++,dy+=tex->Size().y)
     500      for (int i=0,dx=x; i<tw; i++,dx+=tex->Size().x)
    499501        tex->put_image(screen,dx,dy);
    500502
  • abuse/trunk/src/imlib/specs.cpp

    r494 r512  
    2121#   include <sys/stat.h>
    2222#endif
     23
     24#include "common.h"
    2325
    2426#include "image.h"
  • abuse/trunk/src/imlib/sprite.cpp

    r494 r512  
    1313#include <math.h>
    1414
     15#include "common.h"
     16
    1517#include "macs.h"
    1618#include "video.h"
     
    2224
    2325void sprite::restore_background()
    24 { if (x+save->width()>=0 && y+save->height()>=0 && x<=xres && y<=yres)
     26{ if (x+save->Size().x>=0 && y+save->Size().y>=0 && x<=xres && y<=yres)
    2527      save->put_image(screen,x,y); }
    2628
    2729void sprite::get_background()
    28 { if (x+visual->width()>=0 && y+visual->height()>=0 && x<=xres && y<=yres)
    29    screen->put_part(save,0,0,x,y,x+save->width()-1,y+save->height()-1); }
     30{ if (x+visual->Size().x>=0 && y+visual->Size().y>=0 && x<=xres && y<=yres)
     31   screen->put_part(save,0,0,x,y,x+save->Size().x-1,y+save->Size().y-1); }
    3032
    3133void sprite::draw()
    32 { if (x+visual->width()>=0 && y+visual->height()>=0 && x<=xres && y<=yres)
     34{ if (x+visual->Size().x>=0 && y+visual->Size().y>=0 && x<=xres && y<=yres)
    3335   visual->put_image(screen,x,y,1); }
    3436
     
    3739  CHECK(Visual && Screen);
    3840  x=X; y=Y; visual=Visual; screen=Screen;
    39   save=new image(visual->width(),visual->height());
     41  save=new image(visual->Size().x,visual->Size().y);
    4042  get_background();
    4143} ;
     
    6264    delete visual;
    6365  visual=Visual;
    64   if (save->width()!=Visual->width() || save->height()!=Visual->height())
     66  if (save->Size().x!=Visual->Size().x || save->Size().y!=Visual->Size().y)
    6567  {
    6668    delete save;
    67     save=new image(visual->width(),visual->height());
     69    save=new image(visual->Size().x,visual->Size().y);
    6870  }
    6971  get_background();
  • abuse/trunk/src/imlib/status.cpp

    r494 r512  
    1212
    1313#include <string.h>
     14
     15#include "common.h"
    1416
    1517#include "macs.h"
  • abuse/trunk/src/imlib/supmorph.cpp

    r494 r512  
    1010
    1111#include "config.h"
     12
     13#include "common.h"
    1214
    1315#include "supmorph.h"
  • abuse/trunk/src/imlib/timage.cpp

    r494 r512  
    1111#include "config.h"
    1212
     13#include "common.h"
     14
    1315#include "timage.h"
    1416
     
    7072  int size=0,x,y;
    7173  uint8_t *sl,*datap,*marker;
    72   w=im->width();
    73   h=im->height();
     74  w=im->Size().x;
     75  h=im->Size().y;
    7476
    7577  im->lock();
    7678
    7779  // first we must find out how much data to allocate
    78   for (y=0; y<im->height(); y++)
     80  for (y=0; y<im->Size().y; y++)
    7981  {
    8082    sl=im->scan_line(y);
     
    99101
    100102  data=(uint8_t *)malloc(size);
    101   int ww=im->width(),hh=im->height();
     103  int ww=im->Size().x,hh=im->Size().y;
    102104  datap=data;
    103105  if (!datap)
    104   { printf("size = %d %d (%d)\n",im->width(),im->height(),size);  }
     106  { printf("size = %d %d (%d)\n",im->Size().x,im->Size().y,size);  }
    105107  CONDITION(datap,"malloc error for trans_image::data");
    106108
     
    112114    {
    113115      *datap=0;  // start the skip at 0
    114       while (x<im->width() && (*sl)==0)
     116      while (x<im->Size().x && (*sl)==0)
    115117      { sl++; x++; (*datap)++; }
    116118      datap++;
     
    121123    *marker=0;
    122124    datap++;    // skip over this spot
    123         while (x<im->width() && (*sl)!=0)
     125        while (x<im->Size().x && (*sl)!=0)
    124126        {
    125127          (*marker)++;
     
    274276
    275277  screen_line=screen->scan_line(y)+x;
    276   int sw=screen->width()-w;
     278  int sw=screen->Size().x-w;
    277279  x1-=x; x2-=x;
    278280  for (; ysteps>0; ysteps--)
     
    343345
    344346  screen->lock();
    345   screen_skip = screen->width() - w;
     347  screen_skip = screen->Size().x - w;
    346348  for (; ysteps; ysteps--)
    347349  {
     
    366368    ix+=skip;
    367369
    368     if (s_off>=screen->scan_line(screen->height()+1))
     370    if (s_off>=screen->scan_line(screen->Size().y+1))
    369371            printf("bad write in trans_image::put_image_offseted");
    370372      }
     
    386388  screen->lock();
    387389  screen_line=screen->scan_line(y)+x;
    388   int sw=screen->width();
     390  int sw=screen->Size().x;
    389391  x1-=x; x2-=x;
    390392  for (; ysteps>0; ysteps--)
     
    451453  screen->lock();
    452454  screen_line=screen->scan_line(y)+x;
    453   int sw=screen->width();
     455  int sw=screen->Size().x;
    454456  x1-=x; x2-=x;
    455457  for (; ysteps>0; ysteps--)
     
    529531  screen->lock();
    530532  screen_line=screen->scan_line(y)+x;
    531   int sw=screen->width();
     533  int sw=screen->Size().x;
    532534  x1-=x; x2-=x;
    533535  for (; ysteps>0; ysteps--)
     
    857859                *blend_line,*screen_line;
    858860  if (!datap) return ;
    859   CONDITION(y>=blendy && y+ysteps<blendy+blend->height()+1,"Blend doesn't fit on trans_image");
     861  CONDITION(y>=blendy && y+ysteps<blendy+blend->Size().y+1,"Blend doesn't fit on trans_image");
    860862
    861863  blend_amount=16-blend_amount;
     
    979981  screen->lock();
    980982  screen_line=screen->scan_line(y)+x;
    981   int sw=screen->width();
     983  int sw=screen->Size().x;
    982984  x1-=x; x2-=x;
    983985  for (; ysteps>0; ysteps--)
  • abuse/trunk/src/imlib/tools.cpp

    r494 r512  
    1010
    1111#include "config.h"
     12
     13#include "common.h"
    1214
    1315#include "tools.h"
  • abuse/trunk/src/imlib/visobj.h

    r494 r512  
    3333  image_visual(image *img) { im=img; }
    3434  virtual void draw(image *screen, int x, int y, filter *f);
    35   virtual int width() { return im->width(); }
    36   virtual int height() { return im->height(); }
     35  virtual int width() { return im->Size().x; }
     36  virtual int height() { return im->Size().y; }
    3737} ;
    3838
Note: See TracChangeset for help on using the changeset viewer.