Fixed the copy & paste.

src/dialogs/quick.c

@@ -59,10 +59,10 @@ static void do_quick (int action)
   Image *dst;
   Mask *mask_backup;
 
-  if (!is_interactive () || !sprite)
+  if (!is_interactive() || !sprite)
     return;
 
-  dst = GetImage2 (sprite, &x, &y, NULL);
+  dst = GetImage2(sprite, &x, &y, NULL);
   if (!dst)
     return;
 
@@ -70,7 +70,7 @@ static void do_quick (int action)
   dst_layer = sprite->layer;
 
   /* create a new layer from the mask */
-  handle_layer = NewLayerFromMask ();
+  handle_layer = NewLayerFromMask(sprite, sprite);
   if (!handle_layer)
     return;
 
@@ -84,36 +84,36 @@ static void do_quick (int action)
 
   /* save the current mask region */
   if (action != ACTION_COPY) {
-    dirty_rectfill (dirty,
+    dirty_rectfill(dirty,
 		   sprite->mask->x-x,
 		   sprite->mask->y-y,
 		   sprite->mask->x-x + sprite->mask->w-1,
 		   sprite->mask->y-y + sprite->mask->h-1);
 
-    dirty_get (dirty);
+    dirty_get(dirty);
   }
 
   /* clear the mask region */
   if (action == ACTION_MOVE) {
-    int enabled = undo_is_enabled (sprite->undo);
+    int enabled = undo_is_enabled(sprite->undo);
-    undo_disable (sprite->undo);
+    undo_disable(sprite->undo);
-    ClearMask ();
+    ClearMask();
     if (enabled)
-      undo_enable (sprite->undo);
+      undo_enable(sprite->undo);
   }
 
   /* copy the mask */
-  mask_backup = mask_new_copy (sprite->mask);
+  mask_backup = mask_new_copy(sprite->mask);
 
   /* deselect the mask */
-  mask_none (sprite->mask);
+  mask_none(sprite->mask);
 
   /* insert the new layer in the top of the current one */
-  layer_add_layer (sprite->set, handle_layer);
+  layer_add_layer(sprite->set, handle_layer);
-  layer_move_layer (sprite->set, handle_layer, dst_layer);
+  layer_move_layer(sprite->set, handle_layer, dst_layer);
 
   /* select the layer */
-  sprite_set_layer (sprite, handle_layer);
+  sprite_set_layer(sprite, handle_layer);
 
   /* regenerate the boundaries (the mask was deselected) and redraw
      the sprite */
@@ -121,79 +121,79 @@ static void do_quick (int action)
   update_screen_for_sprite(sprite);
 
   /* move the new layer to a new position */
-  ret = interactive_move_layer (MODE_CLICKANDCLICK, FALSE, my_callback);
+  ret = interactive_move_layer(MODE_CLICKANDCLICK, FALSE, my_callback);
 
   /* all ok, merge the layer down */
   if (ret) {
     int u, v;
-    Image *src = GetImage2 (sprite, &u, &v, NULL);
+    Image *src = GetImage2(sprite, &u, &v, NULL);
-    Dirty *dirty_copy = dirty_new_copy (dirty);
+    Dirty *dirty_copy = dirty_new_copy(dirty);
 
     /* restore the "dst" image */
-    dirty_swap (dirty_copy);
+    dirty_swap(dirty_copy);
 
     /* save the mask area in the new position too */
-    dirty_rectfill (dirty, u-x, v-y,
+    dirty_rectfill(dirty, u-x, v-y,
 		   u-x + src->w-1,
 		   v-y + src->h-1);
-    dirty_get (dirty);
+    dirty_get(dirty);
 
     /* put the first cleared part */
-    dirty_put (dirty_copy);
+    dirty_put(dirty_copy);
-    dirty_free (dirty_copy);
+    dirty_free(dirty_copy);
 
     switch (action) {
 
       case ACTION_MOVE:
       case ACTION_COPY:
 	/* merge the source image in the destination */
-	image_merge (dst, src, u-x, v-y, 255, handle_layer->blend_mode);
+	image_merge(dst, src, u-x, v-y, 255, handle_layer->blend_mode);
 	break;
 
       case ACTION_SWAP:
 	/* swap areas */
-	/* sprite_set_mask (sprite, mask_backup); */
+	/* sprite_set_mask(sprite, mask_backup); */
-	/* image_swap (dst, src, u-x, v-y); */
+	/* image_swap(dst, src, u-x, v-y); */
 	break;
     }
 
     /* restore the mask */
-    sprite_set_mask (sprite, mask_backup);
+    sprite_set_mask(sprite, mask_backup);
 
     /* insert the undo operation */
     if (undo_is_enabled (sprite->undo)) {
-      undo_open (sprite->undo);
+      undo_open(sprite->undo);
-      undo_dirty (sprite->undo, dirty);
+      undo_dirty(sprite->undo, dirty);
-      undo_int (sprite->undo, (GfxObj *)sprite->mask, &sprite->mask->x);
+      undo_int(sprite->undo, (GfxObj *)sprite->mask, &sprite->mask->x);
-      undo_int (sprite->undo, (GfxObj *)sprite->mask, &sprite->mask->y);
+      undo_int(sprite->undo, (GfxObj *)sprite->mask, &sprite->mask->y);
-      undo_close (sprite->undo);
+      undo_close(sprite->undo);
     }
 
     /* move the mask to the new position */
-    mask_move (sprite->mask, u-(sprite->mask->x-x), v-(sprite->mask->y-y));
+    mask_move(sprite->mask, u-(sprite->mask->x-x), v-(sprite->mask->y-y));
-    sprite_generate_mask_boundaries (sprite);
+    sprite_generate_mask_boundaries(sprite);
   }
   /* user cancels the operation */
   else {
     /* restore the "dst" image */
-    dirty_put (dirty);
+    dirty_put(dirty);
 
     /* restore the mask */
-    sprite_set_mask (sprite, mask_backup);
+    sprite_set_mask(sprite, mask_backup);
-    sprite_generate_mask_boundaries (sprite);
+    sprite_generate_mask_boundaries(sprite);
   }
 
   /* free the mask copy */
-  mask_free (mask_backup);
+  mask_free(mask_backup);
 
   /* free the dirty */
-  dirty_free (dirty);
+  dirty_free(dirty);
 
   /* select the destination layer */
-  sprite_set_layer (sprite, dst_layer);
+  sprite_set_layer(sprite, dst_layer);
 
   /* remove the temporary created layer */
-  layer_remove_layer ((Layer *)handle_layer->parent, handle_layer);
+  layer_remove_layer((Layer *)handle_layer->parent, handle_layer);
 
   /* refresh the sprite */
   update_screen_for_sprite(sprite);

src/raster/sprite.c

@@ -126,28 +126,28 @@ Sprite *sprite_new_copy(const Sprite *sprite)
 
   /* copy layers */
   if (sprite_copy->set) {
-    layer_free (sprite_copy->set);
+    layer_free(sprite_copy->set);
     sprite_copy->set = NULL;
   }
 
   if (sprite->set) {
-    sprite_copy->set = layer_new_copy (sprite->set);
+    sprite_copy->set = layer_new_copy(sprite->set);
     if (!sprite_copy->set) {
-      sprite_free (sprite_copy);
+      sprite_free(sprite_copy);
       return NULL;
     }
 
     /* setup the layer set */
-    layer_set_parent (sprite_copy->set, (GfxObj *)sprite_copy);
+    layer_set_parent(sprite_copy->set, (GfxObj *)sprite_copy);
   }
 
   /* selected layer */
   if (sprite->layer) { 
-    selected_layer = sprite_layer2index (sprite, sprite->layer);
+    selected_layer = sprite_layer2index(sprite, sprite->layer);
-    sprite_copy->layer = sprite_index2layer (sprite_copy, selected_layer);
+    sprite_copy->layer = sprite_index2layer(sprite_copy, selected_layer);
   }
 
-  sprite_generate_mask_boundaries (sprite_copy);
+  sprite_generate_mask_boundaries(sprite_copy);
 
   return sprite_copy;
 }

src/script/export.h

@@ -225,7 +225,7 @@ Image *GetImage2(Sprite *sprite, int *x, int *y, int *opacity); /* CODE */
 void LoadPalette(const char *filename);
 
 void ClearMask(void);
-Layer *NewLayerFromMask(void);
+Layer *NewLayerFromMask(Sprite *src_sprite, Sprite *dst_sprite);
 
 /* util/msk_file.c */
 

src/script/genbinds.c

@@ -1055,14 +1055,6 @@ static int bind_ClearMask(lua_State *L)
   return 0;
 }
 
