static void ase_file_write_layer_chunk(FILE *f, Layer *layer)
{
ase_file_write_start_chunk(f, ASE_FILE_CHUNK_LAYER);
// Flags
fputw(layer->getFlags(), f);
/* layer type */
fputw(layer->is_image() ? 0: (layer->is_folder() ? 1: -1), f);
/* layer child level */
LayerFolder* parent = layer->get_parent();
int child_level = -1;
while (parent != NULL) {
child_level++;
parent = parent->get_parent();
}
fputw(child_level, f);
/* default width & height, and blend mode */
fputw(0, f);
fputw(0, f);
fputw(layer->is_image() ? static_cast<LayerImage*>(layer)->getBlendMode(): 0, f);
/* padding */
ase_file_write_padding(f, 4);
/* layer name */
ase_file_write_string(f, layer->getName());
ase_file_write_close_chunk(f);
/* fop_error(fop, "Layer name \"%s\" child level: %d\n", layer->name, child_level); */
}
/**
* Removes and destroys the specified layer.
*/
void UndoTransaction::removeLayer(Layer* layer)
{
ASSERT(layer);
LayerFolder* parent = layer->get_parent();
// if the layer to be removed is the selected layer
if (layer == m_sprite->getCurrentLayer()) {
Layer* layer_select = NULL;
// select: previous layer, or next layer, or parent(if it is not the
// main layer of sprite set)
if (layer->get_prev())
layer_select = layer->get_prev();
else if (layer->get_next())
layer_select = layer->get_next();
else if (parent != m_sprite->getFolder())
layer_select = parent;
// select other layer
setCurrentLayer(layer_select);
}
// remove the layer
if (isEnabled())
m_undoHistory->pushUndoer(new undoers::RemoveLayer(m_undoHistory->getObjects(),
layer));
parent->remove_layer(layer);
// destroy the layer
delete layer;
}
void AddLayer::revert(ObjectsContainer* objects, UndoersCollector* redoers)
{
LayerFolder* folder = objects->getObjectT<LayerFolder>(m_folderId);
Layer* layer = objects->getObjectT<Layer>(m_layerId);
redoers->pushUndoer(new RemoveLayer(objects, layer));
folder->remove_layer(layer);
delete layer;
}
void MoveLayer::revert(ObjectsContainer* objects, UndoersCollector* redoers)
{
LayerFolder* folder = objects->getObjectT<LayerFolder>(m_folderId);
Layer* layer = objects->getObjectT<Layer>(m_layerId);
Layer* after = (m_afterId ? objects->getObjectT<Layer>(m_afterId): NULL);
// Backup the current layer position
redoers->pushUndoer(new MoveLayer(objects, layer));
// Restack the layer
folder->stackLayer(layer, after);
}
void RemoveLayer::revert(ObjectsContainer* objects, UndoersCollector* redoers)
{
Document* document = objects->getObjectT<Document>(m_documentId);
LayerFolder* folder = objects->getObjectT<LayerFolder>(m_folderId);
Layer* after = (m_afterId != 0 ? objects->getObjectT<Layer>(m_afterId): NULL);
// Read the layer from the stream
LayerSubObjectsSerializerImpl serializer(objects, folder->sprite());
Layer* layer = read_object<Layer>(objects, m_stream, serializer);
document->getApi(redoers).addLayer(folder, layer, after);
}
void Document::copyLayerContent(const Layer* sourceLayer0, Document* destDoc, Layer* destLayer0) const
{
// Copy the layer name
destLayer0->setName(sourceLayer0->name());
if (sourceLayer0->isImage() && destLayer0->isImage()) {
const LayerImage* sourceLayer = static_cast<const LayerImage*>(sourceLayer0);
LayerImage* destLayer = static_cast<LayerImage*>(destLayer0);
// copy cels
CelConstIterator it = sourceLayer->getCelBegin();
CelConstIterator end = sourceLayer->getCelEnd();
for (; it != end; ++it) {
const Cel* sourceCel = *it;
if (sourceCel->frame() > destLayer->sprite()->lastFrame())
break;
base::UniquePtr<Cel> newCel(new Cel(*sourceCel));
const Image* sourceImage = sourceCel->image();
ASSERT(sourceImage != NULL);
Image* newImage = Image::createCopy(sourceImage);
newCel->setImage(destLayer->sprite()->stock()->addImage(newImage));
destLayer->addCel(newCel);
newCel.release();
}
}
else if (sourceLayer0->isFolder() && destLayer0->isFolder()) {
const LayerFolder* sourceLayer = static_cast<const LayerFolder*>(sourceLayer0);
LayerFolder* destLayer = static_cast<LayerFolder*>(destLayer0);
LayerConstIterator it = sourceLayer->getLayerBegin();
LayerConstIterator end = sourceLayer->getLayerEnd();
for (; it != end; ++it) {
Layer* sourceChild = *it;
base::UniquePtr<Layer> destChild(NULL);
if (sourceChild->isImage()) {
destChild.reset(new LayerImage(destLayer->sprite()));
copyLayerContent(sourceChild, destDoc, destChild);
}
else if (sourceChild->isFolder()) {
destChild.reset(new LayerFolder(destLayer->sprite()));
copyLayerContent(sourceChild, destDoc, destChild);
}
else {
ASSERT(false);
}
ASSERT(destChild != NULL);
// Add the new layer in the sprite.
Layer* newLayer = destChild.release();
Layer* afterThis = destLayer->getLastLayer();
destLayer->addLayer(newLayer);
destChild.release();
destLayer->stackLayer(newLayer, afterThis);
}
}
else {
ASSERT(false && "Trying to copy two incompatible layers");
}
}
void Document::copyLayerContent(const Layer* sourceLayer0, Document* destDoc, Layer* destLayer0) const
{
LayerFlags dstFlags = sourceLayer0->flags();
// Remove the "background" flag if the destDoc already has a background layer.
if (((int)dstFlags & (int)LayerFlags::Background) == (int)LayerFlags::Background &&
(destDoc->sprite()->backgroundLayer())) {
dstFlags = (LayerFlags)((int)dstFlags & ~(int)(LayerFlags::BackgroundLayerFlags));
}
// Copy the layer name
destLayer0->setName(sourceLayer0->name());
destLayer0->setFlags(dstFlags);
if (sourceLayer0->isImage() && destLayer0->isImage()) {
const LayerImage* sourceLayer = static_cast<const LayerImage*>(sourceLayer0);
LayerImage* destLayer = static_cast<LayerImage*>(destLayer0);
// copy cels
CelConstIterator it = sourceLayer->getCelBegin();
CelConstIterator end = sourceLayer->getCelEnd();
std::map<ObjectId, Cel*> linked;
for (; it != end; ++it) {
const Cel* sourceCel = *it;
if (sourceCel->frame() > destLayer->sprite()->lastFrame())
break;
base::UniquePtr<Cel> newCel;
auto it = linked.find(sourceCel->data()->id());
if (it != linked.end()) {
newCel.reset(Cel::createLink(it->second));
newCel->setFrame(sourceCel->frame());
}
else {
newCel.reset(Cel::createCopy(sourceCel));
linked.insert(std::make_pair(sourceCel->data()->id(), newCel.get()));
}
destLayer->addCel(newCel);
newCel.release();
}
}
else if (sourceLayer0->isFolder() && destLayer0->isFolder()) {
const LayerFolder* sourceLayer = static_cast<const LayerFolder*>(sourceLayer0);
LayerFolder* destLayer = static_cast<LayerFolder*>(destLayer0);
LayerConstIterator it = sourceLayer->getLayerBegin();
LayerConstIterator end = sourceLayer->getLayerEnd();
for (; it != end; ++it) {
Layer* sourceChild = *it;
base::UniquePtr<Layer> destChild(NULL);
if (sourceChild->isImage()) {
destChild.reset(new LayerImage(destLayer->sprite()));
copyLayerContent(sourceChild, destDoc, destChild);
}
else if (sourceChild->isFolder()) {
destChild.reset(new LayerFolder(destLayer->sprite()));
copyLayerContent(sourceChild, destDoc, destChild);
}
else {
ASSERT(false);
}
ASSERT(destChild != NULL);
// Add the new layer in the sprite.
Layer* newLayer = destChild.release();
Layer* afterThis = destLayer->getLastLayer();
destLayer->addLayer(newLayer);
destChild.release();
destLayer->stackLayer(newLayer, afterThis);
}
}
else {
ASSERT(false && "Trying to copy two incompatible layers");
}
}
void Document::copyLayerContent(const Layer* sourceLayer0, Document* destDoc, Layer* destLayer0) const
{
DocumentUndo* undo = destDoc->getUndo();
// Copy the layer name
destLayer0->setName(sourceLayer0->getName());
if (sourceLayer0->isImage() && destLayer0->isImage()) {
const LayerImage* sourceLayer = static_cast<const LayerImage*>(sourceLayer0);
LayerImage* destLayer = static_cast<LayerImage*>(destLayer0);
// copy cels
CelConstIterator it = sourceLayer->getCelBegin();
CelConstIterator end = sourceLayer->getCelEnd();
for (; it != end; ++it) {
const Cel* sourceCel = *it;
UniquePtr<Cel> newCel(new Cel(*sourceCel));
ASSERT((sourceCel->getImage() >= 0) &&
(sourceCel->getImage() < sourceLayer->getSprite()->getStock()->size()));
const Image* sourceImage = sourceLayer->getSprite()->getStock()->getImage(sourceCel->getImage());
ASSERT(sourceImage != NULL);
Image* newImage = Image::createCopy(sourceImage);
newCel->setImage(destLayer->getSprite()->getStock()->addImage(newImage));
if (undo->isEnabled()) {
undo->pushUndoer(new undoers::AddImage(undo->getObjects(),
destLayer->getSprite()->getStock(),
newCel->getImage()));
}
destLayer->addCel(newCel);
newCel.release();
}
}
else if (sourceLayer0->isFolder() && destLayer0->isFolder()) {
const LayerFolder* sourceLayer = static_cast<const LayerFolder*>(sourceLayer0);
LayerFolder* destLayer = static_cast<LayerFolder*>(destLayer0);
LayerConstIterator it = sourceLayer->getLayerBegin();
LayerConstIterator end = sourceLayer->getLayerEnd();
for (; it != end; ++it) {
Layer* sourceChild = *it;
UniquePtr<Layer> destChild(NULL);
if (sourceChild->isImage()) {
destChild.reset(new LayerImage(destLayer->getSprite()));
copyLayerContent(sourceChild, destDoc, destChild);
}
else if (sourceChild->isFolder()) {
destChild.reset(new LayerFolder(destLayer->getSprite()));
copyLayerContent(sourceChild, destDoc, destChild);
}
else {
ASSERT(false);
}
ASSERT(destChild != NULL);
// Add the new layer in the sprite.
destDoc->getApi().addLayer(destLayer,
destChild.release(),
destLayer->getLastLayer());
}
}
else {
ASSERT(false && "Trying to copy two incompatible layers");
}
}
