Changeset 115Tweet

Timestamp:

Mar 16, 2008, 10:51:54 PM (14 years ago)

Author:

Sam Hocevar

Message:

• Add lock() and unlock() methods to jimage objects. They're no-ops, but the Win32/DirectX version uses them all over the place because it uses DirectDraw? surfaces. One day we may wish to merge Abuse Win32's video output, or to use the SDL blending functions. You never know.

Location:

abuse/trunk/src

Files:

• automap.cpp (modified) (3 diffs)
• dev.cpp (modified) (4 diffs)
• game.cpp (modified) (2 diffs)
• imlib/filter.cpp (modified) (7 diffs)
• imlib/glread.cpp (modified) (7 diffs)
• imlib/image.cpp (modified) (70 diffs)
• imlib/image.hpp (modified) (5 diffs)
• imlib/morph.cpp (modified) (6 diffs)
• imlib/scroller.cpp (modified) (2 diffs)
• imlib/timage.cpp (modified) (25 diffs)
• level.cpp (modified) (1 diff)
• light.cpp (modified) (3 diffs)
• menu.cpp (modified) (4 diffs)
• particle.cpp (modified) (11 diffs)

abuse/trunk/src/automap.cpp

@@ -59 +59 @@
   if (draw_xstart==old_dx && draw_ystart==old_dy)  
   {
+   automap_window->screen->lock();
    automap_window->screen->add_dirty(centerx,centery,centerx,centery);
     if ((tick++)&4)
@@ -64 +65 @@
     else 
       automap_window->screen->putpixel(centerx,centery,27);
+   automap_window->screen->unlock();
     return ;   
   }
@@ -138 +140 @@
 
 
-  // draw the person as a dot, no need to add a dirty because we marked the whole screen already
+  // draw the person as a dot, no need to add a dirty because we marked the
+  // whole screen already
+  automap_window->screen->lock();
   if ((tick++)&4)
     automap_window->screen->putpixel(centerx,centery,255);
   else 
     automap_window->screen->putpixel(centerx,centery,27);
+  automap_window->screen->unlock();
 
   // set the clip back to full window size because soemthing else could mess with the area

abuse/trunk/src/dev.cpp

@@ -391 +391 @@
     new_height-=y+new_height-cy2;
 
-
+  screen->lock();
+  im->lock();
   for (iy=iy_start;new_height>0;new_height--,y++,iy+=ystep)
   {
@@ -399 +400 @@
       *sl2=sl1[ix>>16];
   }
+  im->unlock();
+  screen->unlock();
 }
 
@@ -431 +434 @@
 
   uint8_t d;
+  screen->lock();
   for (iy=iy_start;new_height>0;new_height--,y++,iy+=ystep)
   {
@@ -442 +446 @@
     }
   }
+  screen->unlock();
 }
 

abuse/trunk/src/game.cpp

@@ -897 +897 @@
       else
         screen->clear(wm->black());
+      screen->lock();
       for(y = y1, draw_y = yo; y <= y2; y++, draw_y += yinc)
       {
@@ -921 +922 @@
     }
       }
+      screen->unlock();
 
       if(dev & EDIT_MODE)

abuse/trunk/src/imlib/filter.cpp

@@ -98 +98 @@
 int color_compare(void *c1, void *c2)
 {
-  long v1,v2;  
+  long v1,v2;
   unsigned char r1,g1,b1,r2,g2,b2;
   compare_pal->get(  *((unsigned char *)c1),r1,g1,b1);
@@ -106 +106 @@
   if (v1<v2) return -1;
   else if (v1>v2) return 1;
-  else return 0;     
+  else return 0;
 }
 
@@ -114 +114 @@
   unsigned char map[256],*last_start,*start;
   int i,last_color=0,color;
-  compare_pal=pal;  
+  compare_pal=pal;
   for (i=0;i,256;i++)
     map[i]=i;
 
-  qsort(map,1,1,color_compare); 
+  qsort(map,1,1,color_compare);
   colors=1<<color_bits;
   last_start=color_table=(unsigned char *)malloc(colors*colors*colors);
 
-  
- 
+
+
   last_color=map[0];
   last_dist=0;
-  
-  
+
+
   for (i=1;i<colors;i++)
-  {   
+  {
     color=map[i<<(8-color_bits)];
-    dist=       
+    dist=
 
     memset(c,
   }
-  
-  
+
+
 }*/
 
 
 color_filter::color_filter(palette *pal, int color_bits, void (*stat_fun)(int))
-{ 
+{
   color_bits=5;      // hard code 5 for now
   int r,g,b,rv,gv,bv,
@@ -147 +147 @@
       lshift=8-color_bits;
   unsigned char *pp;
-  
+
   long dist_sqr,best;
   int colors=1<<color_bits;
@@ -154 +154 @@
   {
     if (stat_fun) stat_fun(r);
-    rv=r<<lshift;    
+    rv=r<<lshift;
     for (g=0;g<colors;g++)
     {
-      gv=g<<lshift;      
+      gv=g<<lshift;
       for (b=0;b<colors;b++)
       {
-        bv=b<<lshift;      
+        bv=b<<lshift;
         best=0x7fffffff;
         for (i=0,pp=(unsigned char *)pal->addr();i<max;i++)
-        { 
+        {
           register long rd=*(pp++)-rv,
                         gd=*(pp++)-gv,
                         bd=*(pp++)-bv;
-          
+        
           dist_sqr=(long)rd*rd+(long)bd*bd+(long)gd*gd;
           if (dist_sqr<best)
@@ -177 +177 @@
       }
     }
-  }  
+  }
 }
 
@@ -203 +203 @@
 
 
-void filter::put_image(image *screen, image *im, short x, short y, char transparent)
-{
-  short cx1,cy1,cx2,cy2,x1=0,y1=0,x2=im->width()-1,y2=im->height()-1;
-  screen->get_clip(cx1,cy1,cx2,cy2);
-  
-  // see if the image gets clipped off the screen
-  if (x>cx2 || y>cy2 || x+(x2-x1)<cx1 || y+(y2-y1)<cy1) return ;
-  
-  if (x<cx1)
-  { x1+=(cx1-x); x=cx1; }
-  if (y<cy1)
-  { y1+=(cy1-y); y=cy1; }
-
-  if (x+x2-x1+1>cx2)
-  { x2=cx2-x+x1; }
-
-  if (y+y2-y1+1>cy2)
-  { y2=cy2-y+y1; }
-  if (x1>x2 || y1>y2) return ;    
-
-  
-
-
-  int xl=x2-x1+1;
-  int yl=y2-y1+1;
-
-  screen->add_dirty(x,y,x+xl-1,y+yl-1);
-
-  uint8_t *pg1=screen->scan_line(y),*source,*dest;
-  uint8_t *pg2=im->scan_line(y1);
-  int i;
-  for (int j=0;j<yl;j++)        
-  {
-    for (i=0,source=&pg2[x1],dest=&pg1[x];i<xl;i++,source++,dest++)     
-      if (!transparent || *source!=current_background) 
-        *dest=fdat[*source];
-    pg1=screen->next_line(y+j,pg1);  
-    pg2=im->next_line(y1+j,pg2);
-  }
-
-}
-
-
-
-
-
+void filter::put_image(image *screen, image *im, short x, short y,
+                       char transparent)
+{
+    short cx1, cy1, cx2, cy2, x1 = 0, y1 = 0,
+          x2 = im->width() - 1, y2 = im->height() - 1;
+    screen->get_clip(cx1,cy1,cx2,cy2);
+
+    // see if the image gets clipped off the screen
+    if(x > cx2 || y > cy2 || x + (x2 - x1) < cx1 || y + (y2 - y1) < cy1)
+        return;
+
+    if(x < cx1)
+    {
+        x1 += (cx1 - x);
+        x = cx1;
+    }
+    if(y < cy1)
+    {
+        y1 += (cy1 - y);
+         y = cy1;
+    }
+
+    if(x + x2 - x1 + 1 > cx2)
+        x2 = cx2 - x + x1;
+
+    if(y + y2 - y1 + 1 > cy2)
+        y2 = cy2 - y + y1;
+
+    if(x1 > x2 || y1 > y2)
+        return;
+
+    int xl = x2 - x1 + 1;
+    int yl = y2 - y1 + 1;
+
+    screen->add_dirty(x, y, x + xl - 1, y + yl - 1);
+
+    screen->lock();
+    im->lock();
+
+    uint8_t *pg1 = screen->scan_line(y), *source, *dest;
+    uint8_t *pg2 = im->scan_line(y1);
+    int i;
+    for(int j = 0; j < yl; j++)
+    {
+        for(i = 0, source = &pg2[x1], dest = &pg1[x];
+            i < xl;
+            i++, source++, dest++)      
+        {
+            if(!transparent || *source != current_background)
+                *dest=fdat[*source];
+        }
+        pg1 = screen->next_line(y + j, pg1);
+        pg2 = im->next_line(y1 + j, pg2);
+    }
+
+    im->unlock();
+    screen->unlock();
+}
+

abuse/trunk/src/imlib/glread.cpp

@@ -41 +41 @@
   while (first<=last)
   {
+    sub->lock();
     for (y=0;(int)y<(int)height;y++)
     {
@@ -46 +47 @@
       sub->unpack_scanline(y);
     }
+    sub->unlock();
     sub->put_image(im,(first%32)*width,(first/32)*height);
     first++;
@@ -55 +57 @@
 image *read_pic(char *fn, palette *&pal)
 {
-  image *im;
+  image *im = NULL;
   char x[4],bpp;
   uint8_t *sl=NULL,esc,c,n,marker,vmode;
@@ -61 +63 @@
   int xx,yy;
   FILE *fp;
-  im=NULL;
   fp=fopen(fn,"rb");
 
@@ -74 +75 @@
   { fclose(fp); set_error(imFILE_CORRUPTED); return NULL; }
 
-  im=new image(w,h);
+  im = new image(w, h);
 
   fread(&vmode,1,1,fp);
@@ -92 +93 @@
 
   yy=h; xx=w;
+
+  im->lock();
 
   while (blocks-- && w>=1 && yy>=0)
@@ -137 +140 @@
     }
   }
+
+  im->unlock();
+
   fclose(fp);
   return im;

abuse/trunk/src/imlib/image.cpp

@@ -36 +36 @@
     "Error occurred while writing, (disk full?)"
 };
-                        
+            
                          
 int16_t imerror=0;
@@ -49 +49 @@
   { printf("Program stopped, error : ");
     if (imerror<=imMAX_ERROR)
-      printf("%s\n",imerr_messages[imerror]);
+      printf("%s\n", imerr_messages[imerror]);
     else
       printf("Unsonsponsered error code, you got trouble\n"); 
@@ -57 +57 @@
     nosound();
 #else
-    printf("%c%c\n",7,8);
+    printf("%c%c\n", 7, 8);
 #endif
     exit(1);
@@ -78 +78 @@
 
 image_descriptor::image_descriptor(int16_t length, int16_t height,
-                                   int keep_dirties, int static_memory)
+                   int keep_dirties, int static_memory)
 
 { clipx1=0; clipy1=0; 
@@ -92 +92 @@
   w=new_width;
   h=new_height;
-  make_page(new_width,new_height,page);
+  make_page(new_width, new_height, page);
 }
 
 image::~image()
 {
-  image_list.unlink((linked_node *)this);
-  delete_page();
-  if (special)
-    delete special;
-
+    if(_locked)
+    {
+        fprintf(stderr, "Error: image is locked upon deletion\n");
+        unlock();
+    }
+
+    image_list.unlink((linked_node *)this);
+    delete_page();
+    if(special)
+        delete special;
 }
 
@@ -107 +112 @@
 void make_block(size_t size)
 {
-  void *dat=jmalloc(size,"make_block : tmp");
-  CONDITION(dat,"Memory error : could not make block\n");
+  void *dat=jmalloc(size, "make_block : tmp");
+  CONDITION(dat, "Memory error : could not make block\n");
   if (dat) jfree((char *)dat);
 }
@@ -125 +130 @@
   if (special)
   { if (x>=special->x1_clip() && x<=special->x2_clip() &&
-        y>=special->y1_clip() && y<=special->y2_clip())
+    y>=special->y1_clip() && y<=special->y2_clip())
       (*(scan_line(y)+x))=color;
   } else (*(scan_line(y)+x))=color;
@@ -138 +143 @@
   { 
     if (create_descriptor==2)
-      special=new image_descriptor(width,height,1,(page_buffer!=NULL));
-    else special=new image_descriptor(width,height,0,(page_buffer!=NULL));
+      special=new image_descriptor(width, height, 1, (page_buffer!=NULL));
+    else special=new image_descriptor(width, height, 0, (page_buffer!=NULL));
   } else special=NULL;
-  make_page(width,height,page_buffer);
+  make_page(width, height, page_buffer);
   image_list.add_end((linked_node *) this);
+    _locked = false;
 }
 
@@ -148 +154 @@
 {
   int16_t i; 
-  fp->seek(e->offset,0);
+  fp->seek(e->offset, 0);
   w=fp->read_uint16();
   h=fp->read_uint16();
   special=NULL;
-  make_page(w,h,NULL);
-  for (i=0;i<h;i++)
-    fp->read(scan_line(i),w);
+  make_page(w, h, NULL);
+  for (i=0; i<h; i++)
+    fp->read(scan_line(i), w);
   image_list.add_end((linked_node *) this); 
+    _locked = false;
 }
 
@@ -164 +171 @@
   h=fp->read_uint16();
   special=NULL;
-  make_page(w,h,NULL);
-  for (i=0;i<h;i++)
-    fp->read(scan_line(i),w);
+  make_page(w, h, NULL);
+  for (i=0; i<h; i++)
+    fp->read(scan_line(i), w);
   image_list.add_end((linked_node *) this); 
