Refactored Sprite class: no public variable members, all functions sprite_* go as Sprite function members, pimpl idiom.

src/app.cpp

@@ -340,7 +340,7 @@ void app_refresh_screen(const Sprite* sprite)
   assert(screen != NULL);
 
   if (sprite)
-    set_current_palette(sprite_get_palette(sprite, sprite->frame), false);
+    set_current_palette(sprite->getCurrentPalette(), false);
   else
     set_current_palette(NULL, false);
 
@@ -360,7 +360,7 @@ void app_realloc_sprite_list()
   for (SpriteList::const_iterator
 	 it = list.begin(); it != list.end(); ++it) {
     Sprite* sprite = *it;
-    tabs_set_text_for_tab(tabsbar, get_filename(sprite->filename), sprite);
+    tabs_set_text_for_tab(tabsbar, get_filename(sprite->getFilename()), sprite);
   }
 }
 
@@ -425,7 +425,7 @@ int app_get_current_image_type()
 
   Sprite* sprite = context->get_current_sprite();
   if (sprite != NULL)
-    return sprite->imgtype;
+    return sprite->getImgType();
   else if (screen != NULL && bitmap_color_depth(screen) == 8)
     return IMAGE_INDEXED;
   else
@@ -450,10 +450,10 @@ int app_get_fg_color(Sprite *sprite)
   color_t c = colorbar_get_fg_color(colorbar);
   assert(sprite != NULL);
 
-  if (sprite->layer != NULL)
-    return get_color_for_layer(sprite->layer, c);
+  if (sprite->getCurrentLayer() != NULL)
+    return get_color_for_layer(sprite->getCurrentLayer(), c);
   else
-    return get_color_for_image(sprite->imgtype, c);
+    return get_color_for_image(sprite->getImgType(), c);
 }
 
 int app_get_bg_color(Sprite *sprite)
@@ -461,10 +461,10 @@ int app_get_bg_color(Sprite *sprite)
   color_t c = colorbar_get_bg_color(colorbar);
   assert(sprite != NULL);
 
-  if (sprite->layer != NULL)
-    return get_color_for_layer(sprite->layer, c);
+  if (sprite->getCurrentLayer() != NULL)
+    return get_color_for_layer(sprite->getCurrentLayer(), c);
   else
-    return get_color_for_image(sprite->imgtype, c);
+    return get_color_for_image(sprite->getImgType(), c);
 }
 
 int app_get_color_to_clear_layer(Layer *layer)

src/commands/cmd_background_from_layer.cpp

@@ -49,11 +49,11 @@ bool BackgroundFromLayerCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite != NULL &&
-    sprite->layer != NULL &&
-    sprite_get_background_layer(sprite) == NULL &&
-    sprite->layer->is_image() &&
-    sprite->layer->is_readable() &&
-    sprite->layer->is_writable();
+    sprite->getCurrentLayer() != NULL &&
+    sprite->getBackgroundLayer() == NULL &&
+    sprite->getCurrentLayer()->is_image() &&
+    sprite->getCurrentLayer()->is_readable() &&
+    sprite->getCurrentLayer()->is_writable();
 }
 
 void BackgroundFromLayerCommand::execute(Context* context)
@@ -63,11 +63,11 @@ void BackgroundFromLayerCommand::execute(Context* context)
   // each frame of the layer to be converted as `Background' must be
   // cleared using the selected background color in the color-bar
   int bgcolor = context->getBgColor();
-  bgcolor = fixup_color_for_background(sprite->imgtype, bgcolor);
+  bgcolor = fixup_color_for_background(sprite->getImgType(), bgcolor);
 
   {
     Undoable undoable(sprite, "Background from Layer");
-    undoable.background_from_layer(static_cast<LayerImage*>(sprite->layer), bgcolor);
+    undoable.background_from_layer(static_cast<LayerImage*>(sprite->getCurrentLayer()), bgcolor);
     undoable.commit();
   }
   update_screen_for_sprite(sprite);

src/commands/cmd_canvas_size.cpp

@@ -100,8 +100,8 @@ void CanvasSizeCommand::execute(Context* context)
 
   int x1 = -m_left;
   int y1 = -m_top;
-  int x2 = sprite->w + m_right;
-  int y2 = sprite->h + m_bottom;
+  int x2 = sprite->getWidth() + m_right;
+  int y2 = sprite->getHeight() + m_bottom;
 
   if (x2 <= x1) x2 = x1+1;
   if (y2 <= y1) y2 = y1+1;
@@ -112,7 +112,7 @@ void CanvasSizeCommand::execute(Context* context)
     undoable.crop_sprite(x1, y1, x2-x1, y2-y1, bgcolor);
     undoable.commit();
   }
-  sprite_generate_mask_boundaries(sprite);
+  sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 }
 

src/commands/cmd_cel_properties.cpp

@@ -57,24 +57,22 @@ bool CelPropertiesCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite &&
-    sprite->layer &&
-    sprite->layer->is_image();
+    sprite->getCurrentLayer() &&
+    sprite->getCurrentLayer()->is_image();
 }
 
 void CelPropertiesCommand::execute(Context* context)
 {
   JWidget label_frame, label_pos, label_size;
   JWidget slider_opacity, button_ok;
-  Layer* layer;
-  Cel* cel;
   char buf[1024];
   int memsize;
 
   const CurrentSpriteReader sprite(context);
-  layer = sprite->layer;
+  const Layer* layer = sprite->getCurrentLayer();
 
-  /* get current cel (can be NULL) */
-  cel = static_cast<LayerImage*>(layer)->get_cel(sprite->frame);
+  // Get current cel (can be NULL)
+  const Cel* cel = static_cast<const LayerImage*>(layer)->get_cel(sprite->getCurrentFrame());
 
   FramePtr window(load_widget("celprop.jid", "cel_properties"));
   get_widgets(window,
@@ -93,7 +91,7 @@ void CelPropertiesCommand::execute(Context* context)
     button_ok->setEnabled(false);
   }
 
-  usprintf(buf, "%d/%d", sprite->frame+1, sprite->frames);
+  usprintf(buf, "%d/%d", sprite->getCurrentFrame()+1, sprite->getTotalFrames());
   label_frame->setText(buf);
 
   if (cel != NULL) {
@@ -103,13 +101,13 @@ void CelPropertiesCommand::execute(Context* context)
 
     /* dimension (and memory size) */
     memsize =
-      image_line_size(sprite->stock->image[cel->image],
-		      sprite->stock->image[cel->image]->w)*
-      sprite->stock->image[cel->image]->h;
+      image_line_size(sprite->getStock()->image[cel->image],
+		      sprite->getStock()->image[cel->image]->w)*
+      sprite->getStock()->image[cel->image]->h;
 
     usprintf(buf, "%dx%d (",
-	     sprite->stock->image[cel->image]->w,
-	     sprite->stock->image[cel->image]->h);
+	     sprite->getStock()->image[cel->image]->w,
+	     sprite->getStock()->image[cel->image]->h);
     get_pretty_memsize(memsize,
 		       buf+ustrsize(buf),
 		       sizeof(buf)-ustrsize(buf));
@@ -135,18 +133,22 @@ void CelPropertiesCommand::execute(Context* context)
   window->open_window_fg();
 
   if (window->get_killer() == button_ok) {
+    SpriteWriter sprite_writer(sprite);
+    Layer* layer_writer = sprite_writer->getCurrentLayer();
+    Cel* cel_writer = static_cast<LayerImage*>(layer_writer)->get_cel(sprite->getCurrentFrame());
+
     int new_opacity = jslider_get_value(slider_opacity);
 
     /* the opacity was changed? */
-    if (cel != NULL &&
-	cel->opacity != new_opacity) {
-      if (undo_is_enabled(sprite->undo)) {
-	undo_set_label(sprite->undo, "Cel Opacity Change");
-	undo_int(sprite->undo, (GfxObj *)cel, &cel->opacity);
+    if (cel_writer != NULL &&
+	cel_writer->opacity != new_opacity) {
+      if (undo_is_enabled(sprite_writer->getUndo())) {
+	undo_set_label(sprite_writer->getUndo(), "Cel Opacity Change");
+	undo_int(sprite_writer->getUndo(), (GfxObj *)cel_writer, &cel_writer->opacity);
       }
 
       /* change cel opacity */
-      cel_set_opacity(cel, new_opacity);
+      cel_set_opacity(cel_writer, new_opacity);
 
       update_screen_for_sprite(sprite);
     }

src/commands/cmd_change_image_type.cpp

@@ -74,7 +74,7 @@ bool ChangeImageTypeCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
 
   if (sprite != NULL &&
-      sprite->imgtype == IMAGE_INDEXED &&
+      sprite->getImgType() == IMAGE_INDEXED &&
       m_imgtype == IMAGE_INDEXED &&
       m_dithering == DITHERING_ORDERED)
     return false;
@@ -88,14 +88,14 @@ bool ChangeImageTypeCommand::checked(Context* context)
   const CurrentSpriteReader sprite(context);
 
   if (sprite != NULL &&
-      sprite->imgtype == IMAGE_INDEXED &&
+      sprite->getImgType() == IMAGE_INDEXED &&
       m_imgtype == IMAGE_INDEXED &&
       m_dithering == DITHERING_ORDERED)
     return false;
 
   return
     sprite != NULL &&
-    sprite->imgtype == m_imgtype;
+    sprite->getImgType() == m_imgtype;
 }
 
 void ChangeImageTypeCommand::execute(Context* context)

src/commands/cmd_clear.cpp

@@ -55,25 +55,25 @@ bool ClearCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite != NULL &&
-    sprite->layer != NULL &&
-    sprite->layer->is_image() &&
-    sprite->layer->is_readable() &&
-    sprite->layer->is_writable();
+    sprite->getCurrentLayer() != NULL &&
+    sprite->getCurrentLayer()->is_image() &&
+    sprite->getCurrentLayer()->is_readable() &&
+    sprite->getCurrentLayer()->is_writable();
 }
 
 void ClearCommand::execute(Context* context)
 {
   CurrentSpriteWriter sprite(context);
-  bool empty_mask = sprite->mask->is_empty();
+  bool empty_mask = sprite->getMask()->is_empty();
   {
     Undoable undoable(sprite, "Clear");
-    undoable.clear_mask(app_get_color_to_clear_layer(sprite->layer));
+    undoable.clear_mask(app_get_color_to_clear_layer(sprite->getCurrentLayer()));
     if (!empty_mask)
       undoable.deselect_mask();
     undoable.commit();
   }
   if (!empty_mask)
-    sprite_generate_mask_boundaries(sprite);
+    sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 }
 

src/commands/cmd_close_file.cpp

@@ -122,11 +122,11 @@ try_again:;
     CurrentSpriteReader sprite(context);
 
     // see if the sprite has changes
-    while (sprite_is_modified(sprite)) {
+    while (sprite->isModified()) {
       // ask what want to do the user with the changes in the sprite
       int ret = jalert("%s<<%s<<%s||%s||%s||%s",
 		       _("Warning"), _("Saving changes in:"),
-		       get_filename(sprite->filename),
+		       get_filename(sprite->getFilename()),
 		       _("&Save"), _("&Discard"), _("&Cancel"));
 
       if (ret == 1) {
@@ -159,7 +159,7 @@ try_again:;
     CurrentSpriteWriter sprite(context);
     app_get_statusbar()
       ->setStatusText(0, "Sprite '%s' closed.",
-		      get_filename(sprite->filename));
+		      get_filename(sprite->getFilename()));
     sprite.destroy();
   }
   return true;

src/commands/cmd_configure_tools.cpp

@@ -453,9 +453,9 @@ static bool set_grid_button_select_hook(JWidget widget, void *data)
     // TODO use the same context as in ConfigureTools::execute
     const CurrentSpriteReader sprite(UIContext::instance());
 
-    if (sprite && sprite->mask && sprite->mask->bitmap) {
-      Rect bounds(sprite->mask->x, sprite->mask->y,
-		  sprite->mask->w, sprite->mask->h);
+    if (sprite && sprite->getMask() && sprite->getMask()->bitmap) {
+      Rect bounds(sprite->getMask()->x, sprite->getMask()->y,
+		  sprite->getMask()->w, sprite->getMask()->h);
 
       UIContext::instance()->getSettings()->setGridBounds(bounds);
 

src/commands/cmd_copy.cpp

@@ -51,12 +51,12 @@ bool CopyCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
 
   if ((sprite) &&
-      (sprite->layer) &&
-      (sprite->layer->is_readable()) &&
-      (sprite->layer->is_writable()) &&
-      (sprite->mask) &&
-      (sprite->mask->bitmap))
-    return GetImage(sprite) ? true: false;
+      (sprite->getCurrentLayer()) &&
+      (sprite->getCurrentLayer()->is_readable()) &&
+      (sprite->getCurrentLayer()->is_writable()) &&
+      (sprite->getMask()) &&
+      (sprite->getMask()->bitmap))
+    return sprite->getCurrentImage() ? true: false;
   else
     return false;
 }

src/commands/cmd_crop.cpp

@@ -57,8 +57,8 @@ bool CropSpriteCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite != NULL &&
-    sprite->mask != NULL &&
-    sprite->mask->bitmap != NULL;
+    sprite->getMask() != NULL &&
+    sprite->getMask()->bitmap != NULL;
 }
 
 void CropSpriteCommand::execute(Context* context)
@@ -66,16 +66,16 @@ void CropSpriteCommand::execute(Context* context)
   CurrentSpriteWriter sprite(context);
   {
     Undoable undoable(sprite, "Sprite Crop");
-    int bgcolor = get_color_for_image(sprite->imgtype,
+    int bgcolor = get_color_for_image(sprite->getImgType(),
 				      colorbar_get_bg_color(app_get_colorbar()));
-    undoable.crop_sprite(sprite->mask->x,
-			 sprite->mask->y,
-			 sprite->mask->w,
-			 sprite->mask->h,
+    undoable.crop_sprite(sprite->getMask()->x,
+			 sprite->getMask()->y,
+			 sprite->getMask()->w,
+			 sprite->getMask()->h,
 			 bgcolor);
     undoable.commit();
   }
-  sprite_generate_mask_boundaries(sprite);
+  sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 }
 
@@ -114,7 +114,7 @@ void AutocropSpriteCommand::execute(Context* context)
     undoable.autocrop_sprite(colorbar_get_bg_color(app_get_colorbar()));
     undoable.commit();
   }
-  sprite_generate_mask_boundaries(sprite);
+  sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 }
 

src/commands/cmd_cut.cpp

@@ -50,12 +50,12 @@ bool CutCommand::enabled(Context* context)
 {
   const CurrentSpriteReader sprite(context);
   if ((sprite) &&
-      (sprite->layer) &&
-      (sprite->layer->is_readable()) &&
-      (sprite->layer->is_writable()) &&
-      (sprite->mask) &&
-      (sprite->mask->bitmap))
-    return GetImage(sprite) ? true: false;
+      (sprite->getCurrentLayer()) &&
+      (sprite->getCurrentLayer()->is_readable()) &&
+      (sprite->getCurrentLayer()->is_writable()) &&
+      (sprite->getMask()) &&
+      (sprite->getMask()->bitmap))
+    return sprite->getCurrentImage() ? true: false;
   else
     return false;
 }

src/commands/cmd_deselect_mask.cpp

@@ -49,7 +49,7 @@ DeselectMaskCommand::DeselectMaskCommand()
 bool DeselectMaskCommand::enabled(Context* context)
 {
   const CurrentSpriteReader sprite(context);
-  return sprite && !sprite->mask->is_empty();
+  return sprite && !sprite->getMask()->is_empty();
 }
 
 void DeselectMaskCommand::execute(Context* context)
@@ -60,7 +60,7 @@ void DeselectMaskCommand::execute(Context* context)
     undoable.deselect_mask();
     undoable.commit();
   }
-  sprite_generate_mask_boundaries(sprite);
+  sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 }
 

src/commands/cmd_duplicate_layer.cpp

@@ -55,7 +55,7 @@ DuplicateLayerCommand::DuplicateLayerCommand()
 bool DuplicateLayerCommand::enabled(Context* context)
 {
   const CurrentSpriteReader sprite(context);
-  return sprite && sprite->layer;
+  return sprite && sprite->getCurrentLayer();
 }
 
 void DuplicateLayerCommand::execute(Context* context)
