Use Sprite::allLayersCount/allLayers() when possible

src/app/cmd/copy_frame.cpp

@@ -1,5 +1,5 @@
 // Aseprite
-// Copyright (C) 2001-2015  David Capello
+// Copyright (C) 2001-2016  David Capello
 //
 // This program is free software; you can redistribute it and/or modify
 // it under the terms of the GNU General Public License version 2 as
@@ -41,8 +41,7 @@ void CopyFrame::onExecute()
   if (fromFrame >= m_newFrame)
     ++fromFrame;
 
-  for (int i=0; i<sprite->countLayers(); ++i) {
-    Layer* layer = sprite->layer(i);
+  for (Layer* layer : sprite->allLayers()) {
     if (layer->isImage())  {
       executeAndAdd(new cmd::CopyCel(
           static_cast<LayerImage*>(layer), fromFrame,

src/app/commands/cmd_remove_layer.cpp

@@ -81,7 +81,7 @@ void RemoveLayerCommand::onExecute(Context* context)
       }
     }
     else {
-      if (sprite->countLayers() == 1) {
+      if (sprite->allLayersCount() == 1) {
         ui::Alert::show("Error<<You cannot delete the last layer.||&OK");
         return;
       }

src/app/document_range_tests.cpp

@@ -102,8 +102,10 @@ public:
     sprite->setFrameDuration(frame_t(2), 3);
     sprite->setFrameDuration(frame_t(3), 4);
 
+    LayerList layers = sprite->allLayers();
+
     for (int i=0; i<4; i++) {
-      LayerImage* layer = static_cast<LayerImage*>(sprite->indexToLayer(LayerIndex(i)));
+      LayerImage* layer = static_cast<LayerImage*>(layers[i]);
 
       for (int j=0; j<4; j++) {
         Cel* cel = layer->cel(frame_t(j));
@@ -127,19 +129,23 @@ public:
   }
 
 protected:
-  bool expect_layer(Layer* expected_layer, int layer) {
-    return expect_layer_frame(sprite->layerToIndex(expected_layer), -1, layer, -1);
+  bool expect_layer(Layer* expected_layer, layer_t layer) {
+    LayerList layers = sprite->allLayers();
+    return expect_layer_frame(
+      find_layer_index(layers, expected_layer), -1, layer, -1);
   }
 
-  bool expect_frame(int expected_frame, frame_t frame) {
-    for (int i=0; i<(int)sprite->countLayers(); ++i) {
+  bool expect_frame(layer_t expected_frame, frame_t frame) {
+    LayerList layers = sprite->allLayers();
+    for (int i=0; i<(int)layers.size(); ++i) {
       if (!expect_layer_frame(i, expected_frame, i, frame))
         return false;
     }
     return true;
   }
 
-  bool expect_layer_frame(int expected_layer, int expected_frame, int layer, frame_t frame) {
+  bool expect_layer_frame(layer_t expected_layer, frame_t expected_frame,
+                          layer_t layer, frame_t frame) {
     if (frame >= 0) {
       if (!expect_cel(expected_layer, expected_frame, layer, frame))
         return false;
@@ -149,9 +155,10 @@ protected:
     }
 
     if (layer >= 0) {
-      Layer* a = sprite->indexToLayer(LayerIndex(expected_layer));
-      Layer* b = sprite->indexToLayer(LayerIndex(layer));
-      EXPECT_EQ(a, b);
+      LayerList layers = sprite->allLayers();
+      Layer* a = layers[expected_layer];
+      Layer* b = layers[layer];
+      EXPECT_EQ(a->name(), b->name());
       if (a != b)
         return false;
     }
@@ -159,10 +166,12 @@ protected:
     return true;
   }
 
-  bool expect_cel(int expected_layer, int expected_frame, int layer, frame_t frame) {
+  bool expect_cel(layer_t expected_layer, frame_t expected_frame,
+                  layer_t layer, frame_t frame) {
     color_t expected_color = white;
 
-    Cel* cel = sprite->indexToLayer(LayerIndex(layer))->cel(frame);
+    LayerList layers = sprite->allLayers();
+    Cel* cel = layers[layer]->cel(frame);
     if (!cel)
       return false;
 
@@ -175,8 +184,9 @@ protected:
     return (expected_color == color);
   }
 
-  bool expect_empty_cel(int layer, frame_t frame) {
-    Cel* cel = sprite->indexToLayer(LayerIndex(layer))->cel(frame);
+  bool expect_empty_cel(layer_t layer, frame_t frame) {
+    LayerList layers = sprite->allLayers();
+    Cel* cel = layers[layer]->cel(frame);
 
     EXPECT_EQ(NULL, cel);
     return (cel == NULL);

src/app/file/pixly_format.cpp

@@ -138,6 +138,7 @@ bool PixlyFormat::onLoad(FileOp* fop)
     int sheetHeight = sheet->height();
 
     // slice cels from sheet
+    LayerList layers = sprite->allLayers();
     std::vector<int> visible(layerCount, 0);
 
     TiXmlElement* xmlFrame = check(xmlFrames->FirstChild("Frame"))->ToElement();
@@ -147,8 +148,8 @@ bool PixlyFormat::onLoad(FileOp* fop)
 
       int index = check_number<int>(xmlIndex->Attribute("linear"));
       frame_t frame(index / layerCount);
-      LayerIndex layer_index(index % layerCount);
-      Layer *layer = sprite->indexToLayer(layer_index);
+      layer_t layer_index(index % layerCount);
+      Layer* layer = layers[layer_index];
 
       const char * duration = xmlFrame->Attribute("duration");
       if (duration) {
@@ -212,16 +213,14 @@ bool PixlyFormat::onLoad(FileOp* fop)
       fop->setProgress(0.5 + 0.5 * ((float)(index+1) / (float)imageCount));
     }
 
-    for (int i=0; i<layerCount; i++) {
-      LayerIndex layer_index(i);
-      Layer *layer = sprite->indexToLayer(layer_index);
-      layer->setVisible(visible[i] > frameCount/2);
+    for (layer_t i=0; i<layerCount; i++) {
+      layers[i]->setVisible(visible[i] > frameCount/2);
     }
 
     fop->createDocument(sprite);
     sprite.release();
   }
-  catch(Exception &e) {
+  catch(Exception& e) {
     fop->setError((std::string("Pixly file format: ")+std::string(e.what())+"\n").c_str());
     return false;
   }

src/render/quantization.cpp

@@ -71,7 +71,7 @@ Palette* create_palette_from_sprite(
     palette,
     // Transparent color is needed if we have transparent layers
     (sprite->backgroundLayer() &&
-     sprite->countLayers() == 1 ? -1: sprite->transparentColor()),
+     sprite->allLayersCount() == 1 ? -1: sprite->transparentColor()),
     delegate);
 
   return palette;