+    _locked = false;
+}
+
+void image::lock()
+{
+    /* This is currently a no-op, because it's unneeded with SDL */
+
+    if(_locked)
+        fprintf(stderr, "Trying to lock a locked picture!\n");
+    _locked = true;
+}
+
+void image::unlock()
+{
+    /* This is currently a no-op, because it's unneeded with SDL */
+
+    if(!_locked)
+        fprintf(stderr, "Trying to unlock an unlocked picture!\n");
+    _locked = false;
 }
 
 void image_uninit()
 {
+    /* FIXME: is this used at all? */
 /*  image *im;
   while (image_list.first())
@@ -188 +215 @@
 {
   uint8_t bt[2];
-  uint16_t wrd,*up;
+  uint16_t wrd, *up;
   bt[0]=1;
   bt[1]=0;
@@ -195 +222 @@
   if (wrd!=0x01)
   { printf("compiled with wrong endianness, edit system.h and try again\n");
-    printf("1 (intel) = %d\n",(int)wrd);
+    printf("1 (intel) = %d\n", (int)wrd);
     exit(1);
   }
@@ -204 +231 @@
 int32_t image::total_pixels(uint8_t background)
 {
-  int16_t i,j;
-  int32_t co;
-  uint8_t *c;
-  for (co=0,i=height()-1;i>=0;i--)
-  { c=scan_line(i);
-    for (j=width()-1;j>=0;j--,c++)
-      if (*c!=background) co++;
-  }
-  return co;
+    int16_t i, j;
+    int32_t co;
+    uint8_t *c;
+
+    lock();
+    for(co = 0, i = height() - 1; i >= 0; i--)
+    {
+        c = scan_line(i);
+        for(j = width() - 1; j >= 0; j--, c++)
+            if(*c != background) co++;
+    }
+    unlock();
+    return co;
 }
 
 void image::clear(int16_t color)
 {
-  int16_t i;
-  if (color==-1) color=current_background;
-  if (special)
-  { if (special->x1_clip()<=special->x2_clip())
-      for (i=special->y2_clip();i>=special->y1_clip();i--)
-        memset(scan_line(i)+special->x1_clip(),color,
-               special->x2_clip()-special->x1_clip()+1);
-  }
-  else
-    for (i=height()-1;i>=0;i--)
-      memset(scan_line(i),color,width());
-  add_dirty(0,0,width()-1,height()-1);
-}
-
+    int16_t i;
+
+    lock();
+    if(color == -1)
+        color = current_background;
+    if(special)
+    {
+        if(special->x1_clip() <= special->x2_clip())
+            for(i = special->y2_clip(); i >= special->y1_clip(); i--)
+                memset(scan_line(i) + special->x1_clip(), color,
+                       special->x2_clip() - special->x1_clip() + 1);
+    }
+    else
+        for(i = height() - 1; i >= 0; i--)
+            memset(scan_line(i), color, width());
+    add_dirty(0, 0, width() - 1, height() - 1);
+    unlock();
+}
 
 image *image::copy()
 {
-  image *im;
-  uint8_t *c,*dat;
-  int i;
-  dat=(uint8_t *)jmalloc(width(),"image copy");
-  im=new image(width(),height());
-  for (i=height()-1;i>=0;i--)
-  { c=scan_line(i);
-    memcpy(dat,c,width());
-    c=im->scan_line(i);
-    memcpy(c,dat,width());
-  }
-  jfree((char *)dat);
-  return im;
-}
-
-
-
-void image::line(int16_t x1, int16_t y1,int16_t x2, int16_t y2, uint8_t color)
-{
-  int16_t i,xc,yc,er,n,m,xi,yi,xcxi,ycyi,xcyi;
-  unsigned dcy,dcx;
+    image *im;
+    uint8_t *c, *dat;
+    int i;
+
+    lock();
+    dat = (uint8_t *)jmalloc(width(), "image copy");
+    im = new image(width(), height());
+    im->lock();
+    for(i = height() - 1; i >= 0; i--)
+    {
+        c = scan_line(i);
+        memcpy(dat, c, width());
+        c = im->scan_line(i);
+        memcpy(c, dat, width());
+    }
+    im->unlock();
+    unlock();
+    jfree((char *)dat);
+    return im;
+}
+
+void image::line(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
+{
+  int16_t i, xc, yc, er, n, m, xi, yi, xcxi, ycyi, xcyi;
+  unsigned dcy, dcx;
   // check to make sure that both endpoint are on the screen
 
-  int16_t cx1,cy1,cx2,cy2;
+  int16_t cx1, cy1, cx2, cy2;
 
   // check to see if the line is completly clipped off
-  get_clip(cx1,cy1,cx2,cy2);  
+  get_clip(cx1, cy1, cx2, cy2);  
   if ((x1<cx1 && x2<cx1) || (x1>cx2 && x2>cx2) || 
       (y1<cy1 && y2<cy1) || (y1>cy2 && y2>cy2))
@@ -275 +314 @@
   {  
     int my=(y2-y1);       
-    int mx=(x2-x1),b;
+    int mx=(x2-x1), b;
     if (!mx) return ;
     if (my)
@@ -290 +329 @@
   {  
     int my=(y2-y1);       
-    int mx=(x2-x1),b;
+    int mx=(x2-x1), b;
     if (!mx) return ;
     if (my)
@@ -311 +350 @@
   {  
     int mx=(x2-x1);       
-    int my=(y2-y1),b;
+    int my=(y2-y1), b;
     if (!my)
       return ;
@@ -327 +366 @@
   {  
     int mx=(x2-x1);       
-    int my=(y2-y1),b;
+    int my=(y2-y1), b;
     if (!my) return ;
     if (mx)
@@ -353 +392 @@
   yi=y2; yc=y1;
 
-  add_dirty(xc,yc,xi,yi);
+  add_dirty(xc, yc, xi, yi);
   dcx=x1; dcy=y1;
   xc=(x2-x1); yc=(y2-y1);
@@ -362 +401 @@
   er=0;
 
+  lock();
   if (n>m)
   {
     xcxi=abs(2*xc*xi);
-    for (i=0;i<=n;i++)
+    for (i=0; i<=n; i++)
     {
       *(scan_line(dcy)+dcx)=color;
       if (er>0)
       { dcy+=yi;
-        er-=xcxi;
+    er-=xcxi;
       }
       er+=ycyi;
@@ -379 +419 @@
   {
     xcyi=abs(2*xc*yi);
-    for (i=0;i<=m;i++)
+    for (i=0; i<=m; i++)
     {
       *(scan_line(dcy)+dcx)=color;
       if (er>0)
       { dcx+=xi;
-        er-=ycyi;
+    er-=ycyi;
       }
       er+=xcyi;
@@ -390 +430 @@
     }
   }
+  unlock();
 }
 
@@ -395 +436 @@
 void image::put_image(image *screen, int16_t x, int16_t y, char transparent)
 {
-  int16_t i,j,xl,yl;
-  uint8_t *pg1,*pg2,*source,*dest;
-  if (screen->special)  // the screen is clipped then we onl want to put
-                    // part of the image
-    put_part(screen,x,y,0,0,width()-1,height()-1,transparent);
-  else
-  {
-    if (x<screen->width() && y<screen->height())
-    {
-      xl=width();
-      if (x+xl>screen->width())     // clip to the border of the screen
-        xl=screen->width()-x;
-      yl=height();
-      if (y+yl>screen->height())
-        yl=screen->height()-y;
-
-      int startx=0,starty=0;
-      if (x<0) { startx=-x; x=0; }
-      if (y<0) { starty=-y; y=0; }
-
-      if (xl<0 || yl<0) return ;
-
-      screen->add_dirty(x,y,x+xl-1,y+yl-1);
-      for (j=starty;j<yl;j++,y++)
-      {
-        pg1=screen->scan_line(y);
-        pg2=scan_line(j);
-        if (transparent)
-        {
-          for (i=startx,source=pg2+startx,dest=pg1+x;i<xl;i++,source++,dest++)
-            if (*source!=current_background) *dest=*source;
-        } else memcpy(&pg1[x],pg2,xl);   // strait copy
-      }
-    }
-  }
+    int16_t i, j, xl, yl;
+    uint8_t *pg1, *pg2, *source, *dest;
+
+    // the screen is clipped then we only want to put part of the image
+    if(screen->special)
+    {
+        put_part(screen, x, y, 0, 0, width()-1, height()-1, transparent);
+        return;
+    }
+
+    if(x < screen->width() && y < screen->height())
+    {
+        xl = width();
+        if(x + xl > screen->width()) // clip to the border of the screen
+            xl = screen->width() - x;
+        yl = height();
+        if(y + yl > screen->height())
+            yl = screen->height() - y;
+
+        int startx = 0, starty = 0;
+        if(x < 0)
+        {
+            startx = -x;
+            x = 0;
+        }
+        if(y < 0)
+        {
+            starty = -y;
+            y = 0;
+        }
+
+        if(xl < 0 || yl < 0)
+            return;
+
+        screen->add_dirty(x, y, x + xl - 1, y + yl - 1);
+        screen->lock();
+        lock();
+        for(j = starty; j < yl; j++, y++)
+        {
+            pg1 = screen->scan_line(y);
+            pg2 = scan_line(j);
+            if(transparent)
+            {
+                for(i = startx, source = pg2+startx, dest = pg1 + x;
+                    i < xl;
+                    i++, source++, dest++)
+                {
+                    if(*source != current_background)
+                        *dest = *source;
+                }
+            }
+            else
+                memcpy(&pg1[x], pg2, xl); // straight copy
+        }
+        unlock();
+        screen->unlock();
+    }
 }
 
 void image::fill_image(image *screen, int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t align)
 {
-  int16_t i,j,w,xx,start,xl,starty;
-  uint8_t *pg1,*pg2;
+  int16_t i, j, w, xx, start, xl, starty;
+  uint8_t *pg1, *pg2;
   CHECK(x1<=x2 && y1<=y2);  // we should have gotten this
 
@@ -452 +515 @@
   if (x2<0 || y2<0 || x1>=screen->width() || y1>=screen->height())
     return ;
-  screen->add_dirty(x1,y1,x2,y2);
+  screen->add_dirty(x1, y1, x2, y2);
   w=width();
   if (align)
@@ -463 +526 @@
     starty=0;
   }
-  for (j=y1;j<=y2;j++)
+  screen->lock();
+  lock();
+  for (j=y1; j<=y2; j++)
   {
     pg1=screen->scan_line(j);
@@ -472 +537 @@
     while (i<=x2)
     {
-      xl=min(w-xx,x2-i+1);
-
-      memcpy(&pg1[i],&pg2[xx],xl);
+      xl=min(w-xx, x2-i+1);
+
+      memcpy(&pg1[i], &pg2[xx], xl);
       xx=0;
       i+=xl;
     }
   }
+  unlock();
+  screen->unlock();
 }
 
 
 void image::put_part(image *screen, int16_t x, int16_t y,
-                int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
-{
-  int16_t xl,yl,j,i;
-  int16_t cx1,cy1,cx2,cy2;
-  uint8_t *pg1,*pg2,*source,*dest;
+        int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
+{
+  int16_t xlen, ylen, j, i;
+  int16_t cx1, cy1, cx2, cy2;
+  uint8_t *pg1, *pg2, *source, *dest;
   CHECK(x1<=x2 && y1<=y2);
 
-  screen->get_clip(cx1,cy1,cx2,cy2);
+  screen->get_clip(cx1, cy1, cx2, cy2);
 
 
@@ -521 +588 @@
 
 
-  xl=x2-x1+1;
-  yl=y2-y1+1;
-
-  screen->add_dirty(x,y,x+xl-1,y+yl-1);
-
+  xlen=x2-x1+1;
+  ylen=y2-y1+1;
+
+  screen->add_dirty(x, y, x+xlen-1, y+ylen-1);
+
+  screen->lock();
+  lock();
   pg1=screen->scan_line(y);
   pg2=scan_line(y1);
@@ -531 +600 @@
   if (transparent)
   {
-    for (j=0;j<yl;j++)        
-    {
-      for (i=0,source=&pg2[x1],dest=&pg1[x];i<xl;i++,source++,dest++)   
+    for (j=0; j<ylen; j++)        
+    {
+      for (i=0, source=&pg2[x1], dest=&pg1[x]; i<xlen; i++, source++, dest++)    
         if (*source!=current_background) *dest=*source;
-      pg1=screen->next_line(y+j,pg1);  
-      pg2=next_line(y1+j,pg2);
+      pg1=screen->next_line(y+j, pg1);  
+      pg2=next_line(y1+j, pg2);
     }      
   }
   else
-  for (j=0;j<yl;j++)
-  {     
-    memcpy(&pg1[x],&pg2[x1],xl);   // strait copy
-    pg1=screen->next_line(y+j,pg1);  
-    pg2=next_line(y1+j,pg2);
+  for (j=0; j<ylen; j++)
+  {    
+    memcpy(&pg1[x], &pg2[x1], xlen);   // strait copy
+    pg1=screen->next_line(y+j, pg1);  
+    pg2=next_line(y1+j, pg2);
   }    
+  unlock();
+  screen->unlock();
 }
 
 void image::put_part_xrev(image *screen, int16_t x, int16_t y,
-                int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
-{
-  int16_t xl,yl,j,i;
-  int16_t cx1,cy1,cx2,cy2;
-  uint8_t *pg1,*pg2,*source,*dest;
+        int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
+{
+  int16_t xl, yl, j, i;
+  int16_t cx1, cy1, cx2, cy2;
+  uint8_t *pg1, *pg2, *source, *dest;
   CHECK(x1<=x2 && y1<=y2);
 
@@ -566 +637 @@
   if (screen->special)
   {
-    screen->special->get_clip(cx1,cy1,cx2,cy2);
+    screen->special->get_clip(cx1, cy1, cx2, cy2);
     if (x>cx2 || y>cy2 || x+(x2-x1)<0 || y+(y2-y1)<0) return ;
     if (x<cx1)
@@ -593 +664 @@
     if (y+yl>screen->height())
       yl=screen->height()-y;
-    screen->add_dirty(x,y,x+xl-1,y+yl-1);
-    for (j=0;j<yl;j++)
+    screen->add_dirty(x, y, x+xl-1, y+yl-1);
+    screen->lock();
+    lock();
+    for (j=0; j<yl; j++)
     {
       pg1=screen->scan_line(y+j);
@@ -600 +673 @@
       if (transparent)
       {
-        for (i=0,source=&pg2[x1],dest=&pg1[x+xl-1];i<xl;i++,source++,dest--)
+    for (i=0, source=&pg2[x1], dest=&pg1[x+xl-1]; i<xl; i++, source++, dest--)
           if (*source!=current_background) *dest=*source;
       }
       else 
-        for (i=0,source=&pg2[x1],dest=&pg1[x+xl-1];i<xl;i++,source++,dest++)
+    for (i=0, source=&pg2[x1], dest=&pg1[x+xl-1]; i<xl; i++, source++, dest++)
           *dest=*source;
     }
+    unlock();
+    screen->unlock();
   }
 }
@@ -612 +687 @@
 
 void image::put_part_masked(image *screen, image *mask, int16_t x, int16_t y,
-                int16_t maskx, int16_t masky,
-                int16_t x1, int16_t y1, int16_t x2, int16_t y2)
-{
-  int16_t xl,yl,j,i,ml,mh;
-  int16_t cx1,cy1,cx2,cy2;
-  uint8_t *pg1,*pg2,*pg3;
+        int16_t maskx, int16_t masky,
+        int16_t x1, int16_t y1, int16_t x2, int16_t y2)
+{
+  int16_t xl, yl, j, i, ml, mh;
+  int16_t cx1, cy1, cx2, cy2;
+  uint8_t *pg1, *pg2, *pg3;
   CHECK(x1<=x2 && y1<=y2);
 
   if (screen->special)
   {
-    screen->special->get_clip(cx1,cy1,cx2,cy2);
+    screen->special->get_clip(cx1, cy1, cx2, cy2);
     if (x>cx2 || y>cy2 || x+(x2-x1)<0 || y+(y2-y1)<0) return ;
     if (x<cx1)
@@ -652 +727 @@
     if (y+yl>screen->height())
       yl=screen->height()-y-1;
-    screen->add_dirty(x,y,x+xl-1,y+yl-1);
-    for (j=0;j<yl;j++)
+    screen->add_dirty(x, y, x+xl-1, y+yl-1);
+    screen->lock();
+    mask->lock();
+    lock();
+    for (j=0; j<yl; j++)
     {
       pg1=screen->scan_line(y+j);
@@ -659 +737 @@
       pg3=mask->scan_line(masky++);
       if (masky>=mh)           // wrap the mask around if out of bounds
-        masky=0;
-      for (i=0;i<xl;i++)
+    masky=0;
+      for (i=0; i<xl; i++)
       {
-        if (pg3[maskx+i])          // check to make sure not 0 before putting
-          pg1[x+i]=pg2[x1+i];
-        if (maskx>=ml)            // wrap x around if it goes to far
-          maskx=0;
+    if (pg3[maskx+i])          // check to make sure not 0 before putting
+      pg1[x+i]=pg2[x1+i];
+    if (maskx>=ml)            // wrap x around if it goes to far
+      maskx=0;
       }
     }
+    unlock();
+    mask->unlock();
+    screen->unlock();
   }
 }
@@ -674 +755 @@
 
 uint8_t image::brightest_color(palette *pal)
-{ uint8_t *p,r,g,b,bri;
-  int16_t i,j;
+{ uint8_t *p, r, g, b, bri;
+  int16_t i, j;
   int32_t brv;
   brv=0; bri=0;
-  for (j=0;j<h;j++)
+  lock();
+  for (j=0; j<h; j++)
   {
     p=scan_line(j);
-    for (i=0;i<w;i++)
-    { pal->get(p[i],r,g,b);
+    for (i=0; i<w; i++)
+    { pal->get(p[i], r, g, b);
       if ((int32_t)r*(int32_t)g*(int32_t)b>brv)
       { brv=(int32_t)r*(int32_t)g*(int32_t)b;
-        bri=p[i];
+    bri=p[i];
       }
     }
   }
+  unlock();
   return bri;
 }
 
 uint8_t image::darkest_color(palette *pal, int16_t noblack)
-{ uint8_t *p,r,g,b,bri;
-  int16_t i,j;
-  int32_t brv,x;
+{ uint8_t *p, r, g, b, bri;
+  int16_t i, j;
+  int32_t brv, x;
   brv=(int32_t)258*(int32_t)258*(int32_t)258; bri=0;
-  for (j=0;j<h;j++)
+  lock();
+  for (j=0; j<h; j++)
   {
     p=scan_line(j);
-    for (i=0;i<w;i++)
-    { pal->get(p[i],r,g,b);
+    for (i=0; i<w; i++)
+    { pal->get(p[i], r, g, b);
       x=(int32_t)r*(int32_t)g*(int32_t)b;
       if (x<brv && (x || !noblack))
       { brv=x;
-        bri=p[i];
+    bri=p[i];
       }
     }
   }
+  unlock();
   return bri;
 }
 
-void image::rectangle(int16_t x1, int16_t y1,int16_t x2, int16_t y2, uint8_t color)
-{
-  line(x1,y1,x2,y1,color);
-  line(x2,y1,x2,y2,color);
-  line(x1,y2,x2,y2,color);
-  line(x1,y1,x1,y2,color);
+void image::rectangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
+{
+  line(x1, y1, x2, y1, color);
+  line(x2, y1, x2, y2, color);
+  line(x1, y2, x2, y2, color);
+  line(x1, y1, x1, y2, color);
 }
 
@@ -735 +820 @@
 {
   if (special)
-    special->get_clip(x1,y1,x2,y2);
+    special->get_clip(x1, y1, x2, y2);
   else
   { x1=0; y1=0; x2=width()-1; y2=height()-1; }
@@ -753 +838 @@
       y2=special->y2_clip();
   }
-  set_clip(x1,y1,x2,y2);
+  set_clip(x1, y1, x2, y2);
 }
 
@@ -762 +847 @@
 void image_descriptor::reduce_dirties()
 {
-  dirty_rect *p,*q;
-  int16_t x1,y1,x2,y2,nn;
+  dirty_rect *p, *q;
+  int16_t x1, y1, x2, y2, nn;
   x1=6000; y1=6000;
   x2=0; y2=0;
@@ -780 +865 @@
     nn--;
   }
-  dirties.add_front((linked_node *) new dirty_rect(x1,y1,x2,y2));
+  dirties.add_front((linked_node *) new dirty_rect(x1, y1, x2, y2));
 }
 
 void image_descriptor::delete_dirty(int x1, int y1, int x2, int y2)
 {
-  int16_t i,ax1,ay1,ax2,ay2;
-  dirty_rect *p,*next;
+  int16_t i, ax1, ay1, ax2, ay2;
+  dirty_rect *p, *next;
   if (keep_dirt)
   {
@@ -801 +886 @@
     else
     {
-      for (p=(dirty_rect *)dirties.first();i;i--,p=(dirty_rect *)next)
+      for (p=(dirty_rect *)dirties.first(); i; i--, p=(dirty_rect *)next)
       {
         next=(dirty_rect *)p->next();
         // are the two touching?
-        if (!(x2<p->dx1 || y2<p->dy1 || x1>p->dx2 || y1>p->dy2))
+    if (!(x2<p->dx1 || y2<p->dy1 || x1>p->dx2 || y1>p->dy2))
         {
           // does it take a x slice off? (across)
@@ -821 +906 @@
             else
             {
-              dirties.add_front((linked_node *) new dirty_rect(p->dx1,p->dy1,p->dx2,y1-1));
+              dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
               p->dy1=y2+1;
             }
@@ -834 +919 @@
             else 
             {
-              dirties.add_front((linked_node *) new dirty_rect(p->dx1,p->dy1,x1-1,p->dy2));
+              dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, x1-1, p->dy2));
               p->dx1=x2+1;
             }
@@ -847 +932 @@
             else if (y1<=p->dy1) { ay1=p->dy1; ay2=y2; }
             else                { ay1=y1; ay2=y2; }
-            dirties.add_front((linked_node *) new dirty_rect(ax1,ay1,ax2,ay2));
+            dirties.add_front((linked_node *) new dirty_rect(ax1, ay1, ax2, ay2));
           
             if (x2>=p->dx2 || x1<=p->dx1)  { ax1=p->dx1; ax2=p->dx2; }
@@ -859 +944 @@
             else           { if (ax1==p->dx1) { ay1=p->dy1; ay2=y1-1; }
                              else { ay1=y1; ay2=y2; } }
-            dirties.add_front((linked_node *) new dirty_rect(ax1,ay1,ax2,ay2));
+            dirties.add_front((linked_node *) new dirty_rect(ax1, ay1, ax2, ay2));
 
             if (x1>p->dx1 && x2<p->dx2)
@@ -865 +950 @@
               if (y1>p->dy1 && y2<p->dy2)
               {
-                dirties.add_front((linked_node *) new dirty_rect(p->dx1,p->dy1,p->dx2,y1-1));
-                dirties.add_front((linked_node *) new dirty_rect(p->dx1,y2+1,p->dx2,p->dy2));
+                dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
+                dirties.add_front((linked_node *) new dirty_rect(p->dx1, y2+1, p->dx2, p->dy2));
               } else if (y1<=p->dy1)
-                dirties.add_front((linked_node *) new dirty_rect(p->dx1,y2+1,p->dx2,p->dy2));
+                dirties.add_front((linked_node *) new dirty_rect(p->dx1, y2+1, p->dx2, p->dy2));
               else 
-                dirties.add_front((linked_node *) new dirty_rect(p->dx1,p->dy1,p->dx2,y1-1));
+                dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
             } else if (y1>p->dy1 && y2<p->dy2)
-              dirties.add_front((linked_node *) new dirty_rect(p->dx1,y2+1,p->dx2,p->dy2));
+              dirties.add_front((linked_node *) new dirty_rect(p->dx1, y2+1, p->dx2, p->dy2));
             dirties.unlink((linked_node *) p);
             delete p;
@@ -897 +982 @@
     i=dirties.number_nodes();
     if (!i)
-      dirties.add_front((linked_node *) new dirty_rect(x1,y1,x2,y2));
+      dirties.add_front((linked_node *) new dirty_rect(x1, y1, x2, y2));
     else if (i>=MAX_DIRTY)
     {
-      dirties.add_front((linked_node *) new dirty_rect(x1,y1,x2,y2));
+      dirties.add_front((linked_node *) new dirty_rect(x1, y1, x2, y2));
       reduce_dirties();  // reduce to one dirty rectangle, we have to many
     }
     else
     {  
-      for (p=(dirty_rect *)dirties.first();i>0;i--)
+      for (p=(dirty_rect *)dirties.first(); i>0; i--)
       {
 
         // check to see if this new rectangle completly encloses the check rectangle
-        if (x1<=p->dx1 && y1<=p->dy1 && x2>=p->dx2 && y2>=p->dy2)
-        {
-          dirty_rect *tmp=(dirty_rect*) p->next();
-          dirties.unlink((linked_node *)p);
-          delete p;
-          if (!dirties.first())
-            i=0;
-          else p=tmp;     
-        }       
-        else if (!(x2<p->dx1 || y2<p->dy1 || x1>p->dx2 || y1>p->dy2))
-        {         
-
-
-         
+    if (x1<=p->dx1 && y1<=p->dy1 && x2>=p->dx2 && y2>=p->dy2)
+    {
+      dirty_rect *tmp=(dirty_rect*) p->next();
+      dirties.unlink((linked_node *)p);
+      delete p;
+      if (!dirties.first())
+          i=0;
+      else p=tmp;      
+    }    
+    else if (!(x2<p->dx1 || y2<p->dy1 || x1>p->dx2 || y1>p->dy2))
+    {      
+
+
+     
 /*          if (x1<=p->dx1) { a+=p->dx1-x1; ax1=x1; } else ax1=p->dx1;
           if (y1<=p->dy1) { a+=p->dy1-y1; ay1=y1; } else ay1=p->dy1; 
           if (x2>=p->dx2) { a+=x2-p->dx2; ax2=x2; } else ax2=p->dx2;
           if (y2>=p->dy2) { a+=y2-p->dy2; ay2=y2; } else ay2=p->dy2;
-          
-          if (a<50) 
-          { p->dx1=ax1;                                // then expand the dirty
-            p->dy1=ay1;
-            p->dx2=ax2;
-            p->dy2=ay2;
-            return ;
-          } 
-          else */
-            {
-              if (x1<p->dx1)
-                add_dirty(x1,max(y1,p->dy1),p->dx1-1,min(y2,p->dy2));
-              if (x2>p->dx2)
-                add_dirty(p->dx2+1,max(y1,p->dy1),x2,min(y2,p->dy2));
-              if (y1<p->dy1)
-                add_dirty(x1,y1,x2,p->dy1-1);
-              if (y2>p->dy2)
-                add_dirty(x1,p->dy2+1,x2,y2);
-              return ;
-            }
-            p=(dirty_rect *)p->next();
-          } else p=(dirty_rect *)p->next();      
-        
+      
+      if (a<50) 
+      { p->dx1=ax1;                         // then expand the dirty
+        p->dy1=ay1;
+        p->dx2=ax2;
+        p->dy2=ay2;
+        return ;
+      } 
+      else */
+        {
+          if (x1<p->dx1)
+            add_dirty(x1, max(y1, p->dy1), p->dx1-1, min(y2, p->dy2));
+          if (x2>p->dx2)
+            add_dirty(p->dx2+1, max(y1, p->dy1), x2, min(y2, p->dy2));
+          if (y1<p->dy1)
+            add_dirty(x1, y1, x2, p->dy1-1);
+          if (y2>p->dy2)
+            add_dirty(x1, p->dy2+1, x2, y2);
+          return ;
+        }
+        p=(dirty_rect *)p->next();
+      } else p=(dirty_rect *)p->next();      
+    
       } 
       CHECK(x1<=x2 && y1<=y2);
-      dirties.add_end((linked_node *)new dirty_rect(x1,y1,x2,y2)); 
+      dirties.add_end((linked_node *)new dirty_rect(x1, y1, x2, y2)); 
     }
   }
@@ -975 +1060 @@
   if (x2<0 || y2<0 || x1>=width() || y1>=height() || x2<x1 || y2<y1)
     return ;
-  for (y=y1;y<=y2;y++)
-    memset(scan_line(y)+x1,color,(x2-x1+1));
-  add_dirty(x1,y1,x2,y2);
+  lock();
+  for (y=y1; y<=y2; y++)
+    memset(scan_line(y)+x1, color, (x2-x1+1));
+  unlock();
+  add_dirty(x1, y1, x2, y2);
 }
 
 void image::xor_bar  (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
 {
-  int16_t y,x;
+  int16_t y, x;
   if (x1>x2 || y1>y2) return ;
   if (special)
@@ -999 +1086 @@
     return ;
 
+  lock();
   uint8_t *sl=scan_line(y1)+x1; 
-  for (y=y1;y<=y2;y++)
+  for (y=y1; y<=y2; y++)
   {
     uint8_t *s=sl;
-    for (x=x1;x<=x2;x++,s++)
+    for (x=x1; x<=x2; x++, s++)
       *s=(*s)^color;
     sl+=w;
   }
-
-  add_dirty(x1,y1,x2,y2);
+  unlock();
+
+  add_dirty(x1, y1, x2, y2);
 }
 
@@ -1015 +1104 @@
 {
   int16_t x;
-  uint8_t *sl,*ex,mask,bt,sh;
-  ex=(uint8_t *)jmalloc(width(),"image::unpacked scanline");
+  uint8_t *sl, *ex, mask, bt, sh;
+  ex=(uint8_t *)jmalloc(width(), "image::unpacked scanline");
+
+  lock();
   sl=scan_line(line);
-  memcpy(ex,sl,width());
+  memcpy(ex, sl, width());
+  unlock();
 
   if (bitsperpixel==1)      { mask=128;           bt=8; }
   else if (bitsperpixel==2) { mask=128+64;        bt=4; }
-  else                      {  mask=128+64+32+16; bt=2; }
-
-  for (x=0;x<width();x++)
+  else                 {  mask=128+64+32+16; bt=2; }
+
+  for (x=0; x<width(); x++)
   { sh=((x%bt)<<(bitsperpixel-1));
     sl[x]=(ex[x/bt]&(mask>>sh))>>(bt-sh-1);
@@ -1034 +1126 @@
 void image::dither(palette *pal)
 {
-  int16_t x,y,i,j;
-  uint8_t dt_matrix[]={0,  136,24, 170,
-                   68, 204,102,238,
-                   51, 187, 17,153,
-                   119,255, 85,221};
+  int16_t x, y, i, j;
+  uint8_t dt_matrix[]={0,  136, 24, 170,
+           68, 204, 102, 238,
+           51, 187, 17, 153,
+           119, 255, 85, 221};
 
   uint8_t *sl;
-  for (y=height()-1;y>=0;y--)
+  lock();
+  for (y=height()-1; y>=0; y--)
   {
     sl=scan_line(y);
-    for (i=0,j=y%4,x=width()-1;x>=0;x--)
+    for (i=0, j=y%4, x=width()-1; x>=0; x--)
     {
       if (pal->red(sl[x])>dt_matrix[j*4+i])
-        sl[x]=255;
+    sl[x]=255;
       else sl[x]=0;
       if (i==3) i=0; else i++;
     }
   }
+  unlock();
 }
 
@@ -1067 +1161 @@
 void image::resize(int16_t new_width, int16_t new_height)
 {
-  int old_width=width(),old_height=height();
-  uint8_t *im=(uint8_t *)jmalloc(width()*height(),"image::resized");
-  memcpy(im,scan_line(0),width()*height());
+  int old_width=width(), old_height=height();
+  uint8_t *im=(uint8_t *)jmalloc(width()*height(), "image::resized");
+  lock();
+  memcpy(im, scan_line(0), width()*height());
 
   delete_page();
-  make_page(new_width,new_height,NULL);
+  make_page(new_width, new_height, NULL);
   w=new_width;      // set the new hieght and width
   h=new_height;
 
-  uint8_t *sl1,*sl2;
-  int16_t y,y2,x2;
-  double yc,xc,yd,xd;
+  uint8_t *sl1, *sl2;
+  int16_t y, y2, x2;
+  double yc, xc, yd, xd;
 
 
@@ -1084 +1179 @@
   yc=(double)old_height/(double)new_height;
   xc=(double)old_width/(double)new_width;
-  for (y2=0,yd=0;y2<new_height;yd+=yc,y2++)
+  for (y2=0, yd=0; y2<new_height; yd+=yc, y2++)
   {
     y=(int)yd;
     sl1=im+y*old_width;
     sl2=scan_line(y2);
-    for (xd=0,x2=0;x2<new_width;xd+=xc,x2++)
+    for (xd=0, x2=0; x2<new_width; xd+=xc, x2++)
     { sl2[x2]=sl1[(int)xd]; }
   }
   jfree(im);
-  if (special) special->resize(new_width,new_height);
+  if (special) special->resize(new_width, new_height);
+  unlock();
 }
 
 void image::scroll(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t xd, int16_t yd)
 {
-  int16_t cx1,cy1,cx2,cy2;
+  int16_t cx1, cy1, cx2, cy2;
   CHECK(x1>=0 && y1>=0 && x1<x2 && y1<y2 && x2<width() && y2<height());
   if (special)
   {
-    special->get_clip(cx1,cy1,cx2,cy2);
-    x1=max(x1,cx1); y1=max(cy1,y1); x2=min(x2,cx2); y2=min(y2,cy2);
-  }
-  int16_t xsrc,ysrc,xdst,ydst,xtot=x2-x1-abs(xd)+1,ytot,xt;
-  uint8_t *src,*dst;
+    special->get_clip(cx1, cy1, cx2, cy2);
+    x1=max(x1, cx1); y1=max(cy1, y1); x2=min(x2, cx2); y2=min(y2, cy2);
+  }
+  int16_t xsrc, ysrc, xdst, ydst, xtot=x2-x1-abs(xd)+1, ytot, xt;
+  uint8_t *src, *dst;
   if (xd<0) { xsrc=x1-xd; xdst=x1; } else { xsrc=x2-xd; xdst=x2; }
   if (yd<0) { ysrc=y1-yd; ydst=y1; } else { ysrc=y2-yd; ydst=y2; }
-  for (ytot=y2-y1-abs(yd)+1;ytot;ytot--)
+  for (ytot=y2-y1-abs(yd)+1; ytot; ytot--)
   { src=scan_line(ysrc)+xsrc;
     dst=scan_line(ydst)+xdst;
     if (xd<0)
-      for (xt=xtot;xt;xt--)
+      for (xt=xtot; xt; xt--)
         *(dst++)=*(src++);
-      else for (xt=xtot;xt;xt--)
+      else for (xt=xtot; xt; xt--)
         *(dst--)=*(src--);
     if (yd<0) { ysrc++; ydst++; } else { ysrc--; ydst--; }
   }
-  add_dirty(x1,y1,x2,y2);
+  add_dirty(x1, y1, x2, y2);
 }
 
@@ -1125 +1221 @@
 image *image::create_smooth(int16_t smoothness)
 {
-  int16_t i,j,k,l,t,d;
+  int16_t i, j, k, l, t, d;
   image *im;
   CHECK(smoothness>=0);
@@ -1131 +1227 @@
   d=smoothness*2+1;
   d=d*d;
-  im=new image(width(),height());
-  for (i=0;i<width();i++)
-    for (j=0;j<height();j++)
-    {
-      for (t=0,k=-smoothness;k<=smoothness;k++)
-        for (l=-smoothness;l<=smoothness;l++)
-          if (i+k>smoothness && i+k<width()-smoothness && j+l<height()-smoothness && j+l>smoothness)
-            t+=pixel(i+k,j+l);
-          else t+=pixel(i,j);
-      im->putpixel(i,j,t/d);
+  im=new image(width(), height());
+  for (i=0; i<width(); i++)
+    for (j=0; j<height(); j++)
+    {
+      for (t=0, k=-smoothness; k<=smoothness; k++)
+    for (l=-smoothness; l<=smoothness; l++)
+      if (i+k>smoothness && i+k<width()-smoothness && j+l<height()-smoothness && j+l>smoothness)
+        t+=pixel(i+k, j+l);
+      else t+=pixel(i, j);
+      im->putpixel(i, j, t/d);
     }
   return im;
@@ -1146 +1242 @@
 
 void image::widget_bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2, 
-        uint8_t light, uint8_t med, uint8_t dark)
-{
-  line(x1,y1,x2,y1,light);
-  line(x1,y1,x1,y2,light);
-  line(x2,y1+1,x2,y2,dark);
-  line(x1+1,y2,x2-1,y2,dark);
-  bar(x1+1,y1+1,x2-1,y2-1,med);
+       uint8_t light, uint8_t med, uint8_t dark)
+{
+  line(x1, y1, x2, y1, light);
+  line(x1, y1, x1, y2, light);
+  line(x2, y1+1, x2, y2, dark);
+  line(x1+1, y2, x2-1, y2, dark);
+  bar(x1+1, y1+1, x2-1, y2-1, med);
 }
 
@@ -1158 +1254 @@
 {
 public :
-  int16_t x,y;
+  int16_t x, y;
   fill_rec *last;
   fill_rec(int16_t X, int16_t Y, fill_rec *Last)
@@ -1166 +1262 @@
 void image::flood_fill(int16_t x, int16_t y, uint8_t color)
 {
-  uint8_t *sl,*above,*below;
-  fill_rec *recs=NULL,*r;
+  uint8_t *sl, *above, *below;
+  fill_rec *recs=NULL, *r;
   uint8_t fcolor;
+  lock();
   sl=scan_line(y);
   fcolor=sl[x];
@@ -1189 +1286 @@
         above=scan_line(y-1);
         if (above[x]==fcolor)
-        { r=new fill_rec(x,y-1,recs);
+        { r=new fill_rec(x, y-1, recs);
           recs=r;  
         }
@@ -1197 +1294 @@
         above=scan_line(y+1);
         if (above[x]==fcolor)
-        { r=new fill_rec(x,y+1,recs);
+        { r=new fill_rec(x, y+1, recs);
           recs=r;
         }
@@ -1210 +1307 @@
         { above=scan_line(y-1);
           if (x>0 && above[x-1]!=fcolor && above[x]==fcolor)
-          { r=new fill_rec(x,y-1,recs);
+          { r=new fill_rec(x, y-1, recs);
             recs=r;  
           }
@@ -1217 +1314 @@
         { below=scan_line(y+1);
           if (x>0 && below[x-1]!=fcolor && below[x]==fcolor)
-          { r=new fill_rec(x,y+1,recs);
+          { r=new fill_rec(x, y+1, recs);
             recs=r;  
           }
@@ -1228 +1325 @@
         above=scan_line(y-1);
         if (above[x]==fcolor)
-        { r=new fill_rec(x,y-1,recs);
+        { r=new fill_rec(x, y-1, recs);
           recs=r;
         }
@@ -1236 +1333 @@
         above=scan_line(y+1);
         if (above[x]==fcolor)
-        { r=new fill_rec(x,y+1,recs);
+        { r=new fill_rec(x, y+1, recs);
           recs=r;
         }
@@ -1242 +1339 @@
     }
   } while (recs);
+  unlock();
 }
 
@@ -1250 +1348 @@
 {
   char st[100];
-  int16_t ledx[]={1,2,1,2,3,3,3,3,1,2,0,0,0,0};
-  int16_t ledy[]={3,3,0,0,1,2,4,6,7,7,4,6,1,2};
-
-  int16_t dig[]={2+4+8+16+32+64,4+8,2+4+1+32+16,2+4+1+8+16,64+1+4+8,
-             2+64+1+8+16,64+32+1+8+16,2+4+8,1+2+4+8+16+32+64,64+2+4+1+8,1};
-  int16_t xx,yy,zz;
-  sprintf(st,"%8ld",(long int)num);
-  for (xx=0;xx<8;xx++)
+  int16_t ledx[]={1, 2, 1, 2, 3, 3, 3, 3, 1, 2, 0, 0, 0, 0};
+  int16_t ledy[]={3, 3, 0, 0, 1, 2, 4, 6, 7, 7, 4, 6, 1, 2};
+
+  int16_t dig[]={2+4+8+16+32+64, 4+8, 2+4+1+32+16, 2+4+1+8+16, 64+1+4+8,
+             2+64+1+8+16, 64+32+1+8+16, 2+4+8, 1+2+4+8+16+32+64, 64+2+4+1+8, 1};
+  int16_t xx, yy, zz;
+  sprintf(st, "%8ld", (long int)num);
+  for (xx=0; xx<8; xx++)
   {
     if (st[xx]!=' ')
     {
       if (st[xx]=='-')
-        zz=10;
+    zz=10;
       else
-        zz=st[xx]-'0';
-      for (yy=0;yy<7;yy++)
-        if ((1<<yy)&dig[zz])
-          line(x+ledx[yy*2]*scale,y+ledy[yy*2]*scale,x+ledx[yy*2+1]*scale,
-            y+ledy[yy*2+1]*scale,color);
+    zz=st[xx]-'0';
+      for (yy=0; yy<7; yy++)
+    if ((1<<yy)&dig[zz])
+      line(x+ledx[yy*2]*scale, y+ledy[yy*2]*scale, x+ledx[yy*2+1]*scale,
+        y+ledy[yy*2+1]*scale, color);
     }
     x+=6*scale;
@@ -1274 +1372 @@
 }
 
-uint8_t dither_matrix[]={0,  136,24, 170,
-                     68, 204,102,238,
-                     51, 187, 17,153,
-                     119,255, 85,221};
+uint8_t dither_matrix[]={0,  136, 24, 170,
+             68, 204, 102, 238,
+             51, 187, 17, 153,
+             119, 255, 85, 221};
 
 image *image::copy_part_dithered (int16_t x1, int16_t y1, int16_t x2, int16_t y2)
 {
-  int16_t x,y,cx1,cy1,cx2,cy2,ry,rx,bo,dity,ditx;
+  int16_t x, y, cx1, cy1, cx2, cy2, ry, rx, bo, dity, ditx;
   image *ret;
-  uint8_t *sl1,*sl2;
-  get_clip(cx1,cy1,cx2,cy2);
+  uint8_t *sl1, *sl2;
+  get_clip(cx1, cy1, cx2, cy2);
   if (y1<cy1) y1=cy1;
   if (x1<cx1) x1=cx1;
@@ -1291 +1389 @@
   CHECK(x2>=x1 && y2>=y1);
   if (x2<x1 || y2<y1) return NULL;
-  ret=new image((x2-x1+8)/8,(y2-y1+1));
+  ret=new image((x2-x1+8)/8, (y2-y1+1));
   if (!last_loaded())
     ret->clear();
   else 
-    for (y=y1,ry=0,dity=(y1%4)*4;y<=y2;y++,ry++)
+  {
+    ret->lock();
+    lock();
+    for (y=y1, ry=0, dity=(y1%4)*4; y<=y2; y++, ry++)
     {
       sl1=ret->scan_line(ry);     // sl1 is the scan linefo the return image
       sl2=scan_line(y);          // sl2 is the orginal image scan line
-      memset(sl1,0,(x2-x1+8)/8);
-      for (bo=7,rx=0,x=x1,ditx=x1%4;x<=x2;x++)
+      memset(sl1, 0, (x2-x1+8)/8);
+      for (bo=7, rx=0, x=x1, ditx=x1%4; x<=x2; x++)
       {
         if (last_loaded()->red(sl2[x])>dither_matrix[ditx+dity]) 
-          sl1[rx]|=1<<bo;
+          sl1[rx]|=1<<bo;
         if (bo!=0)
-        bo--;
+      bo--;
         else
         {
-          rx++;
-          bo=7;
+        rx++;
+      bo=7;
         }
         ditx+=1; if (ditx>3) ditx=0;
@@ -1315 +1416 @@
       dity+=4; if (dity>12) dity=0;
     }
+    unlock();
+    ret->unlock();
+  }
   return ret;
 }
@@ -1320 +1424 @@
 void image::flip_x()
 {
-  uint8_t *rev=(uint8_t *)jmalloc(width(),"image tmp::flipped_x"),*sl;
-  CONDITION(rev,"memory allocation"); 
-  int y,x,i;
-  for (y=0;y<height();y++)
+  uint8_t *rev=(uint8_t *)jmalloc(width(), "image tmp::flipped_x"), *sl;
+  CONDITION(rev, "memory allocation"); 
+  int y, x, i;
+
+  /* FIXME: Abuse Win32 uses RestoreSurface() here instead of locking */
+  lock();
+  for (y=0; y<height(); y++)
   { sl=scan_line(y);
-    for (i=0,x=width()-1;x>=0;x--,i++)
+    for (i=0, x=width()-1; x>=0; x--, i++)
       rev[i]=sl[x]; 
-    memcpy(sl,rev,width());
-  }
+    memcpy(sl, rev, width());
+  }
+  unlock();
   jfree(rev);
 }
@@ -1334 +1442 @@
 void image::flip_y()
 {
-  uint8_t *rev=(uint8_t *)jmalloc(width(),"image::flipped_y"),*sl;
-  CONDITION(rev,"memory allocation"); 
+  uint8_t *rev=(uint8_t *)jmalloc(width(), "image::flipped_y"), *sl;
+  CONDITION(rev, "memory allocation"); 
   int y;
-  for (y=0;y<height()/2;y++)
+
+  /* FIXME: Abuse Win32 uses RestoreSurface() here instead of locking */
+  lock();
+  for (y=0; y<height()/2; y++)
   { sl=scan_line(y);
-    memcpy(rev,sl,width());
-    memcpy(sl,scan_line(height()-y-1),width());
-    memcpy(scan_line(height()-y-1),rev,width());
-  }
+    memcpy(rev, sl, width());
+    memcpy(sl, scan_line(height()-y-1), width());
+    memcpy(scan_line(height()-y-1), rev, width());
+  }
+  unlock();
+  jfree(rev);
 }
 
@@ -1348 +1461 @@
 {
   uint8_t *sl;
-  int y,x;
-  for (y=0;y<height();y++)
+  int y, x;
+  lock();
+  for (y=0; y<height(); y++)
   {
     sl=scan_line(y);
-    for (x=width();x;x--,sl++)
+    for (x=width(); x; x--, sl++)
       if (*sl) 
         *sl=color;
   }
-}
+  unlock();
+}

abuse/trunk/src/imlib/image.hpp

@@ -8 +8 @@
  */
 
-#ifndef _IMGAE_HPP_
-#define _IMGAE_HPP_
+#ifndef _IMAGE_HPP_
+#define _IMAGE_HPP_
+
 #include <stdlib.h>
 #include "linked.hpp"
@@ -19 +20 @@
 
 extern char const *imerr_messages[];  // correspond to imERRORS
-#define imREAD_ERROR           1
+#define imREAD_ERROR            1
 #define imINCORRECT_FILETYPE   2
 #define imFILE_CORRUPTED       3
@@ -26 +27 @@
 #define imNOT_SUPPORTED        6
 #define imWRITE_ERROR          7
-#define imMAX_ERROR            7
+#define imMAX_ERROR            7
 
 int16_t current_error();
@@ -39 +40 @@
 typedef struct image_color_t
 {
-        uint16_t r;
-        uint16_t g;
-        uint16_t b;
+    uint16_t r;
+    uint16_t g;
+    uint16_t b;
 } image_color;
 
@@ -52 +53 @@
   int16_t dx1,dy1,dx2,dy2;
   dirty_rect(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
-  { dx1=x1; dy1=y1; dx2=x2; dy2=y2; 
-    if (x2<x1 || y2<y1) 
+  { dx1=x1; dy1=y1; dx2=x2; dy2=y2;
+    if(x2<x1 || y2<y1)
       printf("add inccorect dirty\n");
   }
   virtual int16_t compare(void *n1, int16_t field)
-  { return ((dirty_rect *)n1)->dy1>dy1; }
+  { return((dirty_rect *)n1)->dy1>dy1; }
 } ;
 
 class image_descriptor
 {
-  int16_t l,h;
-  int16_t clipx1, clipy1, clipx2, clipy2;
-public :  
-  uint8_t keep_dirt,
-          static_mem;      // if this flag is set then don't free memory on exit
-  
-  linked_list dirties;
-  void *extended_descriptor;              // type depends on current system
-
-  image_descriptor(int16_t length, int16_t height,
-                  int keep_dirties=1, int static_memory=0);
-  int16_t bound_x1(int16_t x1)  { return x1<clipx1 ? clipx1 : x1; }
-  int16_t bound_y1(int16_t y1)  { return y1<clipy1 ? clipy1 : y1; }
-  int16_t bound_x2(int16_t x2)  { return x2>clipx2 ? clipx2 : x2; }
-  int16_t bound_y2(int16_t y2)  { return y2>clipy2 ? clipy2 : y2; }
-  int16_t x1_clip() { return clipx1; }
-  int16_t y1_clip() { return clipy1; }
-  int16_t x2_clip() { return clipx2; }
-  int16_t y2_clip() { return clipy2; }
-  void dirty_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ;}
-  void clean_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ; }
-  void clear_dirties();
-  int16_t get_dirty_area(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2) { return 0; }
-  void get_clip(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
-    { x1=clipx1; y1=clipy1; x2=clipx2; y2=clipy2; }
-  void set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
-    { if (x2<x1) x2=x1;
-      if (y2<y1) y2=y1;
-      if (x1<0) clipx1=0; else clipx1=x1;
-      if (y1<0) clipy1=0; else clipy1=y1;
-      if (x2>=l) clipx2=l-1; else clipx2=x2;
-      if (y2>=h) clipy2=h-1; else clipy2=y2;
-    }
-  void reduce_dirties();
-  void add_dirty(int x1, int y1, int x2, int y2);
-  void delete_dirty(int x1, int y1, int x2, int y2);
-  void resize(int16_t length, int16_t height)
-   { l=length; h=height; clipx1=0; clipy1=0; clipx2=l-1; clipy2=h-1; }
-} ;
+private:
+    int16_t l, h;
+    int16_t clipx1, clipy1, clipx2, clipy2;
+
+public:
+    uint8_t keep_dirt,
+            static_mem; // if set, don't free memory on exit
+
+    linked_list dirties;
+    void *extended_descriptor;
+
+    image_descriptor(int16_t length, int16_t height,
+                     int keep_dirties = 1, int static_memory = 0);
+    int16_t bound_x1(int16_t x1)  { return x1 < clipx1 ? clipx1 : x1; }
+    int16_t bound_y1(int16_t y1)  { return y1 < clipy1 ? clipy1 : y1; }
+    int16_t bound_x2(int16_t x2)  { return x2 > clipx2 ? clipx2 : x2; }
+    int16_t bound_y2(int16_t y2)  { return y2 > clipy2 ? clipy2 : y2; }
+    int16_t x1_clip() { return clipx1; }
+    int16_t y1_clip() { return clipy1; }
+    int16_t x2_clip() { return clipx2; }
+    int16_t y2_clip() { return clipy2; }
+    void dirty_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ; }
+    void clean_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ; }
+    void clear_dirties();
+    int16_t get_dirty_area(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
+    {
+        return 0;
+    }
+    void get_clip(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
+    {
+        x1 = clipx1; y1 = clipy1; x2 = clipx2; y2 = clipy2;
+    }
+    void set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
+    {
+        if(x2 < x1) x2 = x1;
+        if(y2 < y1) y2 = y1;
+        if(x1 < 0) clipx1 = 0; else clipx1 = x1;
+        if(y1 < 0) clipy1 = 0; else clipy1 = y1;
+        if(x2 >= l) clipx2 = l - 1; else clipx2 = x2;
+        if(y2 >= h) clipy2 = h - 1; else clipy2 = y2;
+    }
+    void reduce_dirties();
+    void add_dirty(int x1, int y1, int x2, int y2);
+    void delete_dirty(int x1, int y1, int x2, int y2);
+    void resize(int16_t length, int16_t height)
+    {
+        l = length; h = height;
+        clipx1 = 0; clipy1 = 0; clipx2 = l - 1; clipy2 = h - 1;
+    }
+};
 
 class image : public linked_node
-{ 
-  uint8_t *data;
-  int16_t w,h;
-  void make_page(int16_t width, int16_t height, uint8_t *page_buffer);
-  void delete_page();
-public :
-  image_descriptor *special;
-  image(spec_entry *e, bFILE *fp);
-  image(bFILE *fp);
-  image(int16_t width, int16_t height,                 // required
-        uint8_t *page_buffer=NULL,
-        int16_t create_descriptor=0);        // 0=no, 1=yes, 2=yes & keep dirties
-  uint8_t  pixel              (int16_t x, int16_t y);
-  void     putpixel           (int16_t x, int16_t y, char color);
-  uint8_t *scan_line          (int16_t y) { return data+y*w; }
-  uint8_t *next_line          (int16_t lasty, uint8_t *last_scan) 
-                                    { return last_scan+w; }          
-  int32_t  total_pixels       (uint8_t background=0);
-  image    *copy               ();    // makes a copy of an image
-  void     clear              (int16_t color=-1);  // -1 is background color
-  void     to_24bit           (palette &pal);
-  int16_t  width              () { return (int16_t)w; }
-  int16_t  height             () { return (int16_t)h; }
-  void     scroll             (int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t xd, int16_t yd);
-  void     fill_image         (image *screen, int16_t x1, int16_t y1, int16_t x2, int16_t y2, 
-                              int16_t align=1);
-  void     put_image          (image *screen, int16_t x, int16_t y, char transparent=0);
-  void     put_part           (image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1, 
-                                     int16_t x2, int16_t y2, char transparent=0);
-  void     put_part_xrev      (image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1, 
-                                     int16_t x2, int16_t y2, char transparent=0);
-  void     put_part_masked    (image *screen, image *mask, int16_t x, int16_t y, 
-                                     int16_t maskx, int16_t masky, int16_t x1, int16_t y1, int16_t x2, int16_t y2);
-  image    *copy_part_dithered (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
-  void     bar                (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
-  void     xor_bar            (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
-  void     widget_bar          (int16_t x1, int16_t y1, int16_t x2, int16_t y2, 
-                                     uint8_t light, uint8_t med, uint8_t dark);
-  void     line               (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
-  void     rectangle          (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
-  void     burn_led           (int16_t x, int16_t y, int32_t num, int16_t color, int16_t scale=1);
-  void     set_clip           (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
-  void     get_clip           (int16_t &x1,int16_t &y1,int16_t &x2,int16_t &y2);
-  void     in_clip            (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
-
-  void     dirt_off           () { if (special && special->keep_dirt) special->keep_dirt=0; }
-  void     dirt_on            () { if (special) special->keep_dirt=1; }
-
-  void     add_dirty          (int x1, int y1, int x2, int y2) 
-                                    { if (special) special->add_dirty(x1,y1,x2,y2); }
-  void     delete_dirty       (int x1, int y1, int x2, int y2) 
-                                    { if (special) special->delete_dirty(x1,y1,x2,y2); }
-  void     clear_dirties      () { if (special) special->clear_dirties(); }
-  void     dither             (palette *pal); // use a b&w palette!
-  void     resize             (int16_t new_width, int16_t new_height);
-  void     change_size        (int16_t new_width, int16_t new_height, uint8_t *page=NULL);
-  void     flood_fill         (int16_t x, int16_t y, uint8_t color);
-  image    *create_smooth     (int16_t smoothness=1); // 0 no smoothness
-  void     unpack_scanline    (int16_t line, char bitsperpixel=1);
-  uint8_t  brightest_color    (palette *pal);
-  void     flip_x             ();
-  void     flip_y             ();
-  void     make_color         (uint8_t color);
-  uint8_t  darkest_color      (palette *pal, int16_t noblack=0);
-
-  ~image();
-} ;
-
+{
+private:
+    uint8_t *data;
+    int16_t w, h;
+    void make_page(int16_t width, int16_t height, uint8_t *page_buffer);
+    void delete_page();
+    bool _locked;
+
+public:
+    image_descriptor *special;
+
+    image(spec_entry *e, bFILE *fp);
+    image(bFILE *fp);
+    image(int16_t width, int16_t height,
+          uint8_t *page_buffer = NULL, int16_t create_descriptor = 0); 
+    ~image();
+
+    void lock();
+    void unlock();
+
+    uint8_t pixel(int16_t x, int16_t y);
+    void putpixel(int16_t x, int16_t y, char color);
+    uint8_t *scan_line(int16_t y)
+    {
+        return data + y * w;
+    }
+    uint8_t *next_line(int16_t lasty, uint8_t *last_scan)
+    {
+        return last_scan + w;
+    }
+    int32_t total_pixels(uint8_t background=0);
+    image *copy(); // makes a copy of an image
+    void clear(int16_t color = -1); // -1 is background color
+    void to_24bit(palette &pal);
+    int16_t width()
+    {
+        return (int16_t)w;
+    }
+    int16_t height()
+    {
+        return (int16_t)h;
+    }
+    void scroll(int16_t x1, int16_t y1, int16_t x2, int16_t y2,
+                int16_t xd, int16_t yd);
+    void fill_image(image *screen, int16_t x1, int16_t y1,
+                    int16_t x2, int16_t y2, int16_t align = 1);
+    void put_image(image *screen, int16_t x, int16_t y, char transparent = 0);
+    void put_part(image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1,
+                  int16_t x2, int16_t y2, char transparent = 0);
+    void put_part_xrev(image *screen, int16_t x, int16_t y,
+                       int16_t x1, int16_t y1, int16_t x2, int16_t y2,
+                       char transparent = 0);
+    void put_part_masked(image *screen, image *mask, int16_t x, int16_t y,
+                         int16_t maskx, int16_t masky, int16_t x1, int16_t y1,
+                         int16_t x2, int16_t y2);
+    image *copy_part_dithered(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
+    void bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
+    void xor_bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
+    void widget_bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2,
+                    uint8_t light, uint8_t med, uint8_t dark);
+    void line(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
+    void rectangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2,
+                   uint8_t color);
+    void burn_led(int16_t x, int16_t y, int32_t num, int16_t color,
+                  int16_t scale = 1);
+    void set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
+    void get_clip(int16_t &x1,int16_t &y1,int16_t &x2,int16_t &y2);
+    void in_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
+
+    void dirt_off()
+    {
+        if(special && special->keep_dirt) special->keep_dirt = 0;
+    }
+    void dirt_on()
+    {
+        if(special) special->keep_dirt = 1;
+    }
+
+    void add_dirty(int x1, int y1, int x2, int y2)
+    {
+        if(special) special->add_dirty(x1, y1, x2, y2);
+    }
+    void delete_dirty(int x1, int y1, int x2, int y2)
+    {
+        if(special) special->delete_dirty(x1, y1, x2, y2);
+    }
+    void clear_dirties()
+    {
+        if(special) special->clear_dirties();
+    }
+    void dither(palette *pal); // use a b&w palette!
+    void resize(int16_t new_width, int16_t new_height);
+    void change_size(int16_t new_width, int16_t new_height,
+                     uint8_t *page = NULL);
+    void flood_fill(int16_t x, int16_t y, uint8_t color);
+    image *create_smooth(int16_t smoothness = 1); // 0 no smoothness
+    void unpack_scanline(int16_t line, char bitsperpixel = 1);
+    uint8_t brightest_color(palette *pal);
+    void flip_x();
+    void flip_y();
+    void make_color(uint8_t color);
+    uint8_t darkest_color(palette *pal, int16_t noblack = 0);
+};
 
 class image_controller
 {
-public :
-  image_controller() { image_init(); }
-  ~image_controller()
-  { 
-     image_uninit(); 
-  }
-} ;
-
-
-
-#endif
-
-
-
-
-
-
-
-
+public:
+    image_controller()
+    {
+        image_init();
+    }
+    ~image_controller()
+    {
+        image_uninit();
+    }
+};
+
+#endif /* _IMAGE_HPP_ */
+

abuse/trunk/src/imlib/morph.cpp

@@ -33 +33 @@
   {
     morph_point8 *m8=(morph_point8 *)p;
+    screen->lock();
     for (i=0;i<total;i++,m8++)
     {
@@ -50 +51 @@
       }            
     }
+    screen->unlock();
   }    
 }
@@ -62 +64 @@
   short cx1,cy1,cx2,cy2;
   screen->get_clip(cx1,cy1,cx2,cy2);    
+  screen->lock();
   while (tot--)
   {
@@ -76 +79 @@
     }
   }      
+  screen->unlock();
 }
 
@@ -85 +89 @@
   short cx1,cy1,cx2,cy2;
   screen->get_clip(cx1,cy1,cx2,cy2);    
+  screen->lock();
   while (tot--)
   {
@@ -99 +104 @@
     }
   }      
+  screen->unlock();
 }
 

abuse/trunk/src/imlib/scroller.cpp

@@ -59 +59 @@
   remap[2]=wm->dark_color();
 
+  screen->lock();
   for (int yc=ich;yc;yc--,y++)
   {
@@ -72 +73 @@
   }
   screen->add_dirty(x,y,x+icw-1,y+ich-1);
+  screen->unlock();
 }
 

abuse/trunk/src/imlib/timage.cpp

@@ -23 +23 @@
       x+=*(dp++);
       if (x<w)
-      {     
-        int run=*(dp++);
-        memset(dp,c,run);
-        x+=run;
-        dp+=run;
+      {
+    int run=*(dp++);
+    memset(dp,c,run);
+    x+=run;
+    dp+=run;
       }
     }
@@ -36 +36 @@
 {
   image *im=new image(w,h);
+
+  im->lock();
   uint8_t *d=im->scan_line(0),*dp=data,*dline;
   int y,x;
@@ -49 +51 @@
       x+=skip;
       if (x<w)
-      {     
-        int run=*(dp++);
-        memcpy(dline,dp,run);
-        x+=run;
-        dline+=run;
-        dp+=run;
+      {
+    int run=*(dp++);
+    memcpy(dline,dp,run);
+    x+=run;
+    dline+=run;
+    dp+=run;
       }
     }
     d=im->next_line(y,d);
   }
+  im->unlock();
   return im;
 }
@@ -65 +68 @@
 {
   int size=0,x,y;
-  uint8_t *sl,*datap,*marker; 
+  uint8_t *sl,*datap,*marker;
   w=im->width();
   h=im->height();
-  
+
+  im->lock();
+
   // first we must find out how much data to allocate
   for (y=0;y<im->height();y++)
   {
     sl=im->scan_line(y);
-    x=0;    
+    x=0;
     while (x<w)
-    {      
-      size++;     
-      while (x<w && *sl==0) { sl++; x++; }      
-                                                                
+    {
+      size++;
+      while (x<w && *sl==0) { sl++; x++; }
+
       if (x<w)
       {
-        size++;  // byte for the size of the run        
+        size++;  // byte for the size of the run
         while (x<w && (*sl)!=0)
         {
-          size++;
-          x++;
-          sl++;   
-        }       
-      }
-    }        
-  }  
+      size++;
+      x++;
+      sl++;
+    }
+      }
+    }
+  }
 
 #ifdef MEM_CHECK
@@ -104 +109 @@
   { printf("size = %d %d (%d)\n",im->width(),im->height(),size);  }
   CONDITION(datap,"malloc error for trans_image::data");
-  
+
   for (y=0;y<hh;y++)  // now actually make the runs
   {
     sl=im->scan_line(y);
-    x=0;    
+    x=0;
     while (x<ww)
-    {      
-      *datap=0;  // start the skip at 0       
-      while (x<im->width() && (*sl)==0) 
-      { sl++; x++; (*datap)++; }      
-      datap++;      
-                                                                
+    {
+      *datap=0;  // start the skip at 0
+      while (x<im->width() && (*sl)==0)
+      { sl++; x++; (*datap)++; }
+      datap++;
+
       if (x<ww)
       {
         marker=datap;   // let marker be the run size
-        *marker=0;
-        datap++;    // skip over this spot              
+    *marker=0;
+    datap++;    // skip over this spot
         while (x<im->width() && (*sl)!=0)
-        {       
-          (*marker)++;    
-          (*datap)=*sl;
-          datap++;        
-          x++;
-          sl++;           
-        }       
-      }
-    }        
-  }  
-}
-
-void trans_image::put_scan_line(image *screen, int x, int y, int line)   // always transparent   
+        {
+          (*marker)++;
+      (*datap)=*sl;
+          datap++;
+      x++;
+      sl++;
+    }
+      }
+    }
+  }
+  im->unlock();
+}
+
+void trans_image::put_scan_line(image *screen, int x, int y, int line)   // always transparent
 {
   int16_t x1,y1,x2,y2;
@@ -142 +148 @@
 
   uint8_t *datap=data;
-  int ix;  
+  int ix;
   while (line)            // skip scan line data until we get to the line of interest
   {
-    for (ix=0;ix<w;)      
-    {      
+    for (ix=0;ix<w;)
+    {
       ix+=*datap;        // skip blank space
       datap++;
-      if (ix<w)          
-      { 
-        int run_length=*datap;     // skip run
-        ix+=run_length;
-        datap+=run_length+1;
-      }      
-    }
-    line--;    
-    y++;    
-  }
-  
-  
+      if (ix<w)
+      {
+    int run_length=*datap;     // skip run
+    ix+=run_length;
+    datap+=run_length+1;
+      }
+    }
+    line--;
+    y++;
+  }
+
+
   // now slam this list of runs to the screen
+  screen->lock();
   uint8_t *screen_line=screen->scan_line(y)+x;
-    
-  for (ix=0;ix<w;)             
-  {      
+
+  for (ix=0;ix<w;)
+  {
     int skip=*datap;              // how much space to skip?
     datap++;
     screen_line+=skip;
-    ix+=skip;    
-    
+    ix+=skip;
+
     if (ix<w)
-    {      
+    {
       int run_length=*datap;
       datap++;
@@ -178 +185 @@
       if (x+ix+run_length-1<x1)      // is this run clipped out totally?
       {
-        datap+=run_length;
-        ix+=run_length;
-        screen_line+=run_length;
+    datap+=run_length;
+    ix+=run_length;
+    screen_line+=run_length;
       }
       else
-      {     
-        if (x+ix<x1)                 // is the run clipped partially?
-        {       
-          int clip=(x1-(x+ix)); 
-          datap+=clip;  
-          run_length-=clip;
-          screen_line+=clip;
-          ix+=clip;     
-        }
-
-        if (x+ix>x2)                      // clipped totally on the right?  
+      {
+    if (x+ix<x1)                 // is the run clipped partially?
+    {
+      int clip=(x1-(x+ix));
+      datap+=clip;
+      run_length-=clip;
+      screen_line+=clip;
+      ix+=clip;
+    }
+
+    if (x+ix>x2)                      // clipped totally on the right?
+        {
+          screen->unlock();
           return ;                        // we are done, return!
-        else if (x+ix+run_length-1>x2)    // partially clipped?
-        {
-          memcpy(screen_line,datap,(x+ix+run_length-1)-x2);   // slam what we can
-          return ;    // and return 'cause we are done with the line
+        }
+    else if (x+ix+run_length-1>x2)    // partially clipped?
+    {
+      memcpy(screen_line,datap,(x+ix+run_length-1)-x2);   // slam what we can
+          screen->unlock();
+      return ;    // and return 'cause we are done with the line
         } else
         {
-          memcpy(screen_line,datap,run_length); 
-          screen_line+=run_length;
-          datap+=run_length;
-          ix+=run_length;            
-        }      
-      }    
-    }
-  }
-
-}
-
-
-inline uint8_t *trans_image::clip_y(image *screen, int x1, int y1, int x2, int y2, 
-                                   int x, int &y, int &ysteps)
+      memcpy(screen_line,datap,run_length);
+      screen_line+=run_length;
+        datap+=run_length;
+        ix+=run_length;
+        }
+      }
+    }
+  }
+  screen->unlock();
+}
+
+
+inline uint8_t *trans_image::clip_y(image *screen, int x1, int y1, int x2, int y2,
+                   int x, int &y, int &ysteps)
 {
   // check to see if it is total clipped out first
@@ -220 +231 @@
     return NULL;
 
-  register uint8_t *datap=data;  
+  uint8_t *datap=data;
 
 
   ysteps=height();
-  
+
   if (y<y1)  // check to see if the image gets clipped at the top
   {
@@ -230 +241 @@
 
     // because data is stored in runs, we need to skip over the top clipped portion
-    int skips=(y1-y);     // how many lines do we need to skip?    
+    int skips=(y1-y);     // how many lines do we need to skip?
     ysteps-=skips;        // reduce h (number of lines to draw)
     y=y1;                // start drawing here now
     while (skips--)
-    {      
-      register int ix=0;
+    {
+      int ix=0;
       while (ix<w)
-      { 
+      {
         ix+=(*datap);       // skip over empty space
-        datap++; 
-        if (ix<w)                 
-        { ix+=*datap;         
-          datap+=(*datap)+1;   // skip over data
-        }       
-      }      
-    }
-  }
-  
+        datap++;
+        if (ix<w)
+        { ix+=*datap;
+        datap+=(*datap)+1;   // skip over data
+        }
+      }
+    }
+  }
+
   if (y+ysteps>y2)  // check to see if it gets clipped at the bottom
     ysteps-=(y+ysteps-y2-1);
 