@@ -68,15 +68,15 @@ void DuplicateLayerCommand::execute(Context* context)
 static Layer* duplicate_layer(Sprite* sprite)
 {
   /* open undo */
-  if (undo_is_enabled(sprite->undo)) {
-    undo_set_label(sprite->undo, "Layer Duplication");
-    undo_open(sprite->undo);
+  if (undo_is_enabled(sprite->getUndo())) {
+    undo_set_label(sprite->getUndo(), "Layer Duplication");
+    undo_open(sprite->getUndo());
   }
 
-  Layer* layer_copy = sprite->layer->duplicate_for(sprite);
+  Layer* layer_copy = sprite->getCurrentLayer()->duplicate_for(sprite);
   if (!layer_copy) {
-    if (undo_is_enabled(sprite->undo))
-      undo_close(sprite->undo);
+    if (undo_is_enabled(sprite->getUndo()))
+      undo_close(sprite->getUndo());
 
     Console console;
     console.printf("Not enough memory");
@@ -88,19 +88,19 @@ static Layer* duplicate_layer(Sprite* sprite)
   layer_copy->set_name(layer_copy->get_name() + " " + _("Copy"));
 
   /* add the new layer in the sprite */
-  if (undo_is_enabled(sprite->undo))
-    undo_add_layer(sprite->undo, sprite->layer->get_parent(), layer_copy);
+  if (undo_is_enabled(sprite->getUndo()))
+    undo_add_layer(sprite->getUndo(), sprite->getCurrentLayer()->get_parent(), layer_copy);
 
-  sprite->layer->get_parent()->add_layer(layer_copy);
+  sprite->getCurrentLayer()->get_parent()->add_layer(layer_copy);
 
-  if (undo_is_enabled(sprite->undo)) {
-    undo_move_layer(sprite->undo, layer_copy);
-    undo_set_layer(sprite->undo, sprite);
-    undo_close(sprite->undo);
+  if (undo_is_enabled(sprite->getUndo())) {
+    undo_move_layer(sprite->getUndo(), layer_copy);
+    undo_set_layer(sprite->getUndo(), sprite);
+    undo_close(sprite->getUndo());
   }
 
-  sprite->layer->get_parent()->move_layer(layer_copy, sprite->layer);
-  sprite_set_layer(sprite, layer_copy);
+  sprite->getCurrentLayer()->get_parent()->move_layer(layer_copy, sprite->getCurrentLayer());
+  sprite->setCurrentLayer(layer_copy);
 
   return layer_copy;
 }

src/commands/cmd_duplicate_sprite.cpp

@@ -71,9 +71,9 @@ void DuplicateSpriteCommand::execute(Context* context)
   dst_name = jwidget_find_name(window, "dst_name");
   flatten = jwidget_find_name(window, "flatten");
 
-  src_name->setText(get_filename(sprite->filename));
+  src_name->setText(get_filename(sprite->getFilename()));
 
-  sprintf(buf, "%s %s", sprite->filename, _("Copy"));
+  sprintf(buf, "%s %s", sprite->getFilename(), _("Copy"));
   dst_name->setText(buf);
 
   if (get_config_bool("DuplicateSprite", "Flatten", false))
@@ -89,12 +89,12 @@ void DuplicateSpriteCommand::execute(Context* context)
     // make a copy of the current sprite
     Sprite *sprite_copy;
     if (jwidget_is_selected(flatten))
-      sprite_copy = sprite_new_flatten_copy(sprite);
+      sprite_copy = Sprite::createFlattenCopy(*sprite);
     else
-      sprite_copy = sprite_new_copy(sprite);
+      sprite_copy = new Sprite(*sprite);
 
     if (sprite_copy != NULL) {
-      sprite_set_filename(sprite_copy, dst_name->getText());
+      sprite_copy->setFilename(dst_name->getText());
 
       context->add_sprite(sprite_copy);
       set_sprite_in_more_reliable_editor(sprite_copy);

src/commands/cmd_exit.cpp

@@ -51,7 +51,7 @@ void ExitCommand::execute(Context* context)
 
   while (sprite) {
     // check if this sprite is modified
-    if (sprite_is_modified(sprite)) {
+    if (sprite->isModified()) {
       if (jalert(_("Warning<<There are sprites with changes.<<Do you want quit anyway?||&Yes||&No")) != 1) {
 	return;
       }

src/commands/cmd_eyedropper.cpp

@@ -81,8 +81,8 @@ void EyedropperCommand::execute(Context* context)
   editor->screen_to_editor(jmouse_x(0), jmouse_y(0), &x, &y);
 
   // get the color from the image
-  color_t color = color_from_image(sprite->imgtype,
-				   sprite_getpixel(sprite, x, y));
+  color_t color = color_from_image(sprite->getImgType(),
+				   sprite->getPixel(x, y));
 
   if (color_type(color) != COLOR_TYPE_MASK) {
     // TODO replace the color in the "context", not directly from the color-bar

src/commands/cmd_flatten_layers.cpp

@@ -56,7 +56,7 @@ bool FlattenLayersCommand::enabled(Context* context)
 void FlattenLayersCommand::execute(Context* context)
 {
   CurrentSpriteWriter sprite(context);
-  int bgcolor = get_color_for_image(sprite->imgtype,
+  int bgcolor = get_color_for_image(sprite->getImgType(),
 				    colorbar_get_bg_color(app_get_colorbar()));
   {
     Undoable undoable(sprite, "Flatten Layers");

src/commands/cmd_flip.cpp

@@ -98,11 +98,11 @@ void FlipCommand::execute(Context* context)
       int x1, y1, x2, y2;
       int x, y;
 
-      image = GetImage2(sprite, &x, &y, NULL);
+      image = sprite->getCurrentImage(&x, &y);
       if (!image)
 	return;
       // mask is empty?
-      if (sprite->mask->is_empty()) {
+      if (sprite->getMask()->is_empty()) {
 	// so we flip the entire image
 	x1 = 0;
 	y1 = 0;
@@ -111,10 +111,10 @@ void FlipCommand::execute(Context* context)
       }
       else {
 	// apply the cel offset
-	x1 = sprite->mask->x - x;
-	y1 = sprite->mask->y - y;
-	x2 = sprite->mask->x + sprite->mask->w - 1 - x;
-	y2 = sprite->mask->y + sprite->mask->h - 1 - y;
+	x1 = sprite->getMask()->x - x;
+	y1 = sprite->getMask()->y - y;
+	x2 = sprite->getMask()->x + sprite->getMask()->w - 1 - x;
+	y2 = sprite->getMask()->y + sprite->getMask()->h - 1 - y;
 
 	// clip
 	x1 = MID(0, x1, image->w-1);
@@ -129,16 +129,16 @@ void FlipCommand::execute(Context* context)
     else {
       // get all sprite cels
       CelList cels;
-      sprite_get_cels(sprite, cels);
+      sprite->getCels(cels);
 
       // for each cel...
       for (CelIterator it = cels.begin(); it != cels.end(); ++it) {
 	Cel* cel = *it;
-	Image* image = stock_get_image(sprite->stock, cel->image);
+	Image* image = stock_get_image(sprite->getStock(), cel->image);
 
 	undoable.set_cel_position(cel,
-				  m_flip_horizontal ? sprite->w - image->w - cel->x: cel->x,
-				  m_flip_vertical ? sprite->h - image->h - cel->y: cel->y);
+				  m_flip_horizontal ? sprite->getWidth() - image->w - cel->x: cel->x,
+				  m_flip_vertical ? sprite->getHeight() - image->h - cel->y: cel->y);
 
 	undoable.flip_image(image, 0, 0, image->w-1, image->h-1,
 			    m_flip_horizontal, m_flip_vertical);

src/commands/cmd_frame_properties.cpp

@@ -60,7 +60,7 @@ bool FramePropertiesCommand::enabled(Context* context)
 void FramePropertiesCommand::execute(Context* context)
 {
   const CurrentSpriteReader sprite(context);
-  dialogs_frame_length(sprite, sprite->frame);
+  dialogs_frame_length(sprite, sprite->getCurrentFrame());
 }
 
 /* if sprite_frame < 0, set the frame length of all frames */
@@ -81,7 +81,7 @@ void dialogs_frame_length(const SpriteReader& sprite, int sprite_frame)
     sprintf(buf, "%d", sprite_frame+1);
   frame->setText(buf);
 
-  frlen->setTextf("%d", sprite_get_frlen(sprite, sprite->frame));
+  frlen->setTextf("%d", sprite->getFrameDuration(sprite->getCurrentFrame()));
 
   window->open_window_fg();
   if (window->get_killer() == ok) {

src/commands/cmd_goto_frame.cpp

@@ -55,7 +55,7 @@ bool GotoFirstFrameCommand::enabled(Context* context)
 void GotoFirstFrameCommand::execute(Context* context)
 {
   CurrentSpriteWriter sprite(context);
-  sprite->frame = 0;
+  sprite->setCurrentFrame(0);
 
   update_screen_for_sprite(sprite);
   current_editor->editor_update_statusbar_for_standby();
@@ -93,11 +93,12 @@ bool GotoPreviousFrameCommand::enabled(Context* context)
 void GotoPreviousFrameCommand::execute(Context* context)
 {
   CurrentSpriteWriter sprite(context);
+  int frame = sprite->getCurrentFrame();
 
-  if (sprite->frame > 0)
-    sprite->frame--;
+  if (frame > 0)
+    sprite->setCurrentFrame(frame-1);
   else
-    sprite->frame = sprite->frames-1;
+    sprite->setCurrentFrame(sprite->getTotalFrames()-1);
 
   update_screen_for_sprite(sprite);
   current_editor->editor_update_statusbar_for_standby();
@@ -135,11 +136,12 @@ bool GotoNextFrameCommand::enabled(Context* context)
 void GotoNextFrameCommand::execute(Context* context)
 {
   CurrentSpriteWriter sprite(context);
+  int frame = sprite->getCurrentFrame();
 
-  if (sprite->frame < sprite->frames-1)
-    sprite->frame++;
+  if (frame < sprite->getTotalFrames()-1)
+    sprite->setCurrentFrame(frame+1);
   else
-    sprite->frame = 0;
+    sprite->setCurrentFrame(0);
 
   update_screen_for_sprite(sprite);
   current_editor->editor_update_statusbar_for_standby();
@@ -177,7 +179,7 @@ bool GotoLastFrameCommand::enabled(Context* context)
 void GotoLastFrameCommand::execute(Context* context)
 {
   CurrentSpriteWriter sprite(context);
-  sprite->frame = sprite->frames-1;
+  sprite->setCurrentFrame(sprite->getTotalFrames()-1);
 
   update_screen_for_sprite(sprite);
   current_editor->editor_update_statusbar_for_standby();

src/commands/cmd_goto_layer.cpp

@@ -59,21 +59,21 @@ bool GotoPreviousLayerCommand::enabled(Context* context)
 void GotoPreviousLayerCommand::execute(Context* context)
 {
   CurrentSpriteWriter sprite(context);
-  int i = sprite_layer2index(sprite, sprite->layer);
+  int i = sprite->layerToIndex(sprite->getCurrentLayer());
   
   if (i > 0)
     i--;
   else
-    i = sprite_count_layers(sprite)-1;
+    i = sprite->countLayers()-1;
 
-  sprite->layer = sprite_index2layer(sprite, i);
+  sprite->setCurrentLayer(sprite->indexToLayer(i));
 
   update_screen_for_sprite(sprite);
   current_editor->editor_update_statusbar_for_standby();
 
   app_get_statusbar()
     ->showTip(1000, _("Layer `%s' selected"),
-	      sprite->layer->get_name().c_str());
+	      sprite->getCurrentLayer()->get_name().c_str());
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -107,21 +107,21 @@ bool GotoNextLayerCommand::enabled(Context* context)
 void GotoNextLayerCommand::execute(Context* context)
 {
   CurrentSpriteWriter sprite(context);
-  int i = sprite_layer2index(sprite, sprite->layer);
+  int i = sprite->layerToIndex(sprite->getCurrentLayer());
 
-  if (i < sprite_count_layers(sprite)-1)
+  if (i < sprite->countLayers()-1)
     i++;
   else
     i = 0;
 
-  sprite->layer = sprite_index2layer(sprite, i);
+  sprite->setCurrentLayer(sprite->indexToLayer(i));
 
   update_screen_for_sprite(sprite);
   current_editor->editor_update_statusbar_for_standby();
 
   app_get_statusbar()
     ->showTip(1000, _("Layer `%s' selected"),
-	      sprite->layer->get_name().c_str());
+	      sprite->getCurrentLayer()->get_name().c_str());
 }
 
 //////////////////////////////////////////////////////////////////////

src/commands/cmd_invert_mask.cpp

@@ -59,7 +59,7 @@ void InvertMaskCommand::execute(Context* context)
   bool has_mask = false;
   {
     const CurrentSpriteReader sprite(context);
-    if (sprite->mask->bitmap)
+    if (sprite->getMask()->bitmap)
       has_mask = true;
   }
 
@@ -75,39 +75,39 @@ void InvertMaskCommand::execute(Context* context)
     CurrentSpriteWriter sprite(context);
 
     /* undo */
-    if (undo_is_enabled(sprite->undo)) {
-      undo_set_label(sprite->undo, "Mask Invert");
-      undo_set_mask(sprite->undo, sprite);
+    if (undo_is_enabled(sprite->getUndo())) {
+      undo_set_label(sprite->getUndo(), "Mask Invert");
+      undo_set_mask(sprite->getUndo(), sprite);
     }
 
     /* create a new mask */
     Mask* mask = mask_new();
 
     /* select all the sprite area */
-    mask_replace(mask, 0, 0, sprite->w, sprite->h);
+    mask_replace(mask, 0, 0, sprite->getWidth(), sprite->getHeight());
 
     /* remove in the new mask the current sprite marked region */
     image_rectfill(mask->bitmap,
-		   sprite->mask->x, sprite->mask->y,
-		   sprite->mask->x + sprite->mask->w-1,
-		   sprite->mask->y + sprite->mask->h-1, 0);
+		   sprite->getMask()->x, sprite->getMask()->y,
+		   sprite->getMask()->x + sprite->getMask()->w-1,
+		   sprite->getMask()->y + sprite->getMask()->h-1, 0);
 
     /* invert the current mask in the sprite */
-    mask_invert(sprite->mask);
-    if (sprite->mask->bitmap) {
+    mask_invert(sprite->getMask());
+    if (sprite->getMask()->bitmap) {
       /* copy the inverted region in the new mask */
-      image_copy(mask->bitmap, sprite->mask->bitmap,
-		 sprite->mask->x, sprite->mask->y);
+      image_copy(mask->bitmap, sprite->getMask()->bitmap,
+		 sprite->getMask()->x, sprite->getMask()->y);
     }
 
     /* we need only need the area inside the sprite */
-    mask_intersect(mask, 0, 0, sprite->w, sprite->h);
+    mask_intersect(mask, 0, 0, sprite->getWidth(), sprite->getHeight());
 
     /* set the new mask */
-    sprite_set_mask(sprite, mask);
+    sprite->setMask(mask);
     mask_free(mask);
 
-    sprite_generate_mask_boundaries(sprite);
+    sprite->generateMaskBoundaries();
     update_screen_for_sprite(sprite);
   }
 }

src/commands/cmd_layer_from_background.cpp

@@ -52,11 +52,11 @@ bool LayerFromBackgroundCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite &&
-    sprite->layer &&
-    sprite->layer->is_image() &&
-    sprite->layer->is_readable() &&
-    sprite->layer->is_writable() &&
-    sprite->layer->is_background();
+    sprite->getCurrentLayer() &&
+    sprite->getCurrentLayer()->is_image() &&
+    sprite->getCurrentLayer()->is_readable() &&
+    sprite->getCurrentLayer()->is_writable() &&
+    sprite->getCurrentLayer()->is_background();
 }
 
 void LayerFromBackgroundCommand::execute(Context* context)

src/commands/cmd_layer_properties.cpp

@@ -54,7 +54,7 @@ bool LayerPropertiesCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite != NULL &&
-    sprite->layer != NULL;
+    sprite->getCurrentLayer() != NULL;
 }
 
 void LayerPropertiesCommand::execute(Context* context)
@@ -62,8 +62,8 @@ void LayerPropertiesCommand::execute(Context* context)
   JWidget box1, box2, box3, label_name, entry_name;
   JWidget button_ok, button_cancel, label_bm, view_bm, list_bm;
   CurrentSpriteWriter sprite(context);
-  Layer* layer = sprite->layer;
-  bool with_blend_modes = (layer->is_image() && sprite->imgtype != IMAGE_INDEXED);
+  Layer* layer = sprite->getCurrentLayer();
+  bool with_blend_modes = (layer->is_image() && sprite->getImgType() != IMAGE_INDEXED);
 
   FramePtr window(new Frame(false, _("Layer Properties")));
   box1 = jbox_new(JI_VERTICAL);

src/commands/cmd_load_mask.cpp

@@ -84,15 +84,15 @@ void LoadMaskCommand::execute(Context* context)
 			static_cast<const char*>(m_filename.c_str()));
 
   // undo
-  if (undo_is_enabled(sprite->undo)) {
-    undo_set_label(sprite->undo, "Mask Load");
-    undo_set_mask(sprite->undo, sprite);
+  if (undo_is_enabled(sprite->getUndo())) {
+    undo_set_label(sprite->getUndo(), "Mask Load");
+    undo_set_mask(sprite->getUndo(), sprite);
   }
 
-  sprite_set_mask(sprite, mask);
+  sprite->setMask(mask);
   mask_free(mask);
 
-  sprite_generate_mask_boundaries(sprite);
+  sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 }
 

src/commands/cmd_mask_all.cpp

@@ -57,15 +57,15 @@ void MaskAllCommand::execute(Context* context)
   CurrentSpriteWriter sprite(context);
 
   /* undo */
-  if (undo_is_enabled(sprite->undo)) {
-    undo_set_label(sprite->undo, "Mask All");
-    undo_set_mask(sprite->undo, sprite);
+  if (undo_is_enabled(sprite->getUndo())) {
+    undo_set_label(sprite->getUndo(), "Mask All");
+    undo_set_mask(sprite->getUndo(), sprite);
   }
 
   /* change the selection */
-  mask_replace(sprite->mask, 0, 0, sprite->w, sprite->h);
+  mask_replace(sprite->getMask(), 0, 0, sprite->getWidth(), sprite->getHeight());
 
-  sprite_generate_mask_boundaries(sprite);
+  sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 }
 

src/commands/cmd_merge_down_layer.cpp

@@ -58,11 +58,11 @@ bool MergeDownLayerCommand::enabled(Context* context)
   if (!sprite)
     return false;
 
-  Layer *src_layer = sprite->layer;
+  const Layer* src_layer = sprite->getCurrentLayer();
   if (!src_layer || !src_layer->is_image())
     return false;
 
-  Layer* dst_layer = sprite->layer->get_prev();
+  const Layer* dst_layer = sprite->getCurrentLayer()->get_prev();
   if (!dst_layer || !dst_layer->is_image())
     return false;
 
@@ -77,27 +77,27 @@ void MergeDownLayerCommand::execute(Context* context)
   Image *src_image, *dst_image;
   int frpos, index;
 
-  src_layer = sprite->layer;
-  dst_layer = sprite->layer->get_prev();
+  src_layer = sprite->getCurrentLayer();
+  dst_layer = sprite->getCurrentLayer()->get_prev();
 
-  if (undo_is_enabled(sprite->undo)) {
-    undo_set_label(sprite->undo, "Merge Down Layer");
-    undo_open(sprite->undo);
+  if (undo_is_enabled(sprite->getUndo())) {
+    undo_set_label(sprite->getUndo(), "Merge Down Layer");
+    undo_open(sprite->getUndo());
   }
 
-  for (frpos=0; frpos<sprite->frames; ++frpos) {
+  for (frpos=0; frpos<sprite->getTotalFrames(); ++frpos) {
     /* get frames */
     src_cel = static_cast<LayerImage*>(src_layer)->get_cel(frpos);
     dst_cel = static_cast<LayerImage*>(dst_layer)->get_cel(frpos);
 
     /* get images */
     if (src_cel != NULL)
-      src_image = stock_get_image(sprite->stock, src_cel->image);
+      src_image = stock_get_image(sprite->getStock(), src_cel->image);
     else
       src_image = NULL;
 
     if (dst_cel != NULL)
-      dst_image = stock_get_image(sprite->stock, dst_cel->image);
+      dst_image = stock_get_image(sprite->getStock(), dst_cel->image);
     else
       dst_image = NULL;
 
@@ -111,17 +111,17 @@ void MergeDownLayerCommand::execute(Context* context)
 	dst_image = image_new_copy(src_image);
 
 	/* adding it in the stock of images */
-	index = stock_add_image(sprite->stock, dst_image);
-	if (undo_is_enabled(sprite->undo))
-	  undo_add_image(sprite->undo, sprite->stock, index);
+	index = stock_add_image(sprite->getStock(), dst_image);
+	if (undo_is_enabled(sprite->getUndo()))
+	  undo_add_image(sprite->getUndo(), sprite->getStock(), index);
 
 	/* creating a copy of the cell */
 	dst_cel = cel_new(frpos, index);
 	cel_set_position(dst_cel, src_cel->x, src_cel->y);
 	cel_set_opacity(dst_cel, src_cel->opacity);
 
-	if (undo_is_enabled(sprite->undo))
-	  undo_add_cel(sprite->undo, dst_layer, dst_cel);
+	if (undo_is_enabled(sprite->getUndo()))
+	  undo_add_cel(sprite->getUndo(), dst_layer, dst_cel);
 
 	static_cast<LayerImage*>(dst_layer)->add_cel(dst_cel);
       }
@@ -134,8 +134,8 @@ void MergeDownLayerCommand::execute(Context* context)
 	if (dst_layer->is_background()) {
 	  x1 = 0;
 	  y1 = 0;
-	  x2 = sprite->w;
-	  y2 = sprite->h;
+	  x2 = sprite->getWidth();
+	  y2 = sprite->getHeight();
 	  bgcolor = app_get_color_to_clear_layer(dst_layer);
 	}
 	/* merge down in a transparent layer */
@@ -159,29 +159,29 @@ void MergeDownLayerCommand::execute(Context* context)
 		    src_cel->opacity,
 		    static_cast<LayerImage*>(src_layer)->get_blend_mode());
 
-	if (undo_is_enabled(sprite->undo)) {
-	  undo_int(sprite->undo, (GfxObj *)dst_cel, &dst_cel->x);
-	  undo_int(sprite->undo, (GfxObj *)dst_cel, &dst_cel->y);
+	if (undo_is_enabled(sprite->getUndo())) {
+	  undo_int(sprite->getUndo(), (GfxObj *)dst_cel, &dst_cel->x);
+	  undo_int(sprite->getUndo(), (GfxObj *)dst_cel, &dst_cel->y);
 	}
 
 	cel_set_position(dst_cel, x1, y1);
 
-	if (undo_is_enabled(sprite->undo))
-	  undo_replace_image(sprite->undo, sprite->stock, dst_cel->image);
-	stock_replace_image(sprite->stock, dst_cel->image, new_image);
+	if (undo_is_enabled(sprite->getUndo()))
+	  undo_replace_image(sprite->getUndo(), sprite->getStock(), dst_cel->image);
+	stock_replace_image(sprite->getStock(), dst_cel->image, new_image);
 
 	image_free(dst_image);
       }
     }
   }
 
-  if (undo_is_enabled(sprite->undo)) {
-    undo_set_layer(sprite->undo, sprite);
-    undo_remove_layer(sprite->undo, src_layer);
-    undo_close(sprite->undo);
+  if (undo_is_enabled(sprite->getUndo())) {
+    undo_set_layer(sprite->getUndo(), sprite);
+    undo_remove_layer(sprite->getUndo(), src_layer);
+    undo_close(sprite->getUndo());
   }
 
-  sprite_set_layer(sprite, dst_layer);
+  sprite->setCurrentLayer(dst_layer);
   src_layer->get_parent()->remove_layer(src_layer);
 
   delete src_layer;

src/commands/cmd_new_file.cpp

@@ -154,15 +154,15 @@ void NewFileCommand::execute(Context* context)
       }
       else {
 	usprintf(buf, "Sprite-%04d", ++_sprite_counter);
-	sprite_set_filename(sprite, buf);
+	sprite->setFilename(buf);
 
 	/* if the background color isn't transparent, we have to
 	   convert the `Layer 1' in a `Background' */
 	if (color_type(color) != COLOR_TYPE_MASK) {
-	  assert(sprite->layer && sprite->layer->is_image());
+	  assert(sprite->getCurrentLayer() && sprite->getCurrentLayer()->is_image());
 
-	  static_cast<LayerImage*>(sprite->layer)->configure_as_background();
-	  image_clear(GetImage(sprite), get_color_for_image(imgtype, color));
+	  static_cast<LayerImage*>(sprite->getCurrentLayer())->configure_as_background();
+	  image_clear(sprite->getCurrentImage(), get_color_for_image(imgtype, color));
 	}
 
 	/* show the sprite to the user */
@@ -187,7 +187,7 @@ static Sprite *new_sprite(Context* context, int imgtype, int w, int h, int ncolo
   assert(w >= 1 && w <= 9999);
   assert(h >= 1 && h <= 9999);
 
-  return sprite_new_with_layer(imgtype, w, h, ncolors);
+  return Sprite::createWithLayer(imgtype, w, h, ncolors);
 }
 
 //////////////////////////////////////////////////////////////////////

src/commands/cmd_new_frame.cpp

@@ -62,10 +62,10 @@ bool NewFrameCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite != NULL &&
-    sprite->layer != NULL &&
-    sprite->layer->is_readable() &&
-    sprite->layer->is_writable() &&
-    sprite->layer->is_image();
+    sprite->getCurrentLayer() != NULL &&
+    sprite->getCurrentLayer()->is_readable() &&
+    sprite->getCurrentLayer()->is_writable() &&
+    sprite->getCurrentLayer()->is_image();
 }
 
 void NewFrameCommand::execute(Context* context)
@@ -79,8 +79,8 @@ void NewFrameCommand::execute(Context* context)
   update_screen_for_sprite(sprite);
   app_get_statusbar()
     ->showTip(1000, _("New frame %d/%d"),
-	      sprite->frame+1,
-	      sprite->frames);
+	      sprite->getCurrentFrame()+1,
+	      sprite->getTotalFrames());
 }
 
 //////////////////////////////////////////////////////////////////////

src/commands/cmd_new_layer.cpp

@@ -119,7 +119,7 @@ void NewLayerCommand::execute(Context* context)
 static std::string get_unique_layer_name(Sprite* sprite)
 {
   char buf[1024];
-  sprintf(buf, "Layer %d", get_max_layer_num(sprite->get_folder())+1);
+  sprintf(buf, "Layer %d", get_max_layer_num(sprite->getFolder())+1);
   return buf;
 }
 

src/commands/cmd_new_layer_set.cpp

@@ -69,8 +69,8 @@ void NewLayerSetCommand::execute(Context* context)
     Layer* layer = new LayerFolder(sprite);
 
     layer->set_name(name);
-    sprite->get_folder()->add_layer(layer);
-    sprite_set_layer(sprite, layer);
+    sprite->getFolder()->add_layer(layer);
+    sprite->setCurrentLayer(layer);
 
     update_screen_for_sprite(sprite);
   }

src/commands/cmd_palette_editor.cpp

@@ -98,8 +98,8 @@ void PaletteEditorCommand::execute(Context* context)
   int frame, columns;
   Palette *palette = NULL;
   const CurrentSpriteReader sprite(context);
-  int imgtype = sprite ? sprite->imgtype: IMAGE_INDEXED;
-  int frame_bak = sprite ? sprite->frame : 0;
+  int imgtype = sprite ? sprite->getImgType(): IMAGE_INDEXED;
+  int frame_bak = sprite ? sprite->getCurrentFrame() : 0;
   bool all_frames_same_palette = true;
 
   if (imgtype == IMAGE_GRAYSCALE) {
@@ -134,10 +134,10 @@ void PaletteEditorCommand::execute(Context* context)
 
   /* create current_sprite->frames palettes */
   if (sprite) {
-    palettes.resize(sprite->frames);
+    palettes.resize(sprite->getTotalFrames());
 
-    for (frame=0; frame<sprite->frames; ++frame) {
-      Palette* orig = sprite_get_palette(sprite, frame);
+    for (frame=0; frame<sprite->getTotalFrames(); ++frame) {
+      const Palette* orig = sprite->getPalette(frame);
 
       palettes[frame] = new Palette(frame, orig->size());
       orig->copyColorsTo(palettes[frame]);
@@ -185,8 +185,8 @@ void PaletteEditorCommand::execute(Context* context)
   
   /* frame */
   if (sprite) {
-    jslider_set_range(slider_frame, 0, sprite->frames-1);
-    jslider_set_value(slider_frame, sprite->frame);
+    jslider_set_range(slider_frame, 0, sprite->getTotalFrames()-1);
+    jslider_set_value(slider_frame, sprite->getCurrentFrame());
     
     if (jwidget_is_selected(check_all_frames))
       jwidget_disable(slider_frame);
@@ -228,24 +228,24 @@ void PaletteEditorCommand::execute(Context* context)
   if (window->get_killer() == button_ok) {
     if (sprite) {
       SpriteWriter sprite_writer(sprite);
-      sprite_reset_palettes(sprite_writer);
+      sprite_writer->resetPalettes();
 
       /* one palette */
       if (jwidget_is_selected(check_all_frames)) {
 	// Copy the current palette in the first frame
 	get_current_palette()->copyColorsTo(palettes[0]);
 
-	sprite_set_palette(sprite_writer, palettes[0], true);
+	sprite_writer->setPalette(palettes[0], true);
       }
       /* various palettes */
       else {
 	frame = jslider_get_value(slider_frame);
 	get_current_palette()->copyColorsTo(palettes[frame]);
 
-	for (frame=0; frame<sprite_writer->frames; ++frame) {
+	for (frame=0; frame<sprite_writer->getTotalFrames(); ++frame) {
 	  if (frame == 0 ||
 	      palettes[frame]->countDiff(palettes[frame-1], NULL, NULL) > 0) {
-	    sprite_set_palette(sprite_writer, palettes[frame], true);
+	    sprite_writer->setPalette(palettes[frame], true);
 	  }
 	}
       }
@@ -261,9 +261,9 @@ void PaletteEditorCommand::execute(Context* context)
     /* restore the system palette */
     if (sprite) {
       SpriteWriter sprite_writer(sprite);
-      sprite_writer->frame = frame_bak;
+      sprite_writer->setCurrentFrame(frame_bak);
 
-      set_current_palette(sprite_get_palette(sprite, frame_bak), true);
+      set_current_palette(sprite->getPalette(frame_bak), true);
     }
     else {
       set_current_palette(NULL, true);
@@ -283,7 +283,7 @@ void PaletteEditorCommand::execute(Context* context)
   if (!palettes.empty()) {
     assert(sprite);
 
-    for (frame=0; frame<sprite->frames; ++frame)
+    for (frame=0; frame<sprite->getTotalFrames(); ++frame)
       delete palettes[frame];
 
     palettes.clear();
@@ -379,7 +379,7 @@ static void quantize_command(JWidget widget)
   paledit_get_selected_entries(palette_editor, array);
   paledit_get_palette(palette_editor)->copyColorsTo(palette);
 
-  if (sprite->imgtype == IMAGE_RGB) {
+  if (sprite->getImgType() == IMAGE_RGB) {
     SpriteWriter sprite_writer(sprite);
     sprite_quantize_ex(sprite_writer, palette);
   }
@@ -458,13 +458,13 @@ static bool slider_frame_change_hook(JWidget widget, void *data)
   const SpriteReader& sprite = get_sprite(widget);
   assert(sprite != NULL);
 
-  int old_frame = sprite->frame;
+  int old_frame = sprite->getCurrentFrame();
   int new_frame = jslider_get_value(slider_frame);
 
   get_current_palette()->copyColorsTo(palettes[old_frame]);
   {
     SpriteWriter sprite_writer(sprite);
-    sprite_writer->frame = new_frame;
+    sprite_writer->setCurrentFrame(new_frame);
   }
   set_new_palette(palettes[new_frame]);
 
@@ -484,7 +484,7 @@ static bool check_all_frames_change_hook(JWidget widget, void *data)
     bool has_two_or_more_palettes = false;
     int c;
 
-    for (c=1; c<sprite->frames; c++) {
+    for (c=1; c<sprite->getTotalFrames(); c++) {
       if (palettes[c-1]->countDiff(palettes[c], NULL, NULL) > 0) {
 	has_two_or_more_palettes = true;
 	break;

src/commands/cmd_paste.cpp

@@ -57,8 +57,8 @@ void PasteCommand::execute(Context* context)
 {
   CurrentSpriteWriter sprite(context);
 
-  if (undo_is_enabled(sprite->undo))
-    undo_set_label(sprite->undo, "Paste");
+  if (undo_is_enabled(sprite->getUndo()))
+    undo_set_label(sprite->getUndo(), "Paste");
 
   clipboard::paste(sprite);
 }

src/commands/cmd_play_animation.cpp

@@ -77,7 +77,7 @@ void PlayAnimationCommand::execute(Context* context)
   Palette *oldpal, *newpal;
   PALETTE rgbpal;
 
-  if (sprite->frames < 2)
+  if (sprite->getTotalFrames() < 2)
     return;
 
   // desactivate the onionskin
@@ -85,7 +85,7 @@ void PlayAnimationCommand::execute(Context* context)
 
   jmouse_hide();
 
-  old_frame = sprite->frame;
+  old_frame = sprite->getCurrentFrame();
 
   LOCK_VARIABLE(speed_timer);
   LOCK_FUNCTION(speed_timer_callback);
@@ -99,17 +99,17 @@ void PlayAnimationCommand::execute(Context* context)
   oldpal = NULL;
   speed_timer = 0;
   while (!done) {
-    msecs = sprite_get_frlen(sprite, sprite->frame);
+    msecs = sprite->getFrameDuration(sprite->getCurrentFrame());
     install_int_ex(speed_timer_callback, MSEC_TO_TIMER(msecs));
 
-    newpal = sprite_get_palette(sprite, sprite->frame);
+    newpal = sprite->getPalette(sprite->getCurrentFrame());
     if (oldpal != newpal) {
       newpal->toAllegro(rgbpal);
       set_palette(rgbpal);
       oldpal = newpal;
     }
 
-    current_editor->editor_draw_sprite_safe(0, 0, sprite->w, sprite->h);
+    current_editor->editor_draw_sprite_safe(0, 0, sprite->getWidth(), sprite->getHeight());
 
     do {
       poll_mouse();
@@ -120,9 +120,10 @@ void PlayAnimationCommand::execute(Context* context)
     } while (!done && (speed_timer <= 0));
 
     if (!done) {
-      sprite->frame++;
-      if (sprite->frame >= sprite->frames)
-	sprite->frame = 0;
+      int frame = sprite->getCurrentFrame()+1;
+      if (frame >= sprite->getTotalFrames())
+	frame = 0;
+      sprite->setCurrentFrame(frame);
 
       speed_timer--;
     }
@@ -135,10 +136,10 @@ void PlayAnimationCommand::execute(Context* context)
   /* if right-click or ESC */
   if (mouse_b == 2 || (keypressed() && (readkey()>>8) == KEY_ESC))
     /* return to the old frame position */
-    sprite->frame = old_frame;
+    sprite->setCurrentFrame(old_frame);
 
   /* refresh all */
-  newpal = sprite_get_palette(sprite, sprite->frame);
+  newpal = sprite->getPalette(sprite->getCurrentFrame());
   set_current_palette(newpal, true);
   jmanager_refresh_screen();
   gui_feedback();

src/commands/cmd_preview.cpp

@@ -106,7 +106,7 @@ void PreviewCommand::preview_sprite(Context* context, int flags)
     old_mouse_x = jmouse_x(0);
     old_mouse_y = jmouse_y(0);
 
-    bmp = create_bitmap(sprite->w, sprite->h);
+    bmp = create_bitmap(sprite->getWidth(), sprite->getHeight());
     if (bmp) {
       /* print a informative text */
       app_get_statusbar()->setStatusText(1, _("Rendering..."));
@@ -117,8 +117,8 @@ void PreviewCommand::preview_sprite(Context* context, int flags)
       jmouse_set_position(JI_SCREEN_W/2, JI_SCREEN_H/2);
 
       /* render the sprite in the bitmap */
-      image = RenderEngine::renderSprite(sprite, 0, 0, sprite->w, sprite->h,
-					 sprite->frame, 0);
+      image = RenderEngine::renderSprite(sprite, 0, 0, sprite->getWidth(), sprite->getHeight(),
+					 sprite->getCurrentFrame(), 0);
       if (image) {
 	image_to_allegro(image, bmp, 0, 0);
 	image_free(image);
@@ -132,8 +132,8 @@ void PreviewCommand::preview_sprite(Context* context, int flags)
       shiftx = - scroll_x + vp->x1 + editor->editor_get_offset_x();
       shifty = - scroll_y + vp->y1 + editor->editor_get_offset_y();
 
-      w = sprite->w << editor->editor_get_zoom();
-      h = sprite->h << editor->editor_get_zoom();
+      w = sprite->getWidth() << editor->editor_get_zoom();
+      h = sprite->getHeight() << editor->editor_get_zoom();
 
       redraw = true;
       do {
@@ -259,8 +259,8 @@ void PreviewCommand::preview_sprite(Context* context, int flags)
 	    redraw = true;
 
 	    /* render the sprite in the bitmap */
-	    image = RenderEngine::renderSprite(sprite, 0, 0, sprite->w, sprite->h,
-					       sprite->frame, 0);
+	    image = RenderEngine::renderSprite(sprite, 0, 0, sprite->getWidth(), sprite->getHeight(),
+					       sprite->getCurrentFrame(), 0);
 	    if (image) {
 	      image_to_allegro(image, bmp, 0, 0);
 	      image_free(image);

src/commands/cmd_redo.cpp

@@ -49,7 +49,7 @@ bool RedoCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite != NULL &&
-    undo_can_redo(sprite->undo);
+    undo_can_redo(sprite->getUndo());
 }
 
 void RedoCommand::execute(Context* context)
@@ -58,10 +58,10 @@ void RedoCommand::execute(Context* context)
 
   app_get_statusbar()
     ->showTip(1000, _("Redid %s"),
-	      undo_get_next_redo_label(sprite->undo));
+	      undo_get_next_redo_label(sprite->getUndo()));
 
-  undo_do_redo(sprite->undo);
-  sprite_generate_mask_boundaries(sprite);
+  undo_do_redo(sprite->getUndo());
+  sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 }
 

src/commands/cmd_remove_cel.cpp

@@ -52,20 +52,20 @@ bool RemoveCelCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite &&
-    sprite->layer &&
-    sprite->layer->is_readable() &&
-    sprite->layer->is_writable() &&
-    sprite->layer->is_image() &&
-    static_cast<LayerImage*>(sprite->layer)->get_cel(sprite->frame);
+    sprite->getCurrentLayer() &&
+    sprite->getCurrentLayer()->is_readable() &&
+    sprite->getCurrentLayer()->is_writable() &&
+    sprite->getCurrentLayer()->is_image() &&
+    static_cast<const LayerImage*>(sprite->getCurrentLayer())->get_cel(sprite->getCurrentFrame());
 }
 
 void RemoveCelCommand::execute(Context* context)
 {
   CurrentSpriteWriter sprite(context);
-  Cel* cel = static_cast<LayerImage*>(sprite->layer)->get_cel(sprite->frame);
+  Cel* cel = static_cast<LayerImage*>(sprite->getCurrentLayer())->get_cel(sprite->getCurrentFrame());
   {
     Undoable undoable(sprite, "Remove Cel");
-    undoable.remove_cel(static_cast<LayerImage*>(sprite->layer), cel);
+    undoable.remove_cel(static_cast<LayerImage*>(sprite->getCurrentLayer()), cel);
     undoable.commit();
   }
   update_screen_for_sprite(sprite);

src/commands/cmd_remove_frame.cpp

@@ -52,7 +52,7 @@ bool RemoveFrameCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite != NULL &&
-    sprite->frames > 1;
+    sprite->getTotalFrames() > 1;
 }
 
 void RemoveFrameCommand::execute(Context* context)
@@ -60,7 +60,7 @@ void RemoveFrameCommand::execute(Context* context)
   CurrentSpriteWriter sprite(context);
   {
     Undoable undoable(sprite, "Remove Frame");
-    undoable.remove_frame(sprite->frame);
+    undoable.remove_frame(sprite->getCurrentFrame());
     undoable.commit();
   }
   update_screen_for_sprite(sprite);

src/commands/cmd_remove_layer.cpp

@@ -56,7 +56,7 @@ bool RemoveLayerCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite != NULL &&
-    sprite->layer != NULL;
+    sprite->getCurrentLayer() != NULL;
 }
 
 void RemoveLayerCommand::execute(Context* context)
@@ -66,9 +66,9 @@ void RemoveLayerCommand::execute(Context* context)
   {
     Undoable undoable(sprite, "Remove Layer");
 
-    layer_name = sprite->layer->get_name();
+    layer_name = sprite->getCurrentLayer()->get_name();
 
-    undoable.remove_layer(sprite->layer);
+    undoable.remove_layer(sprite->getCurrentLayer());
     undoable.commit();
   }
   update_screen_for_sprite(sprite);

src/commands/cmd_reselect_mask.cpp

@@ -51,7 +51,7 @@ bool ReselectMaskCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite != NULL &&
-    sprite_request_mask(sprite, "*deselected*") != NULL;
+    sprite->requestMask("*deselected*") != NULL;
 }
 
 void ReselectMaskCommand::execute(Context* context)
@@ -59,23 +59,23 @@ void ReselectMaskCommand::execute(Context* context)
   CurrentSpriteWriter sprite(context);
   Mask *mask;
 
-  /* request *deselected* mask */
-  mask = sprite_request_mask(sprite, "*deselected*");
+  // Request *deselected* mask
+  mask = sprite->requestMask("*deselected*");
 
   /* undo */
-  if (undo_is_enabled(sprite->undo)) {
-    undo_set_label(sprite->undo, "Mask Reselection");
-    undo_set_mask(sprite->undo, sprite);
+  if (undo_is_enabled(sprite->getUndo())) {
+    undo_set_label(sprite->getUndo(), "Mask Reselection");
+    undo_set_mask(sprite->getUndo(), sprite);
   }
 
   /* set the mask */
-  sprite_set_mask(sprite, mask);
+  sprite->setMask(mask);
 
   /* remove the *deselected* mask */
-  sprite_remove_mask(sprite, mask);
+  sprite->removeMask(mask);
   mask_free(mask);
 
-  sprite_generate_mask_boundaries(sprite);
+  sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 }
 

src/commands/cmd_rotate_canvas.cpp

@@ -78,32 +78,32 @@ protected:
 
     // get all sprite cels
     CelList cels;
-    sprite_get_cels(m_sprite, cels);
+    m_sprite->getCels(cels);
 
     // for each cel...
     for (CelIterator it = cels.begin(); it != cels.end(); ++it) {
       Cel* cel = *it;
-      Image* image = stock_get_image(m_sprite->stock, cel->image);
+      Image* image = stock_get_image(m_sprite->getStock(), cel->image);
 
       // change it location
       switch (m_angle) {
 	case 180:
 	  undoable.set_cel_position(cel,
-				    m_sprite->w - cel->x - image->w,
-				    m_sprite->h - cel->y - image->h);
+				    m_sprite->getWidth() - cel->x - image->w,
+				    m_sprite->getHeight() - cel->y - image->h);
 	  break;
 	case 90:
-	  undoable.set_cel_position(cel, m_sprite->h - cel->y - image->h, cel->x);
+	  undoable.set_cel_position(cel, m_sprite->getHeight() - cel->y - image->h, cel->x);
 	  break;
 	case -90:
-	  undoable.set_cel_position(cel, cel->y, m_sprite->w - cel->x - image->w);
+	  undoable.set_cel_position(cel, cel->y, m_sprite->getWidth() - cel->x - image->w);
 	  break;
       }
     }
 
     // for each stock's image
-    for (int i=0; i<m_sprite->stock->nimage; ++i) {
-      Image* image = stock_get_image(m_sprite->stock, i);
+    for (int i=0; i<m_sprite->getStock()->nimage; ++i) {
+      Image* image = stock_get_image(m_sprite->getStock(), i);
       if (!image)
 	continue;
 
@@ -115,7 +115,7 @@ protected:
 
       undoable.replace_stock_image(i, new_image);
 
-      job_progress((float)i / m_sprite->stock->nimage);
+      job_progress((float)i / m_sprite->getStock()->nimage);
 
       // cancel all the operation?
       if (is_canceled())
@@ -123,42 +123,42 @@ protected:
     }
 
     // rotate mask
-    if (m_sprite->mask->bitmap) {
+    if (m_sprite->getMask()->bitmap) {
       Mask* new_mask = mask_new();
       int x, y;
 
       switch (m_angle) {
 	case 180:
-	  x = m_sprite->w - m_sprite->mask->x - m_sprite->mask->w;
-	  y = m_sprite->h - m_sprite->mask->y - m_sprite->mask->h;
+	  x = m_sprite->getWidth() - m_sprite->getMask()->x - m_sprite->getMask()->w;
+	  y = m_sprite->getHeight() - m_sprite->getMask()->y - m_sprite->getMask()->h;
 	  break;
 	case 90:
-	  x = m_sprite->h - m_sprite->mask->y - m_sprite->mask->h;
-	  y = m_sprite->mask->x;
+	  x = m_sprite->getHeight() - m_sprite->getMask()->y - m_sprite->getMask()->h;
+	  y = m_sprite->getMask()->x;
 	  break;
 	case -90:
-	  x = m_sprite->mask->y;
-	  y = m_sprite->w - m_sprite->mask->x - m_sprite->mask->w;
+	  x = m_sprite->getMask()->y;
+	  y = m_sprite->getWidth() - m_sprite->getMask()->x - m_sprite->getMask()->w;
 	  break;
       }
 
       // create the new rotated mask
       mask_replace(new_mask, x, y,
-		   m_angle == 180 ? m_sprite->mask->w: m_sprite->mask->h,
-		   m_angle == 180 ? m_sprite->mask->h: m_sprite->mask->w);
-      image_rotate(m_sprite->mask->bitmap, new_mask->bitmap, m_angle);
+		   m_angle == 180 ? m_sprite->getMask()->w: m_sprite->getMask()->h,
+		   m_angle == 180 ? m_sprite->getMask()->h: m_sprite->getMask()->w);
+      image_rotate(m_sprite->getMask()->bitmap, new_mask->bitmap, m_angle);
 
       // copy new mask
       undoable.copy_to_current_mask(new_mask);
       mask_free(new_mask);
 
       // regenerate mask
-      sprite_generate_mask_boundaries(m_sprite);
+      m_sprite->generateMaskBoundaries();
     }
 
     // change the sprite's size
     if (m_angle != 180)
-      undoable.set_sprite_size(m_sprite->h, m_sprite->w);
+      undoable.set_sprite_size(m_sprite->getHeight(), m_sprite->getWidth());
 
     // commit changes
     undoable.commit();
@@ -194,7 +194,7 @@ void RotateCanvasCommand::execute(Context* context)
     RotateCanvasJob job(sprite, m_angle);
     job.do_job();
   }
-  sprite_generate_mask_boundaries(sprite);
+  sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 }
 

src/commands/cmd_save_file.cpp

@@ -105,7 +105,7 @@ static void save_sprite_in_background(Sprite* sprite, bool mark_as_saved)
       data->thread = thread;
       data->alert_window = jalert_new(PACKAGE
 				      "<<Saving file:<<%s||&Cancel",
-				      get_filename(sprite->filename));
+				      get_filename(sprite->getFilename()));
 
       /* add a monitor to check the saving (FileOp) progress */
       data->monitor = add_gui_monitor(monitor_savefile_bg,
@@ -128,13 +128,13 @@ static void save_sprite_in_background(Sprite* sprite, bool mark_as_saved)
       }
       /* no error? */
       else {
-	RecentFiles::addRecentFile(sprite->filename);
+	RecentFiles::addRecentFile(sprite->getFilename());
 	if (mark_as_saved)
-	  sprite_mark_as_saved(sprite);
+	  sprite->markAsSaved();
 
 	app_get_statusbar()
 	  ->setStatusText(2000, "File %s, saved.",
-			  get_filename(sprite->filename));
+			  get_filename(sprite->getFilename()));
       }
 
       delete data->progress;
@@ -154,7 +154,7 @@ static void save_as_dialog(Sprite* sprite, const char* dlg_title, bool mark_as_s
   jstring newfilename;
   int ret;
 
-  filename = sprite->filename;
+  filename = sprite->getFilename();
   get_writable_extensions(exts, sizeof(exts));
 
   for (;;) {
@@ -186,7 +186,7 @@ static void save_as_dialog(Sprite* sprite, const char* dlg_title, bool mark_as_s
     /* "no": we must back to select other file-name */
   }
 
-  sprite_set_filename(sprite, filename.c_str());
+  sprite->setFilename(filename.c_str());
   app_realloc_sprite_list();
 
   save_sprite_in_background(sprite, mark_as_saved);
@@ -236,7 +236,7 @@ void SaveFileCommand::execute(Context* context)
 
   /* if the sprite is associated to a file in the file-system, we can
      save it directly without user interaction */
-  if (sprite_is_associated_to_file(sprite)) {
+  if (sprite->isAssociatedToFile()) {
     save_sprite_in_background(sprite, true);
   }
   /* if the sprite isn't associated to a file, we must to show the
@@ -312,13 +312,13 @@ bool SaveFileCopyAsCommand::enabled(Context* context)
 void SaveFileCopyAsCommand::execute(Context* context)
 {
   CurrentSpriteWriter sprite(context);
-  jstring old_filename = sprite->filename;
+  jstring old_filename = sprite->getFilename();
 
   // show "Save As" dialog
   save_as_dialog(sprite, _("Save Sprite Copy As"), false);
 
   // restore the file name
-  sprite_set_filename(sprite, old_filename.c_str());
+  sprite->setFilename(old_filename.c_str());
   app_realloc_sprite_list();
 }
 

src/commands/cmd_save_mask.cpp

@@ -56,8 +56,8 @@ bool SaveMaskCommand::enabled(Context* context)
   if (!sprite)
     return false;
   else
-    return (sprite->mask &&
-	    sprite->mask->bitmap) ? true: false;
+    return (sprite->getMask() &&
+	    sprite->getMask()->bitmap) ? true: false;
 }
 
 void SaveMaskCommand::execute(Context* context)
@@ -92,7 +92,7 @@ void SaveMaskCommand::execute(Context* context)
     /* "no": we must back to select other file-name */
   }
 
-  if (save_msk_file(sprite->mask, filename.c_str()) != 0)
+  if (save_msk_file(sprite->getMask(), filename.c_str()) != 0)
     jalert("%s<<%s<<%s||%s",
 	   _("Error"), _("Error saving .msk file"),
 	   filename.c_str(), _("&Close"));

src/commands/cmd_screen_shot.cpp

@@ -80,13 +80,13 @@ void ScreenShotCommand::execute(Context* context)
   /* creates a sprite with one layer, one image to save the bitmap as a PNG */
   {
     int imgtype = bitmap_color_depth(bmp) == 8 ? IMAGE_INDEXED: IMAGE_RGB;
-    Sprite *sprite = sprite_new_with_layer(imgtype, bmp->w, bmp->h, 256);
-    Image *image = GetImage2(sprite, NULL, NULL, NULL);
+    Sprite* sprite = Sprite::createWithLayer(imgtype, bmp->w, bmp->h, 256);
+    Image* image = sprite->getCurrentImage();
     int x, y, r, g, b;
 
     Palette *pal = new Palette(0, 256);
     pal->fromAllegro(rgbpal);
-    sprite_set_palette(sprite, pal, true);
+    sprite->setPalette(pal, true);
     delete pal;
 
     /* convert Allegro "BITMAP" to ASE "Image" */
@@ -116,7 +116,7 @@ void ScreenShotCommand::execute(Context* context)
     }
 
     /* save the sprite */
-    sprite_set_filename(sprite, buf);
+    sprite->setFilename(buf);
     sprite_save(sprite);
 
     /* destroy the sprite */

src/commands/cmd_sprite_properties.cpp

@@ -80,7 +80,7 @@ void SpritePropertiesCommand::execute(Context* context)
 	      "ok", &ok, NULL);
 
   /* update widgets values */
-  switch (sprite->imgtype) {
+  switch (sprite->getImgType()) {
     case IMAGE_RGB:
       imgtype_text = "RGB";
       break;
@@ -96,21 +96,21 @@ void SpritePropertiesCommand::execute(Context* context)
   }
 
   /* filename */
-  name->setText(sprite->filename);
+  name->setText(sprite->getFilename());
 
   /* color mode */
   type->setText(imgtype_text.c_str());
 
   /* sprite size (width and height) */
-  usprintf(buf, "%dx%d (", sprite->w, sprite->h);
-  get_pretty_memsize(sprite_get_memsize(sprite),
+  usprintf(buf, "%dx%d (", sprite->getWidth(), sprite->getHeight());
+  get_pretty_memsize(sprite->getMemSize(),
  		     buf+ustrsize(buf),
 		     sizeof(buf)-ustrsize(buf));
   ustrcat(buf, ")");
   size->setText(buf);
 
   /* how many frames */
-  frames->setTextf("%d", sprite->frames);
+  frames->setTextf("%d", sprite->getTotalFrames());
 
   window->remap_window();
   window->center_window();

src/commands/cmd_sprite_size.cpp

@@ -45,8 +45,8 @@ class SpriteSizeJob : public Job
   int m_new_height;
   ResizeMethod m_resize_method;
 
-  inline int scale_x(int x) const { return x * m_new_width / m_sprite->w; }
-  inline int scale_y(int y) const { return y * m_new_height / m_sprite->h; }
+  inline int scale_x(int x) const { return x * m_new_width / m_sprite->getWidth(); }
+  inline int scale_y(int y) const { return y * m_new_height / m_sprite->getHeight(); }
 
 public:
 
@@ -70,7 +70,7 @@ protected:
 
     // get all sprite cels
     CelList cels;
-    sprite_get_cels(m_sprite, cels);
+    m_sprite->getCels(cels);
 
     // for each cel...
     for (CelIterator it = cels.begin(); it != cels.end(); ++it) {
@@ -81,8 +81,8 @@ protected:
     }
 
     // for each stock's image
-    for (int i=0; i<m_sprite->stock->nimage; ++i) {
-      Image* image = stock_get_image(m_sprite->stock, i);
+    for (int i=0; i<m_sprite->getStock()->nimage; ++i) {
+      Image* image = stock_get_image(m_sprite->getStock(), i);
       if (!image)
 	continue;
 
@@ -99,7 +99,7 @@ protected:
 
       undoable.replace_stock_image(i, new_image);
 
-      job_progress((float)i / m_sprite->stock->nimage);
+      job_progress((float)i / m_sprite->getStock()->nimage);
 
       // cancel all the operation?
       if (is_canceled())
@@ -107,17 +107,17 @@ protected:
     }
 
     // resize mask
-    if (m_sprite->mask->bitmap) {
-      Image* old_bitmap = image_crop(m_sprite->mask->bitmap, -1, -1,
-				     m_sprite->mask->bitmap->w+2,
-				     m_sprite->mask->bitmap->h+2, 0);
+    if (m_sprite->getMask()->bitmap) {
+      Image* old_bitmap = image_crop(m_sprite->getMask()->bitmap, -1, -1,
+				     m_sprite->getMask()->bitmap->w+2,
+				     m_sprite->getMask()->bitmap->h+2, 0);
 
       int w = scale_x(old_bitmap->w);
       int h = scale_y(old_bitmap->h);
       Mask* new_mask = mask_new();
       mask_replace(new_mask,
-		   scale_x(m_sprite->mask->x-1),
-		   scale_y(m_sprite->mask->y-1), MAX(1, w), MAX(1, h));
+		   scale_x(m_sprite->getMask()->x-1),
+		   scale_y(m_sprite->getMask()->y-1), MAX(1, w), MAX(1, h));
       image_resize(old_bitmap, new_mask->bitmap,
 		   m_resize_method,
 		   get_current_palette(),
@@ -134,7 +134,7 @@ protected:
       mask_free(new_mask);
 
       // regenerate mask
-      sprite_generate_mask_boundaries(m_sprite);
+      m_sprite->generateMaskBoundaries();
     }
 
     // resize sprite
@@ -197,8 +197,8 @@ void SpriteSizeCommand::execute(Context* context)
 	      "method", &method,
 	      "ok", &ok, NULL);
 
-  width_px->setTextf("%d", sprite->w);
-  height_px->setTextf("%d", sprite->h);
+  width_px->setTextf("%d", sprite->getWidth());
+  height_px->setTextf("%d", sprite->getHeight());
 
   HOOK(lock_ratio, JI_SIGNAL_CHECK_CHANGE, lock_ratio_change_hook, 0);
   HOOK(width_px, JI_SIGNAL_ENTRY_CHANGE, width_px_change_hook, 0);
@@ -249,13 +249,13 @@ static bool width_px_change_hook(JWidget widget, void *data)
 {
   const CurrentSpriteReader sprite(UIContext::instance()); // TODO use the context in sprite size command
   int width = widget->getTextInt();
-  double perc = 100.0 * width / sprite->w;
+  double perc = 100.0 * width / sprite->getWidth();
 
   widget->findSibling("width_perc")->setTextf(PERC_FORMAT, perc);
 
   if (widget->findSibling("lock_ratio")->isSelected()) {
     widget->findSibling("height_perc")->setTextf(PERC_FORMAT, perc);
-    widget->findSibling("height_px")->setTextf("%d", sprite->h * width / sprite->w);
+    widget->findSibling("height_px")->setTextf("%d", sprite->getHeight() * width / sprite->getWidth());
   }
 
   return true;
@@ -265,13 +265,13 @@ static bool height_px_change_hook(JWidget widget, void *data)
 {
   const CurrentSpriteReader sprite(UIContext::instance()); // TODO use the context in sprite size command
   int height = widget->getTextInt();
-  double perc = 100.0 * height / sprite->h;
+  double perc = 100.0 * height / sprite->getHeight();
 
   widget->findSibling("height_perc")->setTextf(PERC_FORMAT, perc);
 
   if (widget->findSibling("lock_ratio")->isSelected()) {
     widget->findSibling("width_perc")->setTextf(PERC_FORMAT, perc);
-    widget->findSibling("width_px")->setTextf("%d", sprite->w * height / sprite->h);
+    widget->findSibling("width_px")->setTextf("%d", sprite->getWidth() * height / sprite->getHeight());
   }
 
   return true;
@@ -282,10 +282,10 @@ static bool width_perc_change_hook(JWidget widget, void *data)
   const CurrentSpriteReader sprite(UIContext::instance()); // TODO use the context in sprite size command
   double width = widget->getTextDouble();
 
-  widget->findSibling("width_px")->setTextf("%d", (int)(sprite->w * width / 100));
+  widget->findSibling("width_px")->setTextf("%d", (int)(sprite->getWidth() * width / 100));
 
   if (widget->findSibling("lock_ratio")->isSelected()) {
-    widget->findSibling("height_px")->setTextf("%d", (int)(sprite->h * width / 100));
+    widget->findSibling("height_px")->setTextf("%d", (int)(sprite->getHeight() * width / 100));
     widget->findSibling("height_perc")->setText(widget->getText());
   }
 
@@ -297,10 +297,10 @@ static bool height_perc_change_hook(JWidget widget, void *data)
   const CurrentSpriteReader sprite(UIContext::instance()); // TODO use the context in sprite size command
   double height = widget->getTextDouble();
 
-  widget->findSibling("height_px")->setTextf("%d", (int)(sprite->h * height / 100));
+  widget->findSibling("height_px")->setTextf("%d", (int)(sprite->getHeight() * height / 100));
 
   if (widget->findSibling("lock_ratio")->isSelected()) {
-    widget->findSibling("width_px")->setTextf("%d", (int)(sprite->w * height / 100));
+    widget->findSibling("width_px")->setTextf("%d", (int)(sprite->getWidth() * height / 100));
     widget->findSibling("width_perc")->setText(widget->getText());
   }
 

src/commands/cmd_undo.cpp

@@ -49,7 +49,7 @@ bool UndoCommand::enabled(Context* context)
   const CurrentSpriteReader sprite(context);
   return
     sprite != NULL &&
-    undo_can_undo(sprite->undo);
+    undo_can_undo(sprite->getUndo());
 }
 
 void UndoCommand::execute(Context* context)
@@ -58,10 +58,10 @@ void UndoCommand::execute(Context* context)
 
   app_get_statusbar()
     ->showTip(1000, _("Undid %s"),
-	      undo_get_next_undo_label(sprite->undo));
+	      undo_get_next_undo_label(sprite->getUndo()));
 
-  undo_do_undo(sprite->undo);
-  sprite_generate_mask_boundaries(sprite);
+  undo_do_undo(sprite->getUndo());
+  sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 }
 

src/commands/fx/cmd_color_curve.cpp

@@ -110,7 +110,7 @@ void ColorCurveCommand::execute(Context* context)
   set_color_curve(the_curve);
 
   curve_editor = curve_editor_new(the_curve, 0, 0, 255, 255);
-  target_button = target_button_new(sprite->imgtype, true);
+  target_button = target_button_new(sprite->getImgType(), true);
   target_button_set_target(target_button, effect.target);
 
   if (get_config_bool("ColorCurve", "Preview", true))

src/commands/fx/cmd_convolution_matrix.cpp

@@ -118,7 +118,7 @@ void ConvolutionMatrixCommand::execute(Context* context)
   list_convmatr = jlistbox_new();
   listbox_fill_convmatg(list_convmatr);
 
-  target_button = target_button_new(sprite->imgtype, true);
+  target_button = target_button_new(sprite->getImgType(), true);
   target_button_set_target(target_button, effect.target);
 
   if (get_config_bool("ConvolutionMatrix", "Preview", true))

src/commands/fx/cmd_despeckle.cpp

@@ -103,7 +103,7 @@ void DespeckleCommand::execute(Context* context)
 
   preview = preview_new(&effect);
 
-  target_button = target_button_new(sprite->imgtype, true);
+  target_button = target_button_new(sprite->getImgType(), true);
   target_button_set_target(target_button, effect.target);
 
   entry_width->setTextf("%d", get_config_int("Median", "Width", 3));

src/commands/fx/cmd_invert_color.cpp

@@ -93,7 +93,7 @@ void InvertColorCommand::execute(Context* context)
 			     TARGET_BLUE_CHANNEL);
 
   preview = preview_new(&effect);
-  target_button = target_button_new(sprite->imgtype, true);
+  target_button = target_button_new(sprite->getImgType(), true);
   target_button_set_target(target_button, effect.target);
 
   if (get_config_bool("InvertColor", "Preview", true))

src/commands/fx/cmd_replace_color.cpp

@@ -104,14 +104,14 @@ void ReplaceColorCommand::execute(Context* context)
   button_color1 = colorbutton_new
     (get_config_color("ReplaceColor", "Color1",
 		      colorbar_get_fg_color(app_get_colorbar())),
-     sprite->imgtype);
+     sprite->getImgType());
 
   button_color2 = colorbutton_new
     (get_config_color("ReplaceColor", "Color2",
 		      colorbar_get_bg_color(app_get_colorbar())),
-     sprite->imgtype);
+     sprite->getImgType());
 
-  target_button = target_button_new(sprite->imgtype, false);
+  target_button = target_button_new(sprite->getImgType(), false);
   target_button_set_target(target_button, effect.target);
 
   jslider_set_value(slider_fuzziness,
@@ -196,8 +196,8 @@ static void make_preview()
   to = get_config_color("ReplaceColor", "Color2", color_mask());
   fuzziness = get_config_int("ReplaceColor", "Fuzziness", 0);
 
-  set_replace_colors(get_color_for_layer(sprite->layer, from),
-		     get_color_for_layer(sprite->layer, to),
+  set_replace_colors(get_color_for_layer(sprite->getCurrentLayer(), from),
+		     get_color_for_layer(sprite->getCurrentLayer(), to),
 		     MID(0, fuzziness, 255));
 
   if (jwidget_is_selected(check_preview))

src/core/color.cpp

@@ -631,14 +631,14 @@ int get_color_for_layer(Layer *layer, color_t color)
 {
   return
     fixup_color_for_layer(layer,
-			  get_color_for_image(layer->getSprite()->imgtype,
+			  get_color_for_image(layer->getSprite()->getImgType(),
 					      color));
 }
 
 int fixup_color_for_layer(Layer *layer, int color)
 {
   if (layer->is_background())
-    return fixup_color_for_background(layer->getSprite()->imgtype, color);
+    return fixup_color_for_background(layer->getSprite()->getImgType(), color);
   else
     return color;
 }

src/dialogs/aniedit.cpp

@@ -99,7 +99,7 @@ enum {
   A_PART_CEL
 };
 
-typedef struct AniEditor
+struct AniEditor
 {
   const Sprite* sprite;
   int state;
@@ -120,7 +120,7 @@ typedef struct AniEditor
   int clk_frame;
   /* keys */
   bool space_pressed;
-} AniEditor;
+};
 
 static JWidget current_anieditor = NULL;
 
@@ -149,7 +149,7 @@ static void anieditor_show_cel(JWidget widget, int layer, int frame);
 static void anieditor_show_current_cel(JWidget widget);
 static void anieditor_clean_clk(JWidget widget);
 static void anieditor_set_scroll(JWidget widget, int x, int y, bool use_refresh_region);
-static int anieditor_get_layer_index(JWidget widget, Layer* layer);
+static int anieditor_get_layer_index(JWidget widget, const Layer* layer);
 
 static void icon_rect(BITMAP* icon, int x1, int y1, int x2, int y2, bool is_selected, bool is_hot, bool is_clk);
 
@@ -176,9 +176,9 @@ void switch_between_animation_and_sprite_editor()
   window->remap_window();
 
   /* show the current cel */
-  int layer = anieditor_get_layer_index(anieditor, sprite->layer);
+  int layer = anieditor_get_layer_index(anieditor, sprite->getCurrentLayer());
   if (layer >= 0)
-    anieditor_center_cel(anieditor, layer, sprite->frame);
+    anieditor_center_cel(anieditor, layer, sprite->getCurrentFrame());
 
   /* show the window */
   window->open_window_fg();
@@ -327,7 +327,7 @@ static bool anieditor_msg_proc(JWidget widget, JMessage msg)
 	  {
 	    const SpriteReader sprite((Sprite*)anieditor->sprite);
 	    SpriteWriter sprite_writer(sprite);
-	    sprite_writer->frame = anieditor->clk_frame;
+	    sprite_writer->setCurrentFrame(anieditor->clk_frame);
 	  }
 	  jwidget_dirty(widget); /* TODO replace this by redrawing old current frame and new current frame */
 	  jwidget_hard_capture_mouse(widget);
@@ -335,14 +335,14 @@ static bool anieditor_msg_proc(JWidget widget, JMessage msg)
 	  break;
 	case A_PART_LAYER: {
 	  const SpriteReader sprite((Sprite*)anieditor->sprite);
-	  int old_layer = anieditor_get_layer_index(widget, sprite->layer);
-	  int frame = anieditor->sprite->frame;
+	  int old_layer = anieditor_get_layer_index(widget, sprite->getCurrentLayer());
+	  int frame = anieditor->sprite->getCurrentFrame();
 
 	  /* did the user select another layer? */
 	  if (old_layer != anieditor->clk_layer) {
 	    {
 	      SpriteWriter sprite_writer(sprite);
-	      sprite_writer->layer = anieditor->layers[anieditor->clk_layer];
+	      sprite_writer->setCurrentLayer(anieditor->layers[anieditor->clk_layer]);
 	    }
 
 	    jmouse_hide();
@@ -355,7 +355,7 @@ static bool anieditor_msg_proc(JWidget widget, JMessage msg)
 	  }
 
 	  /* change the scroll to show the new selected cel */
-	  anieditor_show_cel(widget, anieditor->clk_layer, sprite->frame);
+	  anieditor_show_cel(widget, anieditor->clk_layer, sprite->getCurrentFrame());
 	  jwidget_hard_capture_mouse(widget);
 	  anieditor->state = STATE_MOVING_LAYER;
 	  break;
@@ -368,16 +368,16 @@ static bool anieditor_msg_proc(JWidget widget, JMessage msg)
 	  break;
 	case A_PART_CEL: {
 	  const SpriteReader sprite((Sprite*)anieditor->sprite);
-	  int old_layer = anieditor_get_layer_index(widget, sprite->layer);
-	  int old_frame = sprite->frame;
+	  int old_layer = anieditor_get_layer_index(widget, sprite->getCurrentLayer());
+	  int old_frame = sprite->getCurrentFrame();
 
 	  /* select the new clicked-part */
 	  if (old_layer != anieditor->clk_layer ||
 	      old_frame != anieditor->clk_frame) {
 	    {
 	      SpriteWriter sprite_writer(sprite);
-	      sprite_writer->layer = anieditor->layers[anieditor->clk_layer];
-	      sprite_writer->frame = anieditor->clk_frame;
+	      sprite_writer->setCurrentLayer(anieditor->layers[anieditor->clk_layer]);
+	      sprite_writer->setCurrentFrame(anieditor->clk_frame);
 	    }
 
 	    jmouse_hide();
@@ -394,7 +394,7 @@ static bool anieditor_msg_proc(JWidget widget, JMessage msg)
 	  }
 
 	  /* change the scroll to show the new selected cel */
-	  anieditor_show_cel(widget, anieditor->clk_layer, sprite->frame);
+	  anieditor_show_cel(widget, anieditor->clk_layer, sprite->getCurrentFrame());
 
 	  /* capture the mouse (to move the cel) */
 	  jwidget_hard_capture_mouse(widget);
@@ -546,7 +546,7 @@ static bool anieditor_msg_proc(JWidget widget, JMessage msg)
 		const SpriteReader sprite((Sprite*)anieditor->sprite);
 
 		if (anieditor->hot_frame >= 0 &&
-		    anieditor->hot_frame < sprite->frames &&
+		    anieditor->hot_frame < sprite->getTotalFrames() &&
 		    anieditor->hot_frame != anieditor->clk_frame+1) {
 		  {
 		    SpriteWriter sprite_writer(sprite);
@@ -590,7 +590,7 @@ static bool anieditor_msg_proc(JWidget widget, JMessage msg)
 		    undoable.commit();
 
 		    /* select the new layer */
-		    sprite_writer->layer = anieditor->layers[anieditor->clk_layer];
+		    sprite_writer->setCurrentLayer(anieditor->layers[anieditor->clk_layer]);
 		  }
 		  catch (locked_sprite_exception& e) {
 		    e.show();
@@ -701,9 +701,9 @@ static bool anieditor_msg_proc(JWidget widget, JMessage msg)
       /* undo */
       if (command && strcmp(command->short_name(), CommandId::undo) == 0) {
 	const SpriteReader sprite((Sprite*)anieditor->sprite);
-	if (undo_can_undo(sprite->undo)) {
+	if (undo_can_undo(sprite->getUndo())) {
 	  SpriteWriter sprite_writer(sprite);
-	  undo_do_undo(sprite_writer->undo);
+	  undo_do_undo(sprite_writer->getUndo());
 
 	  destroy_thumbnails();
 	  anieditor_regenerate_layers(widget);
@@ -716,9 +716,9 @@ static bool anieditor_msg_proc(JWidget widget, JMessage msg)
       /* redo */
       if (command && strcmp(command->short_name(), CommandId::redo) == 0) {
 	const SpriteReader sprite((Sprite*)anieditor->sprite);
-	if (undo_can_redo(sprite->undo)) {
+	if (undo_can_redo(sprite->getUndo())) {
 	  SpriteWriter sprite_writer(sprite);
-	  undo_do_redo(sprite_writer->undo);
+	  undo_do_redo(sprite_writer->getUndo());
 
 	  destroy_thumbnails();
 	  anieditor_regenerate_layers(widget);
@@ -874,7 +874,7 @@ static void anieditor_get_drawable_frames(JWidget widget, JRect clip, int *first
   AniEditor* anieditor = anieditor_data(widget);
 
   *first_frame = 0;
-  *last_frame = anieditor->sprite->frames-1;
+  *last_frame = anieditor->sprite->getTotalFrames()-1;
 }
 
 static void anieditor_draw_header(JWidget widget, JRect clip)
@@ -923,7 +923,7 @@ static void anieditor_draw_header_frame(JWidget widget, JRect clip, int frame)
 
   /* draw the header for the layers */
   usprintf(buf1, "%d", frame+1);
-  usprintf(buf2, "%d", sprite_get_frlen(anieditor->sprite, frame));
+  usprintf(buf2, "%d", anieditor->sprite->getFrameDuration(frame));
   anieditor_draw_header_part(widget, clip, x1, y1, x2, y2,
 			     is_hot, is_clk,
 			     buf1, 0,
@@ -938,7 +938,7 @@ static void anieditor_draw_header_frame(JWidget widget, JRect clip, int frame)
   }
 
   /* padding in the right side */
-  if (frame == anieditor->sprite->frames-1) {
+  if (frame == anieditor->sprite->getTotalFrames()-1) {
     if (x2+1 <= widget->rc->x2-1) {
       /* right side */
       vline(ji_screen, x2+1, y1, y2, ji_color_foreground());
@@ -1025,7 +1025,7 @@ static void anieditor_draw_layer(JWidget widget, JRect clip, int layer_index)
   Layer *layer = anieditor->layers[layer_index];
   BITMAP *icon1 = get_gfx(layer->is_readable() ? GFX_BOX_SHOW: GFX_BOX_HIDE);
   BITMAP *icon2 = get_gfx(layer->is_writable() ? GFX_BOX_UNLOCK: GFX_BOX_LOCK);
-  bool selected_layer = (layer == anieditor->sprite->layer);
+  bool selected_layer = (layer == anieditor->sprite->getCurrentLayer());
   bool is_hot = (anieditor->hot_part == A_PART_LAYER && anieditor->hot_layer == layer_index);
   bool is_clk = (anieditor->clk_part == A_PART_LAYER && anieditor->clk_layer == layer_index);
   int bg = selected_layer ?
@@ -1144,7 +1144,7 @@ static void anieditor_draw_cel(JWidget widget, JRect clip, int layer_index, int
   SkinneableTheme* theme = static_cast<SkinneableTheme*>(widget->theme);
   AniEditor* anieditor = anieditor_data(widget);
   Layer *layer = anieditor->layers[layer_index];
-  bool selected_layer = (layer == anieditor->sprite->layer);
+  bool selected_layer = (layer == anieditor->sprite->getCurrentLayer());
   bool is_hot = (anieditor->hot_part == A_PART_CEL &&
 		 anieditor->hot_layer == layer_index &&
 		 anieditor->hot_frame == frame);
@@ -1176,7 +1176,7 @@ static void anieditor_draw_cel(JWidget widget, JRect clip, int layer_index, int
   Rect thumbnail_rect(Point(x1+3, y1+3), Point(x2-2, y2-2));
 
   /* draw the box for the cel */
-  if (selected_layer && frame == anieditor->sprite->frame) {
+  if (selected_layer && frame == anieditor->sprite->getCurrentFrame()) {
     /* current cel */
     if (is_hot)
       jrectedge(ji_screen, x1, y1, x2, y2-1,
@@ -1203,7 +1203,7 @@ static void anieditor_draw_cel(JWidget widget, JRect clip, int layer_index, int
 
   /* empty cel? */
   if (cel == NULL ||
-      stock_get_image(anieditor->sprite->stock,
+      stock_get_image(anieditor->sprite->getStock(),
 		      cel->image) == NULL) { /* TODO why a cel can't have an associated image? */
     jdraw_rectfill(thumbnail_rect, bg);
     draw_emptyset_symbol(thumbnail_rect, ji_color_disabled());
@@ -1236,7 +1236,7 @@ static void anieditor_draw_cel(JWidget widget, JRect clip, int layer_index, int
   }
 
   /* padding in the right side */
-  if (frame == anieditor->sprite->frames-1) {
+  if (frame == anieditor->sprite->getTotalFrames()-1) {
     if (x2+1 <= widget->rc->x2-1) {
       /* right side */
       vline(ji_screen, x2+1, y1, y2, ji_color_foreground());
@@ -1264,7 +1264,7 @@ static bool anieditor_draw_part(JWidget widget, int part, int layer, int frame)
       anieditor_draw_header(widget, widget->rc);
       return true;
     case A_PART_HEADER_FRAME:
-      if (frame >= 0 && frame < anieditor->sprite->frames) {
+      if (frame >= 0 && frame < anieditor->sprite->getTotalFrames()) {
 	anieditor_draw_header_frame(widget, widget->rc, frame);
 	return true;
       }
@@ -1279,7 +1279,7 @@ static bool anieditor_draw_part(JWidget widget, int part, int layer, int frame)
       break;
     case A_PART_CEL:
       if (layer >= 0 && layer < anieditor->nlayers &&
-	  frame >= 0 && frame < anieditor->sprite->frames) {
+	  frame >= 0 && frame < anieditor->sprite->getTotalFrames()) {
 	anieditor_draw_cel(widget, widget->rc, layer, frame);
 	return true;
       }
@@ -1299,15 +1299,14 @@ static void anieditor_regenerate_layers(JWidget widget)
     anieditor->layers = NULL;
   }
 
-  anieditor->nlayers = sprite_count_layers(anieditor->sprite);
+  anieditor->nlayers = anieditor->sprite->countLayers();
 
   /* here we build an array with all the layers */
   if (anieditor->nlayers > 0) {
     anieditor->layers = (Layer**)jmalloc(sizeof(Layer*) * anieditor->nlayers);
 
     for (c=0; c<anieditor->nlayers; c++)
-      anieditor->layers[c] = sprite_index2layer(anieditor->sprite,
-						anieditor->nlayers-c-1);
+      anieditor->layers[c] = (Layer*)anieditor->sprite->indexToLayer(anieditor->nlayers-c-1);
   }
 }
 
@@ -1391,9 +1390,9 @@ static void anieditor_show_cel(JWidget widget, int layer, int frame)
 static void anieditor_show_current_cel(JWidget widget)
 {
   AniEditor* anieditor = anieditor_data(widget);
-  int layer = anieditor_get_layer_index(widget, anieditor->sprite->layer);
+  int layer = anieditor_get_layer_index(widget, anieditor->sprite->getCurrentLayer());
   if (layer >= 0)
-    anieditor_show_cel(widget, layer, anieditor->sprite->frame);
+    anieditor_show_cel(widget, layer, anieditor->sprite->getCurrentFrame());
 }
 
 static void anieditor_clean_clk(JWidget widget)
@@ -1423,7 +1422,7 @@ static void anieditor_set_scroll(JWidget widget, int x, int y, bool use_refresh_
     old_scroll_y = anieditor->scroll_y;
   }
 
-  max_scroll_x = anieditor->sprite->frames * FRMSIZE - jrect_w(widget->rc)/2;
+  max_scroll_x = anieditor->sprite->getTotalFrames() * FRMSIZE - jrect_w(widget->rc)/2;
   max_scroll_y = anieditor->nlayers * LAYSIZE - jrect_h(widget->rc)/2;
   max_scroll_x = MAX(0, max_scroll_x);
   max_scroll_y = MAX(0, max_scroll_y);
@@ -1484,7 +1483,7 @@ static void anieditor_set_scroll(JWidget widget, int x, int y, bool use_refresh_
   }
 }
 
-static int anieditor_get_layer_index(JWidget widget, Layer* layer)
+static int anieditor_get_layer_index(JWidget widget, const Layer* layer)
 {
   AniEditor* anieditor = anieditor_data(widget);
   int i;

src/dialogs/drawtext.cpp

@@ -201,7 +201,7 @@ static Image *render_text(Sprite* sprite, FONT *f, const char *text, int color)
   clear_to_color(bmp, makecol32 (255, 0, 255));
   textout(bmp, f, text, 0, 0, makecol32 (255, 255, 255));
 
-  image = image_new(sprite->imgtype, w, h);
+  image = image_new(sprite->getImgType(), w, h);
   if (!image) {
     destroy_bitmap(bmp);
     return NULL;

src/dialogs/maskcol.cpp

@@ -48,7 +48,7 @@ static bool color_change_hook(JWidget widget, void *data);
 static bool slider_change_hook(JWidget widget, void *data);
 static bool preview_change_hook(JWidget widget, void *data);
 
-static Mask *gen_mask(Sprite* sprite);
+static Mask *gen_mask(const Sprite* sprite);
 static void mask_preview(Sprite* sprite);
 
 void dialogs_mask_color(Sprite* sprite)
@@ -62,7 +62,7 @@ void dialogs_mask_color(Sprite* sprite)
   if (!is_interactive () || !sprite)
     return;
 
-  image = GetImage(sprite);
+  image = sprite->getCurrentImage();
   if (!image)
     return;
 
@@ -75,7 +75,7 @@ void dialogs_mask_color(Sprite* sprite)
   button_color = colorbutton_new
    (get_config_color("MaskColor", "Color",
 		     colorbar_get_fg_color(app_get_colorbar())),
-    sprite->imgtype);
+    sprite->getImgType());
   button_1 = jbutton_new("1");
   button_2 = jbutton_new("2");
   label_fuzziness = jlabel_new(_("Fuzziness:"));
@@ -126,14 +126,14 @@ void dialogs_mask_color(Sprite* sprite)
     Mask *mask;
 
     /* undo */
-    if (undo_is_enabled(sprite->undo)) {
-      undo_set_label(sprite->undo, "Mask by Color");
-      undo_set_mask(sprite->undo, sprite);
+    if (undo_is_enabled(sprite->getUndo())) {
+      undo_set_label(sprite->getUndo(), "Mask by Color");
+      undo_set_mask(sprite->getUndo(), sprite);
     }
 
     /* change the mask */
     mask = gen_mask(sprite);
-    sprite_set_mask(sprite, mask);
+    sprite->setMask(mask);
     mask_free(mask);
 
     set_config_color("MaskColor", "Color",
@@ -147,7 +147,7 @@ void dialogs_mask_color(Sprite* sprite)
   }
 
   /* update boundaries and editors */
-  sprite_generate_mask_boundaries(sprite);
+  sprite->generateMaskBoundaries();
   update_screen_for_sprite(sprite);
 
   /* save window configuration */
@@ -186,13 +186,13 @@ static bool preview_change_hook(JWidget widget, void *data)
   return false;
 }
 
-static Mask *gen_mask(Sprite* sprite)
+static Mask *gen_mask(const Sprite* sprite)
 {
   int xpos, ypos, color, fuzziness;
 
-  Image* image = GetImage2(sprite, &xpos, &ypos, NULL);
+  const Image* image = sprite->getCurrentImage(&xpos, &ypos, NULL);
 
-  color = get_color_for_image(sprite->imgtype,
+  color = get_color_for_image(sprite->getImgType(),
 			      colorbutton_get_color(button_color));
   fuzziness = jslider_get_value(slider_fuzziness);
 
@@ -206,15 +206,11 @@ static Mask *gen_mask(Sprite* sprite)
 static void mask_preview(Sprite* sprite)
 {
   if (jwidget_is_selected(check_preview)) {
-    Mask *mask = gen_mask(sprite);
-    Mask *old_mask = sprite->mask;
+    Mask* mask = gen_mask(sprite);
 
-    sprite->mask = mask;
-
-    sprite_generate_mask_boundaries(sprite);
+    sprite->generateMaskBoundaries(mask);
     update_screen_for_sprite(sprite);
 
-    sprite->mask = old_mask;
     mask_free(mask);
   }
 }

src/dialogs/vectmap.cpp

@@ -133,7 +133,7 @@ void dialogs_vector_map(Sprite* sprite)
   if (!is_interactive () || !sprite)
     return;
 
-  image = GetImage(sprite);
+  image = sprite->getCurrentImage();
   if (!image)
     return;
 
@@ -142,8 +142,8 @@ void dialogs_vector_map(Sprite* sprite)
     return;
 
   /* undo stuff */
-  if (undo_is_enabled(sprite->undo))
-    undo_image(sprite->undo, image, 0, 0, image->w, image->h);
+  if (undo_is_enabled(sprite->getUndo()))
+    undo_image(sprite->getUndo(), image, 0, 0, image->w, image->h);
 
   dmax = std::sqrt(static_cast<double>(image->w/2*image->w/2 + image->h/2*image->h/2));
   for (y=0; y<image->h; y++) {

src/effect/convmatr.cpp

@@ -332,11 +332,11 @@ JList get_convmatr_stock()
 
 void apply_convolution_matrix4(Effect *effect)
 {
-  ConvMatr *matrix = data.convmatr;
-  Image *src = effect->src;
-  Image *dst = effect->dst;
-  ase_uint32 *src_address;
-  ase_uint32 *dst_address;
+  ConvMatr* matrix = data.convmatr;
+  const Image* src = effect->src;
+  Image* dst = effect->dst;
+  ase_uint32* src_address;
+  ase_uint32* dst_address;
   int x, y, dx, dy, color;
   int getx, gety, addx, addy;
   int r, g, b, a;
@@ -409,11 +409,11 @@ void apply_convolution_matrix4(Effect *effect)
 
 void apply_convolution_matrix2(Effect *effect)
 {
-  ConvMatr *matrix = data.convmatr;
-  Image *src = effect->src;
-  Image *dst = effect->dst;
-  ase_uint16 *src_address;
-  ase_uint16 *dst_address;
+  ConvMatr* matrix = data.convmatr;
+  const Image* src = effect->src;
+  Image* dst = effect->dst;
+  ase_uint16* src_address;
+  ase_uint16* dst_address;
   int x, y, dx, dy, color;
   int getx, gety, addx, addy;
   int k, a;
@@ -470,12 +470,12 @@ void apply_convolution_matrix2(Effect *effect)
 
 void apply_convolution_matrix1(Effect *effect)
 {
-  Palette *pal = get_current_palette();
-  ConvMatr *matrix = data.convmatr;
-  Image *src = effect->src;
-  Image *dst = effect->dst;
-  ase_uint8 *src_address;
-  ase_uint8 *dst_address;
+  Palette* pal = get_current_palette();
+  ConvMatr* matrix = data.convmatr;
+  const Image* src = effect->src;
+  Image* dst = effect->dst;
+  ase_uint8* src_address;
+  ase_uint8* dst_address;
   int x, y, dx, dy, color;
   int getx, gety, addx, addy;
   int r, g, b, index;

src/effect/effect.cpp

@@ -69,9 +69,9 @@ static EffectData effects_data[] = {
 };
 
 static EffectData *get_effect_data(const char *name);
-static void effect_init(Effect *effect, Layer *layer, Image *image, int offset_x, int offset_y);
+static void effect_init(Effect* effect, const Layer* layer, Image* image, int offset_x, int offset_y);
 static void effect_apply_to_image(Effect *effect, ImageRef *p, int x, int y);
-static bool effect_update_mask(Effect *effect, Mask *mask, Image *image);
+static bool effect_update_mask(Effect* effect, Mask* mask, const Image* image);
 
 int init_module_effect()
 {
@@ -88,13 +88,12 @@ Effect::Effect(const SpriteReader& sprite, const char* name)
 {
   int offset_x, offset_y;
   EffectData* effect_data;
-  Image* image;
   void (*apply)(Effect*);
 
   effect_data = get_effect_data(name);
 
   apply = NULL;
-  switch (sprite->imgtype) {
+  switch (sprite->getImgType()) {
     case IMAGE_RGB:       apply = effect_data->apply_4; break;
     case IMAGE_GRAYSCALE: apply = effect_data->apply_2; break;
     case IMAGE_INDEXED:   apply = effect_data->apply_1; break;
@@ -119,11 +118,11 @@ Effect::Effect(const SpriteReader& sprite, const char* name)
   this->progress = NULL;
   this->is_cancelled = NULL;
 
-  image = GetImage2(sprite, &offset_x, &offset_y, NULL);
+  Image* image = this->sprite->getCurrentImage(&offset_x, &offset_y);
   if (image == NULL)
     throw no_image_exception();
 
-  effect_init(this, sprite->layer, image, offset_x, offset_y);
+  effect_init(this, sprite->getCurrentLayer(), image, offset_x, offset_y);
 }
 
 Effect::~Effect()
@@ -141,15 +140,15 @@ void effect_set_target(Effect *effect, int target)
   effect->target = target;
 
   /* the alpha channel of the background layer can't be modified */
-  if (effect->sprite->layer &&
-      effect->sprite->layer->is_background())
+  if (effect->sprite->getCurrentLayer() &&
+      effect->sprite->getCurrentLayer()->is_background())
     effect->target &= ~TARGET_ALPHA_CHANNEL;
 }
 
 void effect_begin(Effect *effect)
 {
   effect->row = 0;
-  effect->mask = effect->sprite->mask;
+  effect->mask = effect->sprite->getMask();
 
   effect_update_mask(effect, effect->mask, effect->src);
 }
@@ -161,8 +160,8 @@ void effect_begin_for_preview(Effect *effect)
     effect->preview_mask = NULL;
   }
 
-  if ((effect->sprite->mask) && (effect->sprite->mask->bitmap))
-    effect->preview_mask = mask_new_copy(effect->sprite->mask);
+  if ((effect->sprite->getMask()) && (effect->sprite->getMask()->bitmap))
+    effect->preview_mask = mask_new_copy(effect->sprite->getMask());
   else {
     effect->preview_mask = mask_new();
     mask_replace(effect->preview_mask,
@@ -186,8 +185,8 @@ void effect_begin_for_preview(Effect *effect)
 
     if (x1 < 0) x1 = 0;
     if (y1 < 0) y1 = 0;
-    if (x2 >= effect->sprite->w) x2 = effect->sprite->w-1;
-    if (y2 >= effect->sprite->h) y2 = effect->sprite->h-1;
+    if (x2 >= effect->sprite->getWidth()) x2 = effect->sprite->getWidth()-1;
+    if (y2 >= effect->sprite->getHeight()) y2 = effect->sprite->getHeight()-1;
 
     x = x1;
     y = y1;
@@ -233,7 +232,7 @@ bool effect_apply_step(Effect *effect)
   }
 }
 
-void effect_apply(Effect *effect)
+void effect_apply(Effect* effect)
 {
   bool cancelled = false;
 
@@ -249,15 +248,15 @@ void effect_apply(Effect *effect)
   }
 
   if (!cancelled) {
-    /* undo stuff */
-    if (undo_is_enabled(effect->sprite->undo)) {
-      undo_set_label(effect->sprite->undo,
+    // Undo stuff
+    if (undo_is_enabled(effect->sprite->getUndo())) {
+      undo_set_label(effect->sprite->getUndo(),
 		     effect->effect_data->label);
-      undo_image(effect->sprite->undo, effect->src,
+      undo_image(effect->sprite->getUndo(), effect->src,
 		 effect->x, effect->y, effect->w, effect->h);
     }
 
-    /* copy "dst" to "src" */
+    // Copy "dst" to "src"
     image_copy(effect->src, effect->dst, 0, 0);
   }
 }
@@ -310,8 +309,8 @@ void effect_apply_to_target(Effect *effect)
 
   /* open undo group of operations */
   if (nimages > 1) {
-    if (undo_is_enabled(effect->sprite->undo))
-      undo_open(effect->sprite->undo);
+    if (undo_is_enabled(effect->sprite->getUndo()))
+      undo_open(effect->sprite->getUndo());
   }
   
   effect->progress_base = 0.0f;
@@ -331,8 +330,8 @@ void effect_apply_to_target(Effect *effect)
 
   /* close undo group of operations */
   if (nimages > 1) {
-    if (undo_is_enabled(effect->sprite->undo))
-      undo_close(effect->sprite->undo);
+    if (undo_is_enabled(effect->sprite->getUndo()))
+      undo_close(effect->sprite->getUndo());
   }
 
   /* free all ImageRefs */
@@ -351,13 +350,13 @@ static EffectData *get_effect_data(const char *name)
   throw invalid_effect_exception(name);
 }
 
-static void effect_init(Effect *effect, Layer *layer, Image *image,
+static void effect_init(Effect* effect, const Layer* layer, Image* image,
 			int offset_x, int offset_y)
 {
   effect->offset_x = offset_x;
   effect->offset_y = offset_y;
 
-  if (!effect_update_mask(effect, effect->sprite->mask, image))
+  if (!effect_update_mask(effect, effect->sprite->getMask(), image))
     throw invalid_area_exception();
 
   if (effect->preview_mask) {
@@ -384,13 +383,13 @@ static void effect_init(Effect *effect, Layer *layer, Image *image,
     effect->target &= ~TARGET_ALPHA_CHANNEL;
 }
 
-static void effect_apply_to_image(Effect *effect, ImageRef *p, int x, int y)
+static void effect_apply_to_image(Effect* effect, ImageRef* p, int x, int y)
 {
   effect_init(effect, p->layer, p->image, x, y);
   effect_apply(effect);
 }
 
-static bool effect_update_mask(Effect *effect, Mask *mask, Image *image)
+static bool effect_update_mask(Effect* effect, Mask* mask, const Image* image)
 {
   int x, y, w, h;
 

src/effect/images_ref.cpp

@@ -35,8 +35,8 @@ static ImageRef* images_ref_get_from_layer(Sprite* sprite, Layer* layer, int tar
 
 ImageRef* images_ref_get_from_sprite(Sprite* sprite, int target, bool write)
 {
-  Layer* layer = target & TARGET_ALL_LAYERS ? sprite->get_folder():
-					      sprite->layer;
+  Layer* layer = target & TARGET_ALL_LAYERS ? sprite->getFolder():
+					      sprite->getCurrentLayer();
 
   return images_ref_get_from_layer(sprite, layer, target, write);
 }
@@ -72,7 +72,7 @@ static ImageRef* images_ref_get_from_layer(Sprite* sprite, Layer* layer, int tar
   {								\
     ImageRef* image_ref = jnew(ImageRef, 1);			\
 								\
-    image_ref->image = layer->getSprite()->stock->image[cel->image];	\
+    image_ref->image = layer->getSprite()->getStock()->image[cel->image]; \
     image_ref->layer = layer;					\
     image_ref->cel = cel;					\
     image_ref->next = NULL;					\
@@ -82,7 +82,7 @@ static ImageRef* images_ref_get_from_layer(Sprite* sprite, Layer* layer, int tar
   
   ImageRef* first_image = NULL;
   ImageRef* last_image = NULL;
-  int frame = sprite->frame;
+  int frame = sprite->getCurrentFrame();
 
   if (!layer->is_readable())
     return NULL;
@@ -94,7 +94,7 @@ static ImageRef* images_ref_get_from_layer(Sprite* sprite, Layer* layer, int tar
 
     case GFXOBJ_LAYER_IMAGE: {
       if (target & TARGET_ALL_FRAMES) {
-	for (frame=0; frame<sprite->frames; frame++) {
+	for (frame=0; frame<sprite->getTotalFrames(); frame++) {
 	  Cel* cel = static_cast<LayerImage*>(layer)->get_cel(frame);
 	  if (cel != NULL)
 	    NEW_IMAGE(layer, cel);

src/file/ase_format.cpp

@@ -74,9 +74,9 @@ static int chunk_start;
 static bool load_ASE(FileOp *fop);
 static bool save_ASE(FileOp *fop);
 
-static bool ase_file_read_header(FILE *f, ASE_Header *header);
-static void ase_file_prepare_header(FILE *f, ASE_Header *header, Sprite *sprite);
-static void ase_file_write_header(FILE *f, ASE_Header *header);
+static bool ase_file_read_header(FILE* f, ASE_Header* header);
+static void ase_file_prepare_header(FILE* f, ASE_Header* header, const Sprite* sprite);
+static void ase_file_write_header(FILE* f, ASE_Header* header);
 
 static void ase_file_read_frame_header(FILE *f, ASE_FrameHeader *frame_header);
 static void ase_file_prepare_frame_header(FILE *f, ASE_FrameHeader *frame_header);
@@ -156,15 +156,15 @@ static bool load_ASE(FileOp *fop)
   }
 
   /* set frames and speed */
-  sprite_set_frames(sprite, header.frames);
-  sprite_set_speed(sprite, header.speed);
+  sprite->setTotalFrames(header.frames);
+  sprite->setDurationForAllFrames(header.speed);
 
   /* prepare variables for layer chunks */
-  Layer* last_layer = sprite->get_folder();
+  Layer* last_layer = sprite->getFolder();
   current_level = -1;
 
   /* read frame by frame to end-of-file */
-  for (frame=0; frame<sprite->frames; frame++) {
+  for (frame=0; frame<sprite->getTotalFrames(); frame++) {
     /* start frame position */
     frame_pos = ftell(f);
     fop_progress(fop, (float)frame_pos / (float)header.size);
@@ -176,7 +176,7 @@ static bool load_ASE(FileOp *fop)
     if (frame_header.magic == ASE_FILE_FRAME_MAGIC) {
       /* use frame-duration field? */
       if (frame_header.duration > 0)
-	sprite_set_frlen(sprite, frame, frame_header.duration);
+	sprite->setFrameDuration(frame, frame_header.duration);
 
       /* read chunks */
       for (c=0; c<frame_header.chunks; c++) {
@@ -195,15 +195,15 @@ static bool load_ASE(FileOp *fop)
 	  case ASE_FILE_CHUNK_FLI_COLOR2:
 	    /* fop_error(fop, "Color chunk\n"); */
 
-	    if (sprite->imgtype == IMAGE_INDEXED) {
-	      Palette *prev_pal = sprite_get_palette(sprite, frame);
+	    if (sprite->getImgType() == IMAGE_INDEXED) {
+	      Palette *prev_pal = sprite->getPalette(frame);
 	      Palette *pal =
 		chunk_type == ASE_FILE_CHUNK_FLI_COLOR ? 
 		ase_file_read_color_chunk(f, sprite, frame):
 		ase_file_read_color2_chunk(f, sprite, frame);
 
 	      if (prev_pal->countDiff(pal, NULL, NULL) > 0) {
-		sprite_set_palette(sprite, pal, true);
+		sprite->setPalette(pal, true);
 	      }
 
 	      delete pal;
@@ -225,7 +225,7 @@ static bool load_ASE(FileOp *fop)
 	    /* fop_error(fop, "Cel chunk\n"); */
 
 	    ase_file_read_cel_chunk(f, sprite, frame,
-				    sprite->imgtype, fop, &header,
+				    sprite->getImgType(), fop, &header,
 				    chunk_pos+chunk_size);
 	    break;
 	  }
@@ -237,7 +237,7 @@ static bool load_ASE(FileOp *fop)
 
 	    mask = ase_file_read_mask_chunk(f);
 	    if (mask)
-	      sprite_add_mask(sprite, mask);
+	      sprite->addMask(mask);
 	    else
 	      fop_error(fop, _("Warning: error loading a mask chunk\n"));
 
@@ -299,44 +299,45 @@ static bool save_ASE(FileOp *fop)
   ase_file_prepare_header(f, &header, sprite);
 
   /* write frame */
-  for (frame=0; frame<sprite->frames; frame++) {
+  for (frame=0; frame<sprite->getTotalFrames(); frame++) {
     /* prepare the header */
     ase_file_prepare_frame_header(f, &frame_header);
 
     /* frame duration */
-    frame_header.duration = sprite_get_frlen(sprite, frame);
+    frame_header.duration = sprite->getFrameDuration(frame);
 
     /* the sprite is indexed and the palette changes? (or is the first frame) */
-    if (sprite->imgtype == IMAGE_INDEXED &&
+    if (sprite->getImgType() == IMAGE_INDEXED &&
 	(frame == 0 ||
-	 sprite_get_palette(sprite, frame-1)->countDiff(sprite_get_palette(sprite, frame), NULL, NULL) > 0)) {
+	 sprite->getPalette(frame-1)->countDiff(sprite->getPalette(frame), NULL, NULL) > 0)) {
       /* write the color chunk */
-      ase_file_write_color2_chunk(f, sprite_get_palette(sprite, frame));
+      ase_file_write_color2_chunk(f, sprite->getPalette(frame));
     }
 
     /* write extra chunks in the first frame */
     if (frame == 0) {
-      LayerIterator it = sprite->get_folder()->get_layer_begin();
-      LayerIterator end = sprite->get_folder()->get_layer_end();
+      LayerIterator it = sprite->getFolder()->get_layer_begin();
+      LayerIterator end = sprite->getFolder()->get_layer_end();
 
       /* write layer chunks */
       for (; it != end; ++it)
 	ase_file_write_layers(f, *it);
 
       /* write masks */
-      JI_LIST_FOR_EACH(sprite->repository.masks, link)
+      JList masks = sprite->getMasksRepository();
+      JI_LIST_FOR_EACH(masks, link)
 	ase_file_write_mask_chunk(f, reinterpret_cast<Mask*>(link->data));
     }
 
     /* write cel chunks */
-    ase_file_write_cels(f, sprite, sprite->get_folder(), frame);
+    ase_file_write_cels(f, sprite, sprite->getFolder(), frame);
 
     /* write the frame header */
     ase_file_write_frame_header(f, &frame_header);
 
     /* progress */
-    if (sprite->frames > 1)
-      fop_progress(fop, (float)(frame+1) / (float)(sprite->frames));
+    if (sprite->getTotalFrames() > 1)
+      fop_progress(fop, (float)(frame+1) / (float)(sprite->getTotalFrames()));
   }
 
   /* write the header */
@@ -379,24 +380,24 @@ static bool ase_file_read_header(FILE *f, ASE_Header *header)
   return true;
 }
 
-static void ase_file_prepare_header(FILE *f, ASE_Header *header, Sprite *sprite)
+static void ase_file_prepare_header(FILE *f, ASE_Header *header, const Sprite* sprite)
 {
   header->pos = ftell(f);
 
   header->size = 0;
   header->magic = ASE_FILE_MAGIC;
-  header->frames = sprite->frames;
-  header->width = sprite->w;
-  header->height = sprite->h;
-  header->depth = sprite->imgtype == IMAGE_RGB ? 32:
-		  sprite->imgtype == IMAGE_GRAYSCALE ? 16:
-                  sprite->imgtype == IMAGE_INDEXED ? 8: 0;
+  header->frames = sprite->getTotalFrames();
+  header->width = sprite->getWidth();
+  header->height = sprite->getHeight();
+  header->depth = (sprite->getImgType() == IMAGE_RGB ? 32:
+		   sprite->getImgType() == IMAGE_GRAYSCALE ? 16:
+		   sprite->getImgType() == IMAGE_INDEXED ? 8: 0);
   header->flags = 0;
-  header->speed = sprite_get_frlen(sprite, 0);
+  header->speed = sprite->getFrameDuration(0);
   header->next = 0;
   header->frit = 0;
   header->unknown = 0;
-  header->ncolors = sprite_get_palette(sprite, 0)->size();
+  header->ncolors = sprite->getPalette(0)->size();
 
   fseek(f, header->pos+128, SEEK_SET);
 }
@@ -560,7 +561,7 @@ static Palette *ase_file_read_color_chunk(FILE *f, Sprite *sprite, int frame)
 {
   int i, c, r, g, b, packets, skip, size;
   Palette* pal = new Palette(frame, 256);
-  sprite_get_palette(sprite, frame)->copyColorsTo(pal);
+  sprite->getPalette(frame)->copyColorsTo(pal);
 
   packets = fgetw(f);	// Number of packets
   skip = 0;
@@ -588,7 +589,7 @@ static Palette *ase_file_read_color2_chunk(FILE *f, Sprite *sprite, int frame)
 {
   int i, c, r, g, b, packets, skip, size;
   Palette* pal = new Palette(frame, 256);
-  sprite_get_palette(sprite, frame)->copyColorsTo(pal);
+  sprite->getPalette(frame)->copyColorsTo(pal);
 
   packets = fgetw(f);	/* number of packets */
   skip = 0;
@@ -994,7 +995,7 @@ static Cel *ase_file_read_cel_chunk(FILE *f, Sprite *sprite, int frame, int imgt
 
   ase_file_read_padding(f, 7);
 
-  layer = sprite_index2layer(sprite, layer_index);
+  layer = sprite->indexToLayer(layer_index);
   if (!layer) {
     fop_error(fop, _("Frame %d didn't found layer with index %d\n"),
 	      frame, layer_index);
@@ -1042,7 +1043,7 @@ static Cel *ase_file_read_cel_chunk(FILE *f, Sprite *sprite, int frame, int imgt
 	    break;
 	}
 
-	cel->image = stock_add_image(sprite->stock, image);
+	cel->image = stock_add_image(sprite->getStock(), image);
       }
       break;
     }
@@ -1054,8 +1055,8 @@ static Cel *ase_file_read_cel_chunk(FILE *f, Sprite *sprite, int frame, int imgt
 
       if (link) {
 	// Create a copy of the linked cel (avoid using links cel)
-	Image* image = image_new_copy(stock_get_image(sprite->stock, link->image));
-	cel->image = stock_add_image(sprite->stock, image);
+	Image* image = image_new_copy(stock_get_image(sprite->getStock(), link->image));
+	cel->image = stock_add_image(sprite->getStock(), image);
       }
       else {
 	cel_free(cel);
@@ -1094,7 +1095,7 @@ static Cel *ase_file_read_cel_chunk(FILE *f, Sprite *sprite, int frame, int imgt
 	    break;
 	}
 
-	cel->image = stock_add_image(sprite->stock, image);
+	cel->image = stock_add_image(sprite->getStock(), image);
       }
       break;
     }
@@ -1107,7 +1108,7 @@ static Cel *ase_file_read_cel_chunk(FILE *f, Sprite *sprite, int frame, int imgt
 
 static void ase_file_write_cel_chunk(FILE *f, Cel *cel, LayerImage *layer, Sprite *sprite)
 {
-  int layer_index = sprite_layer2index(sprite, layer);
+  int layer_index = sprite->layerToIndex(layer);
   int cel_type = ASE_FILE_COMPRESSED_CEL;
 
   ase_file_write_start_chunk(f, ASE_FILE_CHUNK_CEL);
@@ -1122,7 +1123,7 @@ static void ase_file_write_cel_chunk(FILE *f, Cel *cel, LayerImage *layer, Sprit
   switch (cel_type) {
 
     case ASE_FILE_RAW_CEL: {
-      Image* image = stock_get_image(sprite->stock, cel->image);
+      Image* image = stock_get_image(sprite->getStock(), cel->image);
 
       if (image) {
 	// Width and height
@@ -1160,7 +1161,7 @@ static void ase_file_write_cel_chunk(FILE *f, Cel *cel, LayerImage *layer, Sprit
       break;
 
     case ASE_FILE_COMPRESSED_CEL: {
-      Image* image = stock_get_image(sprite->stock, cel->image);
+      Image* image = stock_get_image(sprite->getStock(), cel->image);
 
       if (image) {
 	// Width and height

src/file/file.cpp

@@ -70,7 +70,7 @@ static void fop_prepare_for_sequence(FileOp *fop);
 static FileFormat *get_fileformat(const char *extension);
 static int split_filename(const char *filename, char *left, char *right, int *width);
 
-void get_readable_extensions(char *buf, int size)
+void get_readable_extensions(char* buf, int size)
 {
   int c;
 
@@ -87,7 +87,7 @@ void get_readable_extensions(char *buf, int size)
   }
 }
 
-void get_writable_extensions(char *buf, int size)
+void get_writable_extensions(char* buf, int size)
 {
   int c;
 
@@ -260,10 +260,10 @@ FileOp *fop_to_save_sprite(Sprite *sprite)
   fop->sprite = sprite;
 
   /* get the extension of the filename (in lower case) */
-  ustrcpy(extension, get_extension(fop->sprite->filename));
+  ustrcpy(extension, get_extension(fop->sprite->getFilename()));
   ustrlwr(extension);
 
-  PRINTF("Saving sprite \"%s\" (%s)\n", fop->sprite->filename, extension);
+  PRINTF("Saving sprite \"%s\" (%s)\n", fop->sprite->getFilename(), extension);
 
   /* get the format through the extension of the filename */
   fop->format = get_fileformat(extension);
@@ -278,7 +278,7 @@ FileOp *fop_to_save_sprite(Sprite *sprite)
   fatal = false;
 
   /* check image type support */
-  switch (fop->sprite->imgtype) {
+  switch (fop->sprite->getImgType()) {
 
     case IMAGE_RGB:
       if (!(fop->format->flags & FILE_SUPPORT_RGB)) {
@@ -286,7 +286,7 @@ FileOp *fop_to_save_sprite(Sprite *sprite)
 	fatal = true;
       }
       if (!(fop->format->flags & FILE_SUPPORT_RGBA) &&
-	  sprite_need_alpha(fop->sprite)) {
+	  fop->sprite->needAlpha()) {
 	usprintf(buf+ustrlen(buf), "<<- %s", _("Alpha channel"));
       }
       break;
@@ -297,7 +297,7 @@ FileOp *fop_to_save_sprite(Sprite *sprite)
 	fatal = true;
       }
       if (!(fop->format->flags & FILE_SUPPORT_GRAYA) &&
-	  sprite_need_alpha(fop->sprite)) {
+	  fop->sprite->needAlpha()) {
 	usprintf(buf+ustrlen(buf), "<<- %s", _("Alpha channel"));
       }
       break;
@@ -313,19 +313,19 @@ FileOp *fop_to_save_sprite(Sprite *sprite)
   // check frames support
   if (!(fop->format->flags & (FILE_SUPPORT_FRAMES |
 			      FILE_SUPPORT_SEQUENCES))) {
-    if (fop->sprite->frames > 1)
+    if (fop->sprite->getTotalFrames() > 1)
       usprintf(buf+ustrlen(buf), "<<- %s", _("Frames"));
   }
 
   // layers support
-  if (fop->sprite->get_folder()->get_layers_count() > 1) {
+  if (fop->sprite->getFolder()->get_layers_count() > 1) {
     if (!(fop->format->flags & FILE_SUPPORT_LAYERS)) {
       usprintf(buf+ustrlen(buf), "<<- %s", _("Layers"));
     }
   }
 
   /* palettes support */
-  if (jlist_length(fop->sprite->palettes) > 1) {
+  if (jlist_length(fop->sprite->getPalettes()) > 1) {
     if (!(fop->format->flags & (FILE_SUPPORT_PALETTES |
 				FILE_SUPPORT_SEQUENCES))) {
       usprintf(buf+ustrlen(buf), "<<- %s", _("Palette changes between frames"));
@@ -333,15 +333,16 @@ FileOp *fop_to_save_sprite(Sprite *sprite)
   }
 
   /* repositories */
-  if (!jlist_empty(fop->sprite->repository.masks)) {
+  JList masks = fop->sprite->getMasksRepository();
+  if (!jlist_empty(masks)) {
     Mask *mask;
     JLink link;
     int count = 0;
 
-    JI_LIST_FOR_EACH(fop->sprite->repository.masks, link) {
+    JI_LIST_FOR_EACH(masks, link) {
       mask = reinterpret_cast<Mask*>(link->data);
 
-      /* names starting with '*' are ignored */
+      // Names starting with '*' are ignored
       if (mask->name && *mask->name == '*')
 	continue;
 
@@ -353,7 +354,7 @@ FileOp *fop_to_save_sprite(Sprite *sprite)
     }
   }
 
-  if (!jlist_empty(fop->sprite->repository.paths)) {
+  if (!jlist_empty(fop->sprite->getPathsRepository())) {
     if (!(fop->format->flags & FILE_SUPPORT_PATHS_REPOSITORY)) {
       usprintf(buf+ustrlen(buf), "<<- %s", _("Path Repository"));
     }
@@ -394,25 +395,25 @@ FileOp *fop_to_save_sprite(Sprite *sprite)
     fop_prepare_for_sequence(fop);
 
     /* to save one frame */
-    if (fop->sprite->frames == 1) {
+    if (fop->sprite->getTotalFrames() == 1) {
       jlist_append(fop->seq.filename_list,
-		   jstrdup(fop->sprite->filename));
+		   jstrdup(fop->sprite->getFilename()));
     }
     /* to save more frames */
     else {
       char buf[256], left[256], right[256];
       int frame, width, start_from;
 
-      start_from = split_filename(fop->sprite->filename, left, right, &width);
+      start_from = split_filename(fop->sprite->getFilename(), left, right, &width);
       if (start_from < 0) {
 	start_from = 0;
 	width =
-	  (fop->sprite->frames < 10)? 1:
-	  (fop->sprite->frames < 100)? 2:
-	  (fop->sprite->frames < 1000)? 3: 4;
+	  (fop->sprite->getTotalFrames() < 10)? 1:
+	  (fop->sprite->getTotalFrames() < 100)? 2:
+	  (fop->sprite->getTotalFrames() < 1000)? 3: 4;
       }
 
-      for (frame=0; frame<fop->sprite->frames; frame++) {
+      for (frame=0; frame<fop->sprite->getTotalFrames(); frame++) {
 	/* get the name for this frame */
 	usprintf(buf, "%s%0*d%s", left, width, start_from+frame, right);
 	jlist_append(fop->seq.filename_list, jstrdup(buf));
@@ -420,7 +421,7 @@ FileOp *fop_to_save_sprite(Sprite *sprite)
     }
   }
   else
-    fop->filename = jstrdup(fop->sprite->filename);
+    fop->filename = jstrdup(fop->sprite->getFilename());
 
   /* configure output format? */
   if (fop->format->get_options != NULL) {
@@ -433,8 +434,7 @@ FileOp *fop_to_save_sprite(Sprite *sprite)
     }
 
     fop->seq.format_options = format_options;
-    sprite_set_format_options(fop->sprite,
-			      format_options);
+    fop->sprite->setFormatOptions(format_options);
   }
 
   return fop;
@@ -470,16 +470,16 @@ void fop_operate(FileOp *fop)
        /* TODO set_palette for each frame??? */
 #define SEQUENCE_IMAGE()						\
       do {								\
-	image_index = stock_add_image(fop->sprite->stock,		\
+	image_index = stock_add_image(fop->sprite->getStock(),		\
 				      fop->seq.image);			\
 									\
 	fop->seq.last_cel->image = image_index;				\
 	fop->seq.layer->add_cel(fop->seq.last_cel);			\
 									\
-	if (sprite_get_palette(fop->sprite, frame)			\
+	if (fop->sprite->getPalette(frame)				\
 	      ->countDiff(fop->seq.palette, NULL, NULL) > 0) {		\
 	  fop->seq.palette->setFrame(frame);				\
-	  sprite_set_palette(fop->sprite, fop->seq.palette, true);	\
+	  fop->sprite->setPalette(fop->seq.palette, true);		\
 	}								\
 									\
 	old_image = fop->seq.image;					\
@@ -560,18 +560,17 @@ void fop_operate(FileOp *fop)
       }
       fop->filename = jstrdup((char*)jlist_first_data(fop->seq.filename_list));
 
-      /* final setup */
+      // Final setup
       if (fop->sprite != NULL) {
-	/* configure the layer as the `Background' */
+	// Configure the layer as the 'Background'
 	if (!fop->seq.has_alpha)
 	  fop->seq.layer->configure_as_background();
 
-	/* set the frames range */
-	sprite_set_frames(fop->sprite, frame);
+	// Set the frames range
+	fop->sprite->setTotalFrames(frame);
 
-	/* set the frames range */
-	sprite_set_format_options(fop->sprite,
-				  fop->seq.format_options);
+	// Set the frames range
+	fop->sprite->setFormatOptions(fop->seq.format_options);
       }
     }
     /* direct load from one file */
@@ -584,19 +583,18 @@ void fop_operate(FileOp *fop)
 
     if (fop->sprite != NULL) {
       /* select the last layer */
-      if (fop->sprite->get_folder()->get_layers_count() > 0) {
-	LayerIterator last_layer = --fop->sprite->get_folder()->get_layer_end();
-	sprite_set_layer(fop->sprite, *last_layer);
+      if (fop->sprite->getFolder()->get_layers_count() > 0) {
+	LayerIterator last_layer = --fop->sprite->getFolder()->get_layer_end();
+	fop->sprite->setCurrentLayer(*last_layer);
       }
 
       /* set the filename */
       if (fop->seq.filename_list)
-	sprite_set_filename(fop->sprite,
-			    reinterpret_cast<char*>(jlist_first_data(fop->seq.filename_list)));
+	fop->sprite->setFilename(reinterpret_cast<char*>(jlist_first_data(fop->seq.filename_list)));
       else
-	sprite_set_filename(fop->sprite, fop->filename);
+	fop->sprite->setFilename(fop->filename);
 
-      sprite_mark_as_saved(fop->sprite);
+      fop->sprite->markAsSaved();
     }
   }
   /* save ***********************************************************/
@@ -608,36 +606,36 @@ void fop_operate(FileOp *fop)
       assert(fop->format->flags & FILE_SUPPORT_SEQUENCES);
 
       /* create a temporary bitmap */
-      fop->seq.image = image_new(fop->sprite->imgtype,
-				 fop->sprite->w,
-				 fop->sprite->h);
+      fop->seq.image = image_new(fop->sprite->getImgType(),
+				 fop->sprite->getWidth(),
+				 fop->sprite->getHeight());
       if (fop->seq.image != NULL) {
-	int old_frame = fop->sprite->frame;
+	int old_frame = fop->sprite->getCurrentFrame();
 
 	fop->seq.progress_offset = 0.0f;
-	fop->seq.progress_fraction = 1.0f / (float)fop->sprite->frames;
+	fop->seq.progress_fraction = 1.0f / (float)fop->sprite->getTotalFrames();
 
 	/* for each frame in the sprite */
-	for (fop->sprite->frame=0;
-	     fop->sprite->frame<fop->sprite->frames;
-	     fop->sprite->frame++) {
+	for (int frame=0; frame < fop->sprite->getTotalFrames(); ++frame) {
+	  fop->sprite->setCurrentFrame(frame);
+
 	  /* draw all the sprite in this frame in the image */
 	  image_clear(fop->seq.image, 0);
-	  sprite_render(fop->sprite, fop->seq.image, 0, 0);
+	  fop->sprite->render(fop->seq.image, 0, 0);
 
 	  /* setup the palette */
-	  sprite_get_palette(fop->sprite, fop->sprite->frame)
+	  fop->sprite->getPalette(fop->sprite->getCurrentFrame())
 	    ->copyColorsTo(fop->seq.palette);
 
 	  /* setup the filename to be used */
 	  fop->filename = reinterpret_cast<char*>
 	    (jlist_nth_data(fop->seq.filename_list,
-			    fop->sprite->frame));
+			    fop->sprite->getCurrentFrame()));
 
 	  /* call the "save" procedure... did it fail? */
 	  if (!(*fop->format->save)(fop)) {
 	    fop_error(fop, _("Error saving frame %d in the file \"%s\"\n"),
-		      fop->sprite->frame+1, fop->filename);
+		      fop->sprite->getCurrentFrame()+1, fop->filename);
 	    break;
 	  }
 
@@ -645,11 +643,11 @@ void fop_operate(FileOp *fop)
 	}
 	fop->filename = jstrdup(reinterpret_cast<char*>(jlist_first_data(fop->seq.filename_list)));
 
-	/* destroy the image */
+	// Destroy the image
 	image_free(fop->seq.image);
 
-	/* restore frame */
-	fop->sprite->frame = old_frame;
+	// Restore frame
+	fop->sprite->setCurrentFrame(old_frame);
       }
       else {
 	fop_error(fop, _("Not enough memory for the temporary bitmap.\n"));
@@ -743,7 +741,7 @@ Image *fop_sequence_image(FileOp *fop, int imgtype, int w, int h)
       LayerImage* layer = new LayerImage(sprite);
 
       // Add the layer
-      sprite->get_folder()->add_layer(layer);
+      sprite->getFolder()->add_layer(layer);
 
       // Done
       fop->sprite = sprite;
@@ -757,7 +755,7 @@ Image *fop_sequence_image(FileOp *fop, int imgtype, int w, int h)
   else {
     sprite = fop->sprite;
 
-    if (sprite->imgtype != imgtype)
+    if (sprite->getImgType() != imgtype)
       return NULL;
   }
 

src/file/file.h

@@ -109,12 +109,12 @@ struct FileOp
 
 /* available extensions for each load/save operation */
 
-void get_readable_extensions(char *buf, int size);
-void get_writable_extensions(char *buf, int size);
+void get_readable_extensions(char* buf, int size);
+void get_writable_extensions(char* buf, int size);
 
 /* high-level routines to load/save sprites */
 
-Sprite* sprite_load(const char *filename);
+Sprite* sprite_load(const char* filename);
 int sprite_save(Sprite* sprite);
 
 /* low-level routines to load/save sprites */

src/file/fli_format.cpp

@@ -54,7 +54,7 @@ static bool load_FLI(FileOp *fop)
 			       cmap[c*3+2], 255));		\
       }								\
       pal->setFrame(frpos_out);					\
-      sprite_set_palette(sprite, pal, true);			\
+      sprite->setPalette(pal, true);				\
     } while (0)
 
   unsigned char cmap[768];
@@ -102,19 +102,19 @@ static bool load_FLI(FileOp *fop)
     return false;
   }
 
-  /* create the image */
+  // Create the image
   sprite = new Sprite(IMAGE_INDEXED, w, h, 256);
   layer = new LayerImage(sprite);
-  sprite->get_folder()->add_layer(layer);
+  sprite->getFolder()->add_layer(layer);
   layer->configure_as_background();
 
-  /* set frames and speed */
-  sprite_set_frames(sprite, fli_header.frames);
-  sprite_set_speed(sprite, fli_header.speed);
+  // Set frames and speed
+  sprite->setTotalFrames(fli_header.frames);
+  sprite->setDurationForAllFrames(fli_header.speed);
 
   /* write frame by frame */
   for (frpos_in=frpos_out=0;
-       frpos_in<sprite->frames;
+       frpos_in<sprite->getTotalFrames();
        frpos_in++) {
     /* read the frame */
     fli_read_frame(f, &fli_header,
@@ -139,7 +139,7 @@ static bool load_FLI(FileOp *fop)
 	break;
       }
 
-      index = stock_add_image(sprite->stock, image);
+      index = stock_add_image(sprite->getStock(), image);
       if (index < 0) {
 	image_free(image);
 	fop_error(fop, _("Not enough memory\n"));
@@ -173,10 +173,10 @@ static bool load_FLI(FileOp *fop)
       layer_add_cel(layer, cel);
     }
 #endif
-    /* the palette and the image don't change: add duration to the last added frame */
+    // The palette and the image don't change: add duration to the last added frame
     else {
-      sprite_set_frlen(sprite, frpos_out,
-		       sprite_get_frlen(sprite, frpos_out)+fli_header.speed);
+      sprite->setFrameDuration(frpos_out,
+			       sprite->getFrameDuration(frpos_out)+fli_header.speed);
     }
 
     /* update the old image and color-map to the new ones to compare later */
@@ -184,7 +184,7 @@ static bool load_FLI(FileOp *fop)
     memcpy(omap, cmap, 768);
 
     /* update progress */
-    fop_progress(fop, (float)(frpos_in+1) / (float)(sprite->frames));
+    fop_progress(fop, (float)(frpos_in+1) / (float)(sprite->getTotalFrames()));
     if (fop_is_stop(fop))
       break;
 
@@ -193,13 +193,13 @@ static bool load_FLI(FileOp *fop)
       break;
   }
 
-  /* update sprites frames */
-  sprite_set_frames(sprite, frpos_out+1);
+  // Update number of frames
+  sprite->setTotalFrames(frpos_out+1);
 
-  /* close the file */
+  // Close the file
   fclose(f);
 
-  /* destroy the bitmaps */
+  // Destroy the bitmaps
   image_free(bmp);
   image_free(old);
   delete pal;
@@ -223,8 +223,8 @@ static bool save_FLI(FileOp *fop)
   /* prepare fli header */
   fli_header.filesize = 0;
   fli_header.frames = 0;
-  fli_header.width = sprite->w;
-  fli_header.height = sprite->h;
+  fli_header.width = sprite->getWidth();
+  fli_header.height = sprite->getHeight();
 
   if ((fli_header.width == 320) && (fli_header.height == 200))
     fli_header.magic = HEADER_FLI;
@@ -248,8 +248,8 @@ static bool save_FLI(FileOp *fop)
   fseek(f, 128, SEEK_SET);
 
   /* create the bitmaps */
-  bmp = image_new(IMAGE_INDEXED, sprite->w, sprite->h);
-  old = image_new(IMAGE_INDEXED, sprite->w, sprite->h);
+  bmp = image_new(IMAGE_INDEXED, sprite->getWidth(), sprite->getHeight());
+  old = image_new(IMAGE_INDEXED, sprite->getWidth(), sprite->getHeight());
   if ((!bmp) || (!old)) {
     fop_error(fop, _("Not enough memory for temporary bitmaps.\n"));
     if (bmp) image_free(bmp);
@@ -260,10 +260,10 @@ static bool save_FLI(FileOp *fop)
 
   /* write frame by frame */
   for (frpos=0;
-       frpos<sprite->frames;
+       frpos<sprite->getTotalFrames();
        frpos++) {
     /* get color map */
-    pal = sprite_get_palette(sprite, frpos);
+    pal = sprite->getPalette(frpos);
     for (c=0; c<256; c++) {
       cmap[3*c  ] = _rgba_getr(pal->getEntry(c));
       cmap[3*c+1] = _rgba_getg(pal->getEntry(c));
@@ -272,11 +272,11 @@ static bool save_FLI(FileOp *fop)
 
     /* render the frame in the bitmap */
     image_clear(bmp, 0);
-    layer_render(sprite->get_folder(), bmp, 0, 0, frpos);
+    layer_render(sprite->getFolder(), bmp, 0, 0, frpos);
 
     /* how many times this frame should be written to get the same
        time that it has in the sprite */
-    times = sprite_get_frlen(sprite, frpos) / fli_header.speed;
+    times = sprite->getFrameDuration(frpos) / fli_header.speed;
 
     for (c=0; c<times; c++) {
       /* write this frame */
@@ -294,7 +294,7 @@ static bool save_FLI(FileOp *fop)
     }
 
     /* update progress */
-    fop_progress(fop, (float)(frpos+1) / (float)(sprite->frames));
+    fop_progress(fop, (float)(frpos+1) / (float)(sprite->getTotalFrames()));
   }
 
   /* write the header and close the file */
@@ -313,8 +313,8 @@ static int get_time_precision(Sprite *sprite)
   int precision = 1000;
   int c, len;
 
-  for (c = 0; c < sprite->frames && precision > 1; c++) {
-    len = sprite_get_frlen(sprite, c);
+  for (c = 0; c < sprite->getTotalFrames() && precision > 1; c++) {
+    len = sprite->getFrameDuration(c);
 
     while (len / precision == 0)
       precision /= 10;

src/file/gif_format.cpp

@@ -109,7 +109,7 @@ static bool load_GIF(FileOp *fop)
     goto error;
   }
 
-  sprite_set_frames(sprite, gif->frames_count);
+  sprite->setTotalFrames(gif->frames_count);
 
   layer = new LayerImage(sprite);
   if (!layer) {
@@ -117,7 +117,7 @@ static bool load_GIF(FileOp *fop)
     goto error;
   }
 
-  sprite->get_folder()->add_layer(layer);
+  sprite->getFolder()->add_layer(layer);
   layer->configure_as_background();
 
   image_clear(current_image, gif->background_index);
@@ -131,7 +131,7 @@ static bool load_GIF(FileOp *fop)
       pal = &gif->palette;
 
     /* 1/100th seconds to milliseconds */
-    sprite_set_frlen(sprite, i, gif->frames[i].duration*10);
+    sprite->setFrameDuration(i, gif->frames[i].duration*10);
 
     /* make the palette */
     for (c=0; c<pal->colors_count; c++) {
@@ -150,7 +150,7 @@ static bool load_GIF(FileOp *fop)
     /* first frame or palette changes */
     if (i == 0 || opal->countDiff(npal, NULL, NULL)) {
       npal->setFrame(i);
-      sprite_set_palette(sprite, npal, true);
+      sprite->setPalette(npal, true);
     }
 
     /* copy new palette to old palette */
@@ -162,7 +162,7 @@ static bool load_GIF(FileOp *fop)
 		      gif->frames[i].w,
 		      gif->frames[i].h
 #else
-		      sprite->w, sprite->h
+		      sprite->getWidth(), sprite->getHeight()
 #endif
 		      );
     if (!cel || !image) {
@@ -195,7 +195,7 @@ static bool load_GIF(FileOp *fop)
 	       0, 0
 #endif
 	       );
-    cel->image = stock_add_image(sprite->stock, image);
+    cel->image = stock_add_image(sprite->getStock(), image);
     layer->add_cel(cel);
 
 #ifdef LOAD_GIF_STRUCTURE
@@ -291,8 +291,8 @@ static bool save_GIF(FileOp *fop)
   int w, h;
   int ret;
 
-  bmp = image_new(IMAGE_INDEXED, sprite->w, sprite->h);
-  old = image_new(IMAGE_INDEXED, sprite->w, sprite->h);
+  bmp = image_new(IMAGE_INDEXED, sprite->getWidth(), sprite->getHeight());
+  old = image_new(IMAGE_INDEXED, sprite->getWidth(), sprite->getHeight());
   if (!bmp || !old) {
     if (bmp) image_free(bmp);
     if (old) image_free(old);
@@ -300,7 +300,7 @@ static bool save_GIF(FileOp *fop)
     return false;
   }
 
-  gif = gif_create_animation(sprite->frames);
+  gif = gif_create_animation(sprite->getTotalFrames());
   if (!gif) {
     image_free(bmp);
     image_free(old);
@@ -308,8 +308,8 @@ static bool save_GIF(FileOp *fop)
     return false;
   }
 
-  gif->width = sprite->w;
-  gif->height = sprite->h;
+  gif->width = sprite->getWidth();
+  gif->height = sprite->getHeight();
   gif->background_index = 0;
 
   /* defaults:
@@ -324,13 +324,13 @@ static bool save_GIF(FileOp *fop)
   x1 = y1 = x2 = y2 = 0;
 
   opal = NULL;
-  for (i=0; i<sprite->frames; ++i) {
+  for (i=0; i<sprite->getTotalFrames(); ++i) {
     /* frame palette */
-    npal = sprite_get_palette(sprite, i);
+    npal = sprite->getPalette(i);
 
     /* render the frame in the bitmap */
     image_clear(bmp, 0);
-    layer_render(sprite->get_folder(), bmp, 0, 0, i);
+    layer_render(sprite->getFolder(), bmp, 0, 0, i);
 
     /* first frame */
     if (i == 0) {
@@ -424,7 +424,7 @@ static bool save_GIF(FileOp *fop)
     gif->frames[i].yoff = y1;
 
     /* milliseconds to 1/100th seconds */
-    gif->frames[i].duration = sprite_get_frlen(sprite, i)/10;
+    gif->frames[i].duration = sprite->getFrameDuration(i)/10;
 
     /* image data */
     for (y = 0; y < h; y++) {

src/file/ico_format.cpp

@@ -51,7 +51,7 @@ static bool save_ICO(FileOp *fop)
   int depth, bpp, bw, bitsw;
   int size, offset, n, i;
   int c, x, y, b, m, v;
-  int num = fop->sprite->frames;
+  int num = fop->sprite->getTotalFrames();
   Image *bmp;
 
   f = fopen(fop->filename, "wb");
@@ -68,16 +68,16 @@ static bool save_ICO(FileOp *fop)
   for (n=0; n<num; ++n) {
     depth = 8;/* bitmap_color_depth(bmp[n]); */
     bpp = (depth == 8) ? 8 : 24;
-    bw = (((fop->sprite->w * bpp / 8) + 3) / 4) * 4;
-    bitsw = ((((fop->sprite->w + 7) / 8) + 3) / 4) * 4;
-    size = fop->sprite->h * (bw + bitsw) + 40;
+    bw = (((fop->sprite->getWidth() * bpp / 8) + 3) / 4) * 4;
+    bitsw = ((((fop->sprite->getWidth() + 7) / 8) + 3) / 4) * 4;
+    size = fop->sprite->getHeight() * (bw + bitsw) + 40;
 
     if (bpp == 8)
       size += 256 * 4;
 
     /* ICONDIRENTRY */
-    fputc(fop->sprite->w, f);	/* width                       */
-    fputc(fop->sprite->h, f);	/* height                      */
+    fputc(fop->sprite->getWidth(), f);	/* width                       */
+    fputc(fop->sprite->getHeight(), f);	/* height                      */
     fputc(0, f);		/* color count                 */
     fputc(0, f);		/* reserved                    */
     fputw(1, f);		/* color planes                */
@@ -88,13 +88,13 @@ static bool save_ICO(FileOp *fop)
     offset += size;
   }
 
-  bmp = image_new(fop->sprite->imgtype,
-		  fop->sprite->w,
-		  fop->sprite->h);
+  bmp = image_new(fop->sprite->getImgType(),
+		  fop->sprite->getWidth(),
+		  fop->sprite->getHeight());
 
   for (n=0; n<num; ++n) {
     image_clear(bmp, 0);
-    layer_render(fop->sprite->get_folder(), bmp, 0, 0, n);
+    layer_render(fop->sprite->getFolder(), bmp, 0, 0, n);
 
     depth = 8; /* bitmap_color_depth(bmp); */
     bpp = (depth == 8) ? 8 : 24;
@@ -120,7 +120,7 @@ static bool save_ICO(FileOp *fop)
 
     /* PALETTE */
     if (bpp == 8) {
-      Palette *pal = sprite_get_palette(fop->sprite, n);
+      Palette *pal = fop->sprite->getPalette(n);
 
       fputl(0, f);  /* color 0 is black, so the XOR mask works */
 

src/file/png_format.cpp

@@ -355,12 +355,12 @@ static bool save_PNG(FileOp *fop)
 
   switch (image->imgtype) {
     case IMAGE_RGB:
-      color_type = sprite_need_alpha(fop->sprite) ?
+      color_type = fop->sprite->needAlpha() ?
 	PNG_COLOR_TYPE_RGB_ALPHA:
 	PNG_COLOR_TYPE_RGB;
       break;
     case IMAGE_GRAYSCALE:
-      color_type = sprite_need_alpha(fop->sprite) ?
+      color_type = fop->sprite->needAlpha() ?
 	PNG_COLOR_TYPE_GRAY_ALPHA:
 	PNG_COLOR_TYPE_GRAY;
       break;

src/modules/editors.cpp

@@ -121,8 +121,8 @@ void editors_draw_sprite_tiled(const Sprite* sprite, int x1, int y1, int x2, int
 #else
   cx1 = 0;
   cy1 = 0;
-  cx2 = cx1+sprite->w-1;
-  cy2 = cy1+sprite->h-1;
+  cx2 = cx1+sprite->getWidth()-1;
+  cy2 = cy1+sprite->getHeight()-1;
 #endif
 
   lx1 = MAX(x1, cx1);
@@ -156,7 +156,7 @@ void editors_draw_sprite_tiled(const Sprite* sprite, int x1, int y1, int x2, int
 #else
     editors_draw_sprite_tiled(sprite,
 			      cx1, y1,
-			      MIN(lx1-1, x2-sprite->w), y2);
+			      MIN(lx1-1, x2-sprite->getWidth()), y2);
 #endif
   }
 
@@ -169,7 +169,7 @@ void editors_draw_sprite_tiled(const Sprite* sprite, int x1, int y1, int x2, int
 #else
     editors_draw_sprite_tiled(sprite,
 			      x1, cy1,
-			      x2, MIN(ly1-1, y2-sprite->h));
+			      x2, MIN(ly1-1, y2-sprite->getHeight()));
 #endif
   }
 }

src/modules/gui.cpp

@@ -459,7 +459,7 @@ void update_screen_for_sprite(const Sprite* sprite)
   /* with a sprite */
   else {
     /* select the palette of the sprite */
-    if (set_current_palette(sprite_get_palette(sprite, sprite->frame), false)) {
+    if (set_current_palette(sprite->getPalette(sprite->getCurrentFrame()), false)) {
       /* if the palette changes, refresh the whole screen */
       jmanager_refresh_screen();
     }

src/modules/palettes.cpp

@@ -104,9 +104,9 @@ void set_default_palette(Palette* palette)
  * @param palette If "palette" is NULL will be used the default one
  * (ase_default_palette)
  */
-bool set_current_palette(Palette *_palette, bool forced)
+bool set_current_palette(const Palette *_palette, bool forced)
 {
-  Palette *palette = _palette ? _palette: ase_default_palette;
+  const Palette *palette = _palette ? _palette: ase_default_palette;
   bool ret = false;
 
   /* have changes */

src/modules/palettes.h

@@ -35,7 +35,7 @@ Palette* get_default_palette();
 Palette* get_current_palette();
 
 void set_default_palette(Palette* palette);
-bool set_current_palette(Palette* palette, bool forced);
+bool set_current_palette(const Palette* palette, bool forced);
 void set_black_palette();
 void set_current_color(int index, int r, int g, int b);
 

src/raster/layer.cpp

@@ -52,7 +52,7 @@ Layer::Layer(int type, Sprite* sprite)
     LAYER_IS_WRITABLE;
 }
 
-Layer::Layer(Layer* src_layer, Sprite* dst_sprite)
+Layer::Layer(const Layer* src_layer, Sprite* dst_sprite)
   : GfxObj(src_layer->type)
 {
   m_sprite = dst_sprite;
@@ -113,31 +113,31 @@ LayerImage::LayerImage(Sprite* sprite)
   m_blend_mode = BLEND_MODE_NORMAL;
 }
 
-LayerImage::LayerImage(LayerImage* src_layer, Sprite* dst_sprite)
+LayerImage::LayerImage(const LayerImage* src_layer, Sprite* dst_sprite)
   : Layer(src_layer, dst_sprite)
 {
   set_blend_mode(src_layer->get_blend_mode());
 
   try {
     // copy cels
-    CelIterator it = static_cast<LayerImage*>(src_layer)->get_cel_begin();
-    CelIterator end = static_cast<LayerImage*>(src_layer)->get_cel_end();
+    CelConstIterator it = src_layer->get_cel_begin();
+    CelConstIterator end = src_layer->get_cel_end();
 
     for (; it != end; ++it) {
-      Cel* cel = *it;
+      const Cel* cel = *it;
       Cel* cel_copy = cel_new_copy(cel);
 
       assert((cel->image >= 0) &&
-	     (cel->image < src_layer->getSprite()->stock->nimage));
+	     (cel->image < src_layer->getSprite()->getStock()->nimage));
 
-      Image* image = src_layer->getSprite()->stock->image[cel->image];
+      Image* image = src_layer->getSprite()->getStock()->image[cel->image];
       assert(image != NULL);
 
       Image* image_copy = image_new_copy(image);
 
-      cel_copy->image = stock_add_image(dst_sprite->stock, image_copy);
-      if (undo_is_enabled(dst_sprite->undo))
-	undo_add_image(dst_sprite->undo, dst_sprite->stock, cel_copy->image);
+      cel_copy->image = stock_add_image(dst_sprite->getStock(), image_copy);
+      if (undo_is_enabled(dst_sprite->getUndo()))
+	undo_add_image(dst_sprite->getUndo(), dst_sprite->getStock(), cel_copy->image);
 
       add_cel(cel_copy);
     }
@@ -160,11 +160,11 @@ void LayerImage::destroy_all_cels()
 
   for (; it != end; ++it) {
     Cel* cel = *it;
-    Image* image = getSprite()->stock->image[cel->image];
+    Image* image = getSprite()->getStock()->image[cel->image];
 
     assert(image != NULL);
 
-    stock_remove_image(getSprite()->stock, image);
+    stock_remove_image(getSprite()->getStock(), image);
     image_free(image);
     cel_free(cel);
   }
@@ -251,12 +251,12 @@ Cel* LayerImage::get_cel(int frame)
 void LayerImage::configure_as_background()
 {
   assert(getSprite() != NULL);
-  assert(sprite_get_background_layer(getSprite()) == NULL);
+  assert(getSprite()->getBackgroundLayer() == NULL);
 
   *flags_addr() |= LAYER_IS_LOCKMOVE | LAYER_IS_BACKGROUND;
   set_name("Background");
 
-  getSprite()->get_folder()->move_layer(this, NULL);
+  getSprite()->getFolder()->move_layer(this, NULL);
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -268,12 +268,12 @@ LayerFolder::LayerFolder(Sprite* sprite)
   set_name("Layer Set");
 }
 
-LayerFolder::LayerFolder(LayerFolder* src_layer, Sprite* dst_sprite)
+LayerFolder::LayerFolder(const LayerFolder* src_layer, Sprite* dst_sprite)
   : Layer(src_layer, dst_sprite)
 {
   try {
-    LayerIterator it = static_cast<LayerFolder*>(src_layer)->get_layer_begin();
-    LayerIterator end = static_cast<LayerFolder*>(src_layer)->get_layer_end();
+    LayerConstIterator it = src_layer->get_layer_begin();
+    LayerConstIterator end = src_layer->get_layer_end();
 
     for (; it != end; ++it) {
       // duplicate the child
@@ -375,12 +375,12 @@ Layer* layer_new_flatten_copy(Sprite* dst_sprite, const Layer* src_layer,
       /* does this frame have cels to render? */
       if (has_cels(src_layer, frame)) {
 	/* create a new image */
-	Image* image = image_new(flat_layer->getSprite()->imgtype, w, h);
+	Image* image = image_new(flat_layer->getSprite()->getImgType(), w, h);
 
 	try {
 	  /* create the new cel for the output layer (add the image to
 	     stock too) */
-	  Cel* cel = cel_new(frame, stock_add_image(flat_layer->getSprite()->stock, image));
+	  Cel* cel = cel_new(frame, stock_add_image(flat_layer->getSprite()->getStock(), image));
 	  cel_set_position(cel, x, y);
 
 	  /* clear the image and render this frame */
@@ -416,9 +416,9 @@ void layer_render(const Layer* layer, Image* image, int x, int y, int frame)
 
       if (cel) {
 	assert((cel->image >= 0) &&
-	       (cel->image < layer->getSprite()->stock->nimage));
+	       (cel->image < layer->getSprite()->getStock()->nimage));
 
-	src_image = layer->getSprite()->stock->image[cel->image];
+	src_image = layer->getSprite()->getStock()->image[cel->image];
 	assert(src_image != NULL);
 
 	image_merge(image, src_image,

src/raster/layer.h

@@ -48,7 +48,7 @@ class Layer : public GfxObj
 protected:
   Layer(int type, Sprite* sprite);
   Layer(Sprite* sprite);
-  Layer(Layer* src_layer, Sprite* dst_sprite);
+  Layer(const Layer* src_layer, Sprite* dst_sprite);
 
 public:
   virtual ~Layer();
@@ -75,7 +75,7 @@ public:
   void set_writable(bool b) { if (b) m_flags |= LAYER_IS_WRITABLE; else m_flags &= ~LAYER_IS_WRITABLE; }
 
   virtual void get_cels(CelList& cels) = 0;
-  virtual Layer* duplicate_for(Sprite* sprite) = 0;
+  virtual Layer* duplicate_for(Sprite* sprite) const = 0;
 
   // TODO remove these methods (from C backward-compatibility)
   unsigned short* flags_addr() { return &m_flags; }
@@ -92,7 +92,7 @@ class LayerImage : public Layer
 
 public:
   LayerImage(Sprite* sprite);
-  LayerImage(LayerImage* copy, Sprite* sprite);
+  LayerImage(const LayerImage* copy, Sprite* sprite);
   virtual ~LayerImage();
 
   int get_blend_mode() const { return m_blend_mode; }
@@ -113,7 +113,7 @@ public:
   CelConstIterator get_cel_end() const { return m_cels.end(); }
   int get_cels_count() const { return m_cels.size(); }
 
-  LayerImage* duplicate_for(Sprite* sprite) { return new LayerImage(this, sprite); }
+  LayerImage* duplicate_for(Sprite* sprite) const { return new LayerImage(this, sprite); }
 
 private:
   void destroy_all_cels();
@@ -128,7 +128,7 @@ class LayerFolder : public Layer
 
 public:
   LayerFolder(Sprite* sprite);
-  LayerFolder(LayerFolder* copy, Sprite* sprite);
+  LayerFolder(const LayerFolder* copy, Sprite* sprite);
   virtual ~LayerFolder();
 
   LayerList get_layers_list() { return m_layers; }
@@ -144,7 +144,7 @@ public:
 
   void get_cels(CelList& cels);
 
-  LayerFolder* duplicate_for(Sprite* sprite) { return new LayerFolder(this, sprite); }
+  LayerFolder* duplicate_for(Sprite* sprite) const { return new LayerFolder(this, sprite); }
 
 private:
   void destroy_all_layers();

src/raster/sprite.h

@@ -35,129 +35,185 @@ class Path;
 class Stock;
 class Undo;
 class Sprite;
+struct _BoundSeg;
 
-Sprite* sprite_new_copy(const Sprite* src_sprite);
+struct PreferredEditorSettings
+{
+  int scroll_x;
+  int scroll_y;
+  int zoom;
+};
 
 /**
  * The main structure used in the whole program to handle a sprite.
  */
 class Sprite : public GfxObj
 {
-  friend Sprite* sprite_new_copy(const Sprite* src_sprite);
-
-public:
-  char filename[512];		// sprite's file name
-  bool associated_to_file;	// true if this sprite is associated to a file in the file-system
-  int imgtype;			// image type
-  int w, h;			// image width/height size (in pixels)
-  int frames;			// how many frames has this sprite
-  int* frlens;			// duration per frame
-  int frame;			// current frame, range [0,frames)
-  JList palettes;		// list of palettes
-  Stock *stock;			// stock to get images
-private:
-  LayerFolder* m_folder;	// main folder of layers
-public:
-  Layer* layer;			// current layer
-  Path* path;			// working path
-  Mask* mask;			// selected mask region
-  Undo* undo;			// undo stack
-  struct {
-    JList paths;		// paths
-    JList masks;		// masks
-  } repository;
-
-  // Selected mask region boundaries
-  struct {
-    int nseg;
-    struct _BoundSeg *seg;
-  } bound;
-  struct {
-    int scroll_x;
-    int scroll_y;
-    int zoom;
-  } preferred;
-
-private:
-
-  Image* m_extras;		// Image with the sprite size to draw some extra stuff (e.g. editor's cursor)
-  int m_extras_opacity;		// Opacity to be used to draw the extra image
-
-  // Mutex to modify the 'locked' flag.
-  Vaca::Mutex* m_mutex;
-
-  // True if some thread is writing the sprite.
-  bool m_write_lock;
-
-  // Greater than zero when one or more threads are reading the sprite.
-  int m_read_locks;
-
 public:
 
-  // Data to save the file in the same format that it was loaded
-  FormatOptions *format_options;
+  ////////////////////////////////////////
+  // Constructors/Destructor
 
-  Sprite(int imgtype, int w, int h, int ncolors);
+  Sprite(int imgtype, int width, int height, int ncolors);
+  Sprite(const Sprite& original);
   virtual ~Sprite();
 
+  ////////////////////////////////////////
+  // Special constructors
+
+  static Sprite* createFlattenCopy(const Sprite& original);
+  static Sprite* createWithLayer(int imgtype, int width, int height, int ncolors);
+
+  ////////////////////////////////////////
+  // Multi-threading ("sprite wrappers" use this)
+
   bool lock(bool write);
-  bool lock_to_write();
-  void unlock_to_read();
+  bool lockToWrite();
+  void unlockToRead();
   void unlock();
 
-  LayerFolder* get_folder() const { return m_folder; }
+  ////////////////////////////////////////
+  // Main properties
 
-  void prepare_extra();
-  Image* get_extras() { return m_extras; }
-  int get_extras_opacity() const { return m_extras_opacity; }
-  void set_extras_opacity(int opacity) { m_extras_opacity = opacity; }
+  int getImgType() const;
+  void setImgType(int imgtype);
+
+  int getWidth() const;
+  int getHeight() const;
+  void setSize(int width, int height);
+
+  const char* getFilename() const;
+  void setFilename(const char* filename);
+
+  bool isModified() const;
+  bool isAssociatedToFile() const;
+  void markAsSaved();
+
+  bool needAlpha() const;
+
+  int getMemSize() const;
+
+  ////////////////////////////////////////
+  // Layers
+
+  const LayerFolder* getFolder() const;
+  LayerFolder* getFolder();
+
+  const LayerImage* getBackgroundLayer() const;
+  LayerImage* getBackgroundLayer();
+
+  const Layer* getCurrentLayer() const;
+  Layer* getCurrentLayer();
+  void setCurrentLayer(Layer* layer);
+
+  int countLayers() const;
+
+  const Layer* indexToLayer(int index) const;
+  Layer* indexToLayer(int index);
+  int layerToIndex(const Layer* layer) const;
+
+  ////////////////////////////////////////
+  // Palettes
+
+  const Palette* getPalette(int frame) const;
+  Palette* getPalette(int frame);
+  JList getPalettes();
+
+  void setPalette(Palette* pal, bool truncate);
+  void resetPalettes();
+  void deletePalette(Palette* pal);
+
+  const Palette* getCurrentPalette() const;
+  Palette* getCurrentPalette();
+
+  ////////////////////////////////////////
+  // Frames
+
+  int getTotalFrames() const;
+  void setTotalFrames(int frames);
+
+  int getFrameDuration(int frame) const;
+  void setFrameDuration(int frame, int msecs);
+  void setDurationForAllFrames(int msecs);
+
+  int getCurrentFrame() const;
+  void setCurrentFrame(int frame);
+
+  ////////////////////////////////////////
+  // Images
+
+  const Stock* getStock() const;
+  Stock* getStock();
+
+  const Image* getCurrentImage(int* x = NULL, int* y = NULL, int* opacity = NULL) const;
+  Image* getCurrentImage(int* x = NULL, int* y = NULL, int* opacity = NULL);
+
+  void getCels(CelList& cels);
+
+  ////////////////////////////////////////
+  // Undo
+
+  const Undo* getUndo() const;
+  Undo* getUndo();
+
+  ////////////////////////////////////////
+  // Mask
+
+  const Mask* getMask() const;
+  Mask* getMask();
+  void setMask(const Mask* mask);
+
+  void addMask(Mask* mask);
+  void removeMask(Mask* mask);
+  Mask* requestMask(const char* name) const;
+
+  void generateMaskBoundaries(Mask* mask = NULL);
+
+  JList getMasksRepository();
+
+  ////////////////////////////////////////
+  // Path
+
+  void addPath(Path* path);
+  void removePath(Path* path);
+  void setPath(const Path* path);
+
+  JList getPathsRepository();
+
+  ////////////////////////////////////////
+  // Loaded options from file
+
+  void setFormatOptions(FormatOptions* format_options);
+
+  ////////////////////////////////////////
+  // Drawing
+
+  void render(Image* image, int x, int y) const;
+  int getPixel(int x, int y) const;
+
+  ////////////////////////////////////////
+  // Preferred editor settings
+
+  PreferredEditorSettings getPreferredEditorSettings() const;
+  void setPreferredEditorSettings(const PreferredEditorSettings& settings);
+
+  ////////////////////////////////////////
+  // Boundaries
+
+  int getBoundariesSegmentsCount() const;
+  const _BoundSeg* getBoundariesSegments() const;
+
+  ////////////////////////////////////////
+  // Extras
+
+  void prepareExtra();
+  Image* getExtras();
+  int getExtrasOpacity() const;
+  void setExtrasOpacity(int opacity);
+
+private:
+  Sprite();
+  class SpriteImpl* m_impl;
 };
 
-Sprite* sprite_new_flatten_copy(const Sprite* src_sprite);
-Sprite* sprite_new_with_layer(int imgtype, int w, int h, int ncolors);
-
-bool sprite_is_modified(const Sprite* sprite);
-bool sprite_is_associated_to_file(const Sprite* sprite);
-void sprite_mark_as_saved(Sprite* sprite);
-
-bool sprite_need_alpha(const Sprite* sprite);
-
-Palette* sprite_get_palette(const Sprite* sprite, int frame);
-void sprite_set_palette(Sprite* sprite, Palette* pal, bool truncate);
-void sprite_reset_palettes(Sprite* sprite);
-void sprite_delete_palette(Sprite* sprite, Palette* pal);
-
-void sprite_set_filename(Sprite* sprite, const char* filename);
-void sprite_set_format_options(Sprite* sprite, FormatOptions* format_options);
-void sprite_set_size(Sprite* sprite, int w, int h);
-void sprite_set_frames(Sprite* sprite, int frames);
-void sprite_set_frlen(Sprite* sprite, int frame, int msecs);
-int sprite_get_frlen(const Sprite* sprite, int frame);
-void sprite_set_speed(Sprite* sprite, int msecs);
-void sprite_set_path(Sprite* sprite, const Path* path);
-void sprite_set_mask(Sprite* sprite, const Mask* mask);
-void sprite_set_layer(Sprite* sprite, Layer* layer);
-void sprite_set_frame(Sprite* sprite, int frame);
-
-LayerImage* sprite_get_background_layer(const Sprite* sprite);
-
-void sprite_add_path(Sprite* sprite, Path* path);
-void sprite_remove_path(Sprite* sprite, Path* path);
-
-void sprite_add_mask(Sprite* sprite, Mask* mask);
-void sprite_remove_mask(Sprite* sprite, Mask* mask);
-Mask* sprite_request_mask(const Sprite* sprite, const char *name);
-
-void sprite_render(const Sprite* sprite, Image* image, int x, int y);
-void sprite_generate_mask_boundaries(Sprite* sprite);
-
-Layer* sprite_index2layer(const Sprite* sprite, int index);
-int sprite_layer2index(const Sprite* sprite, const Layer* layer);
-int sprite_count_layers(const Sprite* sprite);
-void sprite_get_cels(const Sprite* sprite, CelList& cels);
-
-int sprite_getpixel(const Sprite* sprite, int x, int y);
-
-int sprite_get_memsize(const Sprite* sprite);
-
 #endif

src/raster/stock.cpp

@@ -149,3 +149,11 @@ Image* stock_get_image(Stock* stock, int index)
   return ((index >= 0) && (index < stock->nimage)) ? stock->image[index]: NULL;
 }
 
+/**
+ * Returns the image in the "index" position
+ */
+const Image* stock_get_image(const Stock* stock, int index)
+{
+  return ((index >= 0) && (index < stock->nimage)) ? stock->image[index]: NULL;
+}
+

src/raster/stock.h

@@ -45,5 +45,6 @@ void stock_remove_image(Stock* stock, Image* image);
 void stock_replace_image(Stock* stock, int index, Image* image);
 
 Image* stock_get_image(Stock* stock, int index);
+const Image* stock_get_image(const Stock* stock, int index);
 
 #endif

src/raster/undo.cpp

@@ -79,6 +79,9 @@ enum {
 
   /* misc */
   UNDO_TYPE_SET_MASK,
+  UNDO_TYPE_SET_IMGTYPE,
+  UNDO_TYPE_SET_SIZE,
+  UNDO_TYPE_SET_FRAME,
   UNDO_TYPE_SET_FRAMES,
   UNDO_TYPE_SET_FRLEN,
 };
@@ -100,6 +103,9 @@ struct UndoChunkSetLayer;
 struct UndoChunkAddPalette;
 struct UndoChunkRemovePalette;
 struct UndoChunkSetMask;
+struct UndoChunkSetImgType;
+struct UndoChunkSetSize;
+struct UndoChunkSetFrame;
 struct UndoChunkSetFrames;
 struct UndoChunkSetFrlen;
 
@@ -188,6 +194,15 @@ static void chunk_remove_palette_invert(UndoStream* stream, UndoChunkRemovePalet
 static void chunk_set_mask_new(UndoStream* stream, Sprite *sprite);
 static void chunk_set_mask_invert(UndoStream* stream, UndoChunkSetMask* chunk, int state);
 
+static void chunk_set_imgtype_new(UndoStream* stream, Sprite *sprite);
+static void chunk_set_imgtype_invert(UndoStream* stream, UndoChunkSetImgType *chunk, int state);
+
+static void chunk_set_size_new(UndoStream* stream, Sprite *sprite);
+static void chunk_set_size_invert(UndoStream* stream, UndoChunkSetSize *chunk, int state);
+
+static void chunk_set_frame_new(UndoStream* stream, Sprite *sprite);
+static void chunk_set_frame_invert(UndoStream* stream, UndoChunkSetFrame *chunk, int state);
+
 static void chunk_set_frames_new(UndoStream* stream, Sprite *sprite);
 static void chunk_set_frames_invert(UndoStream* stream, UndoChunkSetFrames *chunk, int state);
 
@@ -218,6 +233,9 @@ static UndoAction undo_actions[] = {
   DECL_UNDO_ACTION(add_palette),
   DECL_UNDO_ACTION(remove_palette),
   DECL_UNDO_ACTION(set_mask),
+  DECL_UNDO_ACTION(set_imgtype),
+  DECL_UNDO_ACTION(set_size),
+  DECL_UNDO_ACTION(set_frame),
   DECL_UNDO_ACTION(set_frames),
   DECL_UNDO_ACTION(set_frlen),
 };
@@ -1333,7 +1351,7 @@ static void chunk_set_layer_new(UndoStream* stream, Sprite *sprite)
 		   sizeof(UndoChunkSetLayer));
 
   chunk->sprite_id = sprite->id;
-  chunk->layer_id = sprite->layer ? sprite->layer->id: 0;
+  chunk->layer_id = sprite->getCurrentLayer() ? sprite->getCurrentLayer()->id: 0;
 }
 
 static void chunk_set_layer_invert(UndoStream* stream, UndoChunkSetLayer* chunk, int state)
@@ -1346,7 +1364,7 @@ static void chunk_set_layer_invert(UndoStream* stream, UndoChunkSetLayer* chunk,
 
   chunk_set_layer_new(stream, sprite);
 
-  sprite->layer = layer;
+  sprite->setCurrentLayer(layer);
 }
 
 /***********************************************************************
@@ -1391,7 +1409,7 @@ static void chunk_add_palette_invert(UndoStream* stream, UndoChunkAddPalette *ch
     throw undo_exception("chunk_add_palette_invert");
 
   chunk_remove_palette_new(stream, sprite, palette);
-  sprite_delete_palette(sprite, palette);
+  sprite->deletePalette(palette);
 }
 
 /***********************************************************************
@@ -1436,7 +1454,7 @@ static void chunk_remove_palette_invert(UndoStream* stream, UndoChunkRemovePalet
   Palette* palette = read_raw_palette(chunk->data);
 
   chunk_add_palette_new(stream, sprite, palette);
-  sprite_set_palette(sprite, palette, true);
+  sprite->setPalette(palette, true);
 
   delete palette;
 }
@@ -1468,10 +1486,10 @@ static void chunk_set_mask_new(UndoStream* stream, Sprite *sprite)
   UndoChunkSetMask* chunk = (UndoChunkSetMask* )
     undo_chunk_new(stream,
 		   UNDO_TYPE_SET_MASK,
-		   sizeof(UndoChunkSetMask)+get_raw_mask_size(sprite->mask));
+		   sizeof(UndoChunkSetMask)+get_raw_mask_size(sprite->getMask()));
 
   chunk->sprite_id = sprite->id;
-  write_raw_mask(chunk->data, sprite->mask);
+  write_raw_mask(chunk->data, sprite->getMask());
 }
 
 static void chunk_set_mask_invert(UndoStream* stream, UndoChunkSetMask* chunk, int state)
@@ -1482,12 +1500,144 @@ static void chunk_set_mask_invert(UndoStream* stream, UndoChunkSetMask* chunk, i
     Mask* mask = read_raw_mask(chunk->data);
 
     chunk_set_mask_new(stream, sprite);
-    mask_copy(sprite->mask, mask);
+    mask_copy(sprite->getMask(), mask);
 
     mask_free(mask);
   }
 }
 
+/***********************************************************************
+
+  "set_imgtype"
+
+     DWORD		sprite ID
+     DWORD		imgtype
+
+***********************************************************************/
+
+struct UndoChunkSetImgType
+{
+  UndoChunk head;
+  ase_uint32 sprite_id;
+  ase_uint32 imgtype;
+};
+
+void undo_set_imgtype(Undo* undo, Sprite* sprite)
+{
+  chunk_set_imgtype_new(undo->undo_stream, sprite);
+  update_undo(undo);
+}
+
+static void chunk_set_imgtype_new(UndoStream* stream, Sprite* sprite)
+{
+  UndoChunkSetImgType* chunk = (UndoChunkSetImgType*)
+    undo_chunk_new(stream,
+		   UNDO_TYPE_SET_IMGTYPE,
+		   sizeof(UndoChunkSetImgType));
+
+  chunk->sprite_id = sprite->id;
+  chunk->imgtype = sprite->getImgType();
+}
+
+static void chunk_set_imgtype_invert(UndoStream* stream, UndoChunkSetImgType *chunk, int state)
+{
+  Sprite *sprite = (Sprite *)gfxobj_find(chunk->sprite_id);
+
+  if (sprite) {
+    chunk_set_imgtype_new(stream, sprite);
+    sprite->setImgType(chunk->imgtype);
+  }
+}
+
+/***********************************************************************
+
+  "set_size"
+
+     DWORD		sprite ID
+     DWORD		width
+     DWORD		height
+
+***********************************************************************/
+
+struct UndoChunkSetSize
+{
+  UndoChunk head;
+  ase_uint32 sprite_id;
+  ase_uint32 width;
+  ase_uint32 height;
+};
+
+void undo_set_size(Undo* undo, Sprite* sprite)
+{
+  chunk_set_size_new(undo->undo_stream, sprite);
+  update_undo(undo);
+}
+
+static void chunk_set_size_new(UndoStream* stream, Sprite* sprite)
+{
+  UndoChunkSetSize* chunk = (UndoChunkSetSize*)
+    undo_chunk_new(stream,
+		   UNDO_TYPE_SET_SIZE,
+		   sizeof(UndoChunkSetSize));
+
+  chunk->sprite_id = sprite->id;
+  chunk->width = sprite->getWidth();
+  chunk->height = sprite->getHeight();
+}
+
+static void chunk_set_size_invert(UndoStream* stream, UndoChunkSetSize *chunk, int state)
+{
+  Sprite *sprite = (Sprite *)gfxobj_find(chunk->sprite_id);
+
+  if (sprite) {
+    chunk_set_size_new(stream, sprite);
+    sprite->setSize(chunk->width, chunk->height);
+  }
+}
+
+/***********************************************************************
+
+  "set_frame"
+
+     DWORD		sprite ID
+     DWORD		frame
+
+***********************************************************************/
+
+struct UndoChunkSetFrame
+{
+  UndoChunk head;
+  ase_uint32 sprite_id;
+  ase_uint32 frame;
+};
+
+void undo_set_frame(Undo* undo, Sprite* sprite)
+{
+  chunk_set_frame_new(undo->undo_stream, sprite);
+  update_undo(undo);
+}
+
+static void chunk_set_frame_new(UndoStream* stream, Sprite* sprite)
+{
+  UndoChunkSetFrame* chunk = (UndoChunkSetFrame*)
+    undo_chunk_new(stream,
+		   UNDO_TYPE_SET_FRAME,
+		   sizeof(UndoChunkSetFrame));
+
+  chunk->sprite_id = sprite->id;
+  chunk->frame = sprite->getCurrentFrame();
+}
+
+static void chunk_set_frame_invert(UndoStream* stream, UndoChunkSetFrame *chunk, int state)
+{
+  Sprite *sprite = (Sprite *)gfxobj_find(chunk->sprite_id);
+
+  if (sprite) {
+    chunk_set_frame_new(stream, sprite);
+    sprite->setCurrentFrame(chunk->frame);
+  }
+}
+
 /***********************************************************************
 
   "set_frames"
@@ -1518,7 +1668,7 @@ static void chunk_set_frames_new(UndoStream* stream, Sprite *sprite)
 		   sizeof(UndoChunkSetFrames));
 
   chunk->sprite_id = sprite->id;
-  chunk->frames = sprite->frames;
+  chunk->frames = sprite->getTotalFrames();
 }
 
 static void chunk_set_frames_invert(UndoStream* stream, UndoChunkSetFrames *chunk, int state)
@@ -1527,7 +1677,7 @@ static void chunk_set_frames_invert(UndoStream* stream, UndoChunkSetFrames *chun
 
   if (sprite) {
     chunk_set_frames_new(stream, sprite);
-    sprite_set_frames(sprite, chunk->frames);
+    sprite->setTotalFrames(chunk->frames);
   }
 }
 
@@ -1537,7 +1687,7 @@ static void chunk_set_frames_invert(UndoStream* stream, UndoChunkSetFrames *chun
 
      DWORD		sprite ID
      DWORD		frame
-     DWORD		frlen
+     DWORD		duration
 
 ***********************************************************************/
 
@@ -1546,7 +1696,7 @@ struct UndoChunkSetFrlen
   UndoChunk head;
   ase_uint32 sprite_id;
   ase_uint32 frame;
-  ase_uint32 frlen;
+  ase_uint32 duration;
 };
 
 void undo_set_frlen(Undo* undo, Sprite *sprite, int frame)
@@ -1557,7 +1707,7 @@ void undo_set_frlen(Undo* undo, Sprite *sprite, int frame)
 
 static void chunk_set_frlen_new(UndoStream* stream, Sprite *sprite, int frame)
 {
-  assert(frame >= 0 && frame < sprite->frames);
+  assert(frame >= 0 && frame < sprite->getTotalFrames());
 
   UndoChunkSetFrlen *chunk = (UndoChunkSetFrlen *)
     undo_chunk_new(stream,
@@ -1566,7 +1716,7 @@ static void chunk_set_frlen_new(UndoStream* stream, Sprite *sprite, int frame)
 
   chunk->sprite_id = sprite->id;
   chunk->frame = frame;
-  chunk->frlen = sprite->frlens[frame];
+  chunk->duration = sprite->getFrameDuration(frame);
 }
 
 static void chunk_set_frlen_invert(UndoStream* stream, UndoChunkSetFrlen *chunk, int state)
@@ -1575,7 +1725,7 @@ static void chunk_set_frlen_invert(UndoStream* stream, UndoChunkSetFrlen *chunk,
 
   if (sprite != NULL) {
     chunk_set_frlen_new(stream, sprite, chunk->frame);
-    sprite_set_frlen(sprite, chunk->frame, chunk->frlen);
+    sprite->setFrameDuration(chunk->frame, chunk->duration);
   }
 }
 
@@ -1993,7 +2143,7 @@ static Layer* read_raw_layer(ase_uint8* raw_data)
 	  Image* image = read_raw_image(raw_data);
 	  raw_data += get_raw_image_size(image);
 
-	  stock_replace_image(layer->getSprite()->stock, cel->image, image);
+	  stock_replace_image(layer->getSprite()->getStock(), cel->image, image);
 	}
       }
       break;
@@ -2064,7 +2214,7 @@ static ase_uint8* write_raw_layer(ase_uint8* raw_data, Layer* layer)
 	Cel* cel = *it;
 	raw_data = write_raw_cel(raw_data, cel);
 
-	Image* image = layer->getSprite()->stock->image[cel->image];
+	Image* image = layer->getSprite()->getStock()->image[cel->image];
 	assert(image != NULL);
 
 	write_raw_uint8(1);
@@ -2108,7 +2258,7 @@ static int get_raw_layer_size(Layer* layer)
 	size += get_raw_cel_size(cel);
 	size++;			// has image?
 
-	Image* image = layer->getSprite()->stock->image[cel->image];
+	Image* image = layer->getSprite()->getStock()->image[cel->image];
 	size += get_raw_image_size(image);
       }
       break;
@@ -2173,7 +2323,7 @@ static ase_uint8* write_raw_palette(ase_uint8* raw_data, Palette* palette)
   write_raw_uint16(palette->getFrame()); // frame
   write_raw_uint16(palette->size());	 // number of colors
 
-  for (int c=0; c<palette->size(); c++) {
+  for (size_t c=0; c<palette->size(); c++) {
     color = palette->getEntry(c);
     write_raw_uint32(color);
   }

src/raster/undo.h

@@ -54,6 +54,7 @@ public:
 
   Undo(Sprite* sprite);
   virtual ~Undo();
+
 };
 
 Undo* undo_new(Sprite* sprite);
@@ -98,6 +99,9 @@ void undo_set_layer(Undo* undo, Sprite* sprite);
 void undo_add_palette(Undo* undo, Sprite* sprite, Palette* palette);
 void undo_remove_palette(Undo* undo, Sprite* sprite, Palette* palette);
 void undo_set_mask(Undo* undo, Sprite* sprite);
+void undo_set_imgtype(Undo* undo, Sprite* sprite);
+void undo_set_size(Undo* undo, Sprite* sprite);
+void undo_set_frame(Undo* undo, Sprite* sprite);
 void undo_set_frames(Undo* undo, Sprite* sprite);
 void undo_set_frlen(Undo* undo, Sprite* sprite, int frame);
 

src/sprite_wrappers.h

@@ -161,7 +161,7 @@ public:
     , m_locked(false)
   {
     if (m_sprite) {
-      if (!m_sprite->lock_to_write())
+      if (!m_sprite->lockToWrite())
 	throw locked_sprite_exception();
 
       m_locked = true;
@@ -183,7 +183,7 @@ public:
     if (m_sprite) {
       m_from_reader = true;
 
-      if (!m_sprite->lock_to_write())
+      if (!m_sprite->lockToWrite())
 	throw locked_sprite_exception();
 
       m_locked = true;
@@ -198,7 +198,7 @@ protected:
   {
     if (m_sprite && m_locked) {
       if (m_from_reader)
-	m_sprite->unlock_to_read();
+	m_sprite->unlockToRead();
       else
 	m_sprite->unlock();
     }

src/tools/inks.h

@@ -62,8 +62,8 @@ public:
     }
 
     m_proc = loop->getOpacity() == 255 ?
-      ink_processing[INK_OPAQUE][MID(0, loop->getSprite()->imgtype, 2)]:
-      ink_processing[INK_TRANSPARENT][MID(0, loop->getSprite()->imgtype, 2)];
+      ink_processing[INK_OPAQUE][MID(0, loop->getSprite()->getImgType(), 2)]:
+      ink_processing[INK_TRANSPARENT][MID(0, loop->getSprite()->getImgType(), 2)];
   }
 
   void inkHline(int x1, int y, int x2, IToolLoop* loop)
@@ -157,7 +157,7 @@ public:
     switch (m_type) {
 
       case Eraser:
-	m_proc = ink_processing[INK_OPAQUE][MID(0, loop->getSprite()->imgtype, 2)];
+	m_proc = ink_processing[INK_OPAQUE][MID(0, loop->getSprite()->getImgType(), 2)];
 
 	// TODO app_get_color_to_clear_layer should receive the context as parameter
 	loop->setPrimaryColor(app_get_color_to_clear_layer(loop->getLayer()));
@@ -165,7 +165,7 @@ public:
 	break;
 
       case ReplaceFgWithBg:
-	m_proc = ink_processing[INK_REPLACE][MID(0, loop->getSprite()->imgtype, 2)];
+	m_proc = ink_processing[INK_REPLACE][MID(0, loop->getSprite()->getImgType(), 2)];
 
 	loop->setPrimaryColor(get_color_for_layer(loop->getLayer(),
 						  loop->getContext()->getSettings()->getFgColor()));
@@ -174,7 +174,7 @@ public:
 	break;
 
       case ReplaceBgWithFg:
-	m_proc = ink_processing[INK_REPLACE][MID(0, loop->getSprite()->imgtype, 2)];
+	m_proc = ink_processing[INK_REPLACE][MID(0, loop->getSprite()->getImgType(), 2)];
 
 	loop->setPrimaryColor(get_color_for_layer(loop->getLayer(),
 						  loop->getContext()->getSettings()->getBgColor()));
@@ -201,7 +201,7 @@ public:
 
   void prepareInk(IToolLoop* loop)
   {
-    m_proc = ink_processing[INK_BLUR][MID(0, loop->getSprite()->imgtype, 2)];
+    m_proc = ink_processing[INK_BLUR][MID(0, loop->getSprite()->getImgType(), 2)];
   }
 
   void inkHline(int x1, int y, int x2, IToolLoop* loop)
@@ -221,7 +221,7 @@ public:
 
   void prepareInk(IToolLoop* loop)
   {
-    m_proc = ink_processing[INK_JUMBLE][MID(0, loop->getSprite()->imgtype, 2)];
+    m_proc = ink_processing[INK_JUMBLE][MID(0, loop->getSprite()->getImgType(), 2)];
   }
 
   void inkHline(int x1, int y, int x2, IToolLoop* loop)
@@ -258,11 +258,11 @@ public:
     m_modify_selection = state;
 
     if (state) {
-      if (undo_is_enabled(loop->getSprite()->undo))
-	undo_set_mask(loop->getSprite()->undo, loop->getSprite());
+      if (undo_is_enabled(loop->getSprite()->getUndo()))
+	undo_set_mask(loop->getSprite()->getUndo(), loop->getSprite());
 
       loop->getMask()->freeze();
-      loop->getMask()->reserve(0, 0, loop->getSprite()->w, loop->getSprite()->h);
+      loop->getMask()->reserve(0, 0, loop->getSprite()->getWidth(), loop->getSprite()->getHeight());
     }
     else {
       loop->getMask()->unfreeze();

src/ui_context.cpp

@@ -50,7 +50,7 @@ void UIContext::on_add_sprite(Sprite* sprite)
 
   // add the tab for this sprite
   tabs_append_tab(app_get_tabsbar(),
-		  get_filename(sprite->filename), sprite);
+		  get_filename(sprite->getFilename()), sprite);
 
   // rebuild the menu list of sprites
   app_realloc_sprite_list();

src/undoable.cpp

@@ -49,11 +49,11 @@ Undoable::Undoable(SpriteWriter& sprite, const char* label)
 
   m_sprite = sprite;
   m_committed = false;
-  m_enabled_flag = undo_is_enabled(m_sprite->undo);
+  m_enabled_flag = undo_is_enabled(m_sprite->getUndo());
 
   if (is_enabled()) {
-    undo_set_label(m_sprite->undo, label);
-    undo_open(m_sprite->undo);
+    undo_set_label(m_sprite->getUndo(), label);
+    undo_open(m_sprite->getUndo());
   }
 }
 
@@ -61,16 +61,16 @@ Undoable::~Undoable()
 {
   if (is_enabled()) {
     // close the undo information
-    undo_close(m_sprite->undo);
+    undo_close(m_sprite->getUndo());
 
     // if it isn't committed, we have to rollback all changes
     if (!m_committed) {
       // undo the group of operations
-      undo_do_undo(m_sprite->undo);
+      undo_do_undo(m_sprite->getUndo());
 
       // clear the redo (sorry to the user, here we lost the old redo
       // information)
-      undo_clear_redo(m_sprite->undo);
+      undo_clear_redo(m_sprite->getUndo());
     }
   }
 }
@@ -91,11 +91,12 @@ void Undoable::set_number_of_frames(int frames)
 {
   assert(frames >= 1);
 
-  // increment frames counter in the sprite
+  // Save in undo the current totalFrames property
   if (is_enabled())
-    undo_set_frames(m_sprite->undo, m_sprite);
+    undo_set_frames(m_sprite->getUndo(), m_sprite);
 
-  sprite_set_frames(m_sprite, frames);
+  // Change the property
+  m_sprite->setTotalFrames(frames);
 }
 
 void Undoable::set_current_frame(int frame)
@@ -103,9 +104,9 @@ void Undoable::set_current_frame(int frame)
   assert(frame >= 0);
 
   if (is_enabled())
-    undo_int(m_sprite->undo, m_sprite, &m_sprite->frame);
+    undo_set_frame(m_sprite->getUndo(), m_sprite);
 
-  sprite_set_frame(m_sprite, frame);
+  m_sprite->setCurrentFrame(frame);
 }
 
 /**
@@ -117,9 +118,9 @@ void Undoable::set_current_frame(int frame)
 void Undoable::set_current_layer(Layer* layer)
 {
   if (is_enabled())
-    undo_set_layer(m_sprite->undo, m_sprite);
+    undo_set_layer(m_sprite->getUndo(), m_sprite);
 
-  sprite_set_layer(m_sprite, layer);
+  m_sprite->setCurrentLayer(layer);
 }
 
 void Undoable::set_sprite_size(int w, int h)
@@ -127,42 +128,44 @@ void Undoable::set_sprite_size(int w, int h)
   assert(w > 0);
   assert(h > 0);
 
-  if (is_enabled()) {
-    undo_int(m_sprite->undo, m_sprite, &m_sprite->w);
-    undo_int(m_sprite->undo, m_sprite, &m_sprite->h);
-  }
+  if (is_enabled())
+    undo_set_size(m_sprite->getUndo(), m_sprite);
 
-  sprite_set_size(m_sprite, w, h);
+  m_sprite->setSize(w, h);
 }
 
 void Undoable::crop_sprite(int x, int y, int w, int h, int bgcolor)
 {
   set_sprite_size(w, h);
 
-  displace_layers(m_sprite->get_folder(), -x, -y);
+  displace_layers(m_sprite->getFolder(), -x, -y);
 
-  Layer *background_layer = sprite_get_background_layer(m_sprite);
+  Layer *background_layer = m_sprite->getBackgroundLayer();
   if (background_layer)
-    crop_layer(background_layer, 0, 0, m_sprite->w, m_sprite->h, bgcolor);
+    crop_layer(background_layer, 0, 0, m_sprite->getWidth(), m_sprite->getHeight(), bgcolor);
 
-  if (!m_sprite->mask->is_empty())
-    set_mask_position(m_sprite->mask->x-x, m_sprite->mask->y-y);
+  if (!m_sprite->getMask()->is_empty())
+    set_mask_position(m_sprite->getMask()->x-x, m_sprite->getMask()->y-y);
 }
 
 void Undoable::autocrop_sprite(int bgcolor)
 {
-  int old_frame = m_sprite->frame;
+  int old_frame = m_sprite->getCurrentFrame();
   int x1, y1, x2, y2;
   int u1, v1, u2, v2;
 
   x1 = y1 = INT_MAX;
   x2 = y2 = INT_MIN;
 
-  Image* image = image_new(m_sprite->imgtype, m_sprite->w, m_sprite->h);
+  Image* image = image_new(m_sprite->getImgType(),
+			   m_sprite->getWidth(),
+			   m_sprite->getHeight());
+
+  for (int frame=0; frame<m_sprite->getTotalFrames(); ++frame) {
+    m_sprite->setCurrentFrame(frame);
 
-  for (m_sprite->frame=0; m_sprite->frame<m_sprite->frames; m_sprite->frame++) {
     image_clear(image, 0);
-    sprite_render(m_sprite, image, 0, 0);
+    m_sprite->render(image, 0, 0);
 
     // TODO configurable (what color pixel to use as "refpixel",
     // here we are using the top-left pixel by default)
@@ -174,7 +177,7 @@ void Undoable::autocrop_sprite(int bgcolor)
       y2 = MAX(y2, v2);
     }
   }
-  m_sprite->frame = old_frame;
+  m_sprite->setCurrentFrame(old_frame);
 
   image_free(image);
 
@@ -194,41 +197,40 @@ void Undoable::set_imgtype(int new_imgtype, int dithering_method)
   Image *new_image;
   int c;
 
-  if (m_sprite->imgtype == new_imgtype)
+  if (m_sprite->getImgType() == new_imgtype)
     return;
 
   /* change imgtype of the stock of images */
   if (is_enabled())
-    undo_int(m_sprite->undo, (GfxObj *)m_sprite->stock, &m_sprite->stock->imgtype);
+    undo_int(m_sprite->getUndo(), m_sprite->getStock(), &m_sprite->getStock()->imgtype);
 
-  m_sprite->stock->imgtype = new_imgtype;
+  m_sprite->getStock()->imgtype = new_imgtype;
 
-  for (c=0; c<m_sprite->stock->nimage; c++) {
-    old_image = stock_get_image(m_sprite->stock, c);
+  for (c=0; c<m_sprite->getStock()->nimage; c++) {
+    old_image = stock_get_image(m_sprite->getStock(), c);
     if (!old_image)
       continue;
 
     new_image = image_set_imgtype(old_image, new_imgtype, dithering_method,
 				  rgb_map,
-				  /* TODO check this out */
-				  sprite_get_palette(m_sprite,
-						     m_sprite->frame));
+				  // TODO check this out
+				  m_sprite->getCurrentPalette());
     if (!new_image)
       return;		/* TODO error handling: not enough memory!
 			   we should undo all work done */
 
     if (is_enabled())
-      undo_replace_image(m_sprite->undo, m_sprite->stock, c);
+      undo_replace_image(m_sprite->getUndo(), m_sprite->getStock(), c);
 
     image_free(old_image);
-    stock_replace_image(m_sprite->stock, c, new_image);
+    stock_replace_image(m_sprite->getStock(), c, new_image);
   }
 
   /* change "sprite.imgtype" field */
   if (is_enabled())
-    undo_int(m_sprite->undo, m_sprite, &m_sprite->imgtype);
+    undo_set_imgtype(m_sprite->getUndo(), m_sprite);
 
-  m_sprite->imgtype = new_imgtype;
+  m_sprite->setImgType(new_imgtype);
 
   // change "sprite.palette"
   if (new_imgtype == IMAGE_GRAYSCALE) {
@@ -237,16 +239,16 @@ void Undoable::set_imgtype(int new_imgtype, int dithering_method)
       JLink link;
 
       // Save all palettes
-      JI_LIST_FOR_EACH(m_sprite->palettes, link) {
+      JI_LIST_FOR_EACH(m_sprite->getPalettes(), link) {
 	palette = reinterpret_cast<Palette*>(link->data);
-	undo_remove_palette(m_sprite->undo, m_sprite, palette);
+	undo_remove_palette(m_sprite->getUndo(), m_sprite, palette);
       }
     }
 
     std::auto_ptr<Palette> graypal(Palette::createGrayscale());
 
-    sprite_reset_palettes(m_sprite);
-    sprite_set_palette(m_sprite, graypal.get(), true);
+    m_sprite->resetPalettes();
+    m_sprite->setPalette(graypal.get(), true);
   }
 }
 
@@ -261,10 +263,10 @@ int Undoable::add_image_in_stock(Image* image)
   assert(image);
 
   // add the image in the stock
-  int image_index = stock_add_image(m_sprite->stock, image);
+  int image_index = stock_add_image(m_sprite->getStock(), image);
 
   if (is_enabled())
-    undo_add_image(m_sprite->undo, m_sprite->stock, image_index);
+    undo_add_image(m_sprite->getUndo(), m_sprite->getStock(), image_index);
 
   return image_index;
 }
@@ -276,27 +278,27 @@ void Undoable::remove_image_from_stock(int image_index)
 {
   assert(image_index >= 0);
 
-  Image* image = stock_get_image(m_sprite->stock, image_index);
+  Image* image = stock_get_image(m_sprite->getStock(), image_index);
   assert(image);
 
   if (is_enabled())
-    undo_remove_image(m_sprite->undo, m_sprite->stock, image_index);
+    undo_remove_image(m_sprite->getUndo(), m_sprite->getStock(), image_index);
 
-  stock_remove_image(m_sprite->stock, image);
+  stock_remove_image(m_sprite->getStock(), image);
   image_free(image);
 }
 
 void Undoable::replace_stock_image(int image_index, Image* new_image)
 {
   // get the current image in the 'image_index' position
-  Image* old_image = stock_get_image(m_sprite->stock, image_index);
+  Image* old_image = stock_get_image(m_sprite->getStock(), image_index);
   assert(old_image);
 
   // replace the image in the stock
   if (is_enabled())
-    undo_replace_image(m_sprite->undo, m_sprite->stock, image_index);
+    undo_replace_image(m_sprite->getUndo(), m_sprite->getStock(), image_index);
 
-  stock_replace_image(m_sprite->stock, image_index, new_image);
+  stock_replace_image(m_sprite->getStock(), image_index, new_image);
 
   // destroy the old image
   image_free(old_image);
@@ -315,9 +317,9 @@ Layer* Undoable::new_layer()
 
   // add the layer in the sprite set
   if (is_enabled())
-    undo_add_layer(m_sprite->undo, m_sprite->get_folder(), layer);
+    undo_add_layer(m_sprite->getUndo(), m_sprite->getFolder(), layer);
 
-  m_sprite->get_folder()->add_layer(layer);
+  m_sprite->getFolder()->add_layer(layer);
 
   // select the new layer
   set_current_layer(layer);
@@ -335,7 +337,7 @@ void Undoable::remove_layer(Layer* layer)
   LayerFolder* parent = layer->get_parent();
 
   // if the layer to be removed is the selected layer
-  if (layer == m_sprite->layer) {
+  if (layer == m_sprite->getCurrentLayer()) {
     Layer* layer_select = NULL;
 
     // select: previous layer, or next layer, or parent(if it is not the
@@ -344,7 +346,7 @@ void Undoable::remove_layer(Layer* layer)
       layer_select = layer->get_prev();
     else if (layer->get_next())
       layer_select = layer->get_next();
-    else if (parent != m_sprite->get_folder())
+    else if (parent != m_sprite->getFolder())
       layer_select = parent;
 
     // select other layer
@@ -353,7 +355,7 @@ void Undoable::remove_layer(Layer* layer)
 
   // remove the layer
   if (is_enabled())
-    undo_remove_layer(m_sprite->undo, layer);
+    undo_remove_layer(m_sprite->getUndo(), layer);
 
   parent->remove_layer(layer);
 
@@ -364,7 +366,7 @@ void Undoable::remove_layer(Layer* layer)
 void Undoable::move_layer_after(Layer* layer, Layer* after_this)
 {
   if (is_enabled())
-    undo_move_layer(m_sprite->undo, layer);
+    undo_move_layer(m_sprite->getUndo(), layer);
 
   layer->get_parent()->move_layer(layer, after_this);
 }
@@ -418,11 +420,13 @@ void Undoable::background_from_layer(LayerImage* layer, int bgcolor)
   assert(layer->is_readable());
   assert(layer->is_writable());
   assert(layer->getSprite() == m_sprite);
-  assert(sprite_get_background_layer(m_sprite) == NULL);
+  assert(m_sprite->getBackgroundLayer() == NULL);
 
   // create a temporary image to draw each frame of the new
   // `Background' layer
-  std::auto_ptr<Image> bg_image_wrap(image_new(m_sprite->imgtype, m_sprite->w, m_sprite->h));
+  std::auto_ptr<Image> bg_image_wrap(image_new(m_sprite->getImgType(),
+					       m_sprite->getWidth(),
+					       m_sprite->getHeight()));
   Image* bg_image = bg_image_wrap.get();
 
   CelIterator it = layer->get_cel_begin();
@@ -431,10 +435,10 @@ void Undoable::background_from_layer(LayerImage* layer, int bgcolor)
   for (; it != end; ++it) {
     Cel* cel = *it;
     assert((cel->image > 0) &&
-	   (cel->image < m_sprite->stock->nimage));
+	   (cel->image < m_sprite->getStock()->nimage));
 
     // get the image from the sprite's stock of images
-    Image* cel_image = stock_get_image(m_sprite->stock, cel->image);
+    Image* cel_image = stock_get_image(m_sprite->getStock(), cel->image);
     assert(cel_image);
 
     image_clear(bg_image, bgcolor);
@@ -451,7 +455,7 @@ void Undoable::background_from_layer(LayerImage* layer, int bgcolor)
     if (bg_image->w == cel_image->w &&
 	bg_image->h == cel_image->h) {
       if (is_enabled())
-	undo_image(m_sprite->undo, cel_image, 0, 0, cel_image->w, cel_image->h);
+	undo_image(m_sprite->getUndo(), cel_image, 0, 0, cel_image->w, cel_image->h);
 
       image_copy(cel_image, bg_image, 0, 0);
     }
@@ -461,10 +465,10 @@ void Undoable::background_from_layer(LayerImage* layer, int bgcolor)
   }
 
   // Fill all empty cels with a flat-image filled with bgcolor
-  for (int frame=0; frame<m_sprite->frames; frame++) {
+  for (int frame=0; frame<m_sprite->getTotalFrames(); frame++) {
     Cel* cel = layer->get_cel(frame);
     if (!cel) {
-      Image* cel_image = image_new(m_sprite->imgtype, m_sprite->w, m_sprite->h);
+      Image* cel_image = image_new(m_sprite->getImgType(), m_sprite->getWidth(), m_sprite->getHeight());
       image_clear(cel_image, bgcolor);
 
       // Add the new image in the stock
@@ -481,25 +485,25 @@ void Undoable::background_from_layer(LayerImage* layer, int bgcolor)
 
 void Undoable::layer_from_background()
 {
-  assert(sprite_get_background_layer(m_sprite) != NULL);
-  assert(m_sprite->layer != NULL);
-  assert(m_sprite->layer->is_image());
-  assert(m_sprite->layer->is_readable());
-  assert(m_sprite->layer->is_writable());
-  assert(m_sprite->layer->is_background());
+  assert(m_sprite->getBackgroundLayer() != NULL);
+  assert(m_sprite->getCurrentLayer() != NULL);
+  assert(m_sprite->getCurrentLayer()->is_image());
+  assert(m_sprite->getCurrentLayer()->is_readable());
+  assert(m_sprite->getCurrentLayer()->is_writable());
+  assert(m_sprite->getCurrentLayer()->is_background());
 
   if (is_enabled()) {
-    undo_data(m_sprite->undo,
-	      m_sprite->layer,
-	      m_sprite->layer->flags_addr(),
-	      sizeof(*m_sprite->layer->flags_addr()));
+    undo_data(m_sprite->getUndo(),
+	      m_sprite->getCurrentLayer(),
+	      m_sprite->getCurrentLayer()->flags_addr(),
+	      sizeof(*m_sprite->getCurrentLayer()->flags_addr()));
 
-    undo_set_layer_name(m_sprite->undo, m_sprite->layer);
+    undo_set_layer_name(m_sprite->getUndo(), m_sprite->getCurrentLayer());
   }
 
-  m_sprite->layer->set_background(false);
-  m_sprite->layer->set_moveable(true);
-  m_sprite->layer->set_name("Layer 0");
+  m_sprite->getCurrentLayer()->set_background(false);
+  m_sprite->getCurrentLayer()->set_moveable(true);
+  m_sprite->getCurrentLayer()->set_name("Layer 0");
 }
 
 void Undoable::flatten_layers(int bgcolor)
@@ -509,42 +513,44 @@ void Undoable::flatten_layers(int bgcolor)
   int frame;
 
   // create a temporary image
-  std::auto_ptr<Image> image_wrap(image_new(m_sprite->imgtype, m_sprite->w, m_sprite->h));
+  std::auto_ptr<Image> image_wrap(image_new(m_sprite->getImgType(),
+					    m_sprite->getWidth(),
+					    m_sprite->getHeight()));
   Image* image = image_wrap.get();
 
   /* get the background layer from the sprite */
-  LayerImage* background = sprite_get_background_layer(m_sprite);
+  LayerImage* background = m_sprite->getBackgroundLayer();
   if (!background) {
     /* if there aren't a background layer we must to create the background */
     background = new LayerImage(m_sprite);
 
     if (is_enabled())
-      undo_add_layer(m_sprite->undo, m_sprite->get_folder(), background);
+      undo_add_layer(m_sprite->getUndo(), m_sprite->getFolder(), background);
 
-    m_sprite->get_folder()->add_layer(background);
+    m_sprite->getFolder()->add_layer(background);
 
     if (is_enabled())
-      undo_move_layer(m_sprite->undo, background);
+      undo_move_layer(m_sprite->getUndo(), background);
     
     background->configure_as_background();
   }
 
   /* copy all frames to the background */
-  for (frame=0; frame<m_sprite->frames; frame++) {
+  for (frame=0; frame<m_sprite->getTotalFrames(); frame++) {
     /* clear the image and render this frame */
     image_clear(image, bgcolor);
-    layer_render(m_sprite->get_folder(), image, 0, 0, frame);
+    layer_render(m_sprite->getFolder(), image, 0, 0, frame);
 
     cel = background->get_cel(frame);
     if (cel) {
-      cel_image = m_sprite->stock->image[cel->image];
+      cel_image = m_sprite->getStock()->image[cel->image];
       assert(cel_image != NULL);
 
       /* we have to save the current state of `cel_image' in the undo */
       if (is_enabled()) {
 	Dirty* dirty = dirty_new_from_differences(cel_image, image);
 	dirty_save_image_data(dirty);
-	undo_dirty(m_sprite->undo, dirty);
+	undo_dirty(m_sprite->getUndo(), dirty);
       }
     }
     else {
@@ -554,7 +560,7 @@ void Undoable::flatten_layers(int bgcolor)
       /* TODO error handling: if (!cel_image) { ... } */
 
       /* here we create the new cel (with the new image `cel_image') */
-      cel = cel_new(frame, stock_add_image(m_sprite->stock, cel_image));
+      cel = cel_new(frame, stock_add_image(m_sprite->getStock(), cel_image));
       /* TODO error handling: if (!cel) { ... } */
 
       /* and finally we add the cel in the background */
@@ -565,15 +571,15 @@ void Undoable::flatten_layers(int bgcolor)
   }
 
   /* select the background */
-  if (m_sprite->layer != background) {
+  if (m_sprite->getCurrentLayer() != background) {
     if (is_enabled())
-      undo_set_layer(m_sprite->undo, m_sprite);
+      undo_set_layer(m_sprite->getUndo(), m_sprite);
 
-    sprite_set_layer(m_sprite, background);
+    m_sprite->setCurrentLayer(background);
   }
 
   /* remove old layers */
-  LayerList layers = m_sprite->get_folder()->get_layers_list();
+  LayerList layers = m_sprite->getFolder()->get_layers_list();
   LayerIterator it = layers.begin();
   LayerIterator end = layers.end();
 
@@ -583,9 +589,9 @@ void Undoable::flatten_layers(int bgcolor)
 
       // remove the layer
       if (is_enabled())
-	undo_remove_layer(m_sprite->undo, old_layer);
+	undo_remove_layer(m_sprite->getUndo(), old_layer);
 
-      m_sprite->get_folder()->remove_layer(old_layer);
+      m_sprite->getFolder()->remove_layer(old_layer);
 
       // destroy the layer
       delete old_layer;
@@ -596,9 +602,9 @@ void Undoable::flatten_layers(int bgcolor)
 void Undoable::configure_layer_as_background(LayerImage* layer)
 {
   if (is_enabled()) {
-    undo_data(m_sprite->undo, layer, layer->flags_addr(), sizeof(*layer->flags_addr()));
-    undo_set_layer_name(m_sprite->undo, layer);
-    undo_move_layer(m_sprite->undo, layer);
+    undo_data(m_sprite->getUndo(), layer, layer->flags_addr(), sizeof(*layer->flags_addr()));
+    undo_set_layer_name(m_sprite->getUndo(), layer);
+    undo_move_layer(m_sprite->getUndo(), layer);
   }
 
   layer->configure_as_background();
@@ -607,14 +613,14 @@ void Undoable::configure_layer_as_background(LayerImage* layer)
 void Undoable::new_frame()
 {
   // add a new cel to every layer
-  new_frame_for_layer(m_sprite->get_folder(),
-		      m_sprite->frame+1);
+  new_frame_for_layer(m_sprite->getFolder(),
+		      m_sprite->getCurrentFrame()+1);
 
   // increment frames counter in the sprite
-  set_number_of_frames(m_sprite->frames+1);
+  set_number_of_frames(m_sprite->getTotalFrames()+1);
 
   // go to next frame (the new one)
-  set_current_frame(m_sprite->frame+1);
+  set_current_frame(m_sprite->getCurrentFrame()+1);
 }
 
 void Undoable::new_frame_for_layer(Layer* layer, int frame)
@@ -626,7 +632,7 @@ void Undoable::new_frame_for_layer(Layer* layer, int frame)
 
     case GFXOBJ_LAYER_IMAGE:
       // displace all cels in '>=frame' to the next frame
-      for (int c=m_sprite->frames-1; c>=frame; --c) {
+      for (int c=m_sprite->getTotalFrames()-1; c>=frame; --c) {
 	Cel* cel = static_cast<LayerImage*>(layer)->get_cel(c);
 	if (cel)
 	  set_cel_frame_position(cel, cel->frame+1);
@@ -651,23 +657,19 @@ void Undoable::remove_frame(int frame)
 {
   assert(frame >= 0);
 
-  // remove cels from this frame (and displace one position backward
+  // Remove cels from this frame (and displace one position backward
   // all next frames)
-  remove_frame_of_layer(m_sprite->get_folder(), frame);
+  remove_frame_of_layer(m_sprite->getFolder(), frame);
 
-  /* decrement frames counter in the sprite */
-  if (is_enabled())
-    undo_set_frames(m_sprite->undo, m_sprite);
+  // New value for totalFrames propety
+  int newTotalFrames = m_sprite->getTotalFrames()-1;
 
-  sprite_set_frames(m_sprite, m_sprite->frames-1);
+  // Move backward if we will be outside the range of frames
+  if (m_sprite->getCurrentFrame() >= newTotalFrames)
+    set_current_frame(newTotalFrames-1);
 
-  /* move backward if we are outside the range of frames */
-  if (m_sprite->frame >= m_sprite->frames) {
-    if (is_enabled())
-      undo_int(m_sprite->undo, m_sprite, &m_sprite->frame);
-
-    sprite_set_frame(m_sprite, m_sprite->frames-1);
-  }
+  // Decrement frames counter in the sprite
+  set_number_of_frames(newTotalFrames);
 }
 
 void Undoable::remove_frame_of_layer(Layer* layer, int frame)
@@ -681,7 +683,7 @@ void Undoable::remove_frame_of_layer(Layer* layer, int frame)
       if (Cel* cel = static_cast<LayerImage*>(layer)->get_cel(frame))
 	remove_cel(static_cast<LayerImage*>(layer), cel);
 
-      for (++frame; frame<m_sprite->frames; ++frame)
+      for (++frame; frame<m_sprite->getTotalFrames(); ++frame)
 	if (Cel* cel = static_cast<LayerImage*>(layer)->get_cel(frame))
 	  set_cel_frame_position(cel, cel->frame-1);
       break;
@@ -708,7 +710,7 @@ void Undoable::copy_previous_frame(Layer* layer, int frame)
 
   // create a copy of the previous cel
   Cel* src_cel = static_cast<LayerImage*>(layer)->get_cel(frame-1);
-  Image* src_image = src_cel ? stock_get_image(m_sprite->stock,
+  Image* src_image = src_cel ? stock_get_image(m_sprite->getStock(),
 					       src_cel->image):
 			       NULL;
 
@@ -737,7 +739,7 @@ void Undoable::add_cel(LayerImage* layer, Cel* cel)
   assert(cel);
 
   if (is_enabled())
-    undo_add_cel(m_sprite->undo, layer, cel);
+    undo_add_cel(m_sprite->getUndo(), layer, cel);
 
   layer->add_cel(cel);
 }
@@ -750,7 +752,7 @@ void Undoable::remove_cel(LayerImage* layer, Cel* cel)
   // find if the image that use the cel to remove, is used by
   // another cels
   bool used = false;
-  for (int frame=0; frame<m_sprite->frames; ++frame) {
+  for (int frame=0; frame<m_sprite->getTotalFrames(); ++frame) {
     Cel* it = layer->get_cel(frame);
     if (it && it != cel && it->image == cel->image) {
       used = true;
@@ -764,7 +766,7 @@ void Undoable::remove_cel(LayerImage* layer, Cel* cel)
     remove_image_from_stock(cel->image);
 
   if (is_enabled())
-    undo_remove_cel(m_sprite->undo, layer, cel);
+    undo_remove_cel(m_sprite->getUndo(), layer, cel);
 
   // remove the cel from the layer
   layer->remove_cel(cel);
@@ -779,7 +781,7 @@ void Undoable::set_cel_frame_position(Cel* cel, int frame)
   assert(frame >= 0);
 
   if (is_enabled())
-    undo_int(m_sprite->undo, cel, &cel->frame);
+    undo_int(m_sprite->getUndo(), cel, &cel->frame);
 
   cel->frame = frame;
 }
@@ -789,8 +791,8 @@ void Undoable::set_cel_position(Cel* cel, int x, int y)
   assert(cel);
 
   if (is_enabled()) {
-    undo_int(m_sprite->undo, cel, &cel->x);
-    undo_int(m_sprite->undo, cel, &cel->y);
+    undo_int(m_sprite->getUndo(), cel, &cel->x);
+    undo_int(m_sprite->getUndo(), cel, &cel->y);
   }
 
   cel->x = x;
@@ -800,53 +802,49 @@ void Undoable::set_cel_position(Cel* cel, int x, int y)
 void Undoable::set_frame_duration(int frame, int msecs)
 {
   if (is_enabled())
-    undo_set_frlen(m_sprite->undo, m_sprite, frame);
+    undo_set_frlen(m_sprite->getUndo(), m_sprite, frame);
 
-  sprite_set_frlen(m_sprite, frame, msecs);
+  m_sprite->setFrameDuration(frame, msecs);
 }
 
 void Undoable::set_constant_frame_rate(int msecs)
 {
   if (is_enabled()) {
-    for (int fr=0; fr<m_sprite->frames; ++fr)
-      undo_set_frlen(m_sprite->undo, m_sprite, fr);
+    for (int fr=0; fr<m_sprite->getTotalFrames(); ++fr)
+      undo_set_frlen(m_sprite->getUndo(), m_sprite, fr);
   }
 
-  sprite_set_speed(m_sprite, msecs);
+  m_sprite->setDurationForAllFrames(msecs);
 }
 
 void Undoable::move_frame_before(int frame, int before_frame)
 {
   if (frame != before_frame &&
       frame >= 0 &&
-      frame < m_sprite->frames &&
+      frame < m_sprite->getTotalFrames() &&
       before_frame >= 0 &&
-      before_frame < m_sprite->frames) {
+      before_frame < m_sprite->getTotalFrames()) {
     // change the frame-lengths...
 
-    int frlen_aux = m_sprite->frlens[frame];
+    int frlen_aux = m_sprite->getFrameDuration(frame);
 
     // moving the frame to the future
     if (frame < before_frame) {
-      frlen_aux = m_sprite->frlens[frame];
-
       for (int c=frame; c<before_frame-1; c++)
-	set_frame_duration(c, m_sprite->frlens[c+1]);
+	set_frame_duration(c, m_sprite->getFrameDuration(c+1));
 
       set_frame_duration(before_frame-1, frlen_aux);
     }
     // moving the frame to the past
     else if (before_frame < frame) {
-      frlen_aux = m_sprite->frlens[frame];
-
       for (int c=frame; c>before_frame; c--)
-	set_frame_duration(c, m_sprite->frlens[c-1]);
+	set_frame_duration(c, m_sprite->getFrameDuration(c-1));
 
       set_frame_duration(before_frame, frlen_aux);
     }
 
     // change the cels of position...
-    move_frame_before_layer(m_sprite->get_folder(), frame, before_frame);
+    move_frame_before_layer(m_sprite->getFolder(), frame, before_frame);
   }
 }
 
@@ -905,15 +903,15 @@ void Undoable::move_frame_before_layer(Layer* layer, int frame, int before_frame
 
 Cel* Undoable::get_current_cel()
 {
-  if (m_sprite->layer && m_sprite->layer->is_image())
-    return static_cast<LayerImage*>(m_sprite->layer)->get_cel(m_sprite->frame);
+  if (m_sprite->getCurrentLayer() && m_sprite->getCurrentLayer()->is_image())
+    return static_cast<LayerImage*>(m_sprite->getCurrentLayer())->get_cel(m_sprite->getCurrentFrame());
   else
     return NULL;
 }
 
 void Undoable::crop_cel(Cel* cel, int x, int y, int w, int h, int bgcolor)
 {
-  Image* cel_image = stock_get_image(m_sprite->stock, cel->image);
+  Image* cel_image = stock_get_image(m_sprite->getStock(), cel->image);
   assert(cel_image);
     
   // create the new image through a crop
@@ -928,8 +926,8 @@ void Undoable::crop_cel(Cel* cel, int x, int y, int w, int h, int bgcolor)
 
 Image* Undoable::get_cel_image(Cel* cel)
 {
-  if (cel && cel->image >= 0 && cel->image < m_sprite->stock->nimage)
-    return m_sprite->stock->image[cel->image];
+  if (cel && cel->image >= 0 && cel->image < m_sprite->getStock()->nimage)
+    return m_sprite->getStock()->image[cel->image];
   else
     return NULL;
 }
@@ -947,11 +945,11 @@ void Undoable::clear_mask(int bgcolor)
 
   // if the mask is empty then we have to clear the entire image
   // in the cel
-  if (m_sprite->mask->is_empty()) {
+  if (m_sprite->getMask()->is_empty()) {
     // if the layer is the background then we clear the image
-    if (m_sprite->layer->is_background()) {
+    if (m_sprite->getCurrentLayer()->is_background()) {
       if (is_enabled())
-	undo_image(m_sprite->undo, image, 0, 0, image->w, image->h);
+	undo_image(m_sprite->getUndo(), image, 0, 0, image->w, image->h);
 
       // clear all
       image_clear(image, bgcolor);
@@ -959,32 +957,32 @@ void Undoable::clear_mask(int bgcolor)
     // if the layer is transparent we can remove the cel (and its
     // associated image)
     else {
-      remove_cel(static_cast<LayerImage*>(m_sprite->layer), cel);
+      remove_cel(static_cast<LayerImage*>(m_sprite->getCurrentLayer()), cel);
     }
   }
   else {
     int u, v, putx, puty;
-    int x1 = MAX(0, m_sprite->mask->x);
-    int y1 = MAX(0, m_sprite->mask->y);
-    int x2 = MIN(image->w-1, m_sprite->mask->x+m_sprite->mask->w-1);
-    int y2 = MIN(image->h-1, m_sprite->mask->y+m_sprite->mask->h-1);
+    int x1 = MAX(0, m_sprite->getMask()->x);
+    int y1 = MAX(0, m_sprite->getMask()->y);
+    int x2 = MIN(image->w-1, m_sprite->getMask()->x+m_sprite->getMask()->w-1);
+    int y2 = MIN(image->h-1, m_sprite->getMask()->y+m_sprite->getMask()->h-1);
 
     // do nothing
     if (x1 > x2 || y1 > y2)
       return;
 
     if (is_enabled())
-      undo_image(m_sprite->undo, image, x1, y1, x2-x1+1, y2-y1+1);
+      undo_image(m_sprite->getUndo(), image, x1, y1, x2-x1+1, y2-y1+1);
 
     // clear the masked zones
-    for (v=0; v<m_sprite->mask->h; v++) {
+    for (v=0; v<m_sprite->getMask()->h; v++) {
       div_t d = div(0, 8);
-      ase_uint8* address = ((ase_uint8 **)m_sprite->mask->bitmap->line)[v]+d.quot;
+      ase_uint8* address = ((ase_uint8 **)m_sprite->getMask()->bitmap->line)[v]+d.quot;
 
-      for (u=0; u<m_sprite->mask->w; u++) {
+      for (u=0; u<m_sprite->getMask()->w; u++) {
 	if ((*address & (1<<d.rem))) {
-	  putx = u + m_sprite->mask->x - cel->x;
-	  puty = v + m_sprite->mask->y - cel->y;
+	  putx = u + m_sprite->getMask()->x - cel->x;
+	  puty = v + m_sprite->getMask()->y - cel->y;
 	  image_putpixel(image, putx, puty, bgcolor);
 	}
 
@@ -1000,10 +998,10 @@ void Undoable::flip_image(Image* image, int x1, int y1, int x2, int y2,
   // insert the undo operation
   if (is_enabled()) {
     if (flip_horizontal)
-      undo_flip(m_sprite->undo, image, x1, y1, x2, y2, true);
+      undo_flip(m_sprite->getUndo(), image, x1, y1, x2, y2, true);
 
     if (flip_vertical)
-      undo_flip(m_sprite->undo, image, x1, y1, x2, y2, false);
+      undo_flip(m_sprite->getUndo(), image, x1, y1, x2, y2, false);
   }
 
   // flip the portion of the bitmap
@@ -1022,45 +1020,45 @@ void Undoable::flip_image(Image* image, int x1, int y1, int x2, int y2,
 
 void Undoable::copy_to_current_mask(Mask* mask)
 {
-  assert(m_sprite->mask);
+  assert(m_sprite->getMask());
   assert(mask);
 
   if (is_enabled())
-    undo_set_mask(m_sprite->undo, m_sprite);
+    undo_set_mask(m_sprite->getUndo(), m_sprite);
 
-  mask_copy(m_sprite->mask, mask);
+  mask_copy(m_sprite->getMask(), mask);
 }
 
 void Undoable::set_mask_position(int x, int y)
 {
-  assert(m_sprite->mask);
+  assert(m_sprite->getMask());
 
   if (is_enabled()) {
-    undo_int(m_sprite->undo, m_sprite->mask, &m_sprite->mask->x);
-    undo_int(m_sprite->undo, m_sprite->mask, &m_sprite->mask->y);
+    undo_int(m_sprite->getUndo(), m_sprite->getMask(), &m_sprite->getMask()->x);
+    undo_int(m_sprite->getUndo(), m_sprite->getMask(), &m_sprite->getMask()->y);
   }
 
-  m_sprite->mask->x = x;
-  m_sprite->mask->y = y;
+  m_sprite->getMask()->x = x;
+  m_sprite->getMask()->y = y;
 }
 
 void Undoable::deselect_mask()
 {
   // Destroy the *deselected* mask
-  Mask* mask = sprite_request_mask(m_sprite, "*deselected*");
+  Mask* mask = m_sprite->requestMask("*deselected*");
   if (mask) {
-    sprite_remove_mask(m_sprite, mask);
+    m_sprite->removeMask(mask);
     mask_free(mask);
   }
 
   // Save the selection in the repository
-  mask = mask_new_copy(m_sprite->mask);
+  mask = mask_new_copy(m_sprite->getMask());
   mask_set_name(mask, "*deselected*");
-  sprite_add_mask(m_sprite, mask);
+  m_sprite->addMask(mask);
 
-  if (undo_is_enabled(m_sprite->undo))
-    undo_set_mask(m_sprite->undo, m_sprite);
+  if (undo_is_enabled(m_sprite->getUndo()))
+    undo_set_mask(m_sprite->getUndo(), m_sprite);
 
   /// Deselect the mask
-  mask_none(m_sprite->mask);
+  mask_none(m_sprite->getMask());
 }

src/util/celmove.cpp

@@ -60,8 +60,8 @@ void move_cel(SpriteWriter& sprite)
 
   assert(src_layer != NULL);
   assert(dst_layer != NULL);
-  assert(src_frame >= 0 && src_frame < sprite->frames);
-  assert(dst_frame >= 0 && dst_frame < sprite->frames);
+  assert(src_frame >= 0 && src_frame < sprite->getTotalFrames());
+  assert(dst_frame >= 0 && dst_frame < sprite->getTotalFrames());
 
   if (src_layer->is_background()) {
     copy_cel(sprite);
@@ -71,16 +71,16 @@ void move_cel(SpriteWriter& sprite)
   src_cel = static_cast<LayerImage*>(src_layer)->get_cel(src_frame);
   dst_cel = static_cast<LayerImage*>(dst_layer)->get_cel(dst_frame);
 
-  if (undo_is_enabled(sprite->undo)) {
-    undo_set_label(sprite->undo, "Move Cel");
-    undo_open(sprite->undo);
+  if (undo_is_enabled(sprite->getUndo())) {
+    undo_set_label(sprite->getUndo(), "Move Cel");
+    undo_open(sprite->getUndo());
 
-    undo_set_layer(sprite->undo, sprite);
-    undo_int(sprite->undo, sprite, &sprite->frame);
+    undo_set_layer(sprite->getUndo(), sprite);
+    undo_set_frame(sprite->getUndo(), sprite);
   }
 
-  sprite_set_layer(sprite, dst_layer);
-  sprite_set_frame(sprite, dst_frame);
+  sprite->setCurrentLayer(dst_layer);
+  sprite->setCurrentFrame(dst_frame);
 
   /* remove the 'dst_cel' (if it exists) because it must be
      replaced with 'src_cel' */
@@ -90,15 +90,15 @@ void move_cel(SpriteWriter& sprite)
   /* move the cel in the same layer */
   if (src_cel != NULL) {
     if (src_layer == dst_layer) {
-      if (undo_is_enabled(sprite->undo))
-	undo_int(sprite->undo, (GfxObj *)src_cel, &src_cel->frame);
+      if (undo_is_enabled(sprite->getUndo()))
+	undo_int(sprite->getUndo(), (GfxObj *)src_cel, &src_cel->frame);
 
       src_cel->frame = dst_frame;
     }
     /* move the cel in different layers */
     else {
-      if (undo_is_enabled(sprite->undo))
-	undo_remove_cel(sprite->undo, src_layer, src_cel);
+      if (undo_is_enabled(sprite->getUndo()))
+	undo_remove_cel(sprite->getUndo(), src_layer, src_cel);
       static_cast<LayerImage*>(src_layer)->remove_cel(src_cel);
 
       src_cel->frame = dst_frame;
@@ -108,18 +108,18 @@ void move_cel(SpriteWriter& sprite)
 	 image */
       if (!src_layer->is_background() &&
 	  dst_layer->is_background()) {
-	Image *src_image = stock_get_image(sprite->stock, src_cel->image);
+	Image *src_image = stock_get_image(sprite->getStock(), src_cel->image);
 	Image *dst_image = image_crop(src_image,
 				      -src_cel->x,
 				      -src_cel->y,
-				      sprite->w,
-				      sprite->h, 0);
+				      sprite->getWidth(),
+				      sprite->getHeight(), 0);
 
-	if (undo_is_enabled(sprite->undo)) {
-	  undo_replace_image(sprite->undo, sprite->stock, src_cel->image);
-	  undo_int(sprite->undo, (GfxObj *)src_cel, &src_cel->x);
-	  undo_int(sprite->undo, (GfxObj *)src_cel, &src_cel->y);
-	  undo_int(sprite->undo, (GfxObj *)src_cel, &src_cel->opacity);
+	if (undo_is_enabled(sprite->getUndo())) {
+	  undo_replace_image(sprite->getUndo(), sprite->getStock(), src_cel->image);
+	  undo_int(sprite->getUndo(), (GfxObj *)src_cel, &src_cel->x);
+	  undo_int(sprite->getUndo(), (GfxObj *)src_cel, &src_cel->y);
+	  undo_int(sprite->getUndo(), (GfxObj *)src_cel, &src_cel->opacity);
 	}
 
 	image_clear(dst_image, app_get_color_to_clear_layer(dst_layer));
@@ -129,19 +129,19 @@ void move_cel(SpriteWriter& sprite)
 	src_cel->y = 0;
 	src_cel->opacity = 255;
 
-	stock_replace_image(sprite->stock, src_cel->image, dst_image);
+	stock_replace_image(sprite->getStock(), src_cel->image, dst_image);
 	image_free(src_image);
       }
       
-      if (undo_is_enabled(sprite->undo))
-	undo_add_cel(sprite->undo, dst_layer, src_cel);
+      if (undo_is_enabled(sprite->getUndo()))
+	undo_add_cel(sprite->getUndo(), dst_layer, src_cel);
 
       static_cast<LayerImage*>(dst_layer)->add_cel(src_cel);
     }
   }
 
-  if (undo_is_enabled(sprite->undo))
-    undo_close(sprite->undo);
+  if (undo_is_enabled(sprite->getUndo()))
+    undo_close(sprite->getUndo());
 
   set_frame_to_handle(NULL, 0, NULL, 0);
 }
@@ -152,22 +152,22 @@ void copy_cel(SpriteWriter& sprite)
 
   assert(src_layer != NULL);
   assert(dst_layer != NULL);
-  assert(src_frame >= 0 && src_frame < sprite->frames);
-  assert(dst_frame >= 0 && dst_frame < sprite->frames);
+  assert(src_frame >= 0 && src_frame < sprite->getTotalFrames());
+  assert(dst_frame >= 0 && dst_frame < sprite->getTotalFrames());
 
   src_cel = static_cast<LayerImage*>(src_layer)->get_cel(src_frame);
   dst_cel = static_cast<LayerImage*>(dst_layer)->get_cel(dst_frame);
 
-  if (undo_is_enabled(sprite->undo)) {
-    undo_set_label(sprite->undo, "Move Cel");
-    undo_open(sprite->undo);
+  if (undo_is_enabled(sprite->getUndo())) {
+    undo_set_label(sprite->getUndo(), "Move Cel");
+    undo_open(sprite->getUndo());
 
-    undo_set_layer(sprite->undo, sprite);
-    undo_int(sprite->undo, sprite, &sprite->frame);
+    undo_set_layer(sprite->getUndo(), sprite);
+    undo_set_frame(sprite->getUndo(), sprite);
   }
 
-  sprite_set_layer(sprite, dst_layer);
-  sprite_set_frame(sprite, dst_frame);
+  sprite->setCurrentLayer(dst_layer);
+  sprite->setCurrentFrame(dst_frame);
 
   /* remove the 'dst_cel' (if it exists) because it must be
      replaced with 'src_cel' */
@@ -176,7 +176,7 @@ void copy_cel(SpriteWriter& sprite)
 
   /* move the cel in the same layer */
   if (src_cel != NULL) {
-    Image *src_image = stock_get_image(sprite->stock, src_cel->image);
+    Image *src_image = stock_get_image(sprite->getStock(), src_cel->image);
     Image *dst_image;
     int image_index;
     int dst_cel_x;
@@ -191,8 +191,8 @@ void copy_cel(SpriteWriter& sprite)
       dst_image = image_crop(src_image,
 			     -src_cel->x,
 			     -src_cel->y,
-			     sprite->w,
-			     sprite->h, 0);
+			     sprite->getWidth(),
+			     sprite->getHeight(), 0);
 
       image_clear(dst_image, app_get_color_to_clear_layer(dst_layer));
       image_merge(dst_image, src_image, src_cel->x, src_cel->y, 255, BLEND_MODE_NORMAL);
@@ -209,23 +209,23 @@ void copy_cel(SpriteWriter& sprite)
     }
 
     /* add the image in the stock */
-    image_index = stock_add_image(sprite->stock, dst_image);
-    if (undo_is_enabled(sprite->undo))
-      undo_add_image(sprite->undo, sprite->stock, image_index);
+    image_index = stock_add_image(sprite->getStock(), dst_image);
+    if (undo_is_enabled(sprite->getUndo()))
+      undo_add_image(sprite->getUndo(), sprite->getStock(), image_index);
 
     /* create the new cel */
     dst_cel = cel_new(dst_frame, image_index);
     cel_set_position(dst_cel, dst_cel_x, dst_cel_y);
     cel_set_opacity(dst_cel, dst_cel_opacity);
 
-    if (undo_is_enabled(sprite->undo))
-      undo_add_cel(sprite->undo, dst_layer, dst_cel);
+    if (undo_is_enabled(sprite->getUndo()))
+      undo_add_cel(sprite->getUndo(), dst_layer, dst_cel);
 
     static_cast<LayerImage*>(dst_layer)->add_cel(dst_cel);
   }
 
-  if (undo_is_enabled(sprite->undo))
-    undo_close(sprite->undo);
+  if (undo_is_enabled(sprite->getUndo()))
+    undo_close(sprite->getUndo());
 
   set_frame_to_handle(NULL, 0, NULL, 0);
 }
@@ -241,7 +241,7 @@ static void remove_cel(Sprite* sprite, LayerImage *layer, Cel *cel)
     /* find if the image that use the cel to remove, is used by
        another cels */
     used = false;
-    for (frame=0; frame<sprite->frames; ++frame) {
+    for (frame=0; frame<sprite->getTotalFrames(); ++frame) {
       it = layer->get_cel(frame);
       if (it != NULL && it != cel && it->image == cel->image) {
 	used = true;
@@ -249,24 +249,24 @@ static void remove_cel(Sprite* sprite, LayerImage *layer, Cel *cel)
       }
     }
 
-    if (undo_is_enabled(sprite->undo))
-      undo_open(sprite->undo);
+    if (undo_is_enabled(sprite->getUndo()))
+      undo_open(sprite->getUndo());
 
     if (!used) {
       /* if the image is only used by this cel, we can remove the
 	 image from the stock */
-      image = stock_get_image(sprite->stock, cel->image);
+      image = stock_get_image(sprite->getStock(), cel->image);
 
-      if (undo_is_enabled(sprite->undo))
-	undo_remove_image(sprite->undo, sprite->stock, cel->image);
+      if (undo_is_enabled(sprite->getUndo()))
+	undo_remove_image(sprite->getUndo(), sprite->getStock(), cel->image);
 
-      stock_remove_image(sprite->stock, image);
+      stock_remove_image(sprite->getStock(), image);
       image_free(image);
     }
 
-    if (undo_is_enabled(sprite->undo)) {
-      undo_remove_cel(sprite->undo, layer, cel);
-      undo_close(sprite->undo);
+    if (undo_is_enabled(sprite->getUndo())) {
+      undo_remove_cel(sprite->getUndo(), layer, cel);
+      undo_close(sprite->getUndo());
     }
 
     /* remove the cel */

src/util/clipboard.cpp

@@ -139,7 +139,7 @@ static bool copy_from_sprite(const Sprite* sprite)
   if (!image)
     return false;
 
-  Palette* pal = sprite_get_palette(sprite, sprite->frame);
+  const Palette* pal = sprite->getPalette(sprite->getCurrentFrame());
   set_clipboard(image, pal ? new Palette(*pal): NULL, true);
   return true;
 }
@@ -165,7 +165,7 @@ bool clipboard::can_paste()
 void clipboard::cut(SpriteWriter& sprite)
 {
   assert(sprite != NULL);
-  assert(sprite->layer != NULL);
+  assert(sprite->getCurrentLayer() != NULL);
 
   if (!copy_from_sprite(sprite)) {
     Console console;
@@ -174,11 +174,11 @@ void clipboard::cut(SpriteWriter& sprite)
   else {
     {
       Undoable undoable(sprite, "Cut");
-      undoable.clear_mask(app_get_color_to_clear_layer(sprite->layer));
+      undoable.clear_mask(app_get_color_to_clear_layer(sprite->getCurrentLayer()));
       undoable.deselect_mask();
       undoable.commit();
     }
-    sprite_generate_mask_boundaries(sprite);
+    sprite->generateMaskBoundaries();
     update_screen_for_sprite(sprite);
   }
 }
@@ -222,7 +222,7 @@ void clipboard::paste(SpriteWriter& sprite)
   assert(sprite != NULL);
 
   // destination image (where to put this image)
-  dst_image = GetImage2(sprite, &dst_x, &dst_y, NULL);
+  dst_image = sprite->getCurrentImage(&dst_x, &dst_y);
   if (!dst_image) {
     Console console;
     console.printf(_("Error: no destination image\n"));
@@ -230,13 +230,12 @@ void clipboard::paste(SpriteWriter& sprite)
   }
 
   // source image (clipboard or a converted copy to the destination 'imgtype')
-  if (clipboard_image->imgtype == sprite->imgtype)
+  if (clipboard_image->imgtype == sprite->getImgType())
     src_image = clipboard_image;
   else {
     CurrentSpriteRgbMap rgbmap;
-    src_image = image_set_imgtype(clipboard_image, sprite->imgtype, DITHERING_NONE,
-				  rgb_map, sprite_get_palette(sprite,
-							      sprite->frame));
+    src_image = image_set_imgtype(clipboard_image, sprite->getImgType(), DITHERING_NONE,
+				  rgb_map, sprite->getPalette(sprite->getCurrentFrame()));
   }
 
   // do the interactive-transform loop (where the user can move the floating image)
@@ -276,8 +275,8 @@ void clipboard::paste(SpriteWriter& sprite)
 
     if (w >= 1 && h >= 1) {
       /* undo region */
-      if (undo_is_enabled(sprite->undo))
-	undo_image(sprite->undo, dst_image, u1, v1, w, h);
+      if (undo_is_enabled(sprite->getUndo()))
+	undo_image(sprite->getUndo(), dst_image, u1, v1, w, h);
 
       /* draw the transformed image */
       image_parallelogram(dst_image, src_image,

src/util/misc.cpp

@@ -39,46 +39,6 @@
 #include "widgets/editor.h"
 #include "widgets/statebar.h"
 
-Image *GetImage(const Sprite *sprite)
-{
-  Image *image = NULL;
-
-  if (sprite && sprite->layer && sprite->layer->is_image()) {
-    Cel *cel = static_cast<LayerImage*>(sprite->layer)->get_cel(sprite->frame);
-    if (cel) {
-      assert((cel->image >= 0) &&
-	     (cel->image < sprite->stock->nimage));
-
-      image = sprite->stock->image[cel->image];
-    }
-  }
-
-  return image;
-}
-
-Image* GetImage2(const Sprite* sprite, int* x, int* y, int* opacity)
-{
-  Image* image = NULL;
-
-  if (sprite != NULL &&
-      sprite->layer != NULL &&
-      sprite->layer->is_image()) {
-    Cel* cel = static_cast<LayerImage*>(sprite->layer)->get_cel(sprite->frame);
-    if (cel) {
-      assert((cel->image >= 0) &&
-	     (cel->image < sprite->stock->nimage));
-
-      image = sprite->stock->image[cel->image];
-
-      if (x) *x = cel->x;
-      if (y) *y = cel->y;
-      if (opacity) *opacity = MID(0, cel->opacity, 255);
-    }
-  }
-
-  return image;
-}
-
 void LoadPalette(Sprite* sprite, const char *filename)
 {
   assert(sprite != NULL);
@@ -100,8 +60,8 @@ void LoadPalette(Sprite* sprite, const char *filename)
 	set_current_palette(pal, false);
 
 	/* just one palette */
-	sprite_reset_palettes(sprite);
-	sprite_set_palette(sprite, pal, 0);
+	sprite->resetPalettes();
+	sprite->setPalette(pal, 0);
 
 	/* redraw the entire screen */
 	jmanager_refresh_screen();
@@ -115,19 +75,20 @@ void LoadPalette(Sprite* sprite, const char *filename)
 
 Image* NewImageFromMask(const Sprite* src_sprite)
 {
-  ase_uint8 *address;
+  const ase_uint8* address;
   int x, y, u, v, getx, gety;
-  Image *dst, *src = GetImage2(src_sprite, &x, &y, NULL);
+  Image *dst;
+  const Image *src = src_sprite->getCurrentImage(&x, &y);
   div_t d;
 
   assert(src_sprite);
-  assert(src_sprite->mask);
-  assert(src_sprite->mask->bitmap);
+  assert(src_sprite->getMask());
+  assert(src_sprite->getMask()->bitmap);
   assert(src);
 
-  dst = image_new(src_sprite->imgtype,
-		  src_sprite->mask->w,
-		  src_sprite->mask->h);
+  dst = image_new(src_sprite->getImgType(),
+		  src_sprite->getMask()->w,
+		  src_sprite->getMask()->h);
   if (!dst)
     return NULL;
 
@@ -135,14 +96,14 @@ Image* NewImageFromMask(const Sprite* src_sprite)
   image_clear(dst, 0);
 
   /* copy the masked zones */
-  for (v=0; v<src_sprite->mask->h; v++) {
+  for (v=0; v<src_sprite->getMask()->h; v++) {
     d = div(0, 8);
-    address = ((ase_uint8 **)src_sprite->mask->bitmap->line)[v]+d.quot;
+    address = ((const ase_uint8 **)src_sprite->getMask()->bitmap->line)[v]+d.quot;
 
-    for (u=0; u<src_sprite->mask->w; u++) {
+    for (u=0; u<src_sprite->getMask()->w; u++) {
       if ((*address & (1<<d.rem))) {
-	getx = u+src_sprite->mask->x-x;
-	gety = v+src_sprite->mask->y-y;
+	getx = u+src_sprite->getMask()->x-x;
+	gety = v+src_sprite->getMask()->y-y;
 
 	if ((getx >= 0) && (getx < src->w) &&
 	    (gety >= 0) && (gety < src->h))
@@ -163,10 +124,10 @@ int interactive_move_layer(int mode, bool use_undo, int (*callback)())
   Editor* editor = current_editor;
   Sprite* sprite = editor->getSprite();
 
-  assert(sprite->layer->is_image());
+  assert(sprite->getCurrentLayer()->is_image());
 
-  LayerImage* layer = static_cast<LayerImage*>(sprite->layer);
-  Cel *cel = layer->get_cel(sprite->frame);
+  LayerImage* layer = static_cast<LayerImage*>(sprite->getCurrentLayer());
+  Cel *cel = layer->get_cel(sprite->getCurrentFrame());
   int start_x, new_x;
   int start_y, new_y;
   int start_b;
@@ -227,12 +188,12 @@ int interactive_move_layer(int mode, bool use_undo, int (*callback)())
   
   /* the position was changed */
   if (!editor->editor_click_cancel()) {
-    if (use_undo && undo_is_enabled(sprite->undo)) {
-      undo_set_label(sprite->undo, "Cel Movement");
-      undo_open(sprite->undo);
-      undo_int(sprite->undo, (GfxObj *)cel, &cel->x);
-      undo_int(sprite->undo, (GfxObj *)cel, &cel->y);
-      undo_close(sprite->undo);
+    if (use_undo && undo_is_enabled(sprite->getUndo())) {
+      undo_set_label(sprite->getUndo(), "Cel Movement");
+      undo_open(sprite->getUndo());
+      undo_int(sprite->getUndo(), (GfxObj *)cel, &cel->x);
+      undo_int(sprite->getUndo(), (GfxObj *)cel, &cel->y);
+      undo_close(sprite->getUndo());
     }
 
     cel_set_position(cel, new_x, new_y);

src/util/misc.h

@@ -28,9 +28,6 @@ class Layer;
 class Sprite;
 class Undo;
 
-Image* GetImage(const Sprite* sprite);
-Image* GetImage2(const Sprite* sprite, int *x, int *y, int *opacity);
-
 void LoadPalette(Sprite* sprite, const char* filename);
 
 Image* NewImageFromMask(const Sprite* src);

src/util/quantize.cpp

@@ -37,8 +37,8 @@ void sprite_quantize(Sprite *sprite)
   sprite_quantize_ex(sprite, palette);
 
   // Just one palette
-  sprite_reset_palettes(sprite);
-  sprite_set_palette(sprite, palette, false);
+  sprite->resetPalettes();
+  sprite->setPalette(palette, false);
 
   delete palette;
 }
@@ -55,9 +55,9 @@ void sprite_quantize_ex(Sprite *sprite, Palette *palette)
 					      TARGET_ALL_FRAMES, false);
   if (images != NULL) {
     /* add a flat image with the current sprite's frame rendered */
-    flat_image = image_new(sprite->imgtype, sprite->w, sprite->h);
+    flat_image = image_new(sprite->getImgType(), sprite->getWidth(), sprite->getHeight());
     image_clear(flat_image, 0);
-    sprite_render(sprite, flat_image, 0, 0);
+    sprite->render(flat_image, 0, 0);
 
     /* count images in the 'images' list */
     c = 0;

src/util/render.cpp

@@ -278,12 +278,12 @@ Image* RenderEngine::renderSprite(Sprite* sprite,
 				  int frame, int zoom)
 {
   void (*zoomed_func)(Image *, Image *, int, int, int, int, int);
-  LayerImage* background = sprite_get_background_layer(sprite);
+  LayerImage* background = sprite->getBackgroundLayer();
   bool need_grid = (background != NULL ? !background->is_readable(): true);
   int depth;
   Image *image;
 
-  switch (sprite->imgtype) {
+  switch (sprite->getImgType()) {
 
     case IMAGE_RGB:
       depth = 32;
@@ -305,7 +305,7 @@ Image* RenderEngine::renderSprite(Sprite* sprite,
   }
 
   /* create a temporary bitmap to draw all to it */
-  image = image_new(sprite->imgtype, width, height);
+  image = image_new(sprite->getImgType(), width, height);
   if (!image)
     return NULL;
 
@@ -371,26 +371,26 @@ Image* RenderEngine::renderSprite(Sprite* sprite,
     color_map = NULL;
     global_opacity = 255;
 
-    renderLayer(sprite, sprite->get_folder(), image, source_x, source_y,
+    renderLayer(sprite, sprite->getFolder(), image, source_x, source_y,
 		frame, zoom, zoomed_func, true, false);
 
     // Draw transparent layers of the previous frame with opacity=128
     color_map = orig_trans_map;
     global_opacity = 128;
 
-    renderLayer(sprite, sprite->get_folder(), image, source_x, source_y,
+    renderLayer(sprite, sprite->getFolder(), image, source_x, source_y,
 		frame-1, zoom, zoomed_func, false, true);
 
     // Draw transparent layers of the current frame with opacity=255
     color_map = NULL;
     global_opacity = 255;
 
-    renderLayer(sprite, sprite->get_folder(), image, source_x, source_y,
+    renderLayer(sprite, sprite->getFolder(), image, source_x, source_y,
 		frame, zoom, zoomed_func, false, true);
   }
   // Just draw the current frame
   else {
-    renderLayer(sprite, sprite->get_folder(), image, source_x, source_y,
+    renderLayer(sprite, sprite->getFolder(), image, source_x, source_y,
 		frame, zoom, zoomed_func, true, true);
   }
 
@@ -420,15 +420,15 @@ void RenderEngine::renderLayer(Sprite *sprite, Layer *layer, Image *image,
 	Image* src_image;
 
 	/* is the 'rastering_image' setted to be used with this layer? */
-	if ((frame == sprite->frame) &&
+	if ((frame == sprite->getCurrentFrame()) &&
 	    (selected_layer == layer) &&
 	    (rastering_image != NULL)) {
 	  src_image = rastering_image;
 	}
 	/* if not, we use the original cel-image from the images' stock */
 	else if ((cel->image >= 0) &&
-		 (cel->image < layer->getSprite()->stock->nimage))
-	  src_image = layer->getSprite()->stock->image[cel->image];
+		 (cel->image < layer->getSprite()->getStock()->nimage))
+	  src_image = layer->getSprite()->getStock()->image[cel->image];
 	else
 	  src_image = NULL;
 
@@ -473,17 +473,17 @@ void RenderEngine::renderLayer(Sprite *sprite, Layer *layer, Image *image,
   }
 
   // Draw extras
-  if (layer == sprite->layer && sprite->get_extras() != NULL) {
-    int opacity = sprite->get_extras_opacity();
+  if (layer == sprite->getCurrentLayer() && sprite->getExtras() != NULL) {
+    int opacity = sprite->getExtrasOpacity();
 
     if (zoom == 0) {
-      image_merge(image, sprite->get_extras(),
+      image_merge(image, sprite->getExtras(),
 		  -source_x,
 		  -source_y,
 		  opacity, BLEND_MODE_NORMAL);
     }
     else {
-      (*zoomed_func)(image, sprite->get_extras(),
+      (*zoomed_func)(image, sprite->getExtras(),
 		     -source_x,
 		     -source_y,
 		     opacity, BLEND_MODE_NORMAL, zoom);

src/util/thmbnail.cpp

@@ -49,7 +49,7 @@ static JList thumbnails = NULL;
 
 static Thumbnail* thumbnail_new(const Cel *cel, BITMAP* bmp);
 static void thumbnail_free(Thumbnail* thumbnail);
-static void thumbnail_render(BITMAP* bmp, Image* image, bool has_alpha);
+static void thumbnail_render(BITMAP* bmp, const Image* image, bool has_alpha);
 
 void destroy_thumbnails()
 {
@@ -85,7 +85,7 @@ BITMAP* generate_thumbnail(const Layer* layer, const Cel* cel, const Sprite *spr
     return NULL;
 
   thumbnail_render(bmp,
-		   stock_get_image(sprite->stock, cel->image),
+		   stock_get_image(sprite->getStock(), cel->image),
 		   !layer->is_background());
 
   thumbnail = thumbnail_new(cel, bmp);
@@ -118,7 +118,7 @@ static void thumbnail_free(Thumbnail* thumbnail)
   jfree(thumbnail);
 }
 
-static void thumbnail_render(BITMAP* bmp, Image* image, bool has_alpha)
+static void thumbnail_render(BITMAP* bmp, const Image* image, bool has_alpha)
 {
   register int c, x, y;
   int w, h, x1, y1;
@@ -179,9 +179,9 @@ static void thumbnail_render(BITMAP* bmp, Image* image, bool has_alpha)
 	  for (x=0; x<w; x++) {
 	    c = image_getpixel(image, x*scale, y*scale);
 	    if (c != 0) {
-	      assert(c >= 0 && c < pal->size());
+	      assert(c >= 0 && (size_t)c < pal->size());
 
-	      c = pal->getEntry(MID(0, c, pal->size()-1));
+	      c = pal->getEntry(MID(0, (size_t)c, pal->size()-1));
 	      putpixel(bmp, x1+x, y1+y, makecol(_rgba_getr(c),
 						_rgba_getg(c),
 						_rgba_getb(c)));
@@ -221,9 +221,9 @@ static void thumbnail_render(BITMAP* bmp, Image* image, bool has_alpha)
 	  for (x=0; x<w; x++) {
 	    c = image_getpixel(image, x*scale, y*scale);
 
-	    assert(c >= 0 && c < pal->size());
+	    assert(c >= 0 && (size_t)c < pal->size());
 
-	    c = pal->getEntry(MID(0, c, pal->size()-1));
+	    c = pal->getEntry(MID(0, (size_t)c, pal->size()-1));
 	    putpixel(bmp, x1+x, y1+y, makecol(_rgba_getr(c),
 					      _rgba_getg(c),
 					      _rgba_getb(c)));

src/widgets/colbut.cpp

@@ -176,8 +176,8 @@ static bool colorbutton_msg_proc(JWidget widget, JMessage msg)
 	      x = msg->mouse.x;
 	      y = msg->mouse.y;
 	      editor->screen_to_editor(x, y, &x, &y);
-	      imgcolor = sprite_getpixel(sprite, x, y);
-	      tmp = color_from_image(sprite->imgtype, imgcolor);
+	      imgcolor = sprite->getPixel(x, y);
+	      tmp = color_from_image(sprite->getImgType(), imgcolor);
 
 	      if (color_type(tmp) != COLOR_TYPE_MASK)
 		color = tmp;

src/widgets/editor/cursor.cpp

@@ -274,21 +274,21 @@ void Editor::editor_draw_cursor(int x, int y, bool refresh)
     Pen* pen = editor_get_current_pen();
 
     // Set the opacity for the 'extra' layer used to show the cursor preview
-    m_sprite->set_extras_opacity(tool_settings->getOpacity());
+    m_sprite->setExtrasOpacity(tool_settings->getOpacity());
 
     // Create the 'extra' image/layer
-    m_sprite->prepare_extra();
+    m_sprite->prepareExtra();
 
     // In 'indexed' images, if the current color is 0, we have to use
     // a different mask color (different from 0) to draw the extra layer
-    if (m_sprite->imgtype == IMAGE_INDEXED && pen_color == 0) {
+    if (m_sprite->getImgType() == IMAGE_INDEXED && pen_color == 0) {
       new_mask_color = 1;
     }
     else {
       new_mask_color = 0;
     }
 
-    Image* extras = m_sprite->get_extras();
+    Image* extras = m_sprite->getExtras();
     if (extras->mask_color != new_mask_color)
       image_clear(extras, extras->mask_color = new_mask_color);
     image_putpen(extras, pen, x, y, pen_color, extras->mask_color);
@@ -405,10 +405,10 @@ void Editor::editor_clean_cursor(bool refresh)
       m_state != EDITOR_STATE_DRAWING) {
     Pen* pen = editor_get_current_pen();
 
-    m_sprite->prepare_extra();
-    image_putpen(m_sprite->get_extras(), pen, x, y,
-		 m_sprite->get_extras()->mask_color,
-		 m_sprite->get_extras()->mask_color);
+    m_sprite->prepareExtra();
+    image_putpen(m_sprite->getExtras(), pen, x, y,
+		 m_sprite->getExtras()->mask_color,
+		 m_sprite->getExtras()->mask_color);
 
     if (refresh) {
       editors_draw_sprite(m_sprite,

src/widgets/editor/editor.cpp

@@ -135,11 +135,12 @@ void Editor::editor_set_sprite(Sprite* sprite)
 
   m_sprite = sprite;
   if (m_sprite) {
-    m_zoom = m_sprite->preferred.zoom;
+    PreferredEditorSettings preferred = m_sprite->getPreferredEditorSettings();
+    m_zoom = preferred.zoom;
 
     editor_update();
-    editor_set_scroll(m_offset_x + m_sprite->preferred.scroll_x,
-		      m_offset_y + m_sprite->preferred.scroll_y,
+    editor_set_scroll(m_offset_x + preferred.scroll_x,
+		      m_offset_y + preferred.scroll_y,
 		      false);
   }
   else {
@@ -169,9 +170,13 @@ void Editor::editor_set_scroll(int x, int y, int use_refresh_region)
   jview_set_scroll(view, x, y);
 
   if (m_sprite) {
-    m_sprite->preferred.scroll_x = x - m_offset_x;
-    m_sprite->preferred.scroll_y = y - m_offset_y;
-    m_sprite->preferred.zoom = m_zoom;
+    PreferredEditorSettings preferred;
+
+    preferred.scroll_x = x - m_offset_x;
+    preferred.scroll_y = y - m_offset_y;
+    preferred.zoom = m_zoom;
+
+    m_sprite->setPreferredEditorSettings(preferred);
   }
 
   if (use_refresh_region) {
@@ -285,12 +290,12 @@ void Editor::editor_draw_sprite(int x1, int y1, int x2, int y2)
     source_y = 0;
   }
 
-  if (source_x+width > (m_sprite->w << m_zoom)) {
-    width = (m_sprite->w << m_zoom) - source_x;
+  if (source_x+width > (m_sprite->getWidth() << m_zoom)) {
+    width = (m_sprite->getWidth() << m_zoom) - source_x;
   }
 
-  if (source_y+height > (m_sprite->h << m_zoom)) {
-    height = (m_sprite->h << m_zoom) - source_y;
+  if (source_y+height > (m_sprite->getHeight() << m_zoom)) {
+    height = (m_sprite->getHeight() << m_zoom) - source_y;
   }
 
   /* draw the sprite */
@@ -300,7 +305,7 @@ void Editor::editor_draw_sprite(int x1, int y1, int x2, int y2)
     Image* rendered = RenderEngine::renderSprite(m_sprite,
 						 source_x, source_y,
 						 width, height,
-						 m_sprite->frame,
+						 m_sprite->getCurrentFrame(),
 						 m_zoom);
 
     if (rendered) {
@@ -323,8 +328,7 @@ void Editor::editor_draw_sprite(int x1, int y1, int x2, int y2)
       }
       else {
 	PALETTE rgbpal;
-	Palette *pal = sprite_get_palette(m_sprite,
-					  m_sprite->frame);
+	Palette *pal = m_sprite->getPalette(m_sprite->getCurrentFrame());
 	pal->toAllegro(rgbpal);
 
 	select_palette(rgbpal);
@@ -384,7 +388,6 @@ void Editor::editor_draw_mask()
   JRect vp = jview_get_viewport_position(view);
   int scroll_x, scroll_y;
   int x1, y1, x2, y2;
-  BoundSeg *seg;
   int c, x, y;
 
   jview_get_scroll(view, &scroll_x, &scroll_y);
@@ -394,17 +397,18 @@ void Editor::editor_draw_mask()
   x = vp->x1 - scroll_x + m_offset_x;
   y = vp->y1 - scroll_y + m_offset_y;
 
-  for (c=0; c<m_sprite->bound.nseg; c++) {
-    seg = &m_sprite->bound.seg[c];
+  int nseg = m_sprite->getBoundariesSegmentsCount();
+  const _BoundSeg* seg = m_sprite->getBoundariesSegments();
 
+  for (c=0; c<nseg; ++c, ++seg) {
     x1 = seg->x1<<m_zoom;
     y1 = seg->y1<<m_zoom;
     x2 = seg->x2<<m_zoom;
     y2 = seg->y2<<m_zoom;
 
-#if 1				/* bounds inside mask */
+#if 1				// Bounds inside mask
     if (!seg->open)
-#else				/* bounds outside mask */
+#else				// Bounds outside mask
     if (seg->open)
 #endif
       {
@@ -439,7 +443,7 @@ void Editor::editor_draw_mask()
 
 void Editor::editor_draw_mask_safe()
 {
-  if ((m_sprite) && (m_sprite->bound.seg)) {
+  if ((m_sprite) && (m_sprite->getBoundariesSegments())) {
     int thick = m_cursor_thick;
 
     JRegion region = jwidget_get_drawable_region(this, JI_GDR_CUTTOPWINDOWS);
@@ -538,9 +542,9 @@ void Editor::turnOnSelectionModifiers()
 
   int x1, y1, x2, y2;
 
-  editor_to_screen(m_sprite->mask->x, m_sprite->mask->y, &x1, &y1);
-  editor_to_screen(m_sprite->mask->x+m_sprite->mask->w-1,
-		   m_sprite->mask->y+m_sprite->mask->h-1, &x2, &y2);
+  editor_to_screen(m_sprite->getMask()->x, m_sprite->getMask()->y, &x1, &y1);
+  editor_to_screen(m_sprite->getMask()->x+m_sprite->getMask()->w-1,
+		   m_sprite->getMask()->y+m_sprite->getMask()->h-1, &x2, &y2);
 
   // TODO addDecorator
   m_decorators.push_back(new Decorator(Decorator::SELECTION_NW, Rect(x1-8,        y1-8, 8, 8)));
@@ -610,11 +614,11 @@ void Editor::editor_update_statusbar_for_standby()
 
   /* for eye-dropper */
   if (m_alt_pressed) {
-    color_t color = color_from_image(m_sprite->imgtype,
-				     sprite_getpixel(m_sprite, x, y));
+    color_t color = color_from_image(m_sprite->getImgType(),
+				     m_sprite->getPixel(x, y));
     if (color_type(color) != COLOR_TYPE_MASK) {
       usprintf(buf, "%s ", _("Color"));
-      color_to_formalstring(m_sprite->imgtype,
+      color_to_formalstring(m_sprite->getImgType(),
 			    color,
 			    buf+ustrlen(buf),
 			    sizeof(buf)-ustrlen(buf), true);
@@ -631,13 +635,13 @@ void Editor::editor_update_statusbar_for_standby()
     (0, "%s %3d %3d (%s %3d %3d) [%s %d] %s",
      _("Pos"), x, y,
      _("Size"),
-     ((m_sprite->mask->bitmap)?
-      m_sprite->mask->w:
-      m_sprite->w),
-     ((m_sprite->mask->bitmap)?
-      m_sprite->mask->h:
-      m_sprite->h),
-     _("Frame"), m_sprite->frame+1,
+     ((m_sprite->getMask()->bitmap)?
+      m_sprite->getMask()->w:
+      m_sprite->getWidth()),
+     ((m_sprite->getMask()->bitmap)?
+      m_sprite->getMask()->h:
+      m_sprite->getHeight()),
+     _("Frame"), m_sprite->getCurrentFrame()+1,
      buf);
 }
 
@@ -751,8 +755,8 @@ bool Editor::msg_proc(JMessage msg)
 	/* draw the background outside of image */
 	x1 = this->rc->x1 + m_offset_x;
 	y1 = this->rc->y1 + m_offset_y;
-	x2 = x1 + (m_sprite->w << m_zoom) - 1;
-	y2 = y1 + (m_sprite->h << m_zoom) - 1;
+	x2 = x1 + (m_sprite->getWidth() << m_zoom) - 1;
+	y2 = y1 + (m_sprite->getHeight() << m_zoom) - 1;
 
 	jrectexclude(ji_screen,
 		     this->rc->x1, this->rc->y1,
@@ -760,14 +764,14 @@ bool Editor::msg_proc(JMessage msg)
 		     x1-1, y1-1, x2+1, y2+2, theme->get_editor_face_color());
 
 	/* draw the sprite in the editor */
-	editor_draw_sprite(0, 0, m_sprite->w-1, m_sprite->h-1);
+	editor_draw_sprite(0, 0, m_sprite->getWidth()-1, m_sprite->getHeight()-1);
 
-	/* draw the sprite boundary */
+	// Draw the sprite boundary
 	rect(ji_screen, x1-1, y1-1, x2+1, y2+1, theme->get_editor_sprite_border());
 	hline(ji_screen, x1-1, y2+2, x2+1, theme->get_editor_sprite_bottom_edge());
 
-	/* draw the mask */
-	if (m_sprite->bound.seg) {
+	// Draw the mask boundaries
+	if (m_sprite->getBoundariesSegments()) {
 	  editor_draw_mask();
 	  jmanager_start_timer(m_mask_timer_id);
 	}
@@ -869,15 +873,15 @@ bool Editor::msg_proc(JMessage msg)
 	}
 	/* move frames position */
 	else if (m_ctrl_pressed) {
-	  if ((m_sprite->layer) &&
-	      (m_sprite->layer->type == GFXOBJ_LAYER_IMAGE)) {
+	  if ((m_sprite->getCurrentLayer()) &&
+	      (m_sprite->getCurrentLayer()->type == GFXOBJ_LAYER_IMAGE)) {
 	    /* TODO you can move the `Background' with tiled mode */
-	    if (m_sprite->layer->is_background()) {
+	    if (m_sprite->getCurrentLayer()->is_background()) {
 	      jalert(_(PACKAGE
 		       "<<You can't move the `Background' layer."
 		       "||&Close"));
 	    }
-	    else if (!m_sprite->layer->is_moveable()) {
+	    else if (!m_sprite->getCurrentLayer()->is_moveable()) {
 	      jalert(_(PACKAGE
 		       "<<The layer movement is locked."
 		       "||&Close"));
@@ -903,7 +907,7 @@ bool Editor::msg_proc(JMessage msg)
 	  return true;
 	}
 	// Start the Tool-Loop
-	else if (m_sprite->layer) {
+	else if (m_sprite->getCurrentLayer()) {
 	  assert(m_toolLoopManager == NULL);
 
 	  IToolLoop* toolLoop = createToolLoopImpl(UIContext::instance(), msg);
@@ -1046,7 +1050,7 @@ bool Editor::msg_proc(JMessage msg)
 	  screen_to_editor(jmouse_x(0), jmouse_y(0), &x, &y);
 	  app_get_statusbar()->setStatusText
 	    (0, "Pos %3d %3d (Size %3d %3d)", x, y,
-	     m_sprite->w, m_sprite->h);
+	     m_sprite->getWidth(), m_sprite->getHeight());
 	}
       }
       return true;
@@ -1256,8 +1260,8 @@ void Editor::editor_request_size(int *w, int *h)
     m_offset_x = jrect_w(vp)/2 - 1;
     m_offset_y = jrect_h(vp)/2 - 1;
 
-    *w = (m_sprite->w << m_zoom) + m_offset_x*2;
-    *h = (m_sprite->h << m_zoom) + m_offset_y*2;
+    *w = (m_sprite->getWidth() << m_zoom) + m_offset_x*2;
+    *h = (m_sprite->getHeight() << m_zoom) + m_offset_y*2;
 
     jrect_free(vp);
   }
@@ -1320,7 +1324,7 @@ void Editor::editor_setcursor(int x, int y)
 	      screen_to_editor(jmouse_x(0), jmouse_y(0), &x, &y);
 	    
 	      // Move selection
-	      if (m_sprite->mask->contains_point(x, y)) {
+	      if (m_sprite->getMask()->contains_point(x, y)) {
 		hide_drawing_cursor();
 		jmouse_set_cursor(JI_CURSOR_MOVE);
 
@@ -1372,10 +1376,10 @@ void Editor::editor_update_candraw()
 {
   m_cursor_candraw =
     (m_sprite != NULL &&
-     m_sprite->layer != NULL &&
-     m_sprite->layer->is_image() &&
-     m_sprite->layer->is_readable() &&
-     m_sprite->layer->is_writable() /* && */
+     m_sprite->getCurrentLayer() != NULL &&
+     m_sprite->getCurrentLayer()->is_image() &&
+     m_sprite->getCurrentLayer()->is_readable() &&
+     m_sprite->getCurrentLayer()->is_writable() /* && */
      /* layer_get_cel(m_sprite->layer, m_sprite->frame) != NULL */
      );
 }
@@ -1493,19 +1497,19 @@ public:
     // Get cel and image where we can draw
 
     if (m_layer->is_image()) {
-      m_cel = static_cast<LayerImage*>(sprite->layer)->get_cel(sprite->frame);
+      m_cel = static_cast<LayerImage*>(sprite->getCurrentLayer())->get_cel(sprite->getCurrentFrame());
       if (m_cel)
-	m_cel_image = sprite->stock->image[m_cel->image];
+	m_cel_image = sprite->getStock()->image[m_cel->image];
     }
 
     if (m_cel == NULL) {
       // create the image
-      m_cel_image = image_new(sprite->imgtype, sprite->w, sprite->h);
+      m_cel_image = image_new(sprite->getImgType(), sprite->getWidth(), sprite->getHeight());
       image_clear(m_cel_image, 0);
 
       // create the cel
-      m_cel = cel_new(sprite->frame, 0);
-      static_cast<LayerImage*>(sprite->layer)->add_cel(m_cel);
+      m_cel = cel_new(sprite->getCurrentFrame(), 0);
+      static_cast<LayerImage*>(sprite->getCurrentLayer())->add_cel(m_cel);
 
       m_cel_created = true;
     }
@@ -1520,14 +1524,14 @@ public:
     if (m_tiled_mode == TILED_NONE) {
       x1 = MIN(m_cel->x, 0);
       y1 = MIN(m_cel->y, 0);
-      x2 = MAX(m_cel->x+m_cel_image->w, m_sprite->w);
-      y2 = MAX(m_cel->y+m_cel_image->h, m_sprite->h);
+      x2 = MAX(m_cel->x+m_cel_image->w, m_sprite->getWidth());
+      y2 = MAX(m_cel->y+m_cel_image->h, m_sprite->getHeight());
     }
     else { 			// tiled
       x1 = 0;
       y1 = 0;
-      x2 = m_sprite->w;
-      y2 = m_sprite->h;
+      x2 = m_sprite->getWidth();
+      y2 = m_sprite->getHeight();
     }
 
     // create two copies of the image region which we'll modify with the tool
@@ -1536,7 +1540,7 @@ public:
 			     y1-m_cel->y, x2-x1, y2-y1, 0);
     m_dst_image = image_new_copy(m_src_image);
 
-    m_mask = m_sprite->mask;
+    m_mask = m_sprite->getMask();
     m_maskOrigin = (!m_mask->is_empty() ? Point(m_mask->x-x1, m_mask->y-y1):
 					  Point(0, 0));
 
@@ -1552,8 +1556,8 @@ public:
     m_offset.y = -y1;
 
     // Set undo label for any kind of undo used in the whole loop
-    if (undo_is_enabled(m_sprite->undo))
-      undo_set_label(m_sprite->undo, m_tool->getText().c_str());
+    if (undo_is_enabled(m_sprite->getUndo()))
+      undo_set_label(m_sprite->getUndo(), m_tool->getText().c_str());
   }
 
   ~ToolLoopImpl()
@@ -1575,34 +1579,34 @@ public:
 	    image_copy(m_cel_image, m_dst_image, 0, 0);
 
 	    /* add the 'cel_image' in the images' stock of the sprite */
-	    m_cel->image = stock_add_image(m_sprite->stock, m_cel_image);
+	    m_cel->image = stock_add_image(m_sprite->getStock(), m_cel_image);
 
 	    /* is the undo enabled? */
-	    if (undo_is_enabled(m_sprite->undo)) {
+	    if (undo_is_enabled(m_sprite->getUndo())) {
 	      /* we can temporary remove the cel */
-	      static_cast<LayerImage*>(m_sprite->layer)->remove_cel(m_cel);
+	      static_cast<LayerImage*>(m_sprite->getCurrentLayer())->remove_cel(m_cel);
 
 	      /* we create the undo information (for the new cel_image
 		 in the stock and the new cel in the layer)... */
-	      undo_open(m_sprite->undo);
-	      undo_add_image(m_sprite->undo, m_sprite->stock, m_cel->image);
-	      undo_add_cel(m_sprite->undo, m_sprite->layer, m_cel);
-	      undo_close(m_sprite->undo);
+	      undo_open(m_sprite->getUndo());
+	      undo_add_image(m_sprite->getUndo(), m_sprite->getStock(), m_cel->image);
+	      undo_add_cel(m_sprite->getUndo(), m_sprite->getCurrentLayer(), m_cel);
+	      undo_close(m_sprite->getUndo());
 
 	      /* and finally we add the cel again in the layer */
-	      static_cast<LayerImage*>(m_sprite->layer)->add_cel(m_cel);
+	      static_cast<LayerImage*>(m_sprite->getCurrentLayer())->add_cel(m_cel);
 	    }
 	  }
 	  else {
 	    /* undo the dirty region */
-	    if (undo_is_enabled(m_sprite->undo)) {
+	    if (undo_is_enabled(m_sprite->getUndo())) {
 	      Dirty* dirty = dirty_new_from_differences(m_cel_image,
 							m_dst_image);
 	      // TODO error handling
 
 	      dirty_save_image_data(dirty);
 	      if (dirty != NULL)
-		undo_dirty(m_sprite->undo, dirty);
+		undo_dirty(m_sprite->getUndo(), dirty);
 
 	      dirty_free(dirty);
 	    }
@@ -1614,28 +1618,28 @@ public:
 	/* if the size of both images are different, we have to replace
 	   the entire image */
 	else {
-	  if (undo_is_enabled(m_sprite->undo)) {
-	    undo_open(m_sprite->undo);
+	  if (undo_is_enabled(m_sprite->getUndo())) {
+	    undo_open(m_sprite->getUndo());
 
 	    if (m_cel->x != m_old_cel_x) {
 	      int x = m_cel->x;
 	      m_cel->x = m_old_cel_x;
-	      undo_int(m_sprite->undo, (GfxObj*)m_cel, &m_cel->x);
+	      undo_int(m_sprite->getUndo(), (GfxObj*)m_cel, &m_cel->x);
 	      m_cel->x = x;
 	    }
 	    if (m_cel->y != m_old_cel_y) {
 	      int y = m_cel->y;
 	      m_cel->y = m_old_cel_y;
-	      undo_int(m_sprite->undo, (GfxObj*)m_cel, &m_cel->y);
+	      undo_int(m_sprite->getUndo(), (GfxObj*)m_cel, &m_cel->y);
 	      m_cel->y = y;
 	    }
 
-	    undo_replace_image(m_sprite->undo, m_sprite->stock, m_cel->image);
-	    undo_close(m_sprite->undo);
+	    undo_replace_image(m_sprite->getUndo(), m_sprite->getStock(), m_cel->image);
+	    undo_close(m_sprite->getUndo());
 	  }
 
 	  /* replace the image in the stock */
-	  stock_replace_image(m_sprite->stock, m_cel->image, m_dst_image);
+	  stock_replace_image(m_sprite->getStock(), m_cel->image, m_dst_image);
 
 	  /* destroy the old cel image */
 	  image_free(m_cel_image);
@@ -1647,7 +1651,7 @@ public:
 
       // Selection ink
       if (getInk()->isSelection())
-	sprite_generate_mask_boundaries(m_sprite);
+	m_sprite->generateMaskBoundaries();
     }
 
     // If the trace was not canceled or it is not a 'paint' ink...
@@ -1733,9 +1737,9 @@ IToolLoop* Editor::createToolLoopImpl(Context* context, JMessage msg)
     return NULL;
 
   Sprite* sprite = getSprite();
-  Layer* layer = sprite->layer;
+  Layer* layer = sprite->getCurrentLayer();
 
-  if (!sprite->layer) {
+  if (!layer) {
     jalert(_(PACKAGE
 	     "<<The current sprite does not have any layer."
 	     "||&Close"));

src/widgets/fileview.cpp

@@ -782,12 +782,12 @@ static void openfile_bg(void *_data)
       delete fop->sprite;
     else {
       /* the palette to convert the Image to a BITMAP */
-      sprite_get_palette(sprite, 0)->toAllegro(data->rgbpal);
+      sprite->getPalette(0)->toAllegro(data->rgbpal);
 
       /* render the 'sprite' in one plain 'image' */
-      image = image_new(sprite->imgtype, sprite->w, sprite->h);
+      image = image_new(sprite->getImgType(), sprite->getWidth(), sprite->getHeight());
       image_clear(image, 0);
-      sprite_render(sprite, image, 0, 0);
+      sprite->render(image, 0, 0);
       delete sprite;
 
       /* calculate the thumbnail size */

src/widgets/preview.cpp

@@ -97,7 +97,7 @@ static bool preview_msg_proc(JWidget widget, JMessage msg)
       break;
       
     case JM_OPEN:
-      RenderEngine::setPreviewImage(effect->sprite->layer, effect->dst);
+      RenderEngine::setPreviewImage(effect->sprite->getCurrentLayer(), effect->dst);
       break;
 
     case JM_CLOSE:

src/widgets/statebar.cpp

@@ -338,16 +338,16 @@ bool StatusBar::msg_proc(JMessage msg)
 	try {
 	  const CurrentSpriteReader sprite(UIContext::instance());
 	  if (sprite) {
-	    LayerFolder* folder = sprite->get_folder();
-	    LayerIterator it = folder->get_layer_begin();
-	    LayerIterator end = folder->get_layer_end();
+	    const LayerFolder* folder = sprite->getFolder();
+	    LayerConstIterator it = folder->get_layer_begin();
+	    LayerConstIterator end = folder->get_layer_end();
 	    size_t count = folder->get_layers_count();
 	    char buf[256];
 
 	    for (size_t c=0; it != end; ++it, ++c) {
 	      int x1 = rc->x2-width + c*width/count;
 	      int x2 = rc->x2-width + (c+1)*width/count;
-	      bool hot = (*it == sprite->layer);
+	      bool hot = (*it == sprite->getCurrentLayer());
 
 	      {
 		BITMAP* old_ji_screen = ji_screen; // TODO fix this ugly hack
@@ -463,9 +463,9 @@ static bool slider_change_hook(JWidget widget, void *data)
   try {
     CurrentSpriteWriter sprite(UIContext::instance());
     if (sprite) {
-      if ((sprite->layer) &&
-	  (sprite->layer->is_image())) {
-	Cel* cel = ((LayerImage*)sprite->layer)->get_cel(sprite->frame);
+      if ((sprite->getCurrentLayer()) &&
+	  (sprite->getCurrentLayer()->is_image())) {
+	Cel* cel = ((LayerImage*)sprite->getCurrentLayer())->get_cel(sprite->getCurrentFrame());
 	if (cel) {
 	  // update the opacity
 	  cel->opacity = jslider_get_value(widget);
@@ -507,10 +507,10 @@ void StatusBar::updateFromLayer()
 
     /* opacity layer */
     if (sprite &&
-	sprite->layer &&
-	sprite->layer->is_image() &&
-	!sprite->layer->is_background() &&
-	(cel = ((LayerImage*)sprite->layer)->get_cel(sprite->frame))) {
+	sprite->getCurrentLayer() &&
+	sprite->getCurrentLayer()->is_image() &&
+	!sprite->getCurrentLayer()->is_background() &&
+	(cel = ((LayerImage*)sprite->getCurrentLayer())->get_cel(sprite->getCurrentFrame()))) {
       jslider_set_value(m_slider, MID(0, cel->opacity, 255));
       jwidget_enable(m_slider);
     }