Ignore:
Timestamp:
Mar 18, 2008, 9:36:56 PM (15 years ago)
Author:
Sam Hocevar
Message:
  • Get rid of ugly tabs and trailing spaces everywhere.
Location:
abuse/trunk/src/imlib
Files:
69 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/src/imlib/convert.cpp

    r56 r124  
    3131  {
    3232    printf("  %s\n",argv[i]);
    33     fp=fopen(argv[i],"r"); 
     33    fp=fopen(argv[i],"r");
    3434    o=fopen("testXDF.out","w");
    3535    while (!feof(fp))
     
    4040        if (c=='\n' && add) { fputc('\r',o); }
    4141        if (!(c=='\r') || !strip)
    42           fputc(c,o); 
     42          fputc(c,o);
    4343      }
    4444    }
     
    4747    sprintf(st,"cp testXDF.out %s",argv[i]);
    4848    system(st);
    49     unlink("testXDF.out"); 
    50   } 
     49    unlink("testXDF.out");
     50  }
    5151}
  • abuse/trunk/src/imlib/decoder.cpp

    r112 r124  
    121121      {
    122122      if (navail_bytes <= 0)
    123         {
    124 
    125         /* Out of bytes in current block, so read next block
    126           */
    127         pbytes = byte_buff;
    128         if ((navail_bytes = get_byte()) < 0)
    129             return(navail_bytes);
    130         else if (navail_bytes)
    131             {
    132             for (i = 0; i < navail_bytes; ++i)
    133                {
    134                if ((x = get_byte()) < 0)
    135                   return(x);
    136                byte_buff[i] = x;
    137                }
    138             }
    139         }
     123    {
     124
     125    /* Out of bytes in current block, so read next block
     126      */
     127    pbytes = byte_buff;
     128    if ((navail_bytes = get_byte()) < 0)
     129        return(navail_bytes);
     130    else if (navail_bytes)
     131        {
     132        for (i = 0; i < navail_bytes; ++i)
     133           {
     134           if ((x = get_byte()) < 0)
     135          return(x);
     136           byte_buff[i] = x;
     137           }
     138        }
     139    }
    140140      b1 = *pbytes++;
    141141      nbits_left = 8;
     
    147147      {
    148148      if (navail_bytes <= 0)
    149         {
    150 
    151         /* Out of bytes in current block, so read next block
    152           */
    153         pbytes = byte_buff;
    154         if ((navail_bytes = get_byte()) < 0)
    155             return(navail_bytes);
    156         else if (navail_bytes)
    157             {
    158             for (i = 0; i < navail_bytes; ++i)
    159                {
    160                if ((x = get_byte()) < 0)
    161                   return(x);
    162                byte_buff[i] = x;
    163                }
    164             }
    165         }
     149    {
     150
     151    /* Out of bytes in current block, so read next block
     152      */
     153    pbytes = byte_buff;
     154    if ((navail_bytes = get_byte()) < 0)
     155        return(navail_bytes);
     156    else if (navail_bytes)
     157        {
     158        for (i = 0; i < navail_bytes; ++i)
     159           {
     160           if ((x = get_byte()) < 0)
     161          return(x);
     162           byte_buff[i] = x;
     163           }
     164        }
     165    }
    166166      b1 = *pbytes++;
    167167      ret |= b1 << nbits_left;
     
    252252       */
    253253      if (c < 0)
    254         {
    255 //      free(buf);
    256         return(0);
    257         }
     254    {
     255//    free(buf);
     256    return(0);
     257    }
    258258
    259259      /* If the code is a clear code, reinitialize all necessary items.
    260260       */
    261261      if (c == clear)
    262         {
    263         curr_size = size + 1;
    264         slot = newcodes;
    265         top_slot = 1 << curr_size;
    266 
    267         /* Continue reading codes until we get a non-clear code
    268           * (Another unlikely, but possible case...)
    269           */
    270         while ((c = get_next_code()) == clear)
    271             ;
    272 
    273         /* If we get an ending code immediately after a clear code
    274           * (Yet another unlikely case), then break out of the loop.
    275           */
    276         if (c == ending)
    277             break;
    278 
    279         /* Finally, if the code is beyond the range of already set codes,
    280           * (This one had better NOT happen...  I have no idea what will
    281           * result from this, but I doubt it will look good...) then set it
    282           * to color zero.
    283           */
    284         CONDITION(c<slot,"Error occurred while reading gif");
    285         if (c >= slot)
    286             c = 0;
    287 
    288         oc = fc = c;
    289 
    290         /* And let us not forget to put the char into the buffer... And
    291           * if, on the off chance, we were exactly one pixel from the end
    292           * of the line, we have to send the buffer to the out_line()
    293           * routine...
    294           */
    295         *bufptr++ = c;
    296         if (--bufcnt == 0)
    297             {
    298 
    299 //          if ((ret = out_line(buf, linewidth)) < 0)
    300 //             {
    301 //             free(buf);
    302 //             return(ret);
    303 //             }
    304             y++;
    305             if (y<im->height())
    306               buf=im->scan_line(y);
    307             bufptr = buf;
    308             bufcnt = im->width()-1;
    309             }
    310         }
     262    {
     263    curr_size = size + 1;
     264    slot = newcodes;
     265    top_slot = 1 << curr_size;
     266
     267    /* Continue reading codes until we get a non-clear code
     268      * (Another unlikely, but possible case...)
     269      */
     270    while ((c = get_next_code()) == clear)
     271        ;
     272
     273    /* If we get an ending code immediately after a clear code
     274      * (Yet another unlikely case), then break out of the loop.
     275      */
     276    if (c == ending)
     277        break;
     278
     279    /* Finally, if the code is beyond the range of already set codes,
     280      * (This one had better NOT happen...  I have no idea what will
     281      * result from this, but I doubt it will look good...) then set it
     282      * to color zero.
     283      */
     284    CONDITION(c<slot,"Error occurred while reading gif");
     285    if (c >= slot)
     286        c = 0;
     287
     288    oc = fc = c;
     289
     290    /* And let us not forget to put the char into the buffer... And
     291      * if, on the off chance, we were exactly one pixel from the end
     292      * of the line, we have to send the buffer to the out_line()
     293      * routine...
     294      */
     295    *bufptr++ = c;
     296    if (--bufcnt == 0)
     297        {
     298
     299//        if ((ret = out_line(buf, linewidth)) < 0)
     300//           {
     301//           free(buf);
     302//           return(ret);
     303//           }
     304        y++;
     305        if (y<im->height())
     306          buf=im->scan_line(y);
     307        bufptr = buf;
     308        bufcnt = im->width()-1;
     309        }
     310    }
    311311      else
    312         {
    313 
    314         /* In this case, it's not a clear code or an ending code, so
    315           * it must be a code code...  So we can now decode the code into
    316           * a stack of character codes. (Clear as mud, right?)
    317           */
    318         code = c;
    319 
    320         /* Here we go again with one of those off chances...  If, on the
    321           * off chance, the code we got is beyond the range of those already
    322           * set up (Another thing which had better NOT happen...) we trick
    323           * the decoder into thinking it actually got the last code read.
    324           * (Hmmn... I'm not sure why this works...  But it does...)
    325           */
    326 
    327         if (code >= slot)
    328             {
    329             if (code > slot)
    330                ++bad_code_count;
    331             code = oc;
    332             *sp++ = fc;
    333             }
    334 
    335         /* Here we scan back along the linked list of prefixes, pushing
    336           * helpless characters (ie. suffixes) onto the stack as we do so.
    337           */
    338         while (code >= newcodes)
    339             {
    340             *sp++ = suffix[code];
    341             code = prefix[code];
    342             }
    343 
    344         /* Push the last character on the stack, and set up the new
    345           * prefix and suffix, and if the required slot number is greater
    346           * than that allowed by the current bit size, increase the bit
    347           * size.  (NOTE - If we are all full, we *don't* save the new
    348           * suffix and prefix...  I'm not certain if this is correct...
    349           * it might be more proper to overwrite the last code...
    350           */
    351         *sp++ = code;
    352         if (slot < top_slot)
    353             {
    354             suffix[slot] = fc = code;
    355             prefix[slot++] = oc;
    356             oc = c;
    357             }
    358         if (slot >= top_slot)
    359             if (curr_size < 12)
    360                {
    361                top_slot <<= 1;
    362                ++curr_size;
    363                }
    364 
    365         /* Now that we've pushed the decoded string (in reverse order)
    366           * onto the stack, lets pop it off and put it into our decode
    367           * buffer...  And when the decode buffer is full, write another
    368           * line...
    369           */
    370         while (sp > stack)
    371             {
    372             *bufptr++ = *(--sp);
    373             if (--bufcnt == 0)
    374                {
    375 /*             if ((ret = out_line(buf, linewidth)) < 0)
    376                   {
    377                   free(buf);
    378                   return(ret);
    379                   } */
    380                y++;
    381                if (y<im->height())
    382                 buf=im->scan_line(y);
    383 
    384                bufptr = buf;
    385                bufcnt = im->width()-1;
    386                }
    387             }
    388         }
     312    {
     313
     314    /* In this case, it's not a clear code or an ending code, so
     315      * it must be a code code...  So we can now decode the code into
     316      * a stack of character codes. (Clear as mud, right?)
     317      */
     318    code = c;
     319
     320    /* Here we go again with one of those off chances...  If, on the
     321      * off chance, the code we got is beyond the range of those already
     322      * set up (Another thing which had better NOT happen...) we trick
     323      * the decoder into thinking it actually got the last code read.
     324      * (Hmmn... I'm not sure why this works...  But it does...)
     325      */
     326
     327    if (code >= slot)
     328        {
     329        if (code > slot)
     330           ++bad_code_count;
     331        code = oc;
     332        *sp++ = fc;
     333        }
     334
     335    /* Here we scan back along the linked list of prefixes, pushing
     336      * helpless characters (ie. suffixes) onto the stack as we do so.
     337      */
     338    while (code >= newcodes)
     339        {
     340        *sp++ = suffix[code];
     341        code = prefix[code];
     342        }
     343
     344    /* Push the last character on the stack, and set up the new
     345      * prefix and suffix, and if the required slot number is greater
     346      * than that allowed by the current bit size, increase the bit
     347      * size.  (NOTE - If we are all full, we *don't* save the new
     348      * suffix and prefix...  I'm not certain if this is correct...
     349      * it might be more proper to overwrite the last code...
     350      */
     351    *sp++ = code;
     352    if (slot < top_slot)
     353        {
     354        suffix[slot] = fc = code;
     355        prefix[slot++] = oc;
     356        oc = c;
     357        }
     358    if (slot >= top_slot)
     359        if (curr_size < 12)
     360           {
     361           top_slot <<= 1;
     362           ++curr_size;
     363           }
     364
     365    /* Now that we've pushed the decoded string (in reverse order)
     366      * onto the stack, lets pop it off and put it into our decode
     367      * buffer...  And when the decode buffer is full, write another
     368      * line...
     369      */
     370    while (sp > stack)
     371        {
     372        *bufptr++ = *(--sp);
     373        if (--bufcnt == 0)
     374           {
     375/*           if ((ret = out_line(buf, linewidth)) < 0)
     376          {
     377          free(buf);
     378          return(ret);
     379          } */
     380           y++;
     381           if (y<im->height())
     382        buf=im->scan_line(y);
     383
     384           bufptr = buf;
     385           bufcnt = im->width()-1;
     386           }
     387        }
     388    }
    389389      }
    390390   ret = 0;
  • abuse/trunk/src/imlib/dprint.cpp

    r56 r124  
    2121void set_dprinter(void (*stat_fun)(char *))
    2222{
    23         dprint_fun = stat_fun;
     23    dprint_fun = stat_fun;
    2424}
    2525
    2626void set_dgetter(void (*stat_fun)(char *,int))
    2727{
    28         dget_fun = stat_fun;
     28    dget_fun = stat_fun;
    2929}
    3030
    3131void dprintf(const char *format, ...)
    3232{
    33         if (dprint_fun)
    34         {
    35                 char st[1000];
    36                 va_list ap;
     33    if (dprint_fun)
     34    {
     35        char st[1000];
     36        va_list ap;
    3737
    38                 va_start(ap, format);
    39                 vsprintf(st,format,ap);
    40                 va_end(ap);
    41                 dprint_fun(st);
    42         }
     38        va_start(ap, format);
     39        vsprintf(st,format,ap);
     40        va_end(ap);
     41        dprint_fun(st);
     42    }
    4343}
    4444
     
    4646void dgets(char *buf, int size)
    4747{
    48         if (dget_fun)
    49         {
    50                 dget_fun(buf,size);
    51         }
    52         else
    53         {
    54                 ERROR(0,"dgets called but no handler set up");
    55         }
     48    if (dget_fun)
     49    {
     50        dget_fun(buf,size);
     51    }
     52    else
     53    {
     54        ERROR(0,"dgets called but no handler set up");
     55    }
    5656}
  • abuse/trunk/src/imlib/emm.hpp

    r57 r124  
    1212#include "system.h"
    1313#ifdef __DOS            // this stuff is DOS specific, don't include
    14                         // on other systems
     14            // on other systems
    1515#include "linked.hpp"
    1616
     
    4949long     EMM_free_memory();
    5050int      EMM_alloc(int pages);  // remeber pages are 16K, 16384 bytes
    51                 // returns handle or -1
     51        // returns handle or -1
    5252int      EMM_free(int handle);   // returns true for success
    5353unsigned EMM_frame_address();
  • abuse/trunk/src/imlib/event.hpp

    r120 r124  
    1414#define EV_KEY            4
    1515#define EV_KEY_SPECIAL    8
    16 #define EV_REDRAW        16 
    17 #define EV_SPURIOUS      32 
     16#define EV_REDRAW        16
     17#define EV_SPURIOUS      32
    1818#define EV_RESIZE        64
    1919#define EV_KEYRELEASE   128
     
    4040  struct { char alt,ctrl,shift; } key_special;
    4141  struct { int x1,y1,x2,y2;
    42            void *start; }         redraw;
     42       void *start; }         redraw;
    4343  Jwindow                        *window;      // NULL is root
    4444  struct { int x,y; }             window_position;
     
    6464  { if (mouse)
    6565    {
    66       x=mouse->x(); y=mouse->y(); button=mouse->button(); 
     66      x=mouse->x(); y=mouse->y(); button=mouse->button();
    6767    } else x=y=button=0;
    6868  }
  • abuse/trunk/src/imlib/filesel.cpp

    r120 r124  
    2929  void free_up();
    3030  ~file_picker() { free_up(); }
    31 } ; 
     31} ;
    3232
    3333void file_picker::free_up()
     
    6969      sx=0;
    7070
    71      
    7271
    73       reconfigure(); 
     72
     73      reconfigure();
    7474      draw_first(screen);
    7575    }
     
    101101  : spicker(X,Y,0,Rows,1,1,0,Next)
    102102{
    103  
     103
    104104  sid=ID;
    105105
    106106  strcpy(cd,".");
    107  
     107
    108108  get_directory(cd,f,tf,d,td);
    109109  wid=0;
     
    113113  for (i=0;i<td;i++)
    114114    if ((int)strlen(d[i])+2>wid) wid=strlen(d[i])+2;
    115   reconfigure(); 
     115  reconfigure();
    116116}
    117117
    118118Jwindow *file_dialog(char const *prompt, char const *def,
    119                      int ok_id, char const *ok_name, int cancel_id,
     119             int ok_id, char const *ok_name, int cancel_id,
    120120                     char const *cancel_name, char const *FILENAME_str,
    121121                     int filename_id)
     
    124124  int wh3 = wh2 + wm->font()->height() + 12;
    125125  Jwindow *j=wm->new_window(0,0,-1,-1,
    126                             new info_field(5, 5, 0, prompt,
     126                new info_field(5, 5, 0, prompt,
    127127                            new text_field(0, wh2, filename_id,
    128                                            ">","****************************************",def,
    129                             new button(50, wh3, ok_id, ok_name,
    130                             new button(100, wh3, cancel_id, cancel_name,
    131                             new file_picker(15, wh3 + wm->font()->height() + 10, filename_id, 8,
    132                                           NULL))))),
     128                       ">","****************************************",def,
     129                new button(50, wh3, ok_id, ok_name,
     130                new button(100, wh3, cancel_id, cancel_name,
     131                new file_picker(15, wh3 + wm->font()->height() + 10, filename_id, 8,
     132                      NULL))))),
    133133
    134                             FILENAME_str);
     134                FILENAME_str);
    135135  return j;
    136136}
  • abuse/trunk/src/imlib/filesel.hpp

    r120 r124  
    1414
    1515Jwindow *file_dialog(char const *prompt, char const *def,
    16                      int ok_id, char const *ok_name, int cancel_id,
     16             int ok_id, char const *ok_name, int cancel_id,
    1717                     char const *cancel_name, char const *FILENAME_str,
    18                      int filename_id);
     18             int filename_id);
    1919
    2020#endif
  • abuse/trunk/src/imlib/filter.cpp

    r115 r124  
    160160      for (b=0;b<colors;b++)
    161161      {
    162         bv=b<<lshift;
     162    bv=b<<lshift;
    163163        best=0x7fffffff;
    164164        for (i=0,pp=(unsigned char *)pal->addr();i<max;i++)
     
    167167                        gd=*(pp++)-gv,
    168168                        bd=*(pp++)-bv;
    169        
     169   
    170170          dist_sqr=(long)rd*rd+(long)bd*bd+(long)gd*gd;
    171171          if (dist_sqr<best)
     
    249249        for(i = 0, source = &pg2[x1], dest = &pg1[x];
    250250            i < xl;
    251             i++, source++, dest++)     
     251            i++, source++, dest++)   
    252252        {
    253253            if(!transparent || *source != current_background)
  • abuse/trunk/src/imlib/filter.hpp

    r57 r124  
    4040  color_filter(spec_entry *e, bFILE *fp);
    4141  color_filter(palette *pal, int color_bits=6, void (*stat_fun)(int)=NULL);
    42   unsigned char lookup_color(int r, int g, int b) 
     42  unsigned char lookup_color(int r, int g, int b)
    4343   { return color_table[r*32*32+g*32+b]; }
    4444  unsigned char *table() { return color_table; }
  • abuse/trunk/src/imlib/fonts.cpp

    r56 r124  
    6060{
    6161  tl=(letters->width()+1)/32;
    62   th=(letters->height()+1)/8;   
     62  th=(letters->height()+1)/8;
    6363
    6464  image tmp(tl,th);
    65  
     65
    6666  int ch;
    67  
     67
    6868  for (ch=0;ch<256;ch++)
    69   {   
    70     tmp.clear();   
     69  {
     70    tmp.clear();
    7171    letters->put_part(&tmp,0,0,((int)ch%32)*tl,((int)ch/32)*th,
    72                       ((int)ch%32)*tl+tl-1,((int)ch/32)*th+th-1,1); 
     72              ((int)ch%32)*tl+tl-1,((int)ch/32)*th+th-1,1);
    7373    let[ch]=new trans_image(&tmp,"JCfont");
    74   } 
     74  }
    7575}
    7676
     
    7878{
    7979  int ch;
    80   for (ch=0;ch<256;ch++) 
    81     delete let[ch]; 
     80  for (ch=0;ch<256;ch++)
     81    delete let[ch];
    8282}
    8383
  • abuse/trunk/src/imlib/gifread.cpp

    r56 r124  
    2727
    2828struct GifScreen {
    29         uint16_t        Width;
    30         uint16_t        Height;
    31         uint8_t         ColorMap[3][256];
    32         uint16_t        BitPixel;
    33         uint16_t        ColorResolution;
    34         uint16_t        Background;
    35         uint16_t        AspectRatio;
     29    uint16_t    Width;
     30    uint16_t    Height;
     31    uint8_t     ColorMap[3][256];
     32    uint16_t    BitPixel;
     33    uint16_t    ColorResolution;
     34    uint16_t    Background;
     35    uint16_t    AspectRatio;
    3636} GifScreen;
    3737
     
    7272        fread((uint8_t *)&gif_screen.background,1,1,fp);
    7373        if (fread((uint8_t *)&gif_screen.reserved,1,1,fp)==1)
    74         {
    75           if (gif_screen.color_info&128)
    76           {
    77             ncolors=2<<(gif_screen.color_info&0x0f);
    78             make_block(sizeof(palette));
    79 //          pal=new palette(ncolors);
    80             pal=new palette(256);
    81             if (pal)
    82             { 
     74    {
     75      if (gif_screen.color_info&128)
     76      {
     77        ncolors=2<<(gif_screen.color_info&0x0f);
     78        make_block(sizeof(palette));
     79//        pal=new palette(ncolors);
     80        pal=new palette(256);
     81        if (pal)
     82        {
    8383              if (fread((uint8_t *)pal->addr(),1,ncolors*3,fp)!=ncolors*3) er=imREAD_ERROR;
    84             } else er=imMEMORY_ERROR;
    85           }
    86           if (!er)
    87           { do
    88             {
    89               if (fread((uint8_t *)&sep,1,1,fp)!=1)
    90                 er=imREAD_ERROR;
    91             } while (!er && sep!=',');
     84        } else er=imMEMORY_ERROR;
     85      }
     86      if (!er)
     87      { do
     88        {
     89          if (fread((uint8_t *)&sep,1,1,fp)!=1)
     90        er=imREAD_ERROR;
     91        } while (!er && sep!=',');
    9292            fread((uint8_t *)&gif_image.xoff,2,1,fp);
    9393            gif_image.xoff=uint16_to_local(gif_image.xoff);
     
    9898            fread((uint8_t *)&gif_image.h,2,1,fp);
    9999            gif_image.h=uint16_to_local(gif_image.h);
    100             if (!er && (fread((uint8_t *)&gif_image.color_info,1,1,fp)==1))
    101             {
    102               if (gif_image.color_info&128)
    103               {
    104                 ncolors=2<<(gif_image.color_info&0x0f);
     100        if (!er && (fread((uint8_t *)&gif_image.color_info,1,1,fp)==1))
     101        {
     102          if (gif_image.color_info&128)
     103          {
     104        ncolors=2<<(gif_image.color_info&0x0f);
    105105                CHECK(ncolors<=256);
    106                 make_block(sizeof(palette));
    107                 pal = new palette(ncolors);
    108                 if (pal)
    109                 { if (fread((uint8_t *)pal->addr(),1,ncolors*3,fp)!=ncolors*3) er=imREAD_ERROR;
    110                 } else er=imMEMORY_ERROR;
    111               }
     106        make_block(sizeof(palette));
     107        pal = new palette(ncolors);
     108        if (pal)
     109        { if (fread((uint8_t *)pal->addr(),1,ncolors*3,fp)!=ncolors*3) er=imREAD_ERROR;
     110        } else er=imMEMORY_ERROR;
     111          }
    112112
    113               if (!er)
    114               {
    115                 make_block(sizeof(image));
    116                 im=new image(gif_image.w+1,gif_image.h);
    117                 decode_gif_data(im,fp);
    118                 fclose(fp);
    119               }
     113          if (!er)
     114          {
     115        make_block(sizeof(image));
     116        im=new image(gif_image.w+1,gif_image.h);
     117        decode_gif_data(im,fp);
     118        fclose(fp);
     119          }
    120120
    121             } else er=imREAD_ERROR;
    122           }
     121        } else er=imREAD_ERROR;
     122      }
    123123
    124         } else er=imREAD_ERROR;
     124    } else er=imREAD_ERROR;
    125125      } else er=imINCORRECT_FILETYPE;
    126126    } else er=imREAD_ERROR;
  • abuse/trunk/src/imlib/glread.cpp

    r115 r124  
    108108      if (c!=esc)
    109109      {
    110         if (xx>=w) { yy--; xx=0; sl=im->scan_line(yy);
    111         if (yy==h) printf("bufsize=%d\n",bufsize); CHECK(yy<h); }
    112         sl[xx++]=c;     len--;
     110    if (xx>=w) { yy--; xx=0; sl=im->scan_line(yy);
     111    if (yy==h) printf("bufsize=%d\n",bufsize); CHECK(yy<h); }
     112    sl[xx++]=c;     len--;
    113113      }
    114114      else
    115115      {
    116         fread(&n,1,1,fp);
    117         if (n!=0)
    118         {
    119           fread(&c,1,1,fp);
    120           while (n-- && yy>=0 && len)
    121           {
    122             if (xx>=w) { yy--; xx=0; sl=im->scan_line(yy);
    123               if (yy==h) printf("bufsize=%d\n",bufsize); CHECK(yy<h); }
    124             sl[xx++]=c; len--;
    125           }
    126         }
    127         else
    128         {
    129           fread(&sn,1,2,fp);
    130           sn=uint16_to_local(sn);
    131           fread(&c,1,1,fp);
    132           while (sn-- && yy>=0 && len)
    133           {
    134             if (xx>=w) { yy--; xx=0; sl=im->scan_line(yy); CHECK(yy<h); }
    135             sl[xx++]=c; len--;
    136           }
    137         }
     116    fread(&n,1,1,fp);
     117    if (n!=0)
     118    {
     119      fread(&c,1,1,fp);
     120      while (n-- && yy>=0 && len)
     121      {
     122        if (xx>=w) { yy--; xx=0; sl=im->scan_line(yy);
     123          if (yy==h) printf("bufsize=%d\n",bufsize); CHECK(yy<h); }
     124        sl[xx++]=c; len--;
     125      }
     126    }
     127    else
     128    {
     129      fread(&sn,1,2,fp);
     130      sn=uint16_to_local(sn);
     131      fread(&c,1,1,fp);
     132      while (sn-- && yy>=0 && len)
     133      {
     134        if (xx>=w) { yy--; xx=0; sl=im->scan_line(yy); CHECK(yy<h); }
     135        sl[xx++]=c; len--;
     136      }
     137    }
    138138
    139139      }
  • abuse/trunk/src/imlib/glview.cpp

    r56 r124  
    3939    pal=NULL;
    4040    printf("reading %s",argv[i]);
    41     im[t]=read_pic(argv[i],pal); 
     41    im[t]=read_pic(argv[i],pal);
    4242    printf(" %d %d\n",im[t]->width(),im[t]->height());
    4343    if (pal)
    4444    { pal->load();
    45         delete pal;
     45    delete pal;
    4646    }
    4747    if (*(argv[i]+strlen(argv[i])-3)=='c')
     
    5454    {
    5555      im[k]->put_image(screen,0,0);
    56         printf("put image\n");
     56    printf("put image\n");
    5757      update_dirty(screen);
    5858      screen->bar(0,0,im[k]->width(),im[k]->height(),0);
  • abuse/trunk/src/imlib/guistat.cpp

    r120 r124  
    1717class gui_status_node
    1818{
    19   public : 
     19  public :
    2020  char *name;
    2121  gui_status_node *next;
     
    2424  int last_update;
    2525  time_marker last_time;
    26   gui_status_node(char const *Name, visual_object *Show, gui_status_node *Next) 
    27   { name=strcpy((char *)jmalloc(strlen(Name)+1,"status name"),Name); 
     26  gui_status_node(char const *Name, visual_object *Show, gui_status_node *Next)
     27  { name=strcpy((char *)jmalloc(strlen(Name)+1,"status name"),Name);
    2828    show=Show;
    29     next=Next; 
     29    next=Next;
    3030    last_update=0;
    3131    stat_win=NULL;
    3232  }
    3333  ~gui_status_node();
    34 } ; 
     34} ;
    3535
    3636
    3737gui_status_node::~gui_status_node()
    38 { 
    39   jfree(name); 
    40   if (show) 
    41     delete show; 
    42   if (stat_win) 
     38{
     39  jfree(name);
     40  if (show)
     41    delete show;
     42  if (stat_win)
    4343  {
    4444    wm->close_window(stat_win);
     
    5353
    5454  whom->stat_win->screen->bar(whom->stat_win->x1()+1,whom->stat_win->y2()-h-1,whom->stat_win->x2()-1,
    55                       whom->stat_win->y2()-1,wm->black());
     55              whom->stat_win->y2()-1,wm->black());
    5656  whom->stat_win->screen->bar(whom->stat_win->x1()+2,whom->stat_win->y2()-h,whom->stat_win->x2()-2,
    57                       whom->stat_win->y2()-2,wm->dark_color());
     57              whom->stat_win->y2()-2,wm->dark_color());
    5858  if (perc)
    5959    whom->stat_win->screen->bar(whom->stat_win->x1()+3,whom->stat_win->y2()-h+1,
    60                                 whom->stat_win->x1()+l*perc/100,
    61                                 whom->stat_win->y2()-3,wm->bright_color());
     60                whom->stat_win->x1()+l*perc/100,
     61                whom->stat_win->y2()-3,wm->bright_color());
    6262}
    6363
    6464void gui_status_manager::push(char const *name, visual_object *show)
    6565{
    66   first=new gui_status_node(name,show,first); 
     66  first=new gui_status_node(name,show,first);
    6767}
    6868
    69 gui_status_manager::gui_status_manager() 
    70 { 
    71   first=NULL; 
    72   strcpy(title,"STATUS"); 
     69gui_status_manager::gui_status_manager()
     70{
     71  first=NULL;
     72  strcpy(title,"STATUS");
    7373  last_perc=0;
    7474}
     
    8484      if (now.diff_time(&first->last_time)>1)
    8585      {
    86         long wx=xres/2,wy=10,len1=strlen(first->name)*wm->font()->width()+10,len2=0,len3,
    87           h1=wm->font()->height()+5,h2=first->show ? first->show->height() : 0;
     86    long wx=xres/2,wy=10,len1=strlen(first->name)*wm->font()->width()+10,len2=0,len3,
     87      h1=wm->font()->height()+5,h2=first->show ? first->show->height() : 0;
    8888
    89         if (first->show) len2=first->show->width()/2;
    90         if (len2>len1) len3=len2; else len3=len1;
    91         wx-=len3/2;
    92        
    93        
    94         gui_status_node *p=first->next;
    95         while (p && !p->stat_win) p=p->next;
    96         if (p) wy=p->stat_win->y+p->stat_win->y2()+5;
     89    if (first->show) len2=first->show->width()/2;
     90    if (len2>len1) len3=len2; else len3=len1;
     91    wx-=len3/2;
     92   
     93   
     94    gui_status_node *p=first->next;
     95    while (p && !p->stat_win) p=p->next;
     96    if (p) wy=p->stat_win->y+p->stat_win->y2()+5;
    9797
    98         int mx = first->stat_win->x1() + 1;
    99         int my = first->stat_win->y1() + wm->font()->height() / 2;
    100         first->stat_win=wm->new_window(wx, wy, len3, h1*2+h2, NULL, "status");
    101         wm->font()->put_string(first->stat_win->screen, mx, my, first->name, wm->black());
    102         wm->font()->put_string(first->stat_win->screen, mx, my, first->name, wm->bright_color());
    103         if (first->show)
    104           first->show->draw(first->stat_win->screen, (first->stat_win->x2()-first->stat_win->x1())/2-
    105                             first->show->width()/2, my+h1, NULL);
     98    int mx = first->stat_win->x1() + 1;
     99    int my = first->stat_win->y1() + wm->font()->height() / 2;
     100    first->stat_win=wm->new_window(wx, wy, len3, h1*2+h2, NULL, "status");
     101    wm->font()->put_string(first->stat_win->screen, mx, my, first->name, wm->black());
     102    wm->font()->put_string(first->stat_win->screen, mx, my, first->name, wm->bright_color());
     103    if (first->show)
     104      first->show->draw(first->stat_win->screen, (first->stat_win->x2()-first->stat_win->x1())/2-
     105                first->show->width()/2, my+h1, NULL);
    106106
    107         draw_bar(first,percentage);
    108         wm->flush_screen();
     107    draw_bar(first,percentage);
     108    wm->flush_screen();
    109109      }
    110110    } else
     
    112112      if (percentage>first->last_update)
    113113      {
    114         first->last_update=percentage;
    115         draw_bar(first,percentage);
    116         wm->flush_screen();
     114    first->last_update=percentage;
     115    draw_bar(first,percentage);
     116    wm->flush_screen();
    117117      }
    118118    }
    119   } 
     119  }
    120120}
    121121
  • abuse/trunk/src/imlib/guistat.hpp

    r106 r124  
    1919  char title[40];
    2020  int last_perc;
    21   public :   
     21  public :
    2222  gui_status_node *first;
    2323  gui_status_manager();
  • abuse/trunk/src/imlib/image-24.cpp

    r56 r124  
    1919image::image( short width, short height, unsigned char *page_buffer, short create_descriptor )
    2020{
    21         w = width;
    22         h = height;
     21    w = width;
     22    h = height;
    2323
    24         if( create_descriptor || page_buffer )
    25         {
    26                 if( create_descriptor == 2 )
    27                 {
    28                         special = new image_descriptor( width, height, 1, ( page_buffer != NULL ) );
    29                 }
    30                 else
    31                 {
    32                         special = new image_descriptor( width, height, 0, ( page_buffer != NULL ) );
    33                 }
    34         }
    35         else
    36         {
    37                 special = NULL;
    38         }
     24    if( create_descriptor || page_buffer )
     25    {
     26        if( create_descriptor == 2 )
     27        {
     28            special = new image_descriptor( width, height, 1, ( page_buffer != NULL ) );
     29        }
     30        else
     31        {
     32            special = new image_descriptor( width, height, 0, ( page_buffer != NULL ) );
     33        }
     34    }
     35    else
     36    {
     37        special = NULL;
     38    }
    3939
    40         make_page( width, height, page_buffer );
    41         image_list.add_end( (linked_node *)this );
     40    make_page( width, height, page_buffer );
     41    image_list.add_end( (linked_node *)this );
    4242}
    4343
     
    4747image::image( spec_entry *e, bFILE *fp )
    4848{
    49         short ii;
     49    short ii;
    5050
    51         fp->seek( e->offset, 0 );
    52         w = fp->read_short();
    53         h = fp->read_short();
    54         special = NULL;
    55         make_page( w, h, NULL );
     51    fp->seek( e->offset, 0 );
     52    w = fp->read_short();
     53    h = fp->read_short();
     54    special = NULL;
     55    make_page( w, h, NULL );
    5656
    57         for( ii = 0; ii < h; ii++ )
    58         {
    59                 fp->read( scan_line( ii ), w );
    60         }
     57    for( ii = 0; ii < h; ii++ )
     58    {
     59        fp->read( scan_line( ii ), w );
     60    }
    6161
    62         image_list.add_end( (linked_node *)this );
     62    image_list.add_end( (linked_node *)this );
    6363}
    6464
     
    6868image::image( bFILE *fp )
    6969{
    70         short ii;
     70    short ii;
    7171
    72         w = fp->read_short();
    73         h = fp->read_short();
    74         special = NULL;
    75         make_page( w, h, NULL );
     72    w = fp->read_short();
     73    h = fp->read_short();
     74    special = NULL;
     75    make_page( w, h, NULL );
    7676
    77         for( ii = 0; ii < h; ii++ )
    78         {
    79                 fp->read( scan_line( ii ), w );
    80         }
     77    for( ii = 0; ii < h; ii++ )
     78    {
     79        fp->read( scan_line( ii ), w );
     80    }
    8181
    82         image_list.add_end( (linked_node *)this );
     82    image_list.add_end( (linked_node *)this );
    8383}
    8484
     
    8888image::~image()
    8989{
    90         image_list.unlink( (linked_node *)this );
    91         delete_page();
    92         if( special )
    93         {
    94                 delete special;
    95         }
     90    image_list.unlink( (linked_node *)this );
     91    delete_page();
     92    if( special )
     93    {
     94        delete special;
     95    }
    9696}
    9797
     
    101101long image::total_pixels( unsigned char background )
    102102{
    103         short ii, jj;
    104         long count;
    105         unsigned char *c;
     103    short ii, jj;
     104    long count;
     105    unsigned char *c;
    106106
    107         count = 0;
    108         for( ii = height() - 1; ii >= 0; ii-- )
    109         {
    110                 c = scan_line( ii );
    111                 for( jj = width() - 1; j >= 0; jj--, c++ )
    112                 {
    113                         if( *c != background )
    114                         {
    115                                 count++;
    116                         }
    117                 }
    118         }
     107    count = 0;
     108    for( ii = height() - 1; ii >= 0; ii-- )
     109    {
     110        c = scan_line( ii );
     111        for( jj = width() - 1; j >= 0; jj--, c++ )
     112        {
     113            if( *c != background )
     114            {
     115                count++;
     116            }
     117        }
     118    }
    119119
    120         return count;
     120    return count;
    121121}
    122122
     
    126126void image::clear( short color )
    127127{
    128        
     128   
    129129}
    130130
  • abuse/trunk/src/imlib/image.cpp

    r115 r124  
    3636    "Error occurred while writing, (disk full?)"
    3737};
    38            
    39                          
     38
     39
    4040int16_t imerror=0;
    4141int16_t swpfile_num=0;
     
    5151      printf("%s\n", imerr_messages[imerror]);
    5252    else
    53       printf("Unsonsponsered error code, you got trouble\n"); 
     53      printf("Unsonsponsered error code, you got trouble\n");
    5454#ifdef __DOS_ONLY
    5555    sound(300);
     
    8080                   int keep_dirties, int static_memory)
    8181
    82 { clipx1=0; clipy1=0; 
    83   l=length; h=height; 
    84   clipx2=l-1; clipy2=h-1; 
    85   keep_dirt=keep_dirties; 
    86   static_mem=static_memory; 
     82{ clipx1=0; clipy1=0;
     83  l=length; h=height;
     84  clipx2=l-1; clipy2=h-1;
     85  keep_dirt=keep_dirties;
     86  static_mem=static_memory;
    8787}
    8888
     
    139139{
    140140  w=width;
    141   h=height; 
     141  h=height;
    142142  if (create_descriptor || page_buffer)
    143   { 
     143  {
    144144    if (create_descriptor==2)
    145145      special=new image_descriptor(width, height, 1, (page_buffer!=NULL));
     
    153153image::image(spec_entry *e, bFILE *fp)
    154154{
    155   int16_t i; 
     155  int16_t i;
    156156  fp->seek(e->offset, 0);
    157157  w=fp->read_uint16();
     
    161161  for (i=0; i<h; i++)
    162162    fp->read(scan_line(i), w);
    163   image_list.add_end((linked_node *) this); 
     163  image_list.add_end((linked_node *) this);
    164164    _locked = false;
    165165}
     
    167167image::image(bFILE *fp)
    168168{
    169   int16_t i; 
     169  int16_t i;
    170170  w=fp->read_uint16();
    171171  h=fp->read_uint16();
     
    174174  for (i=0; i<h; i++)
    175175    fp->read(scan_line(i), w);
    176   image_list.add_end((linked_node *) this); 
     176  image_list.add_end((linked_node *) this);
    177177    _locked = false;
    178178}
     
    299299
    300300  // check to see if the line is completly clipped off
    301   get_clip(cx1, cy1, cx2, cy2); 
    302   if ((x1<cx1 && x2<cx1) || (x1>cx2 && x2>cx2) || 
     301  get_clip(cx1, cy1, cx2, cy2);
     302  if ((x1<cx1 && x2<cx1) || (x1>cx2 && x2>cx2) ||
    303303      (y1<cy1 && y2<cy1) || (y1>cy2 && y2>cy2))
    304304    return ;
    305  
     305
    306306  if (x1>x2)        // make sure that x1 is to the left
    307   {   
     307  {
    308308    i=x1; x1=x2; x2=i;  // if not swap points
    309309    i=y1; y1=y2; y2=i;
    310   } 
     310  }
    311311
    312312  // clip the left side
    313313  if (x1<cx1)
    314   { 
    315     int my=(y2-y1);       
     314  {
     315    int my=(y2-y1);
    316316    int mx=(x2-x1), b;
    317317    if (!mx) return ;
    318318    if (my)
    319319    {
    320       b=y1-(y2-y1)*x1/mx;     
     320      b=y1-(y2-y1)*x1/mx;
    321321      y1=my*cx1/mx+b;
    322       x1=cx1;     
     322      x1=cx1;
    323323    }
    324324    else x1=cx1;
     
    327327  // clip the right side
    328328  if (x2>cx2)
    329   { 
    330     int my=(y2-y1);       
     329  {
     330    int my=(y2-y1);
    331331    int mx=(x2-x1), b;
    332332    if (!mx) return ;
    333333    if (my)
    334334    {
    335       b=y1-(y2-y1)*x1/mx;     
     335      b=y1-(y2-y1)*x1/mx;
    336336      y2=my*cx2/mx+b;
    337       x2=cx2;     
     337      x2=cx2;
    338338    }
    339339    else x2=cx2;
     
    341341
    342342  if (y1>y2)        // make sure that y1 is on top
    343   {   
     343  {
    344344    i=x1; x1=x2; x2=i;  // if not swap points
    345345    i=y1; y1=y2; y2=i;
    346   } 
     346  }
    347347
    348348  // clip the bottom
    349349  if (y2>cy2)
    350   { 
    351     int mx=(x2-x1);       
     350  {
     351    int mx=(x2-x1);
    352352    int my=(y2-y1), b;
    353353    if (!my)
     
    355355    if (mx)
    356356    {
    357       b=y1-(y2-y1)*x1/mx;     
     357      b=y1-(y2-y1)*x1/mx;
    358358      x2=(cy2-b)*mx/my;
    359359      y2=cy2;
     
    364364  // clip the top
    365365  if (y1<cy1)
    366   { 
    367     int mx=(x2-x1);       
     366  {
     367    int mx=(x2-x1);
    368368    int my=(y2-y1), b;
    369369    if (!my) return ;
    370370    if (mx)
    371371    {
    372       b=y1-(y2-y1)*x1/mx;     
     372      b=y1-(y2-y1)*x1/mx;
    373373      x1=(cy1-b)*mx/my;
    374374      y1=cy1;
     
    381381  if (x1<cx1 || x2<cx1 || x1>cx2 || x2>cx2 || y1<cy1 || y2 <cy1 || y1>cy2 || y2>cy2)
    382382    return ;
    383  
    384    
     383
     384
    385385
    386386  if (x1>x2)
     
    560560
    561561
    562   // see if the are to be put is outside of actual image, if so adjust 
     562  // see if the are to be put is outside of actual image, if so adjust
    563563  // to fit in the image
    564   if (x1<0) { x+=-x1; x1=0; } 
    565   if (y1<0) { y+=-y1; y1=0; } 
     564  if (x1<0) { x+=-x1; x1=0; }
     565  if (y1<0) { y+=-y1; y1=0; }
    566566  if (x2>=width()) x2=width()-1;
    567567  if (y2>=height()) y2=height()-1;
    568568  if (x1>x2 || y1>y2) return ;      // return if it was adjusted so that nothing will be put
    569    
     569
    570570
    571571  // see if the image gets clipped off the screen
    572572  if (x>cx2 || y>cy2 || x+(x2-x1)<cx1 || y+(y2-y1)<cy1) return ;
    573573
    574  
     574
    575575  if (x<cx1)
    576576  { x1+=(cx1-x); x=cx1; }
     
    583583  if (y+y2-y1+1>cy2)
    584584  { y2=cy2-y+y1; }
    585   if (x1>x2 || y1>y2) return ;   
    586 
    587  
     585  if (x1>x2 || y1>y2) return ;
     586
     587
    588588
    589589
     
    600600  if (transparent)
    601601  {
    602     for (j=0; j<ylen; j++)       
    603     {
    604       for (i=0, source=&pg2[x1], dest=&pg1[x]; i<xlen; i++, source++, dest++)   
     602    for (j=0; j<ylen; j++)
     603    {
     604      for (i=0, source=&pg2[x1], dest=&pg1[x]; i<xlen; i++, source++, dest++)
    605605        if (*source!=current_background) *dest=*source;
    606       pg1=screen->next_line(y+j, pg1); 
     606      pg1=screen->next_line(y+j, pg1);
    607607      pg2=next_line(y1+j, pg2);
    608     }     
     608    }
    609609  }
    610610  else
    611611  for (j=0; j<ylen; j++)
    612   {   
     612  {
    613613    memcpy(&pg1[x], &pg2[x1], xlen);   // strait copy
    614     pg1=screen->next_line(y+j, pg1); 
     614    pg1=screen->next_line(y+j, pg1);
    615615    pg2=next_line(y1+j, pg2);
    616   }   
     616  }
    617617  unlock();
    618618  screen->unlock();
     
    676676          if (*source!=current_background) *dest=*source;
    677677      }
    678       else 
     678      else
    679679    for (i=0, source=&pg2[x1], dest=&pg1[x+xl-1]; i<xl; i++, source++, dest++)
    680680          *dest=*source;
     
    899899              dirties.unlink((linked_node *)p);
    900900              delete p;
    901             } 
     901            }
    902902            else if (y2>=p->dy2)
    903903              p->dy2=y1-1;
     
    909909              p->dy1=y2+1;
    910910            }
    911           } 
     911          }
    912912          // does it take a y slice off (down)
    913913          else if (y2>=p->dy2 && y1<=p->dy1)
     
    917917            else if (x1<=p->dx1)
    918918              p->dx1=x2+1;
    919             else 
     919            else
    920920            {
    921921              dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, x1-1, p->dy2));
     
    924924          }
    925925          // otherwise it just takes a little chunk off
    926           else 
     926          else
    927927          {
    928928            if (x2>=p->dx2)      { ax1=p->dx1; ax2=x1-1; }
    929929            else if (x1<=p->dx1) { ax1=x2+1; ax2=p->dx2; }
    930             else                { ax1=p->dx1; ax2=x1-1; } 
     930            else                { ax1=p->dx1; ax2=x1-1; }
    931931            if (y2>=p->dy2)      { ay1=y1; ay2=p->dy2; }
    932932            else if (y1<=p->dy1) { ay1=p->dy1; ay2=y2; }
    933933            else                { ay1=y1; ay2=y2; }
    934934            dirties.add_front((linked_node *) new dirty_rect(ax1, ay1, ax2, ay2));
    935          
     935
    936936            if (x2>=p->dx2 || x1<=p->dx1)  { ax1=p->dx1; ax2=p->dx2; }
    937             else                         { ax1=x2+1; ax2=p->dx2; } 
     937            else                         { ax1=x2+1; ax2=p->dx2; }
    938938
    939939            if (y2>=p->dy2)
     
    954954              } else if (y1<=p->dy1)
    955955                dirties.add_front((linked_node *) new dirty_rect(p->dx1, y2+1, p->dx2, p->dy2));
    956               else 
     956              else
    957957                dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
    958958            } else if (y1>p->dy1 && y2<p->dy2)
     
    989989    }
    990990    else
    991     { 
     991    {
    992992      for (p=(dirty_rect *)dirties.first(); i>0; i--)
    993993      {
     
    10011001      if (!dirties.first())
    10021002          i=0;
    1003       else p=tmp;     
    1004     }   
     1003      else p=tmp;
     1004    }
    10051005    else if (!(x2<p->dx1 || y2<p->dy1 || x1>p->dx2 || y1>p->dy2))
    1006     {     
    1007 
    1008 
    1009      
     1006    {
     1007
     1008
     1009
    10101010/*          if (x1<=p->dx1) { a+=p->dx1-x1; ax1=x1; } else ax1=p->dx1;
    1011           if (y1<=p->dy1) { a+=p->dy1-y1; ay1=y1; } else ay1=p->dy1; 
     1011          if (y1<=p->dy1) { a+=p->dy1-y1; ay1=y1; } else ay1=p->dy1;
    10121012          if (x2>=p->dx2) { a+=x2-p->dx2; ax2=x2; } else ax2=p->dx2;
    10131013          if (y2>=p->dy2) { a+=y2-p->dy2; ay2=y2; } else ay2=p->dy2;
    1014      
    1015       if (a<50) 
     1014
     1015      if (a<50)
    10161016      { p->dx1=ax1;                         // then expand the dirty
    10171017        p->dy1=ay1;
     
    10191019        p->dy2=ay2;
    10201020        return ;
    1021       } 
     1021      }
    10221022      else */
    10231023        {
     
    10331033        }
    10341034        p=(dirty_rect *)p->next();
    1035       } else p=(dirty_rect *)p->next();     
    1036    
    1037       } 
     1035      } else p=(dirty_rect *)p->next();
     1036
     1037      }
    10381038      CHECK(x1<=x2 && y1<=y2);
    1039       dirties.add_end((linked_node *)new dirty_rect(x1, y1, x2, y2)); 
     1039      dirties.add_end((linked_node *)new dirty_rect(x1, y1, x2, y2));
    10401040    }
    10411041  }
     
    10871087
    10881088  lock();
    1089   uint8_t *sl=scan_line(y1)+x1; 
     1089  uint8_t *sl=scan_line(y1)+x1;
    10901090  for (y=y1; y<=y2; y++)
    10911091  {
     
    11511151{
    11521152  dirty_rect *dr;
    1153   dr=(dirty_rect *)dirties.first(); 
     1153  dr=(dirty_rect *)dirties.first();
    11541154  while (dr)
    11551155  { dirties.unlink(dr);
     
    12411241}
    12421242
    1243 void image::widget_bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2, 
     1243void image::widget_bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2,
    12441244       uint8_t light, uint8_t med, uint8_t dark)
    12451245{
     
    12871287        if (above[x]==fcolor)
    12881288        { r=new fill_rec(x, y-1, recs);
    1289           recs=r; 
     1289          recs=r;
    12901290        }
    12911291      }
     
    13031303      do
    13041304      {
    1305         sl[x]=color; 
     1305        sl[x]=color;
    13061306        if (y>0)
    13071307        { above=scan_line(y-1);
    13081308          if (x>0 && above[x-1]!=fcolor && above[x]==fcolor)
    13091309          { r=new fill_rec(x, y-1, recs);
    1310             recs=r; 
     1310            recs=r;
    13111311          }
    13121312        }
     
    13151315          if (x>0 && below[x-1]!=fcolor && below[x]==fcolor)
    13161316          { r=new fill_rec(x, y+1, recs);
    1317             recs=r; 
     1317            recs=r;
    13181318          }
    13191319        }
     
    13921392  if (!last_loaded())
    13931393    ret->clear();
    1394   else 
     1394  else
    13951395  {
    13961396    ret->lock();
     
    14031403      for (bo=7, rx=0, x=x1, ditx=x1%4; x<=x2; x++)
    14041404      {
    1405         if (last_loaded()->red(sl2[x])>dither_matrix[ditx+dity]) 
     1405        if (last_loaded()->red(sl2[x])>dither_matrix[ditx+dity])
    14061406          sl1[rx]|=1<<bo;
    14071407        if (bo!=0)
     
    14251425{
    14261426  uint8_t *rev=(uint8_t *)jmalloc(width(), "image tmp::flipped_x"), *sl;
    1427   CONDITION(rev, "memory allocation"); 
     1427  CONDITION(rev, "memory allocation");
    14281428  int y, x, i;
    14291429
     
    14331433  { sl=scan_line(y);
    14341434    for (i=0, x=width()-1; x>=0; x--, i++)
    1435       rev[i]=sl[x]; 
     1435      rev[i]=sl[x];
    14361436    memcpy(sl, rev, width());
    14371437  }
     
    14431443{
    14441444  uint8_t *rev=(uint8_t *)jmalloc(width(), "image::flipped_y"), *sl;
    1445   CONDITION(rev, "memory allocation"); 
     1445  CONDITION(rev, "memory allocation");
    14461446  int y;
    14471447
     
    14671467    sl=scan_line(y);
    14681468    for (x=width(); x; x--, sl++)
    1469       if (*sl) 
     1469      if (*sl)
    14701470        *sl=color;
    14711471  }
  • abuse/trunk/src/imlib/image.hpp

    r115 r124  
    129129    image(bFILE *fp);
    130130    image(int16_t width, int16_t height,
    131           uint8_t *page_buffer = NULL, int16_t create_descriptor = 0); 
     131          uint8_t *page_buffer = NULL, int16_t create_descriptor = 0);
    132132    ~image();
    133133
  • abuse/trunk/src/imlib/image24.cpp

    r56 r124  
    1818  w=width;
    1919  h=height;
    20  
     20
    2121  data=(unsigned char *)jmalloc(width*height*3,"image24");
    22   CONDITION(data,"unable to alloc enough memory for 24 bit image");   
     22  CONDITION(data,"unable to alloc enough memory for 24 bit image");
    2323}
    2424
    25 void image24::clear(unsigned char r, unsigned char g, 
     25void image24::clear(unsigned char r, unsigned char g,
    2626                    unsigned char b)
    2727{
    2828  int x,y;
    29   unsigned char *p=data; 
     29  unsigned char *p=data;
    3030  for (y=0;y<h;y++)
    31   {   
     31  {
    3232    for (x=0;x<w;x++)
    3333    {
     
    3535      *(p++)=g;
    3636      *(p++)=b;
    37     }   
    38   } 
     37    }
     38  }
    3939}
    4040
     
    4444  if (x>=w || x<0 || y>=h || y<0)           // check to make sure this pixel is in the image
    4545    return ;
    46   unsigned char *pix=data+(y*w*3+x*3);   
     46  unsigned char *pix=data+(y*w*3+x*3);
    4747  int result;
    48  
     48
    4949  result=(int)(*pix)+r_error*error_mult/32;
    5050  if (result>255)
    5151    *pix=255;
    5252  else if (result<0) *pix=0;
    53   else *pix=result; 
     53  else *pix=result;
    5454  pix++;
    5555
     
    6060  else *pix=result;
    6161  pix++;
    62  
     62
    6363  result=(int)(*pix)+b_error*error_mult/32;
    6464  if (result>255)
     
    7070
    7171image *image24::dither(palette *pal)
    72 { 
     72{
    7373  int i,j,closest;
    74   unsigned char r,g,b,*cur_pixel=data,ar,ag,ab; 
    75   image *dest=new image(w,h); 
     74  unsigned char r,g,b,*cur_pixel=data,ar,ag,ab;
     75  image *dest=new image(w,h);
    7676  for (j=0;j<h;j++)
    77   {   
     77  {
    7878    for (i=0;i<w;i++)
    7979    {
    8080      r=(*cur_pixel);  cur_pixel++;
    8181      g=(*cur_pixel);  cur_pixel++;
    82       b=(*cur_pixel);  cur_pixel++;     
     82      b=(*cur_pixel);  cur_pixel++;
    8383      closest=pal->find_closest(r,g,b);           // find the closest match in palette
    8484      dest->putpixel(i,j,closest);               // set the pixel to this color
    8585
    8686      pal->get(closest,ar,ag,ab);                   // see what the actual color we used was
    87  
    88       add_error(i+1,j,ar-r,ag-g,ab-b,8); 
    89       add_error(i+2,j,ar-r,ag-g,ab-b,4); 
     87
     88      add_error(i+1,j,ar-r,ag-g,ab-b,8);
     89      add_error(i+2,j,ar-r,ag-g,ab-b,4);
    9090
    9191      add_error(i-2,j+1,ar-r,ag-g,ab-b,2);
     
    9595      add_error(i+2,j+1,ar-r,ag-g,ab-b,2);
    9696    }
    97   }   
     97  }
    9898  return dest;
    9999}
  • abuse/trunk/src/imlib/image24.hpp

    r57 r124  
    1818{
    1919  int w,h;
    20   unsigned char *data; 
     20  unsigned char *data;
    2121public :
    2222  int width() { return w; }
    2323  int height() { return h; }
    2424  image24(unsigned short width, unsigned short height,
    25           unsigned char *buffer=NULL);         
    26   void pixel(short x, short y, unsigned char &r, 
     25          unsigned char *buffer=NULL);
     26  void pixel(short x, short y, unsigned char &r,
    2727                               unsigned char &g,
    28                                unsigned char &b)
     28                   unsigned char &b)
    2929    { CHECK(x>=0 && y>=0 && x<w && y<h);
    3030      unsigned char *p=data+y*w*3; r=*(p++); g=*(p++); b=*(p++); }
    3131  void putpixel(short x, short y, unsigned char r,
    32                                   unsigned char g,
    33                                   unsigned char b)
     32                  unsigned char g,
     33                      unsigned char b)
    3434    { CHECK(x>=0 && y>=0 && x<w && y<h);
    3535      unsigned char *p=data+(y*w+x)*3; *(p++)=r; *(p++)=g; *(p++)=b; }
    3636  unsigned char *scan_line(short y) { return data+y*w*3; }
    3737  image *dither(palette *pal);
    38   void           clear              (unsigned char r=0, unsigned char g=0, 
    39                                      unsigned char b=0);   
    40   void add_error(int x, int y, int r_error, int g_error, int b_error, int error_mult); 
     38  void           clear              (unsigned char r=0, unsigned char g=0,
     39                                unsigned char b=0);
     40  void add_error(int x, int y, int r_error, int g_error, int b_error, int error_mult);
    4141  ~image24() { jfree(data); }
    4242} ;
  • abuse/trunk/src/imlib/include.cpp

    r56 r124  
    4343      for (i=0;i<768;i++,p++)
    4444      {
    45         fprintf(fp,"%d",(int)*p);
    46         if (i==767)
     45    fprintf(fp,"%d",(int)*p);
     46    if (i==767)
    4747        fprintf(fp,"};\n\n");
    48         else
     48    else
    4949        if (i%15==14)
    50         fprintf(fp,",\n    ");
     50    fprintf(fp,",\n    ");
    5151        else fprintf(fp,", ");
    5252      }
    5353    }
    5454    fprintf(fp,"unsigned char %s[%d*%d]={\n    ",tmp_name,
    55             im->width(),im->height()); 
     55            im->width(),im->height());
    5656    int x,y,max=im->width()*im->height()-1;
    5757    for (y=0,i=0;y<im->height();y++)
  • abuse/trunk/src/imlib/input.cpp

    r120 r124  
    4444button_box::button_box(int X, int Y, int ID, int MaxDown, button *Buttons, ifield *Next)
    4545{
    46   x=X; y=Y; id=ID; next=Next; 
     46  x=X; y=Y; id=ID; next=Next;
    4747  buttons=Buttons;
    4848  maxdown=MaxDown;
     
    7575      if (yp1<y1) y1=yp1;
    7676      if (yp2>y2) y2=yp2;
    77     }         
     77    }
    7878  }
    7979}
     
    118118      for (button *b=buttons;!found && b;b=(button *)b->next)  // see if the user clicked on a button
    119119      {
    120         b->area(x1,y1,x2,y2);
    121         if (ev.mouse_move.x>=x1 && ev.mouse_move.x<=x2 &&
    122             ev.mouse_move.y>=y1 && ev.mouse_move.y<=y2)
    123         {
    124           b->handle_event(ev,screen,im);
    125 
    126           int total=0;
    127           button *b2=buttons;
    128           for (;b2;b2=(button *)b2->next)
    129             if (*((int *)b2->read())==0)
    130               total++;
    131 
    132           if (*((int *)b->read())==0)  // did the user press or release the button
    133           {
    134             if (total>maxdown)
    135             {
    136               for (b2=buttons;total>maxdown && b2;b2=(button *)b2->next)
    137                 if ((b!=b2 || maxdown==0) && *((int *)b2->read())==0)
    138                 {
    139                   total--;
    140                   b2->push();
    141                   b2->draw_first(screen);
    142                 }
    143             }
    144             b->draw_first(screen);
    145           } else if (total==0 && maxdown)
    146             b->push();    // don't let the user de-press a button if non others are selected.     
    147 
    148           found=1; // don't look at anymore buttons
    149 
    150         }
     120    b->area(x1,y1,x2,y2);
     121    if (ev.mouse_move.x>=x1 && ev.mouse_move.x<=x2 &&
     122        ev.mouse_move.y>=y1 && ev.mouse_move.y<=y2)
     123    {
     124      b->handle_event(ev,screen,im);
     125
     126      int total=0;
     127      button *b2=buttons;
     128      for (;b2;b2=(button *)b2->next)
     129        if (*((int *)b2->read())==0)
     130          total++;
     131
     132      if (*((int *)b->read())==0)  // did the user press or release the button
     133      {
     134        if (total>maxdown)
     135        {
     136          for (b2=buttons;total>maxdown && b2;b2=(button *)b2->next)
     137            if ((b!=b2 || maxdown==0) && *((int *)b2->read())==0)
     138        {
     139          total--;
     140          b2->push();
     141          b2->draw_first(screen);
     142        }
     143        }
     144        b->draw_first(screen);
     145      } else if (total==0 && maxdown)
     146        b->push();    // don't let the user de-press a button if non others are selected.
     147
     148      found=1; // don't look at anymore buttons
     149
     150    }
    151151      }
    152     } break;   
     152    } break;
    153153  }
    154154}
     
    172172    b->y=y;
    173173    x_on+=(x2-x1+1)+1;
    174   } 
     174  }
    175175}
    176176
    177177void button_box::arrange_up_down()
    178 { 
     178{
    179179  button *b=buttons;
    180180  int y_on=y,x1,y1,x2,y2;
     
    185185    b->x=x;
    186186    y_on+=(y2-y1+1)+1;
    187   } 
     187  }
    188188}
    189189
     
    195195
    196196void button::area(int &x1, int &y1, int &x2, int &y2)
    197 { 
    198   x1=x; y1=y; 
     197{
     198  x1=x; y1=y;
    199199  if (pressed)
    200200  {
     
    205205  {
    206206    if (text)
    207     {   
    208       x2=x+wm->font()->width()*strlen(text)+6; 
    209       y2=y+wm->font()->height()+6; 
     207    {
     208      x2=x+wm->font()->width()*strlen(text)+6;
     209      y2=y+wm->font()->height()+6;
    210210    } else
    211211    {
     
    218218
    219219button::button(int X, int Y, int ID, char const *Text, ifield *Next)
    220 { 
    221   x=X; y=Y; id=ID; 
     220{
     221  x=X; y=Y; id=ID;
    222222  act_id=-1;
    223   text=strcpy((char *)jmalloc(strlen(Text)+1,"input button"),Text); 
     223  text=strcpy((char *)jmalloc(strlen(Text)+1,"input button"),Text);
    224224  up=1; next=Next; act=0;
    225225  visual=NULL;
     
    229229
    230230button::button(int X, int Y, int ID, image *vis, ifield *Next)
    231 { x=X; y=Y; id=ID; text=NULL; 
     231{ x=X; y=Y; id=ID; text=NULL;
    232232  act_id=-1;
    233   visual=vis; up=1; next=Next; act=0; 
     233  visual=vis; up=1; next=Next; act=0;
    234234  pressed=NULL;
    235235}
    236236
    237237button::button(int X, int Y, int ID, image *Depressed, image *Pressed, image *active, ifield *Next)
    238 { x=X; y=Y; id=ID; text=NULL; 
     238{ x=X; y=Y; id=ID; text=NULL;
    239239  act_id=-1;
    240   visual=Depressed; up=1; next=Next; act=0; 
     240  visual=Depressed; up=1; next=Next; act=0;
    241241  pressed=Pressed;
    242242  act_pict=active;
     
    245245
    246246void text_field::change_data(char const *new_data, int new_cursor, // cursor==-1, does not change it.
    247                              int active, image *screen)
     247                 int active, image *screen)
    248248{
    249249  if (strlen(format)<strlen(new_data))
     
    271271    {
    272272      case JK_LEFT : if (cur) { draw_cur(wm->dark_color(),screen); cur--;
    273                            draw_cur(wm->bright_color(),screen); } break; 
     273                           draw_cur(wm->bright_color(),screen); } break;
    274274      case JK_RIGHT : if (cur<(int)strlen(format)-1) { draw_cur(wm->dark_color(),screen); cur++;
    275                            draw_cur(wm->bright_color(),screen); } break; 
    276       case JK_END : if (cur!=last_spot()) 
    277                           { draw_cur(wm->dark_color(),screen); cur=last_spot(); 
    278                             if (cur==(int)strlen(format)-1) cur--; 
    279                            draw_cur(wm->bright_color(),screen); } break; 
    280       case JK_HOME : if (cur) 
     275                           draw_cur(wm->bright_color(),screen); } break;
     276      case JK_END : if (cur!=last_spot())
     277                          { draw_cur(wm->dark_color(),screen); cur=last_spot();
     278                            if (cur==(int)strlen(format)-1) cur--;
     279                           draw_cur(wm->bright_color(),screen); } break;
     280      case JK_HOME : if (cur)
    281281                          { draw_cur(wm->dark_color(),screen); cur=0;
    282                            draw_cur(wm->bright_color(),screen); } break; 
     282                           draw_cur(wm->bright_color(),screen); } break;
    283283      case JK_BACKSPACE : if (cur)
    284284         { draw_cur(wm->dark_color(),screen); cur--;
     
    287287           data[strlen(format)-1]=' ';
    288288           draw_text(screen);
    289            draw_cur(wm->bright_color(),screen); 
     289           draw_cur(wm->bright_color(),screen);
    290290           wm->push_event(new event(id,(char *)this));
    291          } break; 
     291         } break;
    292292      default : if (ev.key>=' ' && ev.key<='~')
    293          { 
    294            draw_cur(wm->dark_color(),screen); 
     293         {
     294           draw_cur(wm->dark_color(),screen);
    295295           for (xx=strlen(format)-1;xx>cur && xx>0;xx--)
    296296             data[xx]=data[xx-1];
     
    298298           if (cur<(int)strlen(format)-1)
    299299             cur++;
    300            data[strlen(format)]=0;
     300       data[strlen(format)]=0;
    301301           draw_text(screen);
    302            draw_cur(wm->bright_color(),screen); 
     302           draw_cur(wm->bright_color(),screen);
    303303           wm->push_event(new event(id,(char *)this));
    304304         } break;
    305305    }
    306   } 
     306  }
    307307}
    308308
     
    323323void text_field::area(int &x1, int &y1, int &x2, int &y2)
    324324{
    325   x1=x; y1=y; 
     325  x1=x; y1=y;
    326326  x2=xend();
    327327  y2=yend();
     
    346346{
    347347  char num[20];
    348   sprintf(num,"%g",Data); 
     348  sprintf(num,"%g",Data);
    349349  int slen=(strlen(Format)>strlen(num) ? strlen(Format) : strlen(num));
    350350  x=X; y=Y; id=ID;
     
    377377void button::draw(int active, image *screen)
    378378{
    379   int x1,y1,x2,y2,color=(active ? wm->bright_color() : wm->medium_color()); 
    380   area(x1,y1,x2,y2); 
     379  int x1,y1,x2,y2,color=(active ? wm->bright_color() : wm->medium_color());
     380  area(x1,y1,x2,y2);
    381381  if (active!=act  && act_id!=-1 && active)
    382382    wm->push_event(new event(act_id,NULL));
    383    
     383
    384384  if (pressed)
    385385  {
     
    401401void button::draw_first(image *screen)
    402402{
    403   if (pressed) 
     403  if (pressed)
    404404    draw(0,screen);
    405405  else
     
    408408    int x1,y1,x2,y2;
    409409    area(x1,y1,x2,y2);
    410    
     410
    411411
    412412    if (up)
    413413    {
    414414      screen->rectangle(x1,y1,x2,y2,wm->black());
    415 //      screen->widget_bar(,wm->bright_color(),wm->medium_color(),wm->dark_color()); 
    416       screen->widget_bar(x1+1,y1+1,x2-1,y2-1,wm->bright_color(),wm->medium_color(),wm->dark_color()); 
     415//      screen->widget_bar(,wm->bright_color(),wm->medium_color(),wm->dark_color());
     416      screen->widget_bar(x1+1,y1+1,x2-1,y2-1,wm->bright_color(),wm->medium_color(),wm->dark_color());
    417417      if (text)
    418418      {
     
    435435        wm->font()->put_string(screen,x+3,y+4,text);
    436436      }
    437     } 
     437    }
    438438  }
    439439}
     
    476476      if (*info=='\n')
    477477      {
    478         h+=fh+1;
    479         w=1;
     478    h+=fh+1;
     479    w=1;
    480480      }
    481       else w+=fw;     
     481      else w+=fw;
    482482    }
    483483    w=maxw;
    484   }     
     484  }
    485485  x1=x;
    486486  y1=y;
     
    489489}
    490490
    491 void info_field::put_para(image *screen, char const *st, int dx, int dy, 
    492                           int xspace, int yspace, JCFont *font, int color)
     491void info_field::put_para(image *screen, char const *st, int dx, int dy,
     492              int xspace, int yspace, JCFont *font, int color)
    493493{
    494494  int ox=dx;
  • abuse/trunk/src/imlib/input.hpp

    r120 r124  
    2121  image *visual,*pressed,*act_pict;
    2222  int act_id;
    23 public : 
     23public :
    2424  button(int X, int Y, int ID, char const *Text, ifield *Next);
    2525  button(int X, int Y, int ID, image *vis, ifield *Next);
     
    2828  virtual void area(int &x1, int &y1, int &x2, int &y2);
    2929  virtual void draw_first(image *screen);
    30   virtual void draw(int active, image *screen); 
     30  virtual void draw(int active, image *screen);
    3131  virtual void handle_event(event &ev, image *screen, InputManager *im);
    3232  void change_visual(image *new_visual);
     
    5151  virtual void area(int &x1, int &y1, int &x2, int &y2);
    5252  virtual void draw_first(image *screen);
    53   virtual void draw(int active, image *screen); 
    54   virtual void handle_event(event &ev, image *screen, InputManager *im); 
     53  virtual void draw(int active, image *screen);
     54  virtual void handle_event(event &ev, image *screen, InputManager *im);
    5555  virtual ~button_box();
    5656  virtual char *read();   // return pointer to first button which is depressed
     
    7474    wm->font()->put_string(screen,xstart()+1,y+3,data);
    7575  }
    76 public : 
    77   text_field(int X, int Y, int ID, char const *Prompt, char const *Format, 
     76public :
     77  text_field(int X, int Y, int ID, char const *Prompt, char const *Format,
    7878                               char const *Data, ifield *Next);
    79   text_field(int X, int Y, int ID, char const *Prompt, char const *Format, 
     79  text_field(int X, int Y, int ID, char const *Prompt, char const *Format,
    8080                               double Data, ifield *Next);
    8181
    8282  virtual void area(int &x1, int &y1, int &x2, int &y2);
    8383  virtual void draw_first(image *screen);
    84   virtual void draw(int active, image *screen); 
     84  virtual void draw(int active, image *screen);
    8585  virtual void handle_event(event &ev, image *screen, InputManager *im);
    86  
     86
    8787  virtual ~text_field() { jfree(prompt); jfree(format); jfree(data); }
    8888  virtual char *read();
    8989  void change_data(char const *new_data, int new_cursor,       // cursor==-1, does not change it.
    90                    int active, image *screen);
     90           int active, image *screen);
    9191} ;
    9292
     
    9696  char *text;
    9797  int w,h;
    98   void put_para(image *screen, char const *st, int dx, int dy, int xspace, 
    99                 int yspace, JCFont *font, int color);
    100 public : 
     98  void put_para(image *screen, char const *st, int dx, int dy, int xspace,
     99        int yspace, JCFont *font, int color);
     100public :
    101101  info_field(int X, int Y, int ID, char const *info, ifield *Next);
    102102  virtual void area(int &x1, int &y1, int &x2, int &y2);
     
    105105  virtual void handle_event(event &ev, image *screen, InputManager *im) { ; }
    106106  virtual char *read() { return text; }
    107   virtual int selectable() { return 0; } 
     107  virtual int selectable() { return 0; }
    108108  virtual ~info_field() { jfree(text); }
    109109} ;
  • abuse/trunk/src/imlib/jmalloc.cpp

    r112 r124  
    4747
    4848struct small_block
    49 { 
     49{
    5050  uint32_t size;             // size of blocks...
    5151  uint32_t alloc_list;            // bit field saying weither each block is allocated or not.
     
    5353#ifdef MEM_CHECK
    5454  char *name[32];
    55 #endif 
     55#endif
    5656} ;
    5757
    58 enum { HI_BLOCK, LOW_BLOCK }; 
     58enum { HI_BLOCK, LOW_BLOCK };
    5959
    6060class block_manager
     
    143143  static_list=(int *)jmalloc(total*sizeof(int),"small static report");
    144144  cache_list=(int *)jmalloc(total*sizeof(int),"small cache report");
    145  
     145
    146146  for (;size<total;size++)
    147147  {
     
    152152    {
    153153      small_block *s=bmanage[i].sblocks[size];
    154       while (s) 
    155       { 
    156         for (x=0;x<32;x++)
    157           if (s->alloc_list&(1<<x))
    158             static_list[size]++;
    159 
    160         s=s->next;
     154      while (s)
     155      {
     156    for (x=0;x<32;x++)
     157      if (s->alloc_list&(1<<x))
     158        static_list[size]++;
     159
     160    s=s->next;
    161161      }
    162162
    163163      s=bmanage[i].cblocks[size];
    164       while (s) 
    165       { 
    166         for (x=0;x<32;x++)
    167           if (s->alloc_list&(1<<x))
    168             cache_list[size]++;
    169 
    170         s=s->next;
     164      while (s)
     165      {
     166    for (x=0;x<32;x++)
     167      if (s->alloc_list&(1<<x))
     168        cache_list[size]++;
     169
     170    s=s->next;
    171171      }
    172172    }
     
    187187      for (int j=0;j<32;j++)
    188188      {
    189         if (s->alloc_list&bit)
    190         {
    191           void *next=(void *)(*(((intptr_t *)addr)));
    192           if ((intptr_t)next!=(intptr_t)s)
    193           {
    194             fprintf(stderr,"inspect : bad pointer\n");
    195             return ;       
    196           }
    197         }
    198         bit=bit<<1;
    199         addr+=s->size+4;
    200       } 
     189    if (s->alloc_list&bit)
     190    {
     191      void *next=(void *)(*(((intptr_t *)addr)));
     192      if ((intptr_t)next!=(intptr_t)s)
     193      {
     194        fprintf(stderr,"inspect : bad pointer\n");
     195        return ;   
     196      }
     197    }
     198    bit=bit<<1;
     199    addr+=s->size+4;
     200      }   
    201201    }
    202202  }
     
    211211  memory_node *f=sfirst;
    212212  for (;f;f=f->next,i++)
    213   {   
     213  {
    214214    fprintf(fp, "%4d   %p (%ld) %4ld      ",
    215215            i, f, (long int)((char *)f - (char *)sfirst), (long int)f->size);
     
    220220#endif
    221221    fprintf(fp,"\n");
    222   }   
     222  }
    223223  for (i=0;i<JM_SMALL_SIZE;i++)
    224224  {
    225225    for (small_block *s=sblocks[i];s;s=s->next)
    226     {     
    227       fprintf(fp,"*** Small Block size = %d ***\n",i);     
     226    {
     227      fprintf(fp,"*** Small Block size = %d ***\n",i);
    228228      uint32_t bit=1;
    229229      char *addr=((char *)(s+1));
    230230      for (int j=0;j<32;j++)
    231231      {
    232         fprintf(fp,"%p   ",addr);
    233         if (s->alloc_list&bit)
    234         {
    235 #ifdef MEM_CHECK
    236           fprintf(fp,"%s\n",s->name[j]);
     232    fprintf(fp,"%p   ",addr);
     233    if (s->alloc_list&bit)
     234    {
     235#ifdef MEM_CHECK
     236      fprintf(fp,"%s\n",s->name[j]);
    237237#else
    238           fprintf(fp,"allocated\n");
    239 #endif   
    240         } else fprintf(fp,"FREE\n");
    241         bit=bit<<1;
    242         addr+=s->size+4;
     238      fprintf(fp,"allocated\n");
     239#endif   
     240    } else fprintf(fp,"FREE\n");
     241    bit=bit<<1;
     242    addr+=s->size+4;
    243243      }
    244244    }
     
    249249  i=0;
    250250  for (f=cfirst;f;f=f->next,i++)
    251   {   
     251  {
    252252    fprintf(fp,"%4d   %p %4d      ",i,f,f->size);
    253253#ifdef MEM_CHECK
     
    257257#endif
    258258    fprintf(fp,"\n");
    259   }   
     259  }
    260260  for (i=0;i<JM_SMALL_SIZE;i++)
    261261  {
    262262    for (small_block *s=cblocks[i];s;s=s->next)
    263     {     
    264       fprintf(fp,"*** Small Block size = %d ***\n",i);     
     263    {
     264      fprintf(fp,"*** Small Block size = %d ***\n",i);
    265265      uint32_t bit=1;
    266266      char *addr=((char *)(s+1));
    267267      for (int j=0;j<32;j++)
    268268      {
    269         fprintf(fp,"%p   ",addr);
    270         if (s->alloc_list&bit)
    271         {
    272 #ifdef MEM_CHECK
    273           fprintf(fp,"%s\n",s->name[j]);
     269    fprintf(fp,"%p   ",addr);
     270    if (s->alloc_list&bit)
     271    {
     272#ifdef MEM_CHECK
     273      fprintf(fp,"%s\n",s->name[j]);
    274274#else
    275           fprintf(fp,"allocated\n");
    276 #endif   
    277         } else fprintf(fp,"FREE\n");
    278         bit=bit<<1;
    279         addr+=s->size+4;
     275      fprintf(fp,"allocated\n");
     276#endif   
     277    } else fprintf(fp,"FREE\n");
     278    bit=bit<<1;
     279    addr+=s->size+4;
    280280      }
    281281    }
     
    324324   * > JM_SMALL_SIZE. All systems I know start pointer address pretty high,
    325325   * but this can be a portability concern. */
    326  
    327   slast=sfirst=(memory_node *)(((char *)block)+JM_SMALL_SIZE);   
     326
     327  slast=sfirst=(memory_node *)(((char *)block)+JM_SMALL_SIZE);
    328328  sfirst->size=-(block_size-sizeof(memory_node)-JM_SMALL_SIZE);
    329329  sfirst->next=NULL;
     
    352352      if ((intptr_t)s==break_mem_point)
    353353        break_mem_fun();
    354 #endif     
     354#endif
    355355      intptr_t *addr=(intptr_t *)(((char *)s)+sizeof(small_block));
    356356      *addr=(intptr_t)s;
     
    362362      while (1)        // we already know there is a bit free
    363363      {
    364         if ((s->alloc_list&bit)==0)
    365         {
    366           s->alloc_list|=bit;
    367 #ifdef MEM_CHECK
    368           s->name[i]=strcpy((char *)malloc(strlen(name)+1),name);
    369 #endif         
    370           *((intptr_t *)addr)=(intptr_t)s;
    371 
    372 #ifdef MEM_CHECK
    373           if ((intptr_t)addr==break_mem_point)
     364    if ((s->alloc_list&bit)==0)
     365    {
     366      s->alloc_list|=bit;
     367#ifdef MEM_CHECK
     368      s->name[i]=strcpy((char *)malloc(strlen(name)+1),name);
     369#endif         
     370      *((intptr_t *)addr)=(intptr_t)s;
     371
     372#ifdef MEM_CHECK
     373      if ((intptr_t)addr==break_mem_point)
    374374            break_mem_fun();
    375375#endif
    376376
    377           return (void *)(addr+4);
    378         }
    379         i++;
    380         bit=bit<<1;
    381         addr+=size+4;
    382       }     
    383     }               
     377      return (void *)(addr+4);
     378    }
     379    i++;
     380    bit=bit<<1;
     381    addr+=size+4;
     382      }
     383    }
    384384  }
    385385
     
    391391
    392392  if (s->size-size>(int)sizeof(memory_node)+4)  // is there enough space to split the block?
    393   {   
     393  {
    394394    memory_node *p=(memory_node *)((char *)s+sizeof(memory_node)+size);
    395395    if (s==slast)
     
    431431      s->name[0]=strcpy((char *)malloc(strlen(name)+1),name);
    432432
    433 #endif     
     433#endif
    434434      intptr_t *addr=(intptr_t *)(((char *)s)+sizeof(small_block));
    435435      *addr=(intptr_t)s;
     
    445445      while (1)        // we already know there is a bit free
    446446      {
    447         if ((s->alloc_list&bit)==0)
    448         {
    449           s->alloc_list|=bit;
    450 #ifdef MEM_CHECK
    451           s->name[i]=strcpy((char *)malloc(strlen(name)+1),name);
    452           if ((intptr_t)s==break_mem_point)
    453             break_mem_fun();
    454 #endif         
    455           *((intptr_t *)addr)=(intptr_t)s;
    456           return (void *)(addr+4);
    457         }
    458         i++;
    459         bit=bit<<1;
    460         addr+=size+4;
    461       }     
    462     }               
     447    if ((s->alloc_list&bit)==0)
     448    {
     449      s->alloc_list|=bit;
     450#ifdef MEM_CHECK
     451      s->name[i]=strcpy((char *)malloc(strlen(name)+1),name);
     452      if ((intptr_t)s==break_mem_point)
     453        break_mem_fun();
     454#endif         
     455      *((intptr_t *)addr)=(intptr_t)s;
     456      return (void *)(addr+4);
     457    }
     458    i++;
     459    bit=bit<<1;
     460    addr+=size+4;
     461      }
     462    }
    463463  }
    464464
     
    478478      slast->size+=size+sizeof(memory_node);
    479479      memory_node *nc=(memory_node *)(((char *)(slast)) + (-slast->size+sizeof(memory_node)));
    480      
     480
    481481      nc->next=NULL;
    482482      nc->size=size;
    483483#ifdef MEM_CHECK
    484       nc->name=strcpy((char *)malloc(strlen(name)+1),name);     
     484      nc->name=strcpy((char *)malloc(strlen(name)+1),name);
    485485      if ((intptr_t)nc==break_mem_point)
    486486        break_mem_fun();
    487 #endif     
     487#endif
    488488      if (!clast)
    489489        cfirst=nc;
     
    544544      for (;n!=s;n=n->next) l=n;
    545545#ifdef MEM_CHECK
    546       if (!n) 
     546      if (!n)
    547547      { printf("Free small block error\n"); }
    548548#endif
     
    551551      else l->next=s->next;
    552552      cache_free(s);
    553     }     
     553    }
    554554  } else
    555555  {
     
    558558    for (;n && n!=o;n=n->next) last=n;
    559559#ifdef MEM_CHECK
    560     if (!n) 
     560    if (!n)
    561561    { printf("Free cached big block error\n"); }
    562562    free(o->name);
    563563#endif
    564    
     564
    565565    if (last && last->size<0)   // can we add into last block
    566566    {
     
    574574      last=prev;
    575575    } else o->size=-o->size;
    576    
     576
    577577    if (!o->next)           // if no next block, then we should add back into static memory
    578578    {
     
    582582      if (slast->size>0)    // if last static is allocated then create a new free static at end of list
    583583      {
    584         slast->next=o;
    585         slast=o;
    586       } else     
    587         slast->size+=o->size-sizeof(memory_node);  // else just increase the size of last block
     584    slast->next=o;
     585    slast=o;
     586      } else
     587    slast->size+=o->size-sizeof(memory_node);  // else just increase the size of last block
    588588    } else if (o->next->size<0)   // see if we can add into next block
    589589    {
    590590      o->next->size+=o->size-sizeof(memory_node);
    591       if (last)     
    592         last->next=o->next;
     591      if (last)
     592    last->next=o->next;
    593593      else
    594594        cfirst=o->next;
    595595    }
    596   } 
     596  }
    597597}
    598598
     
    636636      else l->next=s->next;
    637637      static_free(s);
    638     }     
     638    }
    639639  } else
    640640  {
     
    660660    if (!n) { printf("Free static big block error\n"); }
    661661#endif
    662    
     662
    663663    if (last && last->size<0)
    664664    {
    665665      if (o==slast) slast=last;
    666666      last->next=o->next;
    667       last->size-=o->size+sizeof(memory_node); 
    668     } else o->size=-o->size;           
    669   } 
     667      last->size-=o->size+sizeof(memory_node);   
     668    } else o->size=-o->size;
     669  }
    670670}
    671671
     
    677677    switch (bmanage[i].block_type)
    678678    {
    679       case HI_BLOCK : 
     679      case HI_BLOCK :
    680680      { free(bmanage[i].addr); } break;
    681681    }
     
    687687{ jmalloc_uninit(); }
    688688
    689  
     689
    690690int jmalloc_max_size = 3072000;
    691691int jmalloc_min_low_size = 0x1000;
     
    713713    {
    714714      mem=malloc(size+0x10000);
    715       if (!mem) size-=0x100;       
     715      if (!mem) size-=0x100;
    716716    }
    717717    free(mem);
     
    722722    {
    723723      mem=malloc(size);
    724       if (!mem) size-=0x100;       
     724      if (!mem) size-=0x100;
    725725    }
    726726#endif
     
    728728    {
    729729      bmanage[bmanage_total].init(mem,size,HI_BLOCK);
    730       bmanage_total++;     
     730      bmanage_total++;
    731731      fprintf(stderr,"Added himem block (%d bytes)\n",size);
    732732    }
    733733
    734734/*    bmanage[bmanage_total].init(malloc(2039552),2039552,HI_BLOCK);
    735     bmanage_total++;     
     735    bmanage_total++;
    736736    bmanage[bmanage_total].init(malloc(150224),150224,HI_BLOCK);
    737737    bmanage_total++;      */
     
    750750{
    751751  int32_t size=0;
    752   for (int i=0;i<bmanage_total;i++) 
     752  for (int i=0;i<bmanage_total;i++)
    753753    size+=bmanage[i].available();
    754754  return size;
     
    758758{
    759759  int32_t size=0;
    760   for (int i=0;i<bmanage_total;i++) 
     760  for (int i=0;i<bmanage_total;i++)
    761761    size+=bmanage[i].allocated();
    762762  return size;
     
    765765
    766766void *jmalloc(int32_t size, char const *name)
    767 { 
     767{
    768768  if (!bmanage_total)
    769769    return malloc(size);
     
    786786    }
    787787    free_up_memory();
    788   } while (1); 
     788  } while (1);
    789789}
    790790
     
    793793  if (ptr == NULL)
    794794    return;
    795   if (!bmanage_total) 
    796   { 
    797     free(ptr); 
    798     return ; 
     795  if (!bmanage_total)
     796  {
     797    free(ptr);
     798    return ;
    799799  }
    800800  for (int i=0;i<bmanage_total;i++)
     
    803803      if (ptr<=(void *)bmanage[i].slast)  // is it in static space?
    804804      {
    805         bmanage[i].static_free(ptr);
    806         return ;
     805    bmanage[i].static_free(ptr);
     806    return ;
    807807      } else if (ptr<=(void *)(((char *)bmanage[i].sfirst)+bmanage[i].block_size))  // or cache space?
    808808      {
    809         bmanage[i].cache_free(ptr);
    810         return ;
    811       }
    812     }
    813 
    814   free (ptr); 
     809    bmanage[i].cache_free(ptr);
     810    return ;
     811      }
     812    }
     813
     814  free (ptr);
    815815//  fprintf(stderr,"jfree : bad pointer\n");
    816816}
     
    818818
    819819void *jrealloc(void *ptr, int32_t size, char const *name)
    820 { 
     820{
    821821  if (!ptr) return jmalloc(size,name);
    822822  if (!bmanage_total) { return realloc(ptr,size); }
     
    826826  int32_t old_size=0;
    827827  for (int i=0;i<bmanage_total;i++)
    828     if (ptr>=(void *)bmanage[i].sfirst && 
    829         ptr<=(void *)(((char *)bmanage[i].sfirst)+bmanage[i].block_size))
    830     {
    831       old_size=bmanage[i].pointer_size(ptr); 
     828    if (ptr>=(void *)bmanage[i].sfirst &&
     829    ptr<=(void *)(((char *)bmanage[i].sfirst)+bmanage[i].block_size))
     830    {
     831      old_size=bmanage[i].pointer_size(ptr);
    832832      if (ptr<=(void *)bmanage[i].slast)
    833833      {
    834         int sp=alloc_space; sp=ALLOC_SPACE_STATIC;
    835         void *nptr=jmalloc(size,name);
    836         if (size>old_size)
    837           memcpy(nptr,ptr,old_size);
    838         else memcpy(nptr,ptr,size);
    839         bmanage[i].static_free(ptr);
    840         alloc_space=sp;
    841         return nptr;
     834    int sp=alloc_space; sp=ALLOC_SPACE_STATIC;
     835    void *nptr=jmalloc(size,name);
     836    if (size>old_size)
     837      memcpy(nptr,ptr,old_size);
     838     else memcpy(nptr,ptr,size);
     839    bmanage[i].static_free(ptr);
     840    alloc_space=sp;
     841    return nptr;
    842842      } else
    843843      {
    844         int sp=alloc_space; sp=ALLOC_SPACE_CACHE;
    845         void *nptr=jmalloc(size,name);
    846         if (size>old_size)
    847           memcpy(nptr,ptr,old_size);
    848         else memcpy(nptr,ptr,size);
    849         bmanage[i].cache_free(ptr);
    850         alloc_space=sp;
    851         return nptr;
     844    int sp=alloc_space; sp=ALLOC_SPACE_CACHE;
     845    void *nptr=jmalloc(size,name);
     846    if (size>old_size)
     847      memcpy(nptr,ptr,old_size);
     848    else memcpy(nptr,ptr,size);
     849    bmanage[i].cache_free(ptr);
     850    alloc_space=sp;
     851    return nptr;
    852852      }
    853853    }
     
    864864void mem_report(char const *filename)
    865865{
    866         char *reportpath;
    867         reportpath = (char *)jmalloc( strlen( get_save_filename_prefix() ) + strlen( filename ) + 1, "reportpath" );
    868         sprintf( reportpath, "%s%s", get_save_filename_prefix(), filename );
    869 
    870         FILE *fp = fopen( reportpath, "wb" );
    871         if( fp != NULL )        /* make sure we actually got a file */
    872         {
    873                 for( int i = 0; i < bmanage_total; i++ )
    874                 {
    875                         bmanage[i].report( fp );
    876                 }
    877                 fclose( fp );
    878         }
    879         jfree( reportpath );
     866    char *reportpath;
     867    reportpath = (char *)jmalloc( strlen( get_save_filename_prefix() ) + strlen( filename ) + 1, "reportpath" );
     868    sprintf( reportpath, "%s%s", get_save_filename_prefix(), filename );
     869
     870    FILE *fp = fopen( reportpath, "wb" );
     871    if( fp != NULL )    /* make sure we actually got a file */
     872    {
     873        for( int i = 0; i < bmanage_total; i++ )
     874        {
     875            bmanage[i].report( fp );
     876        }
     877        fclose( fp );
     878    }
     879    jfree( reportpath );
    880880}
    881881
    882882void *operator new( size_t size)
    883 { 
     883{
    884884  return jmalloc(size,"::new object");
    885 } 
     885}
    886886
    887887void operator delete(void *ptr)
     
    905905      if (ptr<=(void *)bmanage[i].slast)  // is it in static space?
    906906      {
    907         return bmanage[i].valid_static_ptr(ptr);
     907    return bmanage[i].valid_static_ptr(ptr);
    908908      } else if (ptr<=(void *)(((char *)bmanage[i].sfirst)+bmanage[i].block_size))  // or cache space?
    909909      {
    910         return bmanage[i].valid_cache_ptr(ptr);
     910    return bmanage[i].valid_cache_ptr(ptr);
    911911      }
    912912    }
  • abuse/trunk/src/imlib/jrand.cpp

    r56 r124  
    2121{
    2222  // make sure random table is always the same.
    23   unsigned long rseed=('F'<<24)|('U'<<16)|('C'<<8)|'K'; 
     23  unsigned long rseed=('F'<<24)|('U'<<16)|('C'<<8)|'K';
    2424  int i;
    2525  unsigned short *tp=rtable;
  • abuse/trunk/src/imlib/jrand.hpp

    r57 r124  
    1212
    1313#define RAND_TABLE_SIZE 1024
    14 extern unsigned short rtable[RAND_TABLE_SIZE];     // can be used directly when 
     14extern unsigned short rtable[RAND_TABLE_SIZE];     // can be used directly when
    1515extern unsigned short rand_on;                     // speed is of essence
    1616
  • abuse/trunk/src/imlib/jwindow.cpp

    r120 r124  
    2929//
    3030void set_frame_size(int x)
    31 { 
     31{
    3232    if(x < 1)
    3333        x = 1;
     
    4141int WindowManager::window_in_area(int x1, int y1, int x2, int y2)
    4242{
    43   for (Jwindow *f=first;f;f=f->next) 
     43  for (Jwindow *f=first;f;f=f->next)
    4444    if (f->x<=x2 && f->y<=y2 && f->x+f->l-1>=x1 && f->y+f->h-1>=y1)
    4545      return 1;
     
    7777  for (p=first;p;p=p->next)
    7878    if (p->is_hidden())
    79       show_window(p);     
     79      show_window(p);
    8080}
    8181
     
    8888  {
    8989    for (k=first;k->next!=j;k=k->next)
    90       k->screen->add_dirty(j->x-k->x,j->y-k->y, 
     90      k->screen->add_dirty(j->x-k->x,j->y-k->y,
    9191                   j->x+j->l-1-k->x,j->y+j->h-1-k->y);
    92     k->screen->add_dirty(j->x-k->x,j->y-k->y, 
     92    k->screen->add_dirty(j->x-k->x,j->y-k->y,
    9393                   j->x+j->l-1-k->x,j->y+j->h-1-k->y);
    9494    k->next=j->next;
     
    130130
    131131      if ((ev.type==EV_MOUSE_BUTTON && ev.mouse_button==1 && ev.window &&
    132            ev.mouse_move.x>=ev.window->x && ev.mouse_move.y>=ev.window->y &&
    133            ev.mouse_move.x<ev.window->x+ev.window->l && ev.mouse_move.y<ev.window->y+ev.window->y1()))
     132       ev.mouse_move.x>=ev.window->x && ev.mouse_move.y>=ev.window->y &&
     133       ev.mouse_move.x<ev.window->x+ev.window->l && ev.mouse_move.y<ev.window->y+ev.window->y1()))
    134134      {
    135         if (ev.mouse_move.x-ev.window->x<11) closew=1;
    136         else if (ev.window->is_moveable()) movew=1;
     135    if (ev.mouse_move.x-ev.window->x<11) closew=1;
     136    else if (ev.window->is_moveable()) movew=1;
    137137      } else if (grab)
    138138        ev.window=grab;
     
    141141        closew=1;
    142142
    143      
    144    
     143
     144
    145145      if (closew)
    146146        ev.type=EV_CLOSE_WINDOW;
    147147      else if (movew)
    148       { 
    149         int red=0;
    150         if (ev.window==first)       // see if we need to raise the window
    151         {
    152           first=first->next;
    153           if (first)
    154             red=1;
    155         }
    156         else
    157         {
    158           Jwindow *last=first;
    159           for (;last->next!=ev.window;last=last->next);
    160           if (ev.window->next)
    161             red=1;
    162           last->next=ev.window->next;
    163         }
    164         if (!first)
    165           first=ev.window;
    166         else
    167         {
    168           Jwindow *last=first;
    169           for (;last->next;last=last->next);
    170           last->next=ev.window;
    171         }
    172         ev.window->next=NULL;
    173         if (red)
    174         {
    175           Jwindow *j=ev.window;
    176 /*        screen->add_dirty(j->x,j->y,j->x+j->l-1,j->y+j->h-1);
    177           for (p=first;p!=j;p=p->next)
    178             p->screen->add_dirty(j->x-p->x,j->y-p->y,j->x+j->l-1-p->x,j->y+j->h-1-p->y);*/
    179           j->screen->add_dirty(0,0,j->l-1,j->h-1);
    180           flush_screen();
    181         }
     148      {   
     149    int red=0;
     150    if (ev.window==first)       // see if we need to raise the window
     151    {
     152      first=first->next;
     153      if (first)
     154        red=1;
     155    }
     156    else
     157    {
     158      Jwindow *last=first;
     159      for (;last->next!=ev.window;last=last->next);
     160      if (ev.window->next)
     161        red=1;
     162      last->next=ev.window->next;
     163    }
     164    if (!first)
     165      first=ev.window;
     166    else
     167    {
     168      Jwindow *last=first;
     169      for (;last->next;last=last->next);
     170      last->next=ev.window;
     171    }
     172    ev.window->next=NULL;
     173    if (red)
     174    {
     175      Jwindow *j=ev.window;
     176/*      screen->add_dirty(j->x,j->y,j->x+j->l-1,j->y+j->h-1);
     177      for (p=first;p!=j;p=p->next)
     178        p->screen->add_dirty(j->x-p->x,j->y-p->y,j->x+j->l-1-p->x,j->y+j->h-1-p->y);*/
     179      j->screen->add_dirty(0,0,j->l-1,j->h-1);
     180      flush_screen();
     181    }
    182182
    183183        state=dragging;
     
    204204       ev.window_position.y=ev.mouse_move.y+drag_mousey;
    205205    }
    206   } 
     206  }
    207207  if (ev.type==EV_REDRAW)
    208208  {
    209     for (j=first;j;j=j->next) 
     209    for (j=first;j;j=j->next)
    210210       j->screen->add_dirty(ev.redraw.x1-j->x,ev.redraw.y1-j->y,
    211                      ev.redraw.x2-j->x,ev.redraw.y2-j->y);
     211             ev.redraw.x2-j->x,ev.redraw.y2-j->y);
    212212    screen->add_dirty(ev.redraw.x1,ev.redraw.y1,ev.redraw.x2,ev.redraw.y2);
    213213    flush_screen();
     
    244244}
    245245
    246 WindowManager::WindowManager(image *Screen, palette *Pal, int Hi, 
    247                               int Med, int Low, JCFont *Font)
     246WindowManager::WindowManager(image *Screen, palette *Pal, int Hi,
     247                             int Med, int Low, JCFont *Font)
    248248{
    249249    wm = this;
     
    315315    if(y > screen->height () - 4)
    316316        y = screen->height () - 10;
    317  
     317
    318318    Jwindow * j = new Jwindow (x, y, l, h, fields, name);
    319319    j->show();
     
    324324void WindowManager::flush_screen()
    325325{
    326   Jwindow *p,*q;
    327 
    328   int mx=0,my=0;
    329   image *mouse_pic=NULL,*mouse_save=NULL;
    330  
    331   if (has_mouse())
    332   {   
    333     mouse_pic=eh->mouse_sprite()->visual;
    334     mouse_save=eh->mouse_sprite()->save;
    335     mx=eh->mouse->drawx();
    336     my=eh->mouse->drawy();
    337 
    338     screen->put_part(mouse_save,0,0,mx,my,mx+mouse_pic->width()-1,my+mouse_pic->height()-1);
    339     mouse_pic->put_image(screen,mx,my,1);
    340   }
    341  
    342   for (p=first;p;p=p->next)
    343     if (!p->is_hidden())
    344        screen->delete_dirty(p->x,p->y,p->x+p->l-1,p->y+p->h-1);
    345   update_dirty(screen);
    346 
    347   if (has_mouse())
    348     mouse_save->put_image(screen,mx,my);
    349 
    350 
    351   for (p=first;p;p=p->next)
    352   {
    353     if (!p->is_hidden())
    354     {
    355       if (has_mouse())
    356       {     
    357         p->screen->put_part(mouse_save,0,0,mx-p->x,my-p->y,
    358                             mx-p->x+mouse_pic->width()-1,
    359                             my-p->y+mouse_pic->height()-1);
    360         if (has_mouse())
    361         mouse_pic->put_image(p->screen,mx-p->x,my-p->y,1);
    362       }
    363      
    364 
    365 //      screen->delete_dirty(p->x,p->y,p->x+p->l-1,p->y+p->h-1);
    366       for (q=p->next;q;q=q->next)
    367         if (!q->is_hidden())
    368           p->screen->delete_dirty(q->x-p->x,
    369                               q->y-p->y,
    370                               q->x+q->l-1-p->x,
    371                               q->y+q->h-1-p->y);
    372       update_dirty(p->screen,p->x,p->y);
    373       if (has_mouse())
    374          mouse_save->put_image(p->screen,mx-p->x,my-p->y,0);
    375     }
    376   }
     326    Jwindow *p, *q;
     327
     328    int mx = 0, my = 0;
     329    image *mouse_pic = NULL, *mouse_save = NULL;
     330
     331    if(has_mouse())
     332    {
     333        mouse_pic = eh->mouse_sprite()->visual;
     334        mouse_save = eh->mouse_sprite()->save;
     335        mx = eh->mouse->drawx();
     336        my = eh->mouse->drawy();
     337
     338        screen->put_part(mouse_save, 0, 0, mx, my,
     339                         mx + mouse_pic->width() - 1,
     340                         my + mouse_pic->height() - 1);
     341        mouse_pic->put_image(screen, mx, my, 1);
     342    }
     343
     344    for(p = first; p; p = p->next)
     345        if(!p->is_hidden())
     346            screen->delete_dirty(p->x, p->y, p->x + p->l - 1, p->y + p->h - 1);
     347    update_dirty(screen);
     348
     349    if(has_mouse())
     350        mouse_save->put_image(screen, mx, my);
     351
     352    for(p = first; p; p = p->next)
     353    {
     354        if(p->is_hidden())
     355            continue;
     356
     357        if(has_mouse())
     358        {
     359            p->screen->put_part(mouse_save, 0, 0, mx - p->x, my - p->y,
     360                                mx - p->x + mouse_pic->width() - 1,
     361                                my - p->y + mouse_pic->height() - 1);
     362            if(has_mouse())
     363                mouse_pic->put_image(p->screen, mx - p->x, my - p->y, 1);
     364        }
     365
     366//          screen->delete_dirty(p->x, p->y, p->x+p->l-1, p->y+p->h-1);
     367        for(q = p->next; q; q = q->next)
     368            if(!q->is_hidden())
     369                p->screen->delete_dirty(q->x - p->x, q->y - p->y,
     370                                        q->x + q->l - 1 - p->x,
     371                                        q->y + q->h - 1 - p->y);
     372        update_dirty(p->screen, p->x, p->y);
     373        if(has_mouse())
     374            mouse_save->put_image(p->screen, mx - p->x, my - p->y, 0);
     375    }
    377376}
    378377
     
    403402{
    404403    l = 0;
    405     h = 0; 
     404    h = 0;
    406405    _hidden = false;
    407406    _moveable = true;
     
    471470        i->set_owner(this);
    472471        i->area(x1, y1, x2, y2);
    473         if ((int)y2 > (int)h) 
     472        if ((int)y2 > (int)h)
    474473            h = y2;
    475         if ((int)x2 > (int)l) 
     474        if ((int)x2 > (int)l)
    476475            l = x2;
    477476    }
     
    492491    if(_name)
    493492    {
     493fprintf(stderr, "redrawing '%s'\n", _name);
    494494        if (right_border() >= 1)
    495495        {
     
    499499                                l - left_border(), h - bottom_border(), low,
    500500                                med, hi);
    501          
     501
    502502          else
    503503            screen->line (left_border() - 1, top_border() - 1,
     
    508508      screen->widget_bar (3, 3, top_border() - 3, top_border() - 4, hi, med, low);     // draws the 'close' button
    509509    }
    510  
     510
    511511  else
    512512    {
     513fprintf(stderr, "redrawing unknown'\n");
    513514      if (right_border() >= 1)
    514515        {
     
    518519                                l - left_border(), h - bottom_border(), low,
    519520                                med, hi);
    520          
     521
    521522          else
    522523            screen->line (left_border() - 1, jw_top + 4, right_border() - 1,
     
    559560
    560561ifield *InputManager::unlink(int id)     // unlinks ID from fields list and return the pointer to it
    561 { 
     562{
    562563  for (ifield *i=first,*last=NULL;i;i=i->next)
    563564  {
    564     if (i->id==id) 
     565    if (i->id==id)
    565566    {
    566567      if (i==first)
    567         first=first->next;
     568    first=first->next;
    568569      else
    569570        last->next=i->next;
     
    579580}
    580581
    581 InputManager::~InputManager() 
    582 { ifield *i; 
    583   while (first) 
    584   { i=first; 
    585     first=first->next; 
    586     delete i; 
    587   } 
    588 } 
     582InputManager::~InputManager()
     583{ ifield *i;
     584  while (first)
     585  { i=first;
     586    first=first->next;
     587    delete i;
     588  }
     589}
    589590
    590591void InputManager::clear_current()
     
    618619      for (i=first;i;i=i->next)
    619620      {
    620         i->area(x1,y1,x2,y2);
    621         if (ev.mouse_move.x>=x1 && ev.mouse_move.y>=y1 &&
    622             ev.mouse_move.x<=x2 && ev.mouse_move.y<=y2)
     621    i->area(x1,y1,x2,y2);
     622    if (ev.mouse_move.x>=x1 && ev.mouse_move.y>=y1 &&
     623        ev.mouse_move.x<=x2 && ev.mouse_move.y<=y2)
    623624        in_area=i;
    624625      }
    625626      if (in_area!=active && (no_selections_allowed || (in_area && in_area->selectable())))
    626627      {
    627         if (active)
     628    if (active)
    628629          active->draw(0,screen);
    629630
    630         active=in_area;
    631 
    632         if (active)
    633           active->draw(1,screen);
     631    active=in_area;
     632
     633    if (active)
     634      active->draw(1,screen);
    634635      }
    635     } 
     636    }
    636637    if (ev.type==EV_KEY && ev.key==JK_TAB && active)
    637     { 
     638    {
    638639      active->draw(0,screen);
    639640      do
    640641      {
    641         active=active->next;
    642         if (!active) active=first;
     642    active=active->next;
     643    if (!active) active=first;
    643644      } while (active && !active->selectable());
    644645      active->draw(1,screen);
     
    656657          ev.mouse_move.x<=x2 && ev.mouse_move.y<=y2))
    657658      {
    658         if (j)
    659           active->handle_event(ev,screen,j->inm);
    660         else active->handle_event(ev,screen,this);
     659    if (j)
     660      active->handle_event(ev,screen,j->inm);
     661    else active->handle_event(ev,screen,this);
    661662      }
    662663    }
     
    713714
    714715void InputManager::grab_focus(ifield *i)
    715 { grab=i; 
     716{ grab=i;
    716717  if (cur)
    717718    wm->grab_focus(cur);
     
    719720
    720721void InputManager::release_focus()
    721 { grab=NULL; 
     722{ grab=NULL;
    722723  if (cur)
    723724    wm->release_focus();
     
    731732}
    732733
    733 void InputManager::add(ifield *i) 
     734void InputManager::add(ifield *i)
    734735{ ifield *f=first;
    735736  if (i->selectable())
     
    740741    {
    741742      while (f->next) f=f->next;
    742       f->next=i; 
     743      f->next=i;
    743744    }
    744745  }
  • abuse/trunk/src/imlib/jwindow.hpp

    r120 r124  
    5252  void release_focus();
    5353  void allow_no_selections();
    54   ~InputManager(); 
     54  ~InputManager();
    5555} ;
    5656
     
    7979    virtual char *read() = 0;
    8080    virtual ifield *find(int search_id) { if (id==search_id) return this; else return NULL; }
    81     virtual ifield *unlink(int id) { return NULL; } 
     81    virtual ifield *unlink(int id) { return NULL; }
    8282    virtual ~ifield();
    8383} ;
     
    124124    void clip_in() { screen->set_clip(x1(), y1(), x2(), y2()); }
    125125    void clip_out() { screen->set_clip(0, 0, l - 1, h - 1); }
    126     char *read(int id) { return inm->get(id)->read(); } 
     126    char *read(int id) { return inm->get(id)->read(); }
    127127    void local_close();
    128128
     
    153153    JCFont *fnt, *wframe_fnt;
    154154
    155     WindowManager(image *, palette *, int hi, int med, int low, JCFont *); 
     155    WindowManager(image *, palette *, int hi, int med, int low, JCFont *);
    156156    ~WindowManager();
    157157
     
    175175    JCFont *font() { return fnt; }
    176176    int has_mouse() { return eh->has_mouse(); }
    177     void mouse_status(int &x, int &y, int &button) {eh->mouse_status(x,y,button); }           
    178     void set_mouse_shape(image *im, int centerx, int centery) 
     177    void mouse_status(int &x, int &y, int &button) {eh->mouse_status(x,y,button); }   
     178    void set_mouse_shape(image *im, int centerx, int centery)
    179179    { eh->set_mouse_shape(im,centerx,centery); }
    180180
  • abuse/trunk/src/imlib/keys.hpp

    r57 r124  
    1111#define __KEYS_HPP_
    1212
    13 #define JK_BACKSPACE 8 
     13#define JK_BACKSPACE 8
    1414#define JK_TAB      9
    1515#define JK_ENTER    13
     
    1717#define JK_SPACE    32
    1818
    19 #define JK_UP       256 
     19#define JK_UP       256
    2020#define JK_DOWN     257
    2121#define JK_LEFT     258
  • abuse/trunk/src/imlib/lbmread.cpp

    r56 r124  
    3131  {
    3232    int32_t size=read_other_uint32(fp);
    33     fread(type,1,4,fp);   
     33    fread(type,1,4,fp);
    3434    if (memcmp(type,"PBM ",4))
    3535    {
     
    4040    else
    4141    {
    42       int32_t ssize;   
     42      int32_t ssize;
    4343      char stype[4];
    4444      int16_t w=0,h=0,x,y,tcolor,pagew,pageh;
    4545      char planes,masking,compr=0,padl,xa,ya;
    46      
     46
    4747      while (ftell(fp)+4<size)
    4848      {
    49         fread(stype,1,4,fp);
    50         ssize=read_other_uint32(fp);
     49    fread(stype,1,4,fp);
     50    ssize=read_other_uint32(fp);
    5151        if (ssize &1) ssize++;            // specs say all chunks are padded by 2
    52         if (!memcmp(stype,"BMHD",4))
    53         {
    54           w=read_other_uint16(fp);
    55           h=read_other_uint16(fp);
    56           x=read_other_uint16(fp);
    57           y=read_other_uint16(fp);
    58           planes=fgetc(fp);
    59           masking=fgetc(fp);
    60           compr=fgetc(fp);
    61           padl=fgetc(fp);
    62           tcolor=read_other_uint16(fp);
    63           xa=fgetc(fp);
    64           ya=fgetc(fp);
    65           pagew=read_other_uint16(fp);
    66           pageh=read_other_uint16(fp);
    67         } else if (!memcmp(stype,"CMAP",4))
    68         {
    69           pal=new palette(256);
    70           fread(pal->addr(),1,768,fp);
    71         } else if (!memcmp(stype,"BODY",4) && w && h)  // make sure we read a BHMD before
    72         {
    73           if (im) delete im;  // shouldn't be two BODY's butjust in case...
    74           im=new image(w,h);
    75           int y;
    76           if (!compr)
    77           {
    78             for (y=0;y<h;h++)
    79               fread(im->scan_line(y),1,w,fp);
    80           } else
    81           {
    82             for (y=0;y<h;y++)      
    83             {
    84               int c,i,n=0;
    85               unsigned char *sl=im->scan_line(y);
    86               do
    87               {
    88                 c=fgetc(fp)&0xff;
    89                 if (c&0x80)
    90                 {
    91                   if (c!=0x80)
    92                   {
    93                     i=((~c)&0xff)+2;
    94                     c=fgetc(fp);
    95                     while (i--) sl[n++]=c;
    96                   }
    97                 }
    98                 else
    99                 {
    100                   i=c+1;
    101                   while (i--) sl[n++]=fgetc(fp);
    102                 }
    103               } while (n<w);
    104             }
    105           }      
    106         }
    107         else
    108           fseek(fp,ssize,SEEK_CUR);
     52    if (!memcmp(stype,"BMHD",4))
     53    {
     54      w=read_other_uint16(fp);
     55      h=read_other_uint16(fp);
     56      x=read_other_uint16(fp);
     57      y=read_other_uint16(fp);
     58      planes=fgetc(fp);
     59      masking=fgetc(fp);
     60      compr=fgetc(fp);
     61      padl=fgetc(fp);
     62      tcolor=read_other_uint16(fp);
     63      xa=fgetc(fp);
     64      ya=fgetc(fp);
     65      pagew=read_other_uint16(fp);
     66      pageh=read_other_uint16(fp);
     67    } else if (!memcmp(stype,"CMAP",4))
     68    {
     69      pal=new palette(256);
     70      fread(pal->addr(),1,768,fp);
     71    } else if (!memcmp(stype,"BODY",4) && w && h)  // make sure we read a BHMD before
     72    {
     73      if (im) delete im;  // shouldn't be two BODY's butjust in case...
     74      im=new image(w,h);
     75      int y;
     76      if (!compr)
     77      {
     78        for (y=0;y<h;h++)
     79          fread(im->scan_line(y),1,w,fp);
     80      } else
     81      {
     82        for (y=0;y<h;y++)    
     83        {
     84          int c,i,n=0;
     85          unsigned char *sl=im->scan_line(y);
     86          do
     87          {
     88        c=fgetc(fp)&0xff;
     89        if (c&0x80)
     90        {
     91          if (c!=0x80)
     92          {
     93            i=((~c)&0xff)+2;
     94            c=fgetc(fp);
     95            while (i--) sl[n++]=c;
     96          }
     97        }
     98        else
     99        {
     100          i=c+1;
     101          while (i--) sl[n++]=fgetc(fp);
     102        }
     103          } while (n<w);
     104        }
     105      }   
     106    }
     107    else
     108      fseek(fp,ssize,SEEK_CUR);
    109109      }
    110110    }
  • abuse/trunk/src/imlib/linked.cpp

    r112 r124  
    3838      q=first()->next();
    3939      while (q!=p && q!=first())    // find the node in the list
    40         q=q->next();
     40    q=q->next();
    4141      if (q!=first())                  // is it in the list at all?
    4242      {  q->last()->set_next(q->next());   // yes unlink the pointers
    43         q->next()->set_last(q->last());
    44         nn--;
    45          return 1;
     43    q->next()->set_last(q->last());
     44    nn--;
     45     return 1;
    4646      }                                    // decrement the number of nodes
    4747    }
     
    141141      if (p->compare(q,sortby)>0)  // repeat until we find a value greater than the one we are inserting
    142142      { p->set_next(q);
    143         p->set_last(q->last());     // insert it with pointers here
    144         q->last()->set_next(p);
    145         q->set_last(p);
    146         q=fn->last();         // set q to the last node so we finish the loop
     143    p->set_last(q->last());     // insert it with pointers here
     144    q->last()->set_next(p);
     145    q->set_last(p);
     146    q=fn->last();         // set q to the last node so we finish the loop
    147147      }
    148148    }
  • abuse/trunk/src/imlib/linked.hpp

    r112 r124  
    2121
    2222
    23 #ifndef linkman         
     23#ifndef linkman
    2424#define linkman
    2525#include <stdio.h>
  • abuse/trunk/src/imlib/loader.cpp

    r56 r124  
    2323int tell_color_size(char *filename)
    2424{
    25   if (bmp_bits(filename)==24) return 24; 
     25  if (bmp_bits(filename)==24) return 24;
    2626  if (PCX_file_type(filename)==PCX_24) return 24;
    27   clear_errors(); 
    28   return 8; 
     27  clear_errors();
     28  return 8;
    2929}
    3030
     
    3434    return read_bmp24(filename);
    3535  else if (PCX_file_type(filename)==PCX_24)
    36     return read_PCX24(filename); 
     36    return read_PCX24(filename);
    3737  else return NULL;
    38  
     38
    3939}
    4040
     
    4747  {
    4848    case LOADER_not_supported : break;
    49     case LOADER_mdl : 
     49    case LOADER_mdl :
    5050      total_read=mdl_total_images(filename);
    5151      if (!current_error())
    5252        images=read_mdl(filename,pal,1,total_read,total_read);
    5353      break;
    54     case LOADER_xwd : 
     54    case LOADER_xwd :
    5555      images=(image **)jmalloc(sizeof(image *),"loader::xwd image * array");
    56       total_read=1; 
     56      total_read=1;
    5757      images[0]=readxwd(filename,pal);
    5858      break;
    59     case LOADER_ppm : 
     59    case LOADER_ppm :
    6060      images=(image **)jmalloc(sizeof(image *),"loader::ppm image * array");
    6161      total_read=1;
     
    6363      images[0]=read_ppm(filename,pal,PPM_REG);
    6464      break;
    65     case LOADER_pic : 
     65    case LOADER_pic :
    6666      images=(image **)jmalloc(sizeof(image *),"loader::pic image * array");
    6767      total_read=1;
     
    6969      images[0]=read_pic(filename,pal);
    7070      break;
    71     case LOADER_bmp8 : 
     71    case LOADER_bmp8 :
    7272      images=(image **)jmalloc(sizeof(image *),"loader::bmp image * array");
    7373      total_read=1;
     
    7575      images[0]=read_bmp(pal,filename);
    7676      break;
    77     case LOADER_pcx8 : 
     77    case LOADER_pcx8 :
    7878      images=(image **)jmalloc(sizeof(image *),"loader::pcx image * array");
    7979      total_read=1;
    8080      pal=NULL;
    81       images[0]=read_PCX(filename,pal);   
    82       break;   
     81      images[0]=read_PCX(filename,pal);
     82      break;
    8383    case LOADER_lbm :
    8484      images=(image **)jmalloc(sizeof(image *),"loader::pcx image * array");
    8585      total_read=1;
    8686      pal=NULL;
    87       images[0]=read_lbm(filename,pal);   
     87      images[0]=read_lbm(filename,pal);
    8888      break;
    8989    case LOADER_targa :
     
    100100    default :
    101101      set_error(imNOT_SUPPORTED);
    102   }   
     102  }
    103103  if (current_error())
    104104  {
    105     short i;   
     105    short i;
    106106    i=current_error();
    107107    set_error(0);
     
    120120    return LOADER_not_supported;
    121121  else if (fread(header,1,12,fp)!=12)
    122   { 
     122  {
    123123    fclose(fp);
    124     return LOADER_not_supported;   
     124    return LOADER_not_supported;
    125125  }
    126126  fclose(fp);
     
    139139  else if (header[0]=='F' && header[1]=='O' && header[2]=='R' && header[3]=='M')
    140140    return LOADER_lbm;
    141   else if (header[0]=='B' && header[1]=='M') 
     141  else if (header[0]=='B' && header[1]=='M')
    142142  {
    143143    switch (tell_color_size(filename))
    144144    {
    145       case 24 : return LOADER_bmp24; break;     
    146       case 8 : return LOADER_bmp8; break;       
     145      case 24 : return LOADER_bmp24; break;
     146      case 8 : return LOADER_bmp8; break;   
    147147      default : return LOADER_not_supported; break;
    148148    }
    149149  } else if (header[0]==10)
    150   { 
     150  {
    151151    switch (tell_color_size(filename))
    152152    {
    153       case 24 : return LOADER_pcx24; break;     
    154       case 8 : return LOADER_pcx8; break;       
     153      case 24 : return LOADER_pcx24; break;
     154      case 8 : return LOADER_pcx8; break;   
    155155      default : return LOADER_not_supported; break;
    156156    }
  • abuse/trunk/src/imlib/loader.hpp

    r57 r124  
    1717// supported graphics file formats so far..
    1818
    19 enum graphics_type 
     19enum graphics_type
    2020{ LOADER_not_supported,
    21   LOADER_mdl,                 // propritary
    22   LOADER_spe,                 // propritary
    23   LOADER_ppm,                 // portable pixmap
    24   LOADER_bmp8,                // 8 bit color Microsoft Bitmap   
    25   LOADER_bmp24,               // 24 bit color Microsoft Bitmap
    26   LOADER_pcx8,                // 8 bit color PC paintbrush
    27   LOADER_pcx24,               // 24 bit color PC paintbrush
    28   LOADER_xwd,                 // X-window dump format
    29   LOADER_pic,                 // Pic (used in Gl's)
     21  LOADER_mdl,                  // propritary
     22  LOADER_spe,              // propritary
     23  LOADER_ppm,              // portable pixmap
     24  LOADER_bmp8,              // 8 bit color Microsoft Bitmap   
     25  LOADER_bmp24,              // 24 bit color Microsoft Bitmap
     26  LOADER_pcx8,              // 8 bit color PC paintbrush
     27  LOADER_pcx24,              // 24 bit color PC paintbrush
     28  LOADER_xwd,              // X-window dump format
     29  LOADER_pic,                  // Pic (used in Gl's)
    3030  LOADER_lbm,                 // Delux Paint
    3131  LOADER_targa                // 24 bit, converted to 8 on load though
     
    3333
    3434graphics_type tell_file_type(char *filename);
    35 int tell_color_size(char *filename);     // returns 8 or 24 
    36 short load_any(char *filename, image **&images, 
    37                palette *&pal, short &total_read, palette *ref_pal=0);
     35int tell_color_size(char *filename);     // returns 8 or 24
     36short load_any(char *filename, image **&images,
     37           palette *&pal, short &total_read, palette *ref_pal=0);
    3838image24 *load_any24(char *filename);
    3939
  • abuse/trunk/src/imlib/macs.hpp

    r57 r124  
    1818// These macros should be removed for the non-debugging version
    1919#ifdef NO_CHECK
    20 #define CONDITION(x,st) 
    21 #define CHECK(x) 
     20#define CONDITION(x,st)
     21#define CHECK(x)
    2222#else
    2323#define CONDITION(x,st) ERROR(x,st)
  • abuse/trunk/src/imlib/mdlread.cpp

    r56 r124  
    2424// but no checking of that is done hhere.
    2525void write_mdl(image **images, int16_t total_images, palette *pal,char *fn,
    26                 int16_t firstpage, int16_t images_per_page)
     26        int16_t firstpage, int16_t images_per_page)
    2727{
    2828  FILE *fp;
     
    6464      fwrite(&page,1,1,fp);         // put all of the image on the first page
    6565      xy[0]=uint16_to_intel(images[i]->width()*images[i]->height()+4);  // calc the size of the image
    66    
     66
    6767      fwrite(xy,2,1,fp);
    6868      xy[0]=uint16_to_intel(images[i]->width());
     
    7272      for (x=0;x<(uint16_t)images[i]->height();x++)   // write all the scan_lines for the
    7373      { c=images[i]->scan_line(x);            // image
    74         fwrite(c,images[i]->width(),1,fp);
     74    fwrite(c,images[i]->width(),1,fp);
    7575      }
    7676    }
     
    157157      while (startn && !current_error())
    158158      { if (fread(buf,1,23,fp)!=23)
    159           set_error(imFILE_CORRUPTED);
    160         fread(xy,2,1,fp);
    161         xy[0]=uint16_to_local(xy[0]);
    162         fseek(fp,xy[0],SEEK_CUR);
    163         startn--; if (endn>0) endn--;
     159      set_error(imFILE_CORRUPTED);
     160    fread(xy,2,1,fp);
     161    xy[0]=uint16_to_local(xy[0]);
     162    fseek(fp,xy[0],SEEK_CUR);
     163    startn--; if (endn>0) endn--;
    164164      }
    165165      if (!current_error())
    166         im=(image **)jmalloc(sizeof(image *)*endn,"mdl_read::image * array");
     166    im=(image **)jmalloc(sizeof(image *)*endn,"mdl_read::image * array");
    167167
    168168      while ((startn<endn || endn==-1) && !feof(fp) && !current_error())
    169169      {
    170         if (fread(buf,1,23,fp)==23)
     170    if (fread(buf,1,23,fp)==23)
    171171        {
    172           if (fread(&j,1,2,fp)!=2) set_error(imFILE_CORRUPTED);
    173           else
    174           {
    175             j=uint16_to_local(j);
    176             j-=4;
     172        if (fread(&j,1,2,fp)!=2) set_error(imFILE_CORRUPTED);
     173      else
     174      {
     175        j=uint16_to_local(j);
     176        j-=4;
    177177            xy[0]=5; xy[1]=5;
    178             if (fread(xy,1,4,fp)!=4) set_error(imFILE_CORRUPTED);
    179             make_block(sizeof(image));
    180             xy[0]=uint16_to_local(xy[0]);
    181             xy[1]=uint16_to_local(xy[1]);
    182             im[startn]=new image(xy[0],xy[1]);
    183             total++;
    184             for (i=0;i<xy[1];i++)
    185               if (fread(im[startn]->scan_line(i),xy[0],1,fp)!=1)
    186                 set_error(imFILE_CORRUPTED);
    187               else j-=xy[0];
    188             if (j)
    189               fseek(fp,j,SEEK_CUR);
    190           }
    191           startn++;
     178        if (fread(xy,1,4,fp)!=4) set_error(imFILE_CORRUPTED);
     179        make_block(sizeof(image));
     180        xy[0]=uint16_to_local(xy[0]);
     181        xy[1]=uint16_to_local(xy[1]);
     182        im[startn]=new image(xy[0],xy[1]);
     183        total++;
     184        for (i=0;i<xy[1];i++)
     185          if (fread(im[startn]->scan_line(i),xy[0],1,fp)!=1)
     186            set_error(imFILE_CORRUPTED);
     187          else j-=xy[0];
     188        if (j)
     189          fseek(fp,j,SEEK_CUR);
     190      }
     191      startn++;
    192192        }
    193193      }
  • abuse/trunk/src/imlib/mdlread.hpp

    r57 r124  
    1717image **read_mdl(char *fn, palette *&pal, short startn, short endn, short &total);
    1818void write_mdl(image **images, short total_images, palette *pal,char *fn,
    19                 short firstpage=0, short images_per_page=20);
     19        short firstpage=0, short images_per_page=20);
    2020
    2121#endif
  • abuse/trunk/src/imlib/morph.cpp

    r115 r124  
    1616long trans(long x1, long x2, long frame)
    1717{
    18   return (((x2-x1)<<5)*frame+(x1<<8))>>8; 
     18  return (((x2-x1)<<5)*frame+(x1<<8))>>8;
    1919}
    2020
    2121
    2222void jmorph::show_step_frame(image *screen, int x, int y, int frame_on,
    23                        color_filter *fli, palette *pal)
     23                   color_filter *fli, palette *pal)
    2424{
    2525  short x1,y1,x2,y2;
    2626  unsigned char r1,g1,b1,r2,g2,b2;
    2727  screen->get_clip(x1,y1,x2,y2);
    28  
     28
    2929  int i;
    3030  long xx,yy;
    31  
     31
    3232  if (small)
    3333  {
     
    3838      xx=x+trans(m8->x1,m8->x2,frame_on);
    3939      yy=y+trans(m8->y1,m8->y2,frame_on);
    40      
     40
    4141      if (xx>=x1 && xx<=x2 && yy>=y1 && yy<=y2)
    42       { 
    43         pal->get(m8->start_color,r1,g1,b1);
    44         pal->get(m8->end_color,r2,g2,b2);
    45  
    46         long r=trans(r1,r2,frame_on)>>3,
     42      {   
     43    pal->get(m8->start_color,r1,g1,b1);
     44    pal->get(m8->end_color,r2,g2,b2);
     45
     46    long r=trans(r1,r2,frame_on)>>3,
    4747             g=trans(g1,g2,frame_on)>>3,
    48              b=trans(b1,b2,frame_on)>>3;
    49        
     48         b=trans(b1,b2,frame_on)>>3;
     49   
    5050        *(screen->scan_line(yy)+xx)=fli->lookup_color(r,g,b);
    51       }           
     51      }
    5252    }
    5353    screen->unlock();
    54   }   
    55 }
    56 
    57 
    58 void patched_morph::show_frame(image *screen, int x, int y, 
    59                                int frame_on, color_filter *fli, palette *pal)
     54  }
     55}
     56
     57
     58void patched_morph::show_frame(image *screen, int x, int y,
     59                   int frame_on, color_filter *fli, palette *pal)
    6060{
    6161  jmorph::show_step_frame(screen,x,y,frame_on,fli,pal);
     
    6363  unsigned char *p=pats[frame_on].patch_data;
    6464  short cx1,cy1,cx2,cy2;
    65   screen->get_clip(cx1,cy1,cx2,cy2);   
     65  screen->get_clip(cx1,cy1,cx2,cy2);
    6666  screen->lock();
    6767  while (tot--)
     
    7676        p++;
    7777      else
    78         *(screen->scan_line(yy)+xx)=*(p++);
    79     }
    80   }     
     78    *(screen->scan_line(yy)+xx)=*(p++);
     79    }
     80  }
    8181  screen->unlock();
    8282}
     
    8585{
    8686  jmorph::show_8(screen,x,y,frame_on,fli,pal);
    87   int tot=pats[frame_on].patches,xx,yy; 
     87  int tot=pats[frame_on].patches,xx,yy;
    8888  unsigned char *p=pats[frame_on].patch_data;
    8989  short cx1,cy1,cx2,cy2;
    90   screen->get_clip(cx1,cy1,cx2,cy2);   
     90  screen->get_clip(cx1,cy1,cx2,cy2);
    9191  screen->lock();
    9292  while (tot--)
     
    101101        p++;
    102102      else
    103         *(screen->scan_line(yy)+xx)=*(p++);
    104     }
    105   }     
     103    *(screen->scan_line(yy)+xx)=*(p++);
     104    }
     105  }
    106106  screen->unlock();
    107107}
     
    111111
    112112patched_morph::patched_morph(image *i1, image *hint1, image *i2, image *hint2, int aneal_steps,
    113                 color_filter *fli, palette *pal, int frames) : jmorph(i1,hint1,i2,hint2,aneal_steps)
     113            color_filter *fli, palette *pal, int frames) : jmorph(i1,hint1,i2,hint2,aneal_steps)
    114114{
    115115  int i,j,w,h,x,y,tot,r,g,b,mark_color,dist;
    116116  unsigned char *cur_patch,*sl,ored,og,ob;
    117  
     117
    118118  frames=9;
    119  
    120   patches=frames; 
     119
     120  patches=frames;
    121121  pats=(morph_patch *)jmalloc(sizeof(morph_patch)*patches,"morph::patch array");
    122122  w=max(bound_x2(0),bound_x2(1));
    123   h=max(bound_y2(0),bound_y2(1));   
     123  h=max(bound_y2(0),bound_y2(1));
    124124  image *im=new image(w,h);
    125125
     
    128128  {
    129129    pats[i].patch_data=NULL;
    130     pats[i].patches=0;   
     130    pats[i].patches=0;
    131131    if (i!=0 && i!=patches-1)
    132     {     
     132    {
    133133      im->clear();
    134134      jmorph::show_step_frame(im,0,0,i,fli,pal);
    135135      for (j=0;j<4;j++)
    136       {     
    137         for (y=0;y<h;y++)
     136      {
     137    for (y=0;y<h;y++)
    138138          for (sl=im->scan_line(y),x=0;x<w;x++,sl++)
    139           {     
    140             mark_color=-1;
    141            
    142             tot=r=g=b=0;                 
    143             if (x!=0 && *(sl-1))
    144             { tot++;
    145               r+=pal->red(*(sl-1));
    146               g+=pal->green(*(sl-1));
    147               b+=pal->blue(*(sl-1));               
    148             }    
    149             if (x!=w-1 && *(sl+1))
    150             { tot++;
    151               r+=pal->red(*(sl+1));
    152               g+=pal->green(*(sl+1));
    153               b+=pal->blue(*(sl+1));   
    154             }    
    155             if (y!=0 && im->pixel(x,y-1))
    156             { tot++;
    157               r+=pal->red(im->pixel(x,y-1));
    158               g+=pal->green(im->pixel(x,y-1));
    159               b+=pal->blue(im->pixel(x,y-1));
    160             }
    161             if (y!=h-1 && im->pixel(x,y+1))
    162             { tot++;
    163               r+=pal->red(im->pixel(x,y+1));
    164               g+=pal->green(im->pixel(x,y+1));
    165               b+=pal->blue(im->pixel(x,y+1));
    166             }
    167 
    168             if (*sl && tot==0)  // kill any separate pixels        
    169               mark_color=0;
    170             else if (*sl)
    171             {
    172               pal->get(*sl,ored,og,ob);       // see if we need to blur this on in
    173               r/=tot;
    174               g/=tot;
    175               b/=tot;
    176              
    177               dist=((int)ored-r)*((int)ored-r)+((int)og-g)*((int)og-g)+((int)ob-b)*((int)ob-b);
    178               if (i>0 && i<patches-1 && dist>3000)
    179               {
    180 //              printf("adding blur at %d %d to frame %d, dist=%d\n",x,y,i,dist);
    181                 mark_color=fli->lookup_color(r>>3,g>>3,b>>3);      
    182               }
    183             }
    184             else if (*sl==0 && tot>=3)     
    185               mark_color=fli->lookup_color((r/tot)>>3,(g/tot)>>3,(b/tot)>>3);      
    186             if (mark_color>=0)
    187             {        
    188               pats[i].patches++;
    189               pats[i].patch_data=(unsigned char *)realloc(pats[i].patch_data,3*pats[i].patches);
    190               cur_patch=pats[i].patch_data+  (pats[i].patches-1)*3;        
    191               *(cur_patch++)=x;
    192               *(cur_patch++)=y;
    193               *sl=mark_color;        
    194               *(cur_patch++)=*sl;            
    195             }    
    196           }
    197       }     
    198     }
    199   } 
     139      {   
     140        mark_color=-1;
     141   
     142        tot=r=g=b=0;         
     143        if (x!=0 && *(sl-1))
     144        { tot++;
     145          r+=pal->red(*(sl-1));
     146          g+=pal->green(*(sl-1));
     147          b+=pal->blue(*(sl-1));        
     148        }   
     149        if (x!=w-1 && *(sl+1))
     150        { tot++;
     151          r+=pal->red(*(sl+1));
     152          g+=pal->green(*(sl+1));
     153          b+=pal->blue(*(sl+1));   
     154        }   
     155        if (y!=0 && im->pixel(x,y-1))
     156        { tot++;
     157          r+=pal->red(im->pixel(x,y-1));
     158          g+=pal->green(im->pixel(x,y-1));
     159          b+=pal->blue(im->pixel(x,y-1));
     160        }
     161        if (y!=h-1 && im->pixel(x,y+1))
     162        { tot++;
     163          r+=pal->red(im->pixel(x,y+1));
     164          g+=pal->green(im->pixel(x,y+1));
     165          b+=pal->blue(im->pixel(x,y+1));
     166        }
     167
     168        if (*sl && tot==0)  // kill any separate pixels   
     169          mark_color=0;
     170        else if (*sl)
     171        {
     172          pal->get(*sl,ored,og,ob);       // see if we need to blur this on in
     173          r/=tot;
     174          g/=tot;
     175          b/=tot;
     176   
     177          dist=((int)ored-r)*((int)ored-r)+((int)og-g)*((int)og-g)+((int)ob-b)*((int)ob-b);
     178          if (i>0 && i<patches-1 && dist>3000)
     179          {
     180//        printf("adding blur at %d %d to frame %d, dist=%d\n",x,y,i,dist);
     181        mark_color=fli->lookup_color(r>>3,g>>3,b>>3);   
     182          }
     183        }
     184        else if (*sl==0 && tot>=3)   
     185          mark_color=fli->lookup_color((r/tot)>>3,(g/tot)>>3,(b/tot)>>3);   
     186        if (mark_color>=0)
     187        {   
     188          pats[i].patches++;
     189          pats[i].patch_data=(unsigned char *)realloc(pats[i].patch_data,3*pats[i].patches);
     190          cur_patch=pats[i].patch_data+  (pats[i].patches-1)*3;   
     191          *(cur_patch++)=x;
     192          *(cur_patch++)=y;
     193          *sl=mark_color;   
     194          *(cur_patch++)=*sl;   
     195        }   
     196      }
     197      }
     198    }
     199  }
    200200  delete im;
    201  
     201
    202202}
    203203
     
    247247    }
    248248  }
    249 } 
     249}
    250250
    251251
     
    253253{
    254254  int w=max(bound_x2(0),bound_x2(1)),h=max(bound_y2(0),bound_y2(1)),
    255       i,pixelx,pixely,k,l,frame_on; 
     255      i,pixelx,pixely,k,l,frame_on;
    256256  morph_point8 **middle_map,*other;
    257257  unsigned char *end_map;
    258258  CONDITION(small,"add filler not defined for 16bit morphs\n");
    259  
     259
    260260  if (frames<3) return ;
    261  
     261
    262262
    263263  middle_map=(morph_point8 **)jmalloc(w*h*sizeof(morph_point8 *),
    264                                       "morph::middle_map");  // create an image of pointers
     264                      "morph::middle_map");  // create an image of pointers
    265265  end_map=(unsigned char *)jmalloc(w*h,
    266                                   "morph::end_map");      // maps all the ending pixels
     266                  "morph::end_map");      // maps all the ending pixels
    267267
    268268  for (frame_on=2;frame_on<frames-1;frame_on++)
    269   {   
     269  {
    270270    memset(middle_map,0,w*h*sizeof(morph_point8 *));            // initialize them middle pointers NULL
    271271    memset(end_map,0,w*h);                                      // clear all end pixels
    272  
     272
    273273    morph_point8 *p_on=(morph_point8 *)p;    // p is the array of morph points
    274     for (i=0;i<total;i++,p_on++)           
    275     {   
     274    for (i=0;i<total;i++,p_on++)
     275    {
    276276      pixelx=(long)((int)p_on->x2-(int)p_on->x1)*(long) frame_on  /(long) frames  +p_on->x1;
    277277      pixely=(long)((int)p_on->y2-(int)p_on->y1)*(long) frame_on  /(long) frames  +p_on->y1;
     
    281281    }
    282282
    283  
     283
    284284    int skipped=0;
     285
     286    for (pixely=0;pixely<h;pixely++)
     287    {
     288      for (pixelx=0;pixelx<w;pixelx++)
     289      {
     290    if (middle_map[pixelx+pixely*w]==NULL)  // we are checking for 'duds'  (misplaced black pixels)
     291    {   
     292      int tot;   
     293      if (pixelx>0) if (middle_map[pixelx-1+pixely*w]) tot=1; else tot=0;
     294      if (pixelx<w-1) if (middle_map[pixelx+1+pixely*w]) tot++;   
     295      if (pixely>0) if (middle_map[pixelx+(pixely-1)*w]) tot++;   
     296      if (pixely<h-1) if (middle_map[pixelx+(pixely+1)*w]) tot++;   
     297
     298      if (tot>=3)                   // it is surronded by 3 non black squares, this is a dud   
     299      {
     300        int distance,shortest_distance,shortest_end_x,shortest_end_y;   
     301        morph_point8 *shortest=NULL;
    285302   
    286     for (pixely=0;pixely<h;pixely++)
    287     {
    288       for (pixelx=0;pixelx<w;pixelx++)
    289       {
    290         if (middle_map[pixelx+pixely*w]==NULL)  // we are checking for 'duds'  (misplaced black pixels)
    291         {       
    292           int tot;     
    293           if (pixelx>0) if (middle_map[pixelx-1+pixely*w]) tot=1; else tot=0;     
    294           if (pixelx<w-1) if (middle_map[pixelx+1+pixely*w]) tot++;     
    295           if (pixely>0) if (middle_map[pixelx+(pixely-1)*w]) tot++;     
    296           if (pixely<h-1) if (middle_map[pixelx+(pixely+1)*w]) tot++;   
    297 
    298           if (tot>=3)                   // it is surronded by 3 non black squares, this is a dud       
    299           {
    300             int distance,shortest_distance,shortest_end_x,shortest_end_y;         
    301             morph_point8 *shortest=NULL;
    302            
    303             for (k=0;k<w;k++)
    304               for (l=0;l<h;l++)
    305               {             
     303        for (k=0;k<w;k++)
     304             for (l=0;l<h;l++)
     305          {     
    306306                other=middle_map[k+(l)*w];
    307                 if (other)
    308                 {
    309                   int end_x=frames*(pixelx-other->x1)/frame_on+other->x1,
    310                       end_y=frames*(pixely-other->y1)/frame_on+other->y1;                
    311                   if (end_x>=0 && end_y>=0 && end_x<w && end_y<h && end_map[end_x+end_y*w])
    312                   {
     307        if (other)
     308        {
     309          int end_x=frames*(pixelx-other->x1)/frame_on+other->x1,
     310              end_y=frames*(pixely-other->y1)/frame_on+other->y1;       
     311          if (end_x>=0 && end_y>=0 && end_x<w && end_y<h && end_map[end_x+end_y*w])
     312          {
    313313                    distance=(other->x1-end_x)*(other->x1-end_x)+
    314                              (other->y1-end_y)*(other->y1-end_y);
    315                     if (!shortest || shortest_distance>distance)
    316                     {
    317                       shortest_distance=distance;
    318                       shortest=other;
    319                       shortest_end_x=end_x;
    320                       shortest_end_y=end_y;                  
    321                     }
    322                   }
    323                 }
    324               }    
    325             if (shortest)
    326             {
    327               total++;
    328               p=(void *)realloc(p,sizeof(morph_point8)*total);           
    329               morph_point8 *mod=((morph_point8 *)p)+total-1;
    330               mod->x1=shortest->x1;
    331               mod->y1=shortest->y1;
    332               mod->start_color=shortest->start_color;            
    333 
    334               mod->x2=shortest_end_x;
    335               mod->y2=shortest_end_y;            
    336               mod->end_color=end_map[shortest_end_x+shortest_end_y*w];           
    337             }           
    338             else
    339             {        
    340               skipped++;
    341               printf("skiped so far : %d (frame %d)\n",skipped,frame_on);
    342             }
    343            
    344 
    345           }     
    346         }
    347       }
    348     } 
    349   }
    350  
     314                     (other->y1-end_y)*(other->y1-end_y);
     315            if (!shortest || shortest_distance>distance)
     316            {
     317              shortest_distance=distance;
     318              shortest=other;
     319              shortest_end_x=end_x;
     320              shortest_end_y=end_y;       
     321            }
     322          }
     323        }
     324          }   
     325        if (shortest)
     326        {
     327          total++;
     328          p=(void *)realloc(p,sizeof(morph_point8)*total);       
     329          morph_point8 *mod=((morph_point8 *)p)+total-1;
     330          mod->x1=shortest->x1;
     331          mod->y1=shortest->y1;
     332          mod->start_color=shortest->start_color;       
     333
     334          mod->x2=shortest_end_x;
     335          mod->y2=shortest_end_y;       
     336          mod->end_color=end_map[shortest_end_x+shortest_end_y*w];       
     337        }       
     338        else
     339        {   
     340            skipped++;
     341          printf("skiped so far : %d (frame %d)\n",skipped,frame_on);
     342        }
     343   
     344
     345      }   
     346    }
     347      }
     348    }
     349  }
     350
    351351  jfree(middle_map);
    352352  jfree(end_map);
    353  
     353
    354354}
    355355
     
    360360  int i;
    361361  fp->seek(e->offset,0);
    362   fp->read(&total,4); 
     362  fp->read(&total,4);
    363363  total=long_to_local(total);
    364364  if (e->type==SPEC_MORPH_POINTS_8 || e->type==SPEC_PATCHED_MORPH)
     
    373373
    374374    for (i=0;i<total;i++)
    375     { 
     375    {
    376376      ((morph_point16 *)p+i)->x1=fp->read_uint16();
    377377      ((morph_point16 *)p+i)->y1=fp->read_uint16();
     
    385385  }
    386386  w[0]=fp->read_uint16();
    387   h[0]=fp->read_uint16(); 
     387  h[0]=fp->read_uint16();
    388388  w[1]=fp->read_uint16();
    389389  h[1]=fp->read_uint16();
    390390}
    391391
    392 void jmorph::show_frame(image *screen, int x, int y, 
     392void jmorph::show_frame(image *screen, int x, int y,
    393393                      int frames, int frame_on, color_filter *fli, palette *pal)
    394394{
     
    435435    }
    436436  }
    437 } 
     437}
    438438
    439439void jmorph::show_24frame(unsigned char *screen, int width, int height,
     
    442442    int pixelx,pixely,i;
    443443  unsigned char *scolor,*ecolor,*addr=(unsigned char *)pal->addr(),*pix;
    444  
     444
    445445  if (small)
    446446  {
     
    452452
    453453      if (pixelx>=0 && pixely>=0 && pixelx<width && pixely<height)
    454       { 
     454      {   
    455455        scolor=addr+((int)p_on->start_color)*3;
    456456        ecolor=addr+((int)p_on->end_color)*3;
    457         pix=screen+pixelx*3+pixely*3*width;               
    458         *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;     
    459         *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;     
     457        pix=screen+pixelx*3+pixely*3*width;
     458        *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;   
     459        *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;   
    460460        *pix=((int)(*ecolor)-(int)(*scolor))*frame_on/frames+*scolor;
    461461      }
     
    471471
    472472      if (pixelx>=0 && pixely>=0 && pixelx<width && pixely<height)
    473       { 
     473      {   
    474474        scolor=addr+((int)p_on->start_color)*3;
    475475        ecolor=addr+((int)p_on->end_color)*3;
    476         pix=screen+pixelx*3+pixely*3*width;               
    477         *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;     
    478         *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;     
     476        pix=screen+pixelx*3+pixely*3*width;
     477        *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;   
     478        *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;   
    479479        *pix=((int)(*ecolor)-(int)(*scolor))*frame_on/frames+*scolor;
    480480      }
     
    484484
    485485
    486 jmorph::jmorph(image *i1, image *hint1, image *i2, image *hint2, 
     486jmorph::jmorph(image *i1, image *hint1, image *i2, image *hint2,
    487487                          int aneal_steps)
    488488{
    489489  w[0]=i1->width();
    490   h[0]=i1->height(); 
     490  h[0]=i1->height();
    491491  w[1]=i2->width();
    492   h[1]=i2->height(); 
     492  h[1]=i2->height();
    493493
    494494  struct { int start,end; } crange[256];
     
    499499
    500500
    501   CONDITION(i1->width()==hint1->width() && i1->height()==hint1->height() && 
     501  CONDITION(i1->width()==hint1->width() && i1->height()==hint1->height() &&
    502502            i2->width()==hint2->width() && i2->height()==hint2->height(),
    503503            "Image sizes do not correspond with hint sizes");
    504   if (i1->width()>255 || i2->width()>255 || i1->height()>255 || i2->height()>255) 
     504  if (i1->width()>255 || i2->width()>255 || i1->height()>255 || i2->height()>255)
    505505    small=0;
    506506  else small=1;
     
    523523
    524524  // check the user and see if the mask match up
    525   for (x=0;x<256;x++) 
     525  for (x=0;x<256;x++)
    526526  {
    527527    if ((hint_hist1[x]!=0 && hint_hist2[x]==0) ||
     
    530530      exit(1);
    531531    } else if (hint_hist1[x])
    532     { 
     532    {
    533533      if (!first) first=x;
    534534      total_hints++;
     
    560560      { total1--;
    561561        do {
    562           findx1++; 
    563           if (findx1>=hint1->width()) { findx1=0; findy1++; } 
     562          findx1++;
     563          if (findx1>=hint1->width()) { findx1=0; findy1++; }
    564564        } while (hint1->pixel(findx1,findy1)!=color);
    565565      }
     
    568568        randp=rand()%j+crange[color].start;
    569569        if (small)
    570         { findx1=((morph_point8 *)plist)[randp].x1; 
     570        { findx1=((morph_point8 *)plist)[randp].x1;
    571571          findy1=((morph_point8 *)plist)[randp].y1;
    572572        } else
    573         { findx1=((morph_point16 *)plist)[randp].x1; 
     573        { findx1=((morph_point16 *)plist)[randp].x1;
    574574          findy1=((morph_point16 *)plist)[randp].y1;
    575575        }
    576576      }
    577577      if (total2)  // are there any more pixels left in this image?
    578       { 
     578      {
    579579        total2--;
    580580        do {
    581           findx2++; 
    582           if (findx2>=hint2->width()) { findx2=0; findy2++; } 
     581          findx2++;
     582          if (findx2>=hint2->width()) { findx2=0; findy2++; }
    583583        } while (hint2->pixel(findx2,findy2)!=color);
    584584      }
     
    587587        randp=rand()%j+crange[color].start;
    588588        if (small)
    589         { findx2=((morph_point8 *)plist)[randp].x2; 
     589        { findx2=((morph_point8 *)plist)[randp].x2;
    590590          findy2=((morph_point8 *)plist)[randp].y2;
    591591        } else
    592         { findx2=((morph_point16 *)plist)[randp].x2; 
     592        { findx2=((morph_point16 *)plist)[randp].x2;
    593593          findy2=((morph_point16 *)plist)[randp].y2;
    594594        }
     
    599599      if (small)
    600600      {
    601         ((morph_point8 *)plist)[cur_pix].x1=findx1; 
    602         ((morph_point8 *)plist)[cur_pix].x2=findx2; 
    603         ((morph_point8 *)plist)[cur_pix].y1=findy1; 
    604         ((morph_point8 *)plist)[cur_pix].y2=findy2; 
     601        ((morph_point8 *)plist)[cur_pix].x1=findx1;
     602        ((morph_point8 *)plist)[cur_pix].x2=findx2;
     603        ((morph_point8 *)plist)[cur_pix].y1=findy1;
     604        ((morph_point8 *)plist)[cur_pix].y2=findy2;
    605605        ((morph_point8 *)plist)[cur_pix].start_color=i1->pixel(findx1,findy1);
    606606        ((morph_point8 *)plist)[cur_pix].end_color=i2->pixel(findx2,findy2);
     
    608608      else
    609609      {
    610         ((morph_point16 *)plist)[cur_pix].x1=findx1; 
    611         ((morph_point16 *)plist)[cur_pix].x2=findx2; 
    612         ((morph_point16 *)plist)[cur_pix].y1=findy1; 
    613         ((morph_point16 *)plist)[cur_pix].y2=findy2; 
     610        ((morph_point16 *)plist)[cur_pix].x1=findx1;
     611        ((morph_point16 *)plist)[cur_pix].x2=findx2;
     612        ((morph_point16 *)plist)[cur_pix].y1=findy1;
     613        ((morph_point16 *)plist)[cur_pix].y2=findy2;
    614614        ((morph_point16 *)plist)[cur_pix].start_color=i1->pixel(findx1,findy1);
    615615        ((morph_point16 *)plist)[cur_pix].end_color=i2->pixel(findx2,findy2);
     
    630630      start=crange[hint_color].start;
    631631      range=crange[hint_color].end-start+1;
    632       for(k=crange[hint_color].start;k<=crange[hint_color].end;k++) 
     632      for(k=crange[hint_color].start;k<=crange[hint_color].end;k++)
    633633      {
    634634        swap_point=rand()%range+start;
     
    644644                       (pk->x2-ps->x1)*(pk->x2-ps->x1)+(pk->y2-ps->y1)*(pk->y2-ps->y1);
    645645          if (new_distance<distance)
    646           { 
     646          {
    647647            sx2=pk->x2;         sy2=pk->y2;
    648648            sec=pk->end_color;
     
    663663                       (pk->x2-ps->x1)*(pk->x2-ps->x1)+(pk->y2-ps->y1)*(pk->y2-ps->y1);
    664664          if (new_distance<distance)
    665           { 
     665          {
    666666            sx2=pk->x2;         sy2=pk->y2;
    667667            sec=pk->end_color;
     
    677677  }
    678678  p=plist;
    679 } 
     679}
    680680
    681681int morph_width;
     
    683683int morph8_compare(const void *p1, const void *p2)
    684684{
    685   int pos1=((morph_point8 *)p1)->x1+((morph_point8 *)p1)->y1*morph_width; 
    686   int pos2=((morph_point8 *)p2)->x1+((morph_point8 *)p2)->y1*morph_width; 
     685  int pos1=((morph_point8 *)p1)->x1+((morph_point8 *)p1)->y1*morph_width;
     686  int pos2=((morph_point8 *)p2)->x1+((morph_point8 *)p2)->y1*morph_width;
    687687  if (pos1<pos2) return -1;
    688688  else if (pos1==pos2) return 0;
    689689  else return 1;
    690  
     690
    691691}
    692692
     
    696696  int i;
    697697
    698  
    699   fp->write_uint32(total); 
     698
     699  fp->write_uint32(total);
    700700  if (small)
    701701  {
     
    703703    // if the points are put in order then they can be compressed easier
    704704    morph_width=max(bound_x2(0),bound_x2(1));      // global used by qsort compare routine
    705     qsort(p,total,sizeof(morph_point8),morph8_compare); 
    706    
    707     fp->write(p,sizeof(morph_point8)*total); 
    708   } 
     705    qsort(p,total,sizeof(morph_point8),morph8_compare);
     706
     707    fp->write(p,sizeof(morph_point8)*total);
     708  }
    709709  else
    710710  {
     
    732732  int i;
    733733  pm=mor;
    734  
    735   total=mor->total_points();     
    736   points=(step_struct *)jmalloc(sizeof(step_struct)*total,"step_morph::points"); 
    737  
     734
     735  total=mor->total_points();
     736  points=(step_struct *)jmalloc(sizeof(step_struct)*total,"step_morph::points");
     737
    738738  dir=frame_direction;
    739739  face_dir=face_direction;
    740  
     740
    741741  if (dir>0)
    742742    frame_on=0;
    743743  else
    744744    frame_on=mor->patches-1;
    745  
     745
    746746  if (mor->small_morph())
    747   {   
     747  {
    748748      int x1,y1,x2,y2;
    749749
     750
     751      if (frame_direction>0)
     752      {
     753    morph_point8 *m8=mor->small_points();
    750754   
    751       if (frame_direction>0)
    752       {     
    753         morph_point8 *m8=mor->small_points();     
    754        
    755         for (i=0;i<total;i++,m8++)
    756         {       
    757           x1=(int)m8->x1;
    758           x2=(int)m8->x2;
    759 
    760           y1=(int)m8->y1;
    761           y2=(int)m8->y2;
    762 
    763           points[i].x=x1<<8;
    764           points[i].y=y1<<8;       
    765           points[i].dx=(x2-x1)<<5;
    766           points[i].dy=(y2-y1)<<5;             
    767          
    768           unsigned char r1,g1,b1,r2,g2,b2;
    769           pal->get(m8->start_color,r1,g1,b1);
    770           pal->get(m8->end_color,r2,g2,b2);
    771           points[i].r=r1<<8;
    772           points[i].g=g1<<8;
    773           points[i].b=b1<<8;
    774 
    775           points[i].dr=(long)((int)r2-(int)r1)<<5;
    776           points[i].dg=(long)((int)g2-(int)g1)<<5;
    777           points[i].db=(long)((int)b2-(int)b1)<<5;                     
    778         }
    779       }   
     755    for (i=0;i<total;i++,m8++)
     756    {         
     757      x1=(int)m8->x1;
     758      x2=(int)m8->x2;
     759
     760      y1=(int)m8->y1;
     761      y2=(int)m8->y2;
     762
     763      points[i].x=x1<<8;
     764      points[i].y=y1<<8;
     765      points[i].dx=(x2-x1)<<5;
     766      points[i].dy=(y2-y1)<<5;       
     767
     768      unsigned char r1,g1,b1,r2,g2,b2;
     769      pal->get(m8->start_color,r1,g1,b1);
     770      pal->get(m8->end_color,r2,g2,b2);
     771      points[i].r=r1<<8;
     772      points[i].g=g1<<8;
     773      points[i].b=b1<<8;
     774
     775      points[i].dr=(long)((int)r2-(int)r1)<<5;
     776      points[i].dg=(long)((int)g2-(int)g1)<<5;
     777      points[i].db=(long)((int)b2-(int)b1)<<5;           
     778    }
     779      }
    780780      else
    781       {     
    782         morph_point8 *m8=mor->small_points();     
    783         for (i=0;i<total;i++,m8++)
    784         {       
    785           x1=(int)m8->x1;
    786           x2=(int)m8->x2;
    787 
    788           y1=(int)m8->y1;
    789           y2=(int)m8->y2;
    790 
    791           points[i].x=x2<<8;
    792           points[i].y=y2<<8;       
    793           points[i].dx=(x1-x2)<<5;
    794           points[i].dy=(y1-y2)<<5;             
    795 
    796           unsigned char r1,g1,b1,r2,g2,b2;
    797           pal->get(m8->start_color,r2,g2,b2);
    798           pal->get(m8->end_color,r1,g1,b1);
    799           points[i].r=r1<<8;
    800           points[i].g=g1<<8;
    801           points[i].b=b1<<8;
    802 
    803           points[i].dr=(long)((int)r2-(int)r1)<<5;
    804           points[i].dg=(long)((int)g2-(int)g1)<<5;
    805           points[i].db=(long)((int)b2-(int)b1)<<5;                     
    806         }
    807       }   
    808   } 
     781      {
     782    morph_point8 *m8=mor->small_points();
     783    for (i=0;i<total;i++,m8++)
     784    {         
     785      x1=(int)m8->x1;
     786      x2=(int)m8->x2;
     787
     788      y1=(int)m8->y1;
     789      y2=(int)m8->y2;
     790
     791      points[i].x=x2<<8;
     792      points[i].y=y2<<8;
     793      points[i].dx=(x1-x2)<<5;
     794      points[i].dy=(y1-y2)<<5;       
     795
     796      unsigned char r1,g1,b1,r2,g2,b2;
     797      pal->get(m8->start_color,r2,g2,b2);
     798      pal->get(m8->end_color,r1,g1,b1);
     799      points[i].r=r1<<8;
     800      points[i].g=g1<<8;
     801      points[i].b=b1<<8;
     802
     803      points[i].dr=(long)((int)r2-(int)r1)<<5;
     804      points[i].dg=(long)((int)g2-(int)g1)<<5;
     805      points[i].db=(long)((int)b2-(int)b1)<<5;           
     806    }
     807      }
     808  }
    809809
    810810
     
    819819  step_struct *ss;
    820820
    821   morph_patch *pat=pm->pats+frame_on; 
     821  morph_patch *pat=pm->pats+frame_on;
    822822  int j,tp=pat->patches;
    823   unsigned char *sl=pat->patch_data;   
     823  unsigned char *sl=pat->patch_data;
    824824
    825825  if (face_dir>0)
    826   {   
     826  {
    827827    for (i=0,ss=points;i<total;i++,ss++)
    828828    {
     
    836836      ss->r+=ss->dr;
    837837      ss->g+=ss->dg;
    838       ss->b+=ss->db;       
    839     } 
     838      ss->b+=ss->db;
     839    }
    840840
    841841    for (j=0;j<tp;j++,sl++)
     
    845845      if (px>=x1 && px<=x2 && py>=y1 && py<=y2)
    846846        *(screen->scan_line(py)+px)=*sl;
    847     }             
     847    }
    848848  } else
    849849  {
     
    859859      ss->r+=ss->dr;
    860860      ss->g+=ss->dg;
    861       ss->b+=ss->db;       
    862     } 
     861      ss->b+=ss->db;
     862    }
    863863
    864864    for (j=0;j<tp;j++,sl++)
     
    868868      if (px>=x1 && px<=x2 && py>=y1 && py<=y2)
    869869        *(screen->scan_line(py)+px)=*sl;
    870     }         
    871   }
    872  
     870    }
     871  }
     872
    873873  frame_on+=dir;
    874  
     874
    875875}
    876876
     
    878878{
    879879  step_struct *s=points;
    880   int i; 
     880  int i;
    881881  for (i=0;i<total;i++,s++)
    882882  {
     
    885885    s->dr=-s->dr;
    886886    s->dg=-s->dg;
    887     s->db=-s->db;   
     887    s->db=-s->db;
    888888  }
    889889  dir=-dir;
    890  
     890
    891891}
    892892
     
    895895{
    896896  int i;
    897  
     897
    898898  patches=fp->read_uint16();
    899899  pats=(morph_patch *)jmalloc(sizeof(morph_patch)*patches,"patched_morph::points");
    900  
     900
    901901  for (i=0;i<patches;i++)
    902902  {
    903903    pats[i].patches=fp->read_uint16();
    904904    if (pats[i].patches)
    905     {     
     905    {
    906906      pats[i].patch_data=(unsigned char *)jmalloc(3*pats[i].patches,"patched_morph::patch_data");
    907       fp->read(pats[i].patch_data,3*pats[i].patches);     
     907      fp->read(pats[i].patch_data,3*pats[i].patches);
    908908    }
    909909    else
    910910      pats[i].patch_data=NULL;
    911   }   
    912 }
    913 
    914 
     911  }
     912}
     913
     914
  • abuse/trunk/src/imlib/morph.hpp

    r66 r124  
    2424
    2525struct morph_point8
    26 { 
     26{
    2727  unsigned char x1,y1,x2,y2;
    2828  unsigned char start_color,end_color;
     
    3030
    3131struct morph_point16
    32 { 
     32{
    3333  unsigned short x1,y1,x2,y2;
    3434  unsigned char start_color,end_color;
     
    4646  unsigned char small;
    4747  void *p;                  // points to a 8 or 16 struct
    48   long total; 
     48  long total;
    4949  unsigned short w[2],h[2];
    50 public : 
     50public :
    5151  int total_points() { return total; }
    5252  morph_point8 *small_points() { return (morph_point8 *)p; }
    5353  jmorph(spec_entry *e, FILE *fp);
    5454  jmorph(image *i1, image *hint1, image *i2, image *hint2, int aneal_steps);
    55   void show_frame(image *screen, int x, int y, int frames, int frame_on, 
    56              color_filter *fli, palette *pal); 
    57   void show_8(image *screen, int x, int y, int frame_on, color_filter *fli, palette *pal); 
     55  void show_frame(image *screen, int x, int y, int frames, int frame_on,
     56             color_filter *fli, palette *pal);
     57  void show_8(image *screen, int x, int y, int frame_on, color_filter *fli, palette *pal);
    5858  void show_24frame(unsigned char *screen, int width, int height,
    59                     int x, int y, int frames, int frame_on, palette *pal); 
     59                    int x, int y, int frames, int frame_on, palette *pal);
    6060  void show_step_frame(image *screen, int x, int y, int frame_on, color_filter *fli, palette *pal);
    6161  int bound_x1(int which) { return 0; }
     
    6767  int small_morph() { return small; }
    6868  ~jmorph() { jfree(p); }
    69 } ; 
     69} ;
    7070
    7171
     
    7878  patched_morph(spec_entry *e, FILE *fp);
    7979  patched_morph(image *i1, image *hint1, image *i2, image *hint2, int aneal_steps,
    80                 color_filter *fli, palette *pal, int frames);
    81   void show_frame(image *screen, int x, int y, int frame_on, color_filter *fli, palette *pal); 
    82   void show_8(image *screen, int x, int y, int frame_on, color_filter *fli, palette *pal); 
     80            color_filter *fli, palette *pal, int frames);
     81  void show_frame(image *screen, int x, int y, int frame_on, color_filter *fli, palette *pal);
     82  void show_8(image *screen, int x, int y, int frame_on, color_filter *fli, palette *pal);
    8383  ~patched_morph() { jfree(pats); }
    8484
     
    9999public :
    100100  step_morph(patched_morph *mor, palette *pal, int frame_direction, int face_direction);
    101   void show_frame(image *screen, int x, int y,  color_filter *fli); 
     101  void show_frame(image *screen, int x, int y,  color_filter *fli);
    102102  void reverse_direction();
    103103  ~step_morph() { jfree(points); }
  • abuse/trunk/src/imlib/mouse.hpp

    r57 r124  
    3737  void set_position(int new_mx, int new_my);
    3838  ~JCMouse();
    39  
     39
    4040#ifdef __POWERPC__
    41         int set_button(int b) { return (but = b); }
     41    int set_button(int b) { return (but = b); }
    4242#endif
    4343} ;
  • abuse/trunk/src/imlib/packet.cpp

    r56 r124  
    4242{ jfree(buf); }
    4343
    44 packet::packet(int prefix_size) 
    45 { 
     44packet::packet(int prefix_size)
     45{
    4646  pre_size=prefix_size;
    4747
     
    5353  buf_size=1000;
    5454  buf=(uint8_t *)jmalloc(buf_size,"packet buffer");
    55   reset(); 
     55  reset();
    5656
    5757#ifdef MANAGE_MEM
     
    6565  while (len>1 && !eop() && *b)
    6666  {
    67     *st=*b; 
     67    *st=*b;
    6868    st++;
    6969    ro++;
     
    7575}
    7676
    77 void packet::reset() 
     77void packet::reset()
    7878{ ro=wo=rend=pre_size; }
    7979
     
    8383  {
    8484    buf_size=max;
    85     buf=(uint8_t *)jrealloc(buf,max,"packet buffer"); 
     85    buf=(uint8_t *)jrealloc(buf,max,"packet buffer");
    8686  }
    8787}
  • abuse/trunk/src/imlib/palette.cpp

    r56 r124  
    9393    if (usd[ub]&mask)
    9494      if (r==pal[i].red && b==pal[i].blue && g==pal[i].green)
    95         find=i;
     95    find=i;
    9696    mask>>=1;
    9797    if (mask==0)
     
    220220      {
    221221        if (pal[i].red==r && pal[i].green==g && pal[i].blue==b)
    222         f=i;
     222    f=i;
    223223      }
    224224      else
     
    239239      for (i=0,f=0,u=10000;i<ncolors;i++)
    240240      { c=(pal[i].red-r)*(pal[i].red-r)+
    241           (pal[i].green-g)*(pal[i].green-g)+
    242           (pal[i].blue-b)*(pal[i].blue-b);
    243         if (c<u)
    244         { f=i;
    245           u=c;
    246         }
     241      (pal[i].green-g)*(pal[i].green-g)+
     242      (pal[i].blue-b)*(pal[i].blue-b);
     243    if (c<u)
     244    { f=i;
     245      u=c;
     246    }
    247247      }
    248248    }
    249   } 
     249  }
    250250  return f;
    251251}
     
    293293{ CONDITION(x>=0 && x<ncolors,"Pallete::set passed bad x");
    294294  CONDITION((int)red<=ncolors && (int)green<=ncolors && (int)blue<=ncolors,
    295             "pallette::set color values bigger than palette");
     295        "pallette::set color values bigger than palette");
    296296  pal[x].red=red; pal[x].green=green; pal[x].blue=blue;
    297297}
     
    323323  { for (i=0;i<8;i++)
    324324      if (children[i])
    325       { delete children[i];
    326         children[i]=NULL;
     325      {    delete children[i];
     326    children[i]=NULL;
    327327      }
    328328  } */
     
    353353  { for (i=0;i<8;i++)
    354354      if (children[i])
    355         children[i]->total(tnodes,tr,tg,tb);
     355    children[i]->total(tnodes,tr,tg,tb);
    356356  }
    357357}
    358358
    359359quant_node::quant_node(int level, quant_node *dad,
    360         unsigned char r, unsigned char g, unsigned char b)
     360    unsigned char r, unsigned char g, unsigned char b)
    361361{
    362362  int i;
     
    380380    if (!who->is_leaf())
    381381    { for (x=0;x<8;x++)
    382         if (who->children[x])
    383         {
    384           CONDITION(lev<8,"Levl > 7");
    385           re_delete(who->children[x],lev+1);
    386           level[lev].unlink((linked_node *)who->children[x]);
    387           delete who->children[x];
    388         }
     382    if (who->children[x])
     383    {
     384      CONDITION(lev<8,"Levl > 7");
     385      re_delete(who->children[x],lev+1);
     386      level[lev].unlink((linked_node *)who->children[x]);
     387      delete who->children[x];
     388    }
    389389    }
    390390  }
     
    401401    { do
    402402      {
    403         f=p->father();
    404         for (x=0;x<8 && !pruned;x++)
    405           if (f->children[x])
    406             if (f->children[x]->next()!=p->next())        // if this son is not me!
    407             pruned=1;                   //  I have a brother! stop
     403    f=p->father();
     404    for (x=0;x<8 && !pruned;x++)
     405      if (f->children[x])
     406        if (f->children[x]->next()!=p->next())        // if this son is not me!
     407        pruned=1;                   //  I have a brother! stop
    408408       p=(quant_node *)p->next();
    409409      } while ((linked_node *) p!=level[lev-1].first() && !pruned);
     
    442442    lev++;
    443443    if (!(*p))
    444     { 
     444    {
    445445      if (lev>2 && !fat)
    446         printf("h");
     446    printf("h");
    447447      (*p)=new quant_node(lev,fat);
    448448      level[lev-1].add_end((linked_node *)(*p));
     
    473473  for (x=0,i=7;i>=0;i++)
    474474    for (pn=(quant_node *)level[i].first();
    475         pn!=(quant_node *)level[i].first();pn=(quant_node *)pn->next())
     475    pn!=(quant_node *)level[i].first();pn=(quant_node *)pn->next())
    476476      if (pn->is_leaf())
    477         p->set(x++,pn->red,pn->green,pn->blue);
     477    p->set(x++,pn->red,pn->green,pn->blue);
    478478  return p;
    479479}
     
    500500      if ((long)r*(long)g*(long)b>brv)
    501501      { brv=(long)r*(long)g*(long)b;
    502         bri=i;
     502    bri=i;
    503503      }
    504504    }
     
    521521      if (x<brv && (x || !noblack))
    522522      { brv=(long)r*(long)g*(long)b;
    523         bri=i;
     523    bri=i;
    524524      }
    525525    }
     
    544544    x=(( dest_g-(int)*sl)*fade_on/total_fades+*sl);
    545545    *(sl++)=x;
    546     x=(( dest_b-(int)*sl)*fade_on/total_fades+*sl);   
     546    x=(( dest_b-(int)*sl)*fade_on/total_fades+*sl);
    547547    *(sl++)=x;
    548   } 
    549 }
     548  }
     549}
  • abuse/trunk/src/imlib/palette.hpp

    r57 r124  
    6161  int background(unsigned char b)  { return bg; }
    6262  int add_color(unsigned int r, unsigned int g, unsigned int b,
    63                  int closest_only=0);
     63             int closest_only=0);
    6464  int find_color(unsigned char r, unsigned char g, unsigned char b);
    6565  int find_closest(unsigned char r, unsigned char g, unsigned char b);
     
    7474
    7575class quant_node : public linked_node
    76 { 
     76{
    7777  quant_node *padre;
    7878public :
     
    8383  quant_node *father() { return padre; }
    8484  quant_node(int level, quant_node *dad,
    85         unsigned char r=0, unsigned char g=0, unsigned char b=0);
     85    unsigned char r=0, unsigned char g=0, unsigned char b=0);
    8686  void total(int &tnodes, int &tr, int &tg, int &tb);
    8787//  void prune();
  • abuse/trunk/src/imlib/pcxread.cpp

    r56 r124  
    2525int read_PCX_header(FILE *fp)
    2626{
    27   if (!fread(&PCX_header.manufactururer,1,1,fp)) return 0; 
    28   if (!fread(&PCX_header.version,1,1,fp)) return 0; 
    29   if (!fread(&PCX_header.encoding,1,1,fp)) return 0; 
    30   if (!fread(&PCX_header.bits_per_pixel,1,1,fp)) return 0; 
     27  if (!fread(&PCX_header.manufactururer,1,1,fp)) return 0;
     28  if (!fread(&PCX_header.version,1,1,fp)) return 0;
     29  if (!fread(&PCX_header.encoding,1,1,fp)) return 0;
     30  if (!fread(&PCX_header.bits_per_pixel,1,1,fp)) return 0;
    3131  PCX_header.xmin=read_uint16(fp);
    32   PCX_header.ymin=read_uint16(fp); 
     32  PCX_header.ymin=read_uint16(fp);
    3333  PCX_header.xmax=read_uint16(fp);
    3434  PCX_header.ymax=read_uint16(fp);
     
    3838  if (!fread(&PCX_header.reserved,1,1,fp)) return 0;
    3939  if (!fread(&PCX_header.color_planes,1,1,fp)) return 0;
    40   PCX_header.bytes_per_line=read_uint16(fp); 
    41   PCX_header.palette_type=read_uint16(fp); 
     40  PCX_header.bytes_per_line=read_uint16(fp);
     41  PCX_header.palette_type=read_uint16(fp);
    4242  if (!fread(PCX_header.filter,1,58,fp)) return 0;
    4343  return 1;
     
    4646int write_PCX_header(FILE *fp)
    4747{
    48   if (!fwrite(&PCX_header.manufactururer,1,1,fp)) return 0; 
    49   if (!fwrite(&PCX_header.version,1,1,fp)) return 0; 
    50   if (!fwrite(&PCX_header.encoding,1,1,fp)) return 0; 
    51   if (!fwrite(&PCX_header.bits_per_pixel,1,1,fp)) return 0; 
     48  if (!fwrite(&PCX_header.manufactururer,1,1,fp)) return 0;
     49  if (!fwrite(&PCX_header.version,1,1,fp)) return 0;
     50  if (!fwrite(&PCX_header.encoding,1,1,fp)) return 0;
     51  if (!fwrite(&PCX_header.bits_per_pixel,1,1,fp)) return 0;
    5252  write_uint16(fp,PCX_header.xmin);
    53   write_uint16(fp,PCX_header.ymin); 
     53  write_uint16(fp,PCX_header.ymin);
    5454  write_uint16(fp,PCX_header.xmax);
    5555  write_uint16(fp,PCX_header.ymax);
     
    5959  if (!fwrite(&PCX_header.reserved,1,1,fp)) return 0;
    6060  if (!fwrite(&PCX_header.color_planes,1,1,fp)) return 0;
    61   write_uint16(fp,PCX_header.bytes_per_line); 
    62   write_uint16(fp,PCX_header.palette_type); 
     61  write_uint16(fp,PCX_header.bytes_per_line);
     62  write_uint16(fp,PCX_header.palette_type);
    6363  if (!fwrite(PCX_header.filter,1,58,fp)) return 0;
    6464  return 1;
     
    6969PCX_type PCX_file_type(char const *filename)
    7070{
    71   FILE *fp=fopen(filename,"rb"); 
     71  FILE *fp=fopen(filename,"rb");
    7272  if (!fp)
    73   { set_error(imREAD_ERROR); 
     73  { set_error(imREAD_ERROR);
    7474    return not_PCX;
    7575  }
    76  
    77   if (!read_PCX_header(fp))     
    78   {
    79     fclose(fp);   
    80     set_error(imREAD_ERROR); 
    81     return not_PCX;   
    82   }
    83   fclose(fp);     
    84   if (PCX_header.manufactururer!=10) 
    85     return not_PCX; 
     76
     77  if (!read_PCX_header(fp))
     78  {
     79    fclose(fp);
     80    set_error(imREAD_ERROR);
     81    return not_PCX;
     82  }
     83  fclose(fp);
     84  if (PCX_header.manufactururer!=10)
     85    return not_PCX;
    8686  if (PCX_header.color_planes==3 && PCX_header.bits_per_pixel==8)
    8787    return PCX_24;
    8888  else if (PCX_header.color_planes==1 && PCX_header.bits_per_pixel==8)
    8989    return PCX_8;
    90   else return not_PCX;   
     90  else return not_PCX;
    9191}
    9292
     
    9494{
    9595  int c,n=0,i;
    96  
     96
    9797  do
    9898  {
     
    102102      i=c&0x3f;
    103103      c=fgetc(fp);
    104       while (i--) 
     104      while (i--)
    105105      {
    106         *start=c;
    107         start+=skip;
    108         n++;   
     106    *start=c;
     107    start+=skip;
     108        n++;   
    109109      }
    110110    }
     
    114114      start+=skip;
    115115      n++;
    116     }   
    117   } while (n<width);   
     116    }
     117  } while (n<width);
    118118}
    119119
     
    121121image24 *read_PCX24(char const *filename)
    122122{
    123   if (PCX_file_type(filename)!=PCX_24) return NULL; 
     123  if (PCX_file_type(filename)!=PCX_24) return NULL;
    124124  FILE *fp=fopen(filename,"rb");
    125   read_PCX_header(fp); 
     125  read_PCX_header(fp);
    126126  image24 *im=new image24(PCX_header.xmax-PCX_header.xmin+1,
    127                           PCX_header.ymax-PCX_header.ymin+1);
     127              PCX_header.ymax-PCX_header.ymin+1);
    128128  int y;
    129129  for (y=0;y<im->height();y++)
     
    131131    read_PCX_line(fp,im->scan_line(y),3,PCX_header.bytes_per_line);
    132132    read_PCX_line(fp,im->scan_line(y)+1,3,PCX_header.bytes_per_line);
    133     read_PCX_line(fp,im->scan_line(y)+2,3,PCX_header.bytes_per_line);   
    134   }
    135   fclose(fp);
    136   return im; 
     133    read_PCX_line(fp,im->scan_line(y)+2,3,PCX_header.bytes_per_line);
     134  }
     135  fclose(fp);
     136  return im;
    137137}
    138138
    139139image *read_PCX(char const *filename, palette *&pal)
    140140{
    141   if (PCX_file_type(filename)!=PCX_8) return NULL; 
     141  if (PCX_file_type(filename)!=PCX_8) return NULL;
    142142  FILE *fp=fopen(filename,"rb");
    143143  read_PCX_header(fp);
    144  
     144
    145145  image *im=new image(PCX_header.xmax-PCX_header.xmin+1,
    146                       PCX_header.ymax-PCX_header.ymin+1);
     146              PCX_header.ymax-PCX_header.ymin+1);
    147147  int y;
    148148  for (y=0;y<im->height();y++)
    149149    read_PCX_line(fp,im->scan_line(y),1,PCX_header.bytes_per_line);
    150   unsigned char palette_confirm; 
     150  unsigned char palette_confirm;
    151151  if (!fread(&palette_confirm,1,1,fp) || palette_confirm!=12)
    152   {   
     152  {
    153153    pal=new palette;
    154154    pal->defaults();
     
    158158    pal=new palette;
    159159    fread(pal->addr(),1,256*3,fp);
    160   } 
    161   fclose(fp);
    162   return im; 
    163 } 
     160  }
     161  fclose(fp);
     162  return im;
     163}
    164164
    165165void write_PCX(image *im, palette *pal, char const *filename)
    166166{
    167167  FILE *fp=fopen(filename,"wb");
    168   if (!fp) 
     168  if (!fp)
    169169  {
    170170    set_error(imWRITE_ERROR);
    171171    return ;
    172172  }
    173  
    174  
    175   PCX_header.manufactururer=10; 
    176   PCX_header.version=5; 
     173
     174
     175  PCX_header.manufactururer=10;
     176  PCX_header.version=5;
    177177  PCX_header.encoding=1;
    178178  PCX_header.bits_per_pixel=8;
     
    190190
    191191
    192   if (!write_PCX_header(fp)) 
     192  if (!write_PCX_header(fp))
    193193  {
    194194    set_error( imWRITE_ERROR);
    195     return ; 
    196   }
    197  
     195    return ;
     196  }
     197
    198198  int y,run_length,x;
    199   unsigned char *sl,code; 
     199  unsigned char *sl,code;
    200200  for (y=0;y<im->height();y++)
    201201  {
     
    203203    for (x=0;x<im->width();)
    204204    {
    205       run_length=1;     
     205      run_length=1;
    206206      while (x+run_length<im->width() && sl[x]==sl[x+run_length])
    207207        run_length++;
    208       if (run_length==1 && sl[x]<64) 
    209         fputc(sl[x],fp);     
     208      if (run_length==1 && sl[x]<64)
     209        fputc(sl[x],fp);
    210210      else
    211211      {
    212212        if (run_length>=64)
    213           run_length=63;
    214         code=0xc0 | run_length;
    215         fputc(code,fp);
    216         fputc(sl[x],fp);
    217        
    218       }     
     213      run_length=63;
     214    code=0xc0 | run_length;
     215    fputc(code,fp);
     216    fputc(sl[x],fp);
     217   
     218      }
    219219      x+=run_length;
    220      
    221     }   
     220
     221    }
    222222  }
    223223  fputc(12,fp);  // note that there is a palette attached
    224224  fwrite(pal->addr(),1,256*3,fp);
    225   fclose(fp);   
    226 }
    227 
    228 
    229 
     225  fclose(fp);
     226}
     227
     228
     229
  • abuse/trunk/src/imlib/pmenu.cpp

    r120 r124  
    1818
    1919pmenu::pmenu(int X, int Y, pmenu_item *first, image *screen)
    20 { 
    21   top=first; 
    22   active=NULL; 
     20{
     21  top=first;
     22  active=NULL;
    2323
    2424  short cx1,cy1,cx2,cy2;
     
    3131  bar->freeze();  // can't drag this window
    3232  bar->screen->widget_bar(0,0,w-1,h-1,wm->bright_color(),wm->medium_color(),
    33                     wm->dark_color());
     33            wm->dark_color());
    3434
    3535