-  screen->add_dirty(max(x,x1),y,min(x+width()-1,x2),y+h-1);  
+  screen->add_dirty(max(x,x1),y,min(x+width()-1,x2),y+h-1);
   return datap;
-} 
-
-void trans_image::put_image_filled(image *screen, int x, int y, 
-                                   uint8_t fill_color)
+}
+
+void trans_image::put_image_filled(image *screen, int x, int y,
+                   uint8_t fill_color)
 {
  int16_t x1,y1,x2,y2;
@@ -262 +273 @@
 
   screen->get_clip(x1,y1,x2,y2);
-  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
+  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
   if (!datap) return ;     // if clip_y says nothing to draw, return
-  
-  screen_line=screen->scan_line(y)+x;  
+
+  screen->lock();
+
+  screen_line=screen->scan_line(y)+x;
   int sw=screen->width()-w;
   x1-=x; x2-=x;
   for (;ysteps>0;ysteps--)
-  {         
-    register int ix,slam_length;
+  {
+    int ix,slam_length;
     for (ix=0;ix<w;)
     {
@@ -277 +290 @@
       ix+=blank;       // skip over empty space
       screen_line+=blank;
-      
-      datap++; 
-      if (ix<w)           
-      { 
-        slam_length=*datap;     // find the length of this run    
-        datap++;          
-        if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
-        {
-          datap+=slam_length;
-          ix+=slam_length;
-          screen_line+=slam_length;
-        }
-        else
-        {                   
-          if (ix<x1)                // the left side needs to be chopped ?
-          {                   
-            chop_length=(x1-ix); 
-            
-            if (chop_length>=slam_length)  // see if we chopped it all off
-            {                              // yes, we did
-              ix+=slam_length;             // advance everything to the end of run
-              screen_line+=slam_length;
-              datap+=slam_length;             
-              slam_length=0;           
-            } else
-            {        
-              slam_length-=chop_length;   // else advance everything to begining of slam  
-              ix+=chop_length;
-              screen_line+=chop_length;
-              datap+=chop_length;           
-            }       
-          }               
-
-          if (slam_length)   // see if there is anything left to slam
-          {
-            if (ix+slam_length>x2) // see if right side needs to be chopped off
-              memcpy(screen_line,datap,x2-ix+1);
-            else
-              memcpy(screen_line,datap,slam_length);
-            datap+=slam_length;
-            ix+=slam_length;        
-            screen_line+=slam_length;
-          }                   
-        }
-      }      
+
+      datap++;
+      if (ix<w)
+      {
+    slam_length=*datap;     // find the length of this run
+    datap++;
+    if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
+    {
+      datap+=slam_length;
+      ix+=slam_length;
+      screen_line+=slam_length;
+    }
+    else
+    {
+      if (ix<x1)                // the left side needs to be chopped ?
+      {
+        chop_length=(x1-ix);
+
+        if (chop_length>=slam_length)  // see if we chopped it all off
+        {                              // yes, we did
+          ix+=slam_length;             // advance everything to the end of run
+          screen_line+=slam_length;
+          datap+=slam_length;
+          slam_length=0;
+        } else
+        {
+          slam_length-=chop_length;   // else advance everything to begining of slam
+          ix+=chop_length;
+          screen_line+=chop_length;
+          datap+=chop_length;
+        }
+      }
+
+      if (slam_length)   // see if there is anything left to slam
+      {
+        if (ix+slam_length>x2) // see if right side needs to be chopped off
+          memcpy(screen_line,datap,x2-ix+1);
+        else
+          memcpy(screen_line,datap,slam_length);
+        datap+=slam_length;
+        ix+=slam_length;
+        screen_line+=slam_length;
+      }
+    }
+      }
     }
     screen_line+=sw;
-  }    
+  }
+  screen->unlock();
 }
 