-static int bind_NewLayerFromMask(lua_State *L)
-{
-  Layer *return_value;
-  return_value = NewLayerFromMask();
-  push_userdata(L, Type_Layer, return_value);
-  return 1;
-}
-
 static int bind_load_msk_file(lua_State *L)
 {
   Mask *return_value;
@@ -3256,7 +3248,6 @@ const luaL_reg bindings_routines[] = {
   { "GetImage2", bind_GetImage2 },
   { "LoadPalette", bind_LoadPalette },
   { "ClearMask", bind_ClearMask },
-  { "NewLayerFromMask", bind_NewLayerFromMask },
   { "load_msk_file", bind_load_msk_file },
   { "save_msk_file", bind_save_msk_file },
   { "sprite_quantize", bind_sprite_quantize },

src/util/clipbrd.c

@@ -117,7 +117,7 @@ bool has_clipboard_image(int *w, int *h)
   }
 }
 
-void copy_image_to_clipboard(struct Image *image)
+void copy_image_to_clipboard(Image *image)
 {
   Sprite *sprite;
   Image *dest;
@@ -138,7 +138,7 @@ void cut_to_clipboard(void)
   if (!current_sprite)
     return;
 
-  if (!low_copy ())
+  if (!low_copy())
     console_printf ("Can't copying an image portion from the current layer\n");
   else {
     ClearMask ();
@@ -164,7 +164,9 @@ void paste_from_clipboard(void)
   int xout[4], yout[4];
   bool paste;
 
-  if (!current_sprite || current_sprite == clipboard || !clipboard->layer ||
+  if (!current_sprite ||
+      current_sprite == clipboard ||
+      !clipboard->layer ||
       !is_interactive())
     return;
 
@@ -636,13 +638,18 @@ static int low_copy(void)
   Sprite *sprite;
   Layer *layer;
 
-  layer = NewLayerFromMask();
-  if (!layer)
-    return FALSE;
-
   sprite = sprite_new(current_sprite->imgtype,
 		      current_sprite->w,
 		      current_sprite->h);
+  if (!sprite)
+    return FALSE;
+
+  layer = NewLayerFromMask(current_sprite, sprite);
+  if (!layer) {
+    sprite_free(sprite);
+    return FALSE;
+  }
+
   layer_add_layer(sprite->set, layer);
   sprite_set_layer(sprite, layer);
   sprite_set_frame(sprite, current_sprite->frame);

src/util/misc.c

@@ -184,20 +184,21 @@ void ClearMask(void)
 
 /* returns a new layer created from the current mask in the current
    sprite, the layer isn't added to the sprite */
-Layer *NewLayerFromMask(void)
+Layer *NewLayerFromMask(Sprite *src_sprite, Sprite *dst_sprite)
 {
-  Sprite *sprite = current_sprite;
   unsigned char *address;
   int x, y, u, v, getx, gety;
-  Image *dst, *src = GetImage2 (sprite, &x, &y, NULL);
+  Image *dst, *src = GetImage2(src_sprite, &x, &y, NULL);
   Layer *layer;
   Cel *cel;
   div_t d;
 
-  if (!sprite || !sprite->mask || !sprite->mask->bitmap || !src)
+  if (!src_sprite || !src_sprite->mask || !src_sprite->mask->bitmap || !src)
     return NULL;
 
-  dst = image_new(sprite->imgtype, sprite->mask->w, sprite->mask->h);
+  dst = image_new(dst_sprite->imgtype,
+		  src_sprite->mask->w,
+		  src_sprite->mask->h);
   if (!dst)
     return NULL;
 
@@ -205,35 +206,35 @@ Layer *NewLayerFromMask(void)
   image_clear(dst, 0);
 
   /* copy the masked zones */
-  for (v=0; v<sprite->mask->h; v++) {
+  for (v=0; v<src_sprite->mask->h; v++) {
-    d = div (0, 8);
+    d = div(0, 8);
-    address = ((unsigned char **)sprite->mask->bitmap->line)[v]+d.quot;
+    address = ((unsigned char **)src_sprite->mask->bitmap->line)[v]+d.quot;
 
-    for (u=0; u<sprite->mask->w; u++) {
+    for (u=0; u<src_sprite->mask->w; u++) {
       if ((*address & (1<<d.rem))) {
-	getx = u+sprite->mask->x-x;
+	getx = u+src_sprite->mask->x-x;
-	gety = v+sprite->mask->y-y;
+	gety = v+src_sprite->mask->y-y;
 
 	if ((getx >= 0) && (getx < src->w) &&
 	    (gety >= 0) && (gety < src->h))
-	  dst->method->putpixel (dst, u, v,
+	  dst->method->putpixel(dst, u, v,
-				 src->method->getpixel (src, getx, gety));
+				src->method->getpixel(src, getx, gety));
       }
 
-      _image_bitmap_next_bit (d, address);
+      _image_bitmap_next_bit(d, address);
     }
   }
 
-  layer = layer_new(sprite);
+  layer = layer_new(dst_sprite);
   if (!layer) {
-    image_free (dst);
+    image_free(dst);
     return NULL;
   }
 
   layer_set_blend_mode(layer, BLEND_MODE_NORMAL);
 
-  cel = cel_new(sprite->frame, stock_add_image(sprite->stock, dst));
+  cel = cel_new(dst_sprite->frame, stock_add_image(dst_sprite->stock, dst));
-  cel_set_position(cel, sprite->mask->x, sprite->mask->y);
+  cel_set_position(cel, dst_sprite->mask->x, dst_sprite->mask->y);
 
   layer_add_cel(layer, cel);
 

src/util/misc.h

@@ -33,7 +33,7 @@ struct Image *GetImage2(struct Sprite *sprite, int *x, int *y, int *opacity);
 void LoadPalette(const char *filename);
 
 void ClearMask(void);
-struct Layer *NewLayerFromMask(void);
+struct Layer *NewLayerFromMask(struct Sprite *src, struct Sprite *dst);
 
 struct Image *GetLayerImage(struct Layer *layer, int *x, int *y, int frame);