@@ -330 +344 @@
 {
   int ix,ysteps=height();
-  int screen_skip=screen->width()-w;
+  int screen_skip;
   uint8_t skip,*datap=data;
+
+  screen->lock();
+  screen_skip = screen->width() - w;
   for (;ysteps;ysteps--)
   {
@@ -342 +359 @@
 
       if (s_off<screen->scan_line(0))
-        printf("bad write");
+          printf("bad write in trans_image::put_image_offseted");
 
 
       if (ix<w)
       {
-        skip=*datap;
-        datap++;
-        memcpy(s_off,datap,skip);
-        datap+=skip;
-        s_off+=skip;
-        ix+=skip;
-
-        if (s_off>=screen->scan_line(screen->height()+1))
-          printf("bad write");
+    skip=*datap;
+    datap++;
+    memcpy(s_off,datap,skip);
+    datap+=skip;
+    s_off+=skip;
+    ix+=skip;
+
+    if (s_off>=screen->scan_line(screen->height()+1))
+            printf("bad write in trans_image::put_image_offseted");
       }
     }
     s_off+=screen_skip;
   }
-}
-
-void trans_image::put_image(image *screen, int x, int y) 
+  screen->unlock();
+}
+
+void trans_image::put_image(image *screen, int x, int y)
 {
   int16_t x1,y1,x2,y2;
@@ -368 +386 @@
 
   screen->get_clip(x1,y1,x2,y2);
-  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
+  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
   if (!datap) return ;     // if clip_y says nothing to draw, return
-  
-  screen_line=screen->scan_line(y)+x;  
+
+  screen->lock();
+  screen_line=screen->scan_line(y)+x;
   int sw=screen->width();
   x1-=x; x2-=x;
   for (;ysteps>0;ysteps--)
-  {         
-    register int ix,slam_length;
+  {
+    int ix,slam_length;
     for (ix=0;ix<w;)
     {
       ix+=(*datap);       // skip over empty space
-      datap++; 
-      if (ix<w)           
-      { 
-        slam_length=*datap;     // find the length of this run    
-        datap++;          
-        if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
-        {
-          datap+=slam_length;
-          ix+=slam_length;          
-        }
-        else
-        {                   
-          if (ix<x1)                // the left side needs to be chopped ?
-          {                   
-            chop_length=(x1-ix); 
-            
-            if (chop_length>=slam_length)  // see if we chopped it all off
-            {                              // yes, we did
-              ix+=slam_length;             // advance everything to the end of run
-              datap+=slam_length;             
-              slam_length=0;           
-            } else
-            {        
-              slam_length-=chop_length;   // else advance everything to begining of slam  
-              ix+=chop_length;
-              datap+=chop_length;           
-            }       
-          }               
-
-          if (slam_length)   // see if there is anything left to slam
-          {
-            if (ix+slam_length>x2) // see if right side needs to be chopped off
-              memcpy(screen_line+ix,datap,x2-ix+1);
-            else
-              memcpy(screen_line+ix,datap,slam_length);
-            datap+=slam_length;
-            ix+=slam_length;        
-          }                   
-        }
-      }      
+      datap++;
+      if (ix<w)
+      {
+    slam_length=*datap;     // find the length of this run
+    datap++;
+    if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
+    {
+      datap+=slam_length;
+      ix+=slam_length;
+    }
+    else
+    {
+      if (ix<x1)                // the left side needs to be chopped ?
+      {
+        chop_length=(x1-ix);
+
+        if (chop_length>=slam_length)  // see if we chopped it all off
+        {                              // yes, we did
+          ix+=slam_length;             // advance everything to the end of run
+          datap+=slam_length;
+          slam_length=0;
+        } else
+        {
+          slam_length-=chop_length;   // else advance everything to begining of slam
+          ix+=chop_length;
+          datap+=chop_length;
+        }
+      }
+
+      if (slam_length)   // see if there is anything left to slam
+      {
+        if (ix+slam_length>x2) // see if right side needs to be chopped off
+          memcpy(screen_line+ix,datap,x2-ix+1);
+        else
+          memcpy(screen_line+ix,datap,slam_length);
+        datap+=slam_length;
+        ix+=slam_length;
+      }
+    }
+      }
     }
     screen_line+=sw;
-  }    
-}
-
-void trans_image::put_remaped(image *screen, int x, int y, uint8_t *remap) 
+  }
+  screen->unlock();
+}
+
+void trans_image::put_remaped(image *screen, int x, int y, uint8_t *remap)
 {
   int16_t x1,y1,x2,y2;
@@ -431 +451 @@
 
   screen->get_clip(x1,y1,x2,y2);
-  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
+  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
   if (!datap) return ;     // if clip_y says nothing to draw, return
-  
-  screen_line=screen->scan_line(y)+x;  
+
+  screen->lock();
+  screen_line=screen->scan_line(y)+x;
   int sw=screen->width();
   x1-=x; x2-=x;
   for (;ysteps>0;ysteps--)
-  {         
-    register int ix,slam_length;
+  {
+    int ix,slam_length;
     for (ix=0;ix<w;)
     {
       ix+=(*datap);       // skip over empty space
-      datap++; 
-      if (ix<w)           
-      { 
-        slam_length=*datap;     // find the length of this run    
-        datap++;          
-        if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
-        {
-          datap+=slam_length;
-          ix+=slam_length;          
-        }
-        else
-        {                   
-          if (ix<x1)                // the left side needs to be chopped ?
-          {                   
-            chop_length=(x1-ix); 
-            
-            if (chop_length>=slam_length)  // see if we chopped it all off
-            {                              // yes, we did
-              ix+=slam_length;             // advance everything to the end of run
-              datap+=slam_length;             
-              slam_length=0;           
-            } else
-            {        
-              slam_length-=chop_length;   // else advance everything to begining of slam  
-              ix+=chop_length;
-              datap+=chop_length;           
-            }       
-          }               
-
-
-          if (slam_length)   // see if there is anything left to slam
-          {
-            register int counter;
-            if (ix+slam_length>x2) // see if right side needs to be chopped off     
-              counter=x2-ix+1;
-            else
-              counter=slam_length;
-
-            register uint8_t *sl=screen_line+ix,*sl2=datap;
-            ix+=slam_length;        
-            datap+=slam_length;
-            while (counter)
-            {
-              counter--;
-              *(sl)=remap[*(sl2)];
-              sl++;
-              sl2++;
-            }
-          }                   
-        }
-      }      
+      datap++;
+      if (ix<w)
+      {
+    slam_length=*datap;     // find the length of this run
+    datap++;
+    if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
+    {
+      datap+=slam_length;
+      ix+=slam_length;
+    }
+    else
+    {
+      if (ix<x1)                // the left side needs to be chopped ?
+      {
+        chop_length=(x1-ix);
+
+        if (chop_length>=slam_length)  // see if we chopped it all off
+        {                              // yes, we did
+          ix+=slam_length;             // advance everything to the end of run
+          datap+=slam_length;
+          slam_length=0;
+        } else
+        {
+          slam_length-=chop_length;   // else advance everything to begining of slam
+          ix+=chop_length;
+          datap+=chop_length;
+        }
+      }
+
+
+      if (slam_length)   // see if there is anything left to slam
+      {
+        int counter;
+        if (ix+slam_length>x2) // see if right side needs to be chopped off
+          counter=x2-ix+1;
+        else
+          counter=slam_length;
+
+        uint8_t *sl=screen_line+ix,*sl2=datap;
+        ix+=slam_length;
+        datap+=slam_length;
+        while (counter)
+        {
+          counter--;
+          *(sl)=remap[*(sl2)];
+          sl++;
+          sl2++;
+        }
+      }
+    }
+      }
     }
     screen_line+=sw;
-  }    
-}
-
-
-
-void trans_image::put_double_remaped(image *screen, int x, int y, uint8_t *remap, uint8_t *remap2) 
+  }
+  screen->unlock();
+}
+
+
+
+void trans_image::put_double_remaped(image *screen, int x, int y, uint8_t *remap, uint8_t *remap2)
 {
   int16_t x1,y1,x2,y2;
@@ -507 +529 @@
 
   screen->get_clip(x1,y1,x2,y2);
-  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
+  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
   if (!datap) return ;     // if clip_y says nothing to draw, return
-  
-  screen_line=screen->scan_line(y)+x;  
+
+  screen->lock();
+  screen_line=screen->scan_line(y)+x;
   int sw=screen->width();
   x1-=x; x2-=x;
   for (;ysteps>0;ysteps--)
-  {         
-    register int ix,slam_length;
+  {
+    int ix,slam_length;
     for (ix=0;ix<w;)
     {
       ix+=(*datap);       // skip over empty space
-      datap++; 
-      if (ix<w)           
-      { 
-        slam_length=*datap;     // find the length of this run    
-        datap++;          
-        if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
-        {
-          datap+=slam_length;
-          ix+=slam_length;          
-        }
-        else
-        {                   
-          if (ix<x1)                // the left side needs to be chopped ?
-          {                   
-            chop_length=(x1-ix); 
-            
-            if (chop_length>=slam_length)  // see if we chopped it all off
-            {                              // yes, we did
-              ix+=slam_length;             // advance everything to the end of run
-              datap+=slam_length;             
-              slam_length=0;           
-            } else
-            {        
-              slam_length-=chop_length;   // else advance everything to begining of slam  
-              ix+=chop_length;
-              datap+=chop_length;           
-            }       
-          }               
-
-
-          if (slam_length)   // see if there is anything left to slam
-          {
-            register int counter;
-            if (ix+slam_length>x2) // see if right side needs to be chopped off     
-              counter=x2-ix+1;
-            else
-              counter=slam_length;
-
-            register uint8_t *sl=screen_line+ix,*sl2=datap;
-            ix+=slam_length;        
-            datap+=slam_length;
-            while (counter)
-            {
-              counter--;
-              *(sl)=remap2[remap[*(sl2)]];
-              sl++;
-              sl2++;
-            }
-          }                   
-        }
-      }      
+      datap++;
+      if (ix<w)
+      {
+    slam_length=*datap;     // find the length of this run
+    datap++;
+    if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
+    {
+      datap+=slam_length;
+      ix+=slam_length;
+    }
+    else
+    {
+      if (ix<x1)                // the left side needs to be chopped ?
+      {
+        chop_length=(x1-ix);
+
+        if (chop_length>=slam_length)  // see if we chopped it all off
+        {                              // yes, we did
+          ix+=slam_length;             // advance everything to the end of run
+          datap+=slam_length;
+          slam_length=0;
+        } else
+        {
+          slam_length-=chop_length;   // else advance everything to begining of slam
+          ix+=chop_length;
+          datap+=chop_length;
+        }
+      }
+
+
+      if (slam_length)   // see if there is anything left to slam
+      {
+        int counter;
+        if (ix+slam_length>x2) // see if right side needs to be chopped off
+          counter=x2-ix+1;
+        else
+          counter=slam_length;
+
+        uint8_t *sl=screen_line+ix,*sl2=datap;
+        ix+=slam_length;
+        datap+=slam_length;
+        while (counter)
+        {
+          counter--;
+          *(sl)=remap2[remap[*(sl2)]];
+          sl++;
+          sl2++;
+        }
+      }
+    }
+      }
     }
     screen_line+=sw;
-  }    
+  }
+  screen->unlock();
 }
 
@@ -578 +602 @@
 
 void trans_image::put_fade(image *screen, int x, int y,
-                           int frame_on, int total_frames, 
-                           color_filter *f, palette *pal) 
+               int frame_on, int total_frames,
+               color_filter *f, palette *pal)
 {
   int16_t x1,y1,x2,y2;
@@ -593 +617 @@
 
   long fixmul=(frame_on<<16)/total_frames;
+  screen->lock();
   for (;ysteps>0;ysteps--,y++)
-  {         
+  {
     screen_line=screen->scan_line(y);
-      
+
     for (ix=0;ix<w;)
     {
       ix+=(*datap);       // skip over empty space
-      datap++; 
-      if (ix<w)           
-      { 
-        slam_length=*datap;     // find the length of this run    
-        datap++;          
-        if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
-        {
-          datap+=slam_length;
-          ix+=slam_length;          
-        }
-        else
-        {                   
-          if (x+ix<x1)                // the left side needs to be chopped ?
-          {                   
-            chop_length=(x1-x-ix); 
-            
-            if (chop_length>=slam_length)  // see if we chopped it all off
-            {                              // yes, we did
-              ix+=slam_length;             // advance everything to the end of run
-              datap+=slam_length;             
-              slam_length=0;           
-            } else
-            {        
-              slam_length-=chop_length;   // else advance everything to begining of slam  
-              ix+=chop_length;
-              datap+=chop_length;           
-            }       
-          }               
-
-          if (slam_length)   // see if there is anything left to slam
-          {
-            if (x+ix+slam_length>x2) // see if right side needs to be chopped off
-              chop_length=x2-x-ix;
-            else chop_length=slam_length;
-            screen_run=screen_line+x+ix;
-              
-            slam_length-=chop_length;
-            ix+=chop_length;
-              
-            while (chop_length--)
-            {
-              caddr1=paddr+(int)(*screen_run)*3;
-              caddr2=paddr+(int)(*datap)*3;
-              
-              r_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
-              caddr1++; caddr2++;
-
-              g_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
-              caddr1++; caddr2++;
-
-              b_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
-              *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
-
-              screen_run++;
-              datap++;          
-            }
-            datap+=slam_length;
-            ix+=slam_length;        
-          }                   
-        }
-      }      
-    }      
-  }    
+      datap++;
+      if (ix<w)
+      {
+    slam_length=*datap;     // find the length of this run
+    datap++;
+    if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
+    {
+      datap+=slam_length;
+      ix+=slam_length;
+    }
+    else
+    {
+      if (x+ix<x1)                // the left side needs to be chopped ?
+      {
+        chop_length=(x1-x-ix);
+
+        if (chop_length>=slam_length)  // see if we chopped it all off
+        {                              // yes, we did
+          ix+=slam_length;             // advance everything to the end of run
+          datap+=slam_length;
+          slam_length=0;
+        } else
+        {
+          slam_length-=chop_length;   // else advance everything to begining of slam
+          ix+=chop_length;
+          datap+=chop_length;
+        }
+      }
+
+      if (slam_length)   // see if there is anything left to slam
+      {
+        if (x+ix+slam_length>x2) // see if right side needs to be chopped off
+          chop_length=x2-x-ix;
+        else chop_length=slam_length;
+        screen_run=screen_line+x+ix;
+
+        slam_length-=chop_length;
+        ix+=chop_length;
+
+        while (chop_length--)
+        {
+          caddr1=paddr+(int)(*screen_run)*3;
+          caddr2=paddr+(int)(*datap)*3;
+
+          r_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
+          caddr1++; caddr2++;
+
+          g_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
+          caddr1++; caddr2++;
+
+          b_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
+          *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
+
+          screen_run++;
+          datap++;
+        }
+        datap+=slam_length;
+        ix+=slam_length;
+      }
+    }
+      }
+    }
+  }
+  screen->unlock();
 }
 
@@ -669 +695 @@
 
 void trans_image::put_fade_tint(image *screen, int x, int y,
-                                int frame_on, int total_frames, 
-                                uint8_t *tint,
-                                color_filter *f, palette *pal) 
+                int frame_on, int total_frames,
+                uint8_t *tint,
+                color_filter *f, palette *pal)
 {
   int16_t x1,y1,x2,y2;
@@ -681 +707 @@
   if (!datap) return ;
 
+  screen->lock();
   uint8_t *screen_run,*paddr=(uint8_t *)pal->addr(),
                 *caddr1,*caddr2,r_dest,g_dest,b_dest;
@@ -686 +713 @@
   long fixmul=(frame_on<<16)/total_frames;
   for (;ysteps>0;ysteps--,y++)
-  {         
+  {
     screen_line=screen->scan_line(y);
-      
+
     for (ix=0;ix<w;)
     {
       ix+=(*datap);       // skip over empty space
-      datap++; 
-      if (ix<w)           
-      { 
-        slam_length=*datap;     // find the length of this run    
-        datap++;          
-        if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
-        {
-          datap+=slam_length;
-          ix+=slam_length;          
-        }
-        else
-        {                   
-          if (x+ix<x1)                // the left side needs to be chopped ?
-          {                   
-            chop_length=(x1-x-ix); 
-            
-            if (chop_length>=slam_length)  // see if we chopped it all off
-            {                              // yes, we did
-              ix+=slam_length;             // advance everything to the end of run
-              datap+=slam_length;             
-              slam_length=0;           
-            } else
-            {        
-              slam_length-=chop_length;   // else advance everything to begining of slam  
-              ix+=chop_length;
-              datap+=chop_length;           
-            }       
-          }               
-
-          if (slam_length)   // see if there is anything left to slam
-          {
-            if (x+ix+slam_length>x2) // see if right side needs to be chopped off
-              chop_length=x2-x-ix;
-            else chop_length=slam_length;
-            screen_run=screen_line+x+ix;
-              
-            slam_length-=chop_length;
-            ix+=chop_length;
-              
-            while (chop_length--)
-            {
-              caddr1=paddr+(int)(*screen_run)*3;
-              caddr2=paddr+(int)(tint[*datap])*3;
-              
-              r_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
-              caddr1++; caddr2++;
-
-              g_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
-              caddr1++; caddr2++;
-
-              b_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
-              *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
-
-              screen_run++;
-              datap++;          
-            }
-            datap+=slam_length;
-            ix+=slam_length;        
-          }                   
-        }
-      }      
-    }      
-  }    
-}
-
-
-
-
-
-
-void trans_image::put_color(image *screen, int x, int y, int color) 
+      datap++;
+      if (ix<w)
+      {
+    slam_length=*datap;     // find the length of this run
+    datap++;
+    if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
+    {
+      datap+=slam_length;
+      ix+=slam_length;
+    }
+    else
+    {
+      if (x+ix<x1)                // the left side needs to be chopped ?
+      {
+        chop_length=(x1-x-ix);
+
+        if (chop_length>=slam_length)  // see if we chopped it all off
+        {                              // yes, we did
+          ix+=slam_length;             // advance everything to the end of run
+          datap+=slam_length;
+          slam_length=0;
+        } else
+        {
+          slam_length-=chop_length;   // else advance everything to begining of slam
+          ix+=chop_length;
+          datap+=chop_length;
+        }
+      }
+
+      if (slam_length)   // see if there is anything left to slam
+      {
+        if (x+ix+slam_length>x2) // see if right side needs to be chopped off
+          chop_length=x2-x-ix;
+        else chop_length=slam_length;
+        screen_run=screen_line+x+ix;
+
+        slam_length-=chop_length;
+        ix+=chop_length;
+
+        while (chop_length--)
+        {
+          caddr1=paddr+(int)(*screen_run)*3;
+          caddr2=paddr+(int)(tint[*datap])*3;
+
+          r_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
+          caddr1++; caddr2++;
+
+          g_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
+          caddr1++; caddr2++;
+
+          b_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
+          *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
+
+          screen_run++;
+          datap++;
+        }
+        datap+=slam_length;
+        ix+=slam_length;
+      }
+    }
+      }
+    }
+  }
+  screen->unlock();
+}
+
+void trans_image::put_color(image *screen, int x, int y, int color)
 {
   int16_t x1,y1,x2,y2;
   int ix,slam_length,chop_length,ysteps;
-  
+
   screen->get_clip(x1,y1,x2,y2);
   uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
                 *screen_line;
   if (!datap) return ;
-  
-  
+
+  screen->lock();
   for (;ysteps>0;ysteps--,y++)
-  {         
+  {
     screen_line=screen->scan_line(y);
-      
+
     for (ix=0;ix<w;)
     {
       ix+=(*datap);       // skip over empty space
-      datap++; 
-      if (ix<w)           
-      { 
-        slam_length=*datap;     // find the length of this run    
-        datap++;          
-        if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
-        {
-          datap+=slam_length;
-          ix+=slam_length;          
-        }
-        else
-        {                   
-          if (x+ix<x1)                // the left side needs to be chopped ?
-          {                   
-            chop_length=(x1-x-ix); 
-            
-            if (chop_length>=slam_length)  // see if we chopped it all off
-            {                              // yes, we did
-              ix+=slam_length;             // advance everything to the end of run
-              datap+=slam_length;             
-              slam_length=0;           
-            } else
-            {        
-              slam_length-=chop_length;   // else advance everything to begining of slam  
-              ix+=chop_length;
-              datap+=chop_length;           
-            }       
-          }               
-
-          if (slam_length)   // see if there is anything left to slam
-          {
-            if (x+ix+slam_length>x2) // see if right side needs to be chopped off
-              memset(screen_line+x+ix,color,x2-x-ix+1);
-            else
-              memset(screen_line+x+ix,color,slam_length);
-            datap+=slam_length;
-            ix+=slam_length;        
-          }     
-        }
-      }      
-    }      
-  }    
+      datap++;
+      if (ix<w)
+      {
+    slam_length=*datap;     // find the length of this run
+    datap++;
+    if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
+    {
+      datap+=slam_length;
+      ix+=slam_length;
+    }
+    else
+    {
+      if (x+ix<x1)                // the left side needs to be chopped ?
+      {
+        chop_length=(x1-x-ix);
+
+        if (chop_length>=slam_length)  // see if we chopped it all off
+        {                              // yes, we did
+          ix+=slam_length;             // advance everything to the end of run
+          datap+=slam_length;
+          slam_length=0;
+        } else
+        {
+          slam_length-=chop_length;   // else advance everything to begining of slam
+          ix+=chop_length;
+          datap+=chop_length;
+        }
+      }
+
+      if (slam_length)   // see if there is anything left to slam
+      {
+        if (x+ix+slam_length>x2) // see if right side needs to be chopped off
+          memset(screen_line+x+ix,color,x2-x-ix+1);
+        else
+          memset(screen_line+x+ix,color,slam_length);
+        datap+=slam_length;
+        ix+=slam_length;
+      }
+    }
+      }
+    }
+  }
+  screen->unlock();
 }
 
 
 // ASSUMES that the blend image completly covers this image
-void trans_image::put_blend16(image *screen, image *blend, int x, int y, 
-                   int blendx, int blendy, int blend_amount, color_filter *f, palette *pal)
+void trans_image::put_blend16(image *screen, image *blend, int x, int y,
+                  int blendx, int blendy, int blend_amount, color_filter *f, palette *pal)
 
 {
   int16_t x1,y1,x2,y2;
   int ix,slam_length,chop_length,ysteps;
-  uint8_t *paddr=(uint8_t *)pal->addr();  
-  
+  uint8_t *paddr=(uint8_t *)pal->addr();
+
   screen->get_clip(x1,y1,x2,y2);
   uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
@@ -839 +863 @@
   if (!datap) return ;
   CONDITION(y>=blendy && y+ysteps<blendy+blend->height()+1,"Blend doesn't fit on trans_image");
-  
+
   blend_amount=16-blend_amount;
-  
+
+  screen->lock();
   for (;ysteps>0;ysteps--,y++)
-  {         
+  {
     screen_line=screen->scan_line(y);
     blend_line=blend->scan_line(y-blendy);
-    
-      
+
+
     for (ix=0;ix<w;)
     {
       ix+=(*datap);       // skip over empty space
-      datap++; 
-      if (ix<w)           
-      { 
-        slam_length=*datap;     // find the length of this run    
-        datap++;          
-        if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
-        {
-          datap+=slam_length;
-          ix+=slam_length;          
-        }
-        else
-        {                   
-          if (x+ix<x1)                // the left side needs to be chopped ?
-          {                   
-            chop_length=(x1-x-ix); 
-            
-            if (chop_length>=slam_length)  // see if we chopped it all off
-            {                              // yes, we did
-              ix+=slam_length;             // advance everything to the end of run
-              datap+=slam_length;             
-              slam_length=0;           
-            } else
-            {        
-              slam_length-=chop_length;   // else advance everything to begining of slam  
-              ix+=chop_length;
-              datap+=chop_length;           
-            }       
-          }               
-
-          if (slam_length)   // see if there is anything left to slam
-          {
-
-            if (x+ix+slam_length>x2) // see if right side needs to be chopped off
-              chop_length=x2-x-ix;
-            else chop_length=slam_length;
-
-            uint8_t *screen_run=screen_line+x+ix,
-                          *blend_run=blend_line+x+ix-blendx,
-                          *caddr1,*caddr2,r_dest,g_dest,b_dest;      
-              
-            slam_length-=chop_length;
-            ix+=chop_length;    
-
-
-            while (chop_length--)
-            {
-              caddr1=paddr+(int)(*blend_run)*3;
-              caddr2=paddr+(int)(*datap)*3;
-              
-              r_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
-              caddr1++; caddr2++;
-
-              g_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
-              caddr1++; caddr2++;
-
-              b_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
-
-              *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
-
-              
-              screen_run++;
-              blend_run++;
-              datap++;          
-            }
-            datap+=slam_length;
-            ix+=slam_length;        
-          }                 
-
-        }
-      }      
-    }      
-  }    
-
-
-}
-
-void trans_image::put_predator(image *screen, int x, int y) 
+      datap++;
+      if (ix<w)
+      {
+    slam_length=*datap;     // find the length of this run
+    datap++;
+    if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
+    {
+      datap+=slam_length;
+      ix+=slam_length;
+    }
+    else
+    {
+      if (x+ix<x1)                // the left side needs to be chopped ?
+      {
+        chop_length=(x1-x-ix);
+
+        if (chop_length>=slam_length)  // see if we chopped it all off
+        {                              // yes, we did
+          ix+=slam_length;             // advance everything to the end of run
+          datap+=slam_length;
+          slam_length=0;
+        } else
+        {
+          slam_length-=chop_length;   // else advance everything to begining of slam
+          ix+=chop_length;
+          datap+=chop_length;
+        }
+      }
+
+      if (slam_length)   // see if there is anything left to slam
+      {
+
+        if (x+ix+slam_length>x2) // see if right side needs to be chopped off
+          chop_length=x2-x-ix;
+        else chop_length=slam_length;
+
+        uint8_t *screen_run=screen_line+x+ix,
+                      *blend_run=blend_line+x+ix-blendx,
+                      *caddr1,*caddr2,r_dest,g_dest,b_dest;
+
+        slam_length-=chop_length;
+        ix+=chop_length;
+
+
+        while (chop_length--)
+        {
+          caddr1=paddr+(int)(*blend_run)*3;
+          caddr2=paddr+(int)(*datap)*3;
+
+          r_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
+          caddr1++; caddr2++;
+
+          g_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
+          caddr1++; caddr2++;
+
+          b_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
+
+          *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
+
+
+          screen_run++;
+          blend_run++;
+          datap++;
+        }
+        datap+=slam_length;
+        ix+=slam_length;
+      }
+
+    }
+      }
+    }
+  }
+
+  screen->unlock();
+}
+
+void trans_image::put_predator(image *screen, int x, int y)
 {
   int16_t x1,y1,x2,y2;
@@ -933 +958 @@
 
   screen->get_clip(x1,y1,x2,y2);
-  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
+  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
   if (!datap) return ;     // if clip_y says nothing to draw, return
 
@@ -946 +971 @@
       if (x<w)
       {
-        int run_size=*datap;
-        datap+=run_size+1;
-        x+=run_size;
-      }
-    }
-    if (y==y2) 
+    int run_size=*datap;
+    datap+=run_size+1;
+    x+=run_size;
+      }
+    }
+    if (y==y2)
       return;
     else
-      y++;    
+      y++;
   }*/
-  
-  screen_line=screen->scan_line(y)+x;  
+
+  screen->lock();
+  screen_line=screen->scan_line(y)+x;
   int sw=screen->width();
   x1-=x; x2-=x;
   for (;ysteps>0;ysteps--)
-  {         
-    register int ix,slam_length;
+  {
+    int ix,slam_length;
     for (ix=0;ix<w;)
     {
       ix+=(*datap);       // skip over empty space
-      datap++; 
-      if (ix<w)           
-      { 
-        slam_length=*datap;     // find the length of this run    
-        datap++;          
-        if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
-        {
-          datap+=slam_length;
-          ix+=slam_length;          
-        }
-        else
-        {                   
-          if (ix<x1)                // the left side needs to be chopped ?
-          {                   
-            chop_length=(x1-ix); 
-            
-            if (chop_length>=slam_length)  // see if we chopped it all off
-            {                              // yes, we did
-              ix+=slam_length;             // advance everything to the end of run
-              datap+=slam_length;             
-              slam_length=0;           
-            } else
-            {        
-              slam_length-=chop_length;   // else advance everything to begining of slam  
-              ix+=chop_length;
-              datap+=chop_length;           
-            }       
-          }               
-
-          if (slam_length)   // see if there is anything left to slam
-          {
-            if (ix+slam_length>x2) // see if right side needs to be chopped off
-              memcpy(screen_line+ix,screen_line+sw+sw+ix,x2-ix+1);
-            else
-              memcpy(screen_line+ix,screen_line+sw+sw+ix,slam_length);
-            datap+=slam_length;
-            ix+=slam_length;        
-          }                   
-        }
-      }      
+      datap++;
+      if (ix<w)
+      {
+    slam_length=*datap;     // find the length of this run
+    datap++;
+    if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
+    {
+      datap+=slam_length;
+      ix+=slam_length;
+    }
+    else
+    {
+      if (ix<x1)                // the left side needs to be chopped ?
+      {
+        chop_length=(x1-ix);
+
+        if (chop_length>=slam_length)  // see if we chopped it all off
+        {                              // yes, we did
+          ix+=slam_length;             // advance everything to the end of run
+          datap+=slam_length;
+          slam_length=0;
+        } else
+        {
+          slam_length-=chop_length;   // else advance everything to begining of slam
+          ix+=chop_length;
+          datap+=chop_length;
+        }
+      }
+
+      if (slam_length)   // see if there is anything left to slam
+      {
+        if (ix+slam_length>x2) // see if right side needs to be chopped off
+          memcpy(screen_line+ix,screen_line+sw+sw+ix,x2-ix+1);
+        else
+          memcpy(screen_line+ix,screen_line+sw+sw+ix,slam_length);
+        datap+=slam_length;
+        ix+=slam_length;
+      }
+    }
+      }
     }
     screen_line+=sw;
-  }    
+  }
+  screen->unlock();
 }
 
@@ -1023 +1050 @@
       if (x<w)
       {
-        int s=*d; d++; t+=s+1;
-        d+=s;
-        x+=s;
-      }      
+    int s=*d; d++; t+=s+1;
+    d+=s;
+    x+=s;
+      }
     }
   }

abuse/trunk/src/level.cpp

@@ -1657 +1657 @@
   fp->write_uint16(i->width());
   fp->write_uint16(i->height());
-  int y=0;
-  for (;y<i->height();y++)
+
+  i->lock();
+  for(int y = 0; y < i->height(); y++)
     fp->write(i->scan_line(y),i->width());
+  i->unlock();
 
   delete i;

abuse/trunk/src/light.cpp

@@ -776 +776 @@
   light_patch *first=make_patch_list(cx2-cx1+1,cy2-cy1+1,screenx,screeny);
 
-  int scr_w=screen->width();
-
   int prefix_x=(screenx&7);
   int prefix=screenx&7;
@@ -791 +789 @@
 
   light_patch *f=first;
+
+  screen->lock();
+
+  int scr_w=screen->width();
   uint8_t *screen_line=screen->scan_line(cy1)+cx1;
 
@@ -880 +882 @@
 
     screen_line-=prefix;
-
-
-
-  }
-
+  }
+  screen->unlock();
 
   while (first)

abuse/trunk/src/menu.cpp

@@ -49 +49 @@
   percent=256-percent;
 
+  screen->lock();
   for (y=y1;y<=y2;y++)
   {
@@ -62 +63 @@
   }
   screen->add_dirty(x1,y1,x2,y2);  
+  screen->unlock();
 }
 
@@ -75 +77 @@
   if (x2<x1 || y2<y1) return ;
 
+  screen->lock();
   for (y=y1;y<=y2;y++)
   {
@@ -88 +91 @@
   }
   screen->add_dirty(x1,y1,x2,y2);
+  screen->unlock();
 }
 

abuse/trunk/src/particle.cpp

@@ -45 +45 @@
     last_anim->next=pan;
     last_anim=pan;
-  }  
+  }
 }
 
@@ -76 +76 @@
   args=lcdr(args);
   pseqs[total_pseqs]=new part_sequence(args);
-  total_pseqs++;  
+  total_pseqs++;
   return total_pseqs;
 }
@@ -84 +84 @@
 part_sequence::part_sequence(void *args)
 {
-  char *fn=lstring_value(lcar(args)); 
+  char *fn=lstring_value(lcar(args));
   bFILE *fp=open_file(fn,"rb");
   if (fp->open_failure())
@@ -106 +106 @@
     if (sd.entries[i]->type==SPEC_PARTICLE) tframes++;
   frames=(int *)jmalloc(sizeof(int)*tframes,"part_frame id list\n");
- 
+
   int on=0;
   for (i=0;i<sd.total;i++)
-    if (sd.entries[i]->type==SPEC_PARTICLE)     
+    if (sd.entries[i]->type==SPEC_PARTICLE)
       frames[on++]=cash.reg(fn,sd.entries[i]->name,SPEC_PARTICLE,1);
 
@@ -128 +128 @@
     if (y>y2) y2=x;
     data[i].x=x;
-    data[i].y=y;   
-    data[i].color=fp->read_uint8(); 
+    data[i].y=y;
+    data[i].color=fp->read_uint8();
   }
 }
@@ -148 +148 @@
       p=p->next;
       delete d;
-    } else 
+    } else
     {
       last=p;
@@ -159 +159 @@
 void draw_panims(view *v)
 {
-  for (part_animation *p=first_anim;p;p=p->next)      
+  for (part_animation *p=first_anim;p;p=p->next)
   {
     cash.part(p->seq->frames[p->frame])->draw(screen,p->x-v->xoff()+v->cx1,p->y-v->yoff()+v->cy1,p->dir);
@@ -178 +178 @@
   while (i && pon->y<cy1) { pon++; i--; }
   if (!i) return ;
+  screen->lock();
   if (dir>0)
   {
@@ -187 +188 @@
       i--;
       pon++;
-    }   
+    }
   } else
   {
@@ -197 +198 @@
       i--;
       pon++;
-    }   
-  }
-
-}
-
-
-
+    }
+  }
+  screen->unlock();
+}
 
 void scatter_line(int x1, int y1, int x2, int y2, int c, int s)
 {
-        int16_t cx1, cy1, cx2, cy2;
-        screen->get_clip( cx1, cy1, cx2, cy2 );
-
-        int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;
-        long xo = x1 << 16, yo = y1 << 16, dx = ( ( x2 - x1 ) << 16 ) / t, dy = ( ( y2 - y1 ) << 16 ) / t, x, y;
-
-        int xm = ( 1 << s );
-        int ym = ( 1 << s );
-        s = ( 15 - s );
-
-        while( t-- )
-        {
-                x = ( xo >> 16 ) + ( jrand() >> s ) - xm;
-                y = ( yo >> 16 ) + ( jrand() >> s ) - ym;
-                if( !( x < cx1 || y < cy1 || x > cx2 || y > cy2 ) )
-                {
-                        *(screen->scan_line( y ) + x ) = c;
-                }
-                xo += dx;
-                yo += dy;
-        }
+    int16_t cx1, cy1, cx2, cy2;
+    screen->get_clip( cx1, cy1, cx2, cy2 );
+
+    int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;
+    long xo = x1 << 16, yo = y1 << 16, dx = ( ( x2 - x1 ) << 16 ) / t, dy = ( ( y2 - y1 ) << 16 ) / t, x, y;
+
+    int xm = ( 1 << s );
+    int ym = ( 1 << s );
+    s = ( 15 - s );
+
+    screen->lock();
+    while( t-- )
+    {
+        x = ( xo >> 16 ) + ( jrand() >> s ) - xm;
+        y = ( yo >> 16 ) + ( jrand() >> s ) - ym;
+        if( !( x < cx1 || y < cy1 || x > cx2 || y > cy2 ) )
+        {
+            *(screen->scan_line( y ) + x ) = c;
+        }
+        xo += dx;
+        yo += dy;
+    }
+    screen->unlock();
 }
 
@@ -234 +234 @@
 void ascatter_line(int x1, int y1, int x2, int y2, int c1, int c2, int s)
 {
-        int16_t cx1, cy1, cx2, cy2;
-        screen->get_clip( cx1, cy1, cx2, cy2 );
-
-        int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;
-        long xo = x1 << 16, yo = y1 << 16, dx = ( ( x2 - x1 ) << 16 ) / t, dy = ( ( y2 - y1 ) <<16 ) / t, x, y;
-
-        int xm = ( 1 << s );
-        int ym = ( 1 << s );
-        s = ( 15 - s );
-
-        int w = screen->width();
-        uint8_t *addr;
-
-        while( t-- )
-        {
-                x = ( xo >> 16 ) + ( jrand() >> s ) - xm;
-                y = ( yo >> 16 ) + ( jrand() >> s ) - ym;
-                if( !( x <= cx1 || y <= cy1 || x >= cx2 || y >= cy2 ) )
-                {
-                        addr = screen->scan_line( y ) + x;
-                        *addr = c1;
-                        *(addr + w) = c2;
-                        *(addr - w) = c2;
-                        *(addr - 1) = c2;
-                        *(addr + 1) = c2;
-                }
-                xo += dx;
-                yo += dy;
-        }
-}
+    int16_t cx1, cy1, cx2, cy2;
+    screen->get_clip( cx1, cy1, cx2, cy2 );
+
+    int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;
+    long xo = x1 << 16, yo = y1 << 16, dx = ( ( x2 - x1 ) << 16 ) / t, dy = ( ( y2 - y1 ) <<16 ) / t, x, y;
+
+    int xm = ( 1 << s );
+    int ym = ( 1 << s );
+    s = ( 15 - s );
+
+    screen->lock();
+
+    int w = screen->width();
+    uint8_t *addr;
+
+    while( t-- )
+    {
+        x = ( xo >> 16 ) + ( jrand() >> s ) - xm;
+        y = ( yo >> 16 ) + ( jrand() >> s ) - ym;
+        if( !( x <= cx1 || y <= cy1 || x >= cx2 || y >= cy2 ) )
+        {
+            addr = screen->scan_line( y ) + x;
+            *addr = c1;
+            *(addr + w) = c2;
+            *(addr - w) = c2;
+            *(addr - 1) = c2;
+            *(addr + 1) = c2;
+        }
+        xo += dx;
+        yo += dy;
+    }
+
+    screen->unlock();
+}
+