mirror of
https://github.com/aseprite/aseprite.git
synced 2025-02-04 15:40:10 +00:00
Replace doc::FrameNumber with doc::frame_t
This commit is contained in:
parent
da1358c5dc
commit
06d18f1e8a
1
TODO.md
1
TODO.md
@ -46,7 +46,6 @@
|
||||
* Convert doc::PixelFormat to a enum class
|
||||
* Add doc::Spec with width/height/channels/ColorMode/ncolors
|
||||
* Convert doc::LayerIndex -> typedef int doc::layer_t;
|
||||
* Convert doc::FrameNumber -> typedef int doc::frame_t;
|
||||
* Replace doc::LayerImage::getCel() with doc::Layer::cel()
|
||||
* Replace doc::Sprite::getPalette() with doc::Sprite::palette()
|
||||
* Replace doc::Palette::getEntry() with doc::Palette::entry()
|
||||
|
@ -138,8 +138,8 @@
|
||||
</section>
|
||||
<section id="loop">
|
||||
<option id="visible" type="bool" default="false" />
|
||||
<option id="from" type="doc::FrameNumber" default="doc::FrameNumber(0)" />
|
||||
<option id="to" type="doc::FrameNumber" default="doc::FrameNumber(1)" />
|
||||
<option id="from" type="doc::frame_t" default="0" />
|
||||
<option id="to" type="doc::frame_t" default="1" />
|
||||
<option id="ani_dir" type="AniDir" default="AniDir::FORWARD" />
|
||||
</section>
|
||||
</document>
|
||||
|
@ -294,7 +294,7 @@ void App::initialize(const AppOptions& options)
|
||||
hide->setVisible(hide == show);
|
||||
|
||||
std::string frameStr;
|
||||
if (doc->sprite()->totalFrames() > FrameNumber(1))
|
||||
if (doc->sprite()->totalFrames() > frame_t(1))
|
||||
frameStr += " 1";
|
||||
|
||||
std::string fn = value.value();
|
||||
|
@ -79,10 +79,10 @@ void ClearCelCommand::onExecute(Context* context)
|
||||
|
||||
LayerImage* layerImage = static_cast<LayerImage*>(layer);
|
||||
|
||||
for (FrameNumber frame = range.frameEnd(),
|
||||
begin = range.frameBegin().previous();
|
||||
for (frame_t frame = range.frameEnd(),
|
||||
begin = range.frameBegin()-1;
|
||||
frame != begin;
|
||||
frame = frame.previous()) {
|
||||
--frame) {
|
||||
document->getApi().clearCel(layerImage, frame);
|
||||
}
|
||||
}
|
||||
|
@ -303,7 +303,7 @@ void ExportSpriteSheetCommand::onExecute(Context* context)
|
||||
m_height = fit.height;
|
||||
}
|
||||
|
||||
FrameNumber nframes = sprite->totalFrames();
|
||||
frame_t nframes = sprite->totalFrames();
|
||||
int columns;
|
||||
int sheet_w = 0;
|
||||
int sheet_h = 0;
|
||||
@ -333,7 +333,7 @@ void ExportSpriteSheetCommand::onExecute(Context* context)
|
||||
render::Render render;
|
||||
|
||||
int column = 0, row = 0;
|
||||
for (FrameNumber frame(0); frame<nframes; ++frame) {
|
||||
for (frame_t frame = 0; frame<nframes; ++frame) {
|
||||
render.renderSprite(resultImage, sprite, frame,
|
||||
gfx::Clip(column*sprite->width(), row*sprite->height(),
|
||||
sprite->bounds()));
|
||||
@ -346,8 +346,9 @@ void ExportSpriteSheetCommand::onExecute(Context* context)
|
||||
|
||||
// Store the frame in the current editor so we can restore it
|
||||
// after change and restore the setTotalFrames() number.
|
||||
FrameNumber oldSelectedFrame = (current_editor ? current_editor->frame():
|
||||
FrameNumber(0));
|
||||
frame_t oldSelectedFrame = (current_editor ?
|
||||
current_editor->frame():
|
||||
frame_t(0));
|
||||
|
||||
{
|
||||
// The following steps modify the sprite, so we wrap all
|
||||
@ -364,7 +365,7 @@ void ExportSpriteSheetCommand::onExecute(Context* context)
|
||||
resultImage.release();
|
||||
|
||||
// Create the cel.
|
||||
base::UniquePtr<Cel> resultCel(new Cel(FrameNumber(0), indexInStock));
|
||||
base::UniquePtr<Cel> resultCel(new Cel(frame_t(0), indexInStock));
|
||||
|
||||
// Add the cel in the layer.
|
||||
api.addCel(resultLayer, resultCel);
|
||||
@ -383,7 +384,7 @@ void ExportSpriteSheetCommand::onExecute(Context* context)
|
||||
// we are using the observable API, all DocumentView will change
|
||||
// its current frame to frame 1. We'll try to restore the
|
||||
// selected frame for the current_editor later.
|
||||
api.setTotalFrames(sprite, FrameNumber(1));
|
||||
api.setTotalFrames(sprite, frame_t(1));
|
||||
|
||||
// Set the size of the sprite to the tile size.
|
||||
api.setSpriteSize(sprite, sheet_w, sheet_h);
|
||||
|
@ -58,7 +58,7 @@ private:
|
||||
// Frame to be shown. It can be ALL_FRAMES, CURRENT_RANGE, or a
|
||||
// number indicating a specific frame (1 is the first frame).
|
||||
Target m_target;
|
||||
FrameNumber m_frame;
|
||||
frame_t m_frame;
|
||||
};
|
||||
|
||||
FramePropertiesCommand::FramePropertiesCommand()
|
||||
@ -79,7 +79,7 @@ void FramePropertiesCommand::onLoadParams(Params* params)
|
||||
}
|
||||
else {
|
||||
m_target = SPECIFIC_FRAME;
|
||||
m_frame = FrameNumber(base::convert_to<int>(frame)-1);
|
||||
m_frame = frame_t(base::convert_to<int>(frame)-1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -98,8 +98,8 @@ void FramePropertiesCommand::onExecute(Context* context)
|
||||
Widget* frlen = app::find_widget<Widget>(window, "frlen");
|
||||
Widget* ok = app::find_widget<Widget>(window, "ok");
|
||||
|
||||
FrameNumber firstFrame(0);
|
||||
FrameNumber lastFrame(0);
|
||||
frame_t firstFrame(0);
|
||||
frame_t lastFrame(0);
|
||||
|
||||
switch (m_target) {
|
||||
|
||||
@ -130,7 +130,7 @@ void FramePropertiesCommand::onExecute(Context* context)
|
||||
else
|
||||
frame->setTextf("%d", (int)firstFrame+1);
|
||||
|
||||
frlen->setTextf("%d", sprite->getFrameDuration(firstFrame));
|
||||
frlen->setTextf("%d", sprite->frameDuration(firstFrame));
|
||||
|
||||
window->openWindowInForeground();
|
||||
if (window->getKiller() == ok) {
|
||||
|
@ -49,7 +49,7 @@ protected:
|
||||
current_editor->setFrame(onGetFrame(current_editor));
|
||||
}
|
||||
|
||||
virtual FrameNumber onGetFrame(Editor* editor) = 0;
|
||||
virtual frame_t onGetFrame(Editor* editor) = 0;
|
||||
};
|
||||
|
||||
class GotoFirstFrameCommand : public GotoCommand {
|
||||
@ -60,8 +60,8 @@ public:
|
||||
Command* clone() const override { return new GotoFirstFrameCommand(*this); }
|
||||
|
||||
protected:
|
||||
FrameNumber onGetFrame(Editor* editor) override {
|
||||
return FrameNumber(0);
|
||||
frame_t onGetFrame(Editor* editor) override {
|
||||
return frame_t(0);
|
||||
}
|
||||
};
|
||||
|
||||
@ -73,11 +73,11 @@ public:
|
||||
Command* clone() const override { return new GotoPreviousFrameCommand(*this); }
|
||||
|
||||
protected:
|
||||
FrameNumber onGetFrame(Editor* editor) override {
|
||||
FrameNumber frame = editor->frame();
|
||||
frame_t onGetFrame(Editor* editor) override {
|
||||
frame_t frame = editor->frame();
|
||||
|
||||
if (frame > FrameNumber(0))
|
||||
return frame.previous();
|
||||
if (frame > frame_t(0))
|
||||
return frame-1;
|
||||
else
|
||||
return editor->sprite()->lastFrame();
|
||||
}
|
||||
@ -90,12 +90,12 @@ public:
|
||||
Command* clone() const override { return new GotoNextFrameCommand(*this); }
|
||||
|
||||
protected:
|
||||
FrameNumber onGetFrame(Editor* editor) override {
|
||||
FrameNumber frame = editor->frame();
|
||||
frame_t onGetFrame(Editor* editor) override {
|
||||
frame_t frame = editor->frame();
|
||||
if (frame < editor->sprite()->lastFrame())
|
||||
return frame.next();
|
||||
return frame+1;
|
||||
else
|
||||
return FrameNumber(0);
|
||||
return frame_t(0);
|
||||
}
|
||||
};
|
||||
|
||||
@ -106,7 +106,7 @@ public:
|
||||
Command* clone() const override { return new GotoLastFrameCommand(*this); }
|
||||
|
||||
protected:
|
||||
FrameNumber onGetFrame(Editor* editor) override {
|
||||
frame_t onGetFrame(Editor* editor) override {
|
||||
return editor->sprite()->lastFrame();
|
||||
}
|
||||
};
|
||||
@ -126,7 +126,7 @@ protected:
|
||||
else m_frame = 0;
|
||||
}
|
||||
|
||||
FrameNumber onGetFrame(Editor* editor) override {
|
||||
frame_t onGetFrame(Editor* editor) override {
|
||||
if (m_frame == 0) {
|
||||
base::UniquePtr<Window> window(app::load_widget<Window>("goto_frame.xml", "goto_frame"));
|
||||
Widget* frame = app::find_widget<Widget>(window, "frame");
|
||||
@ -141,7 +141,7 @@ protected:
|
||||
m_frame = frame->getTextInt();
|
||||
}
|
||||
|
||||
return MID(FrameNumber(0), FrameNumber(m_frame-1), editor->sprite()->lastFrame());
|
||||
return MID(0, m_frame-1, editor->sprite()->lastFrame());
|
||||
}
|
||||
|
||||
private:
|
||||
|
@ -164,7 +164,7 @@ protected:
|
||||
|
||||
try {
|
||||
Sprite* sprite = m_document->sprite();
|
||||
FrameNumber currentFrame = m_context->activeLocation().frame();
|
||||
frame_t currentFrame = m_context->activeLocation().frame();
|
||||
render::Render render;
|
||||
|
||||
// As first step, we cut each tile and add them into "animation" list.
|
||||
@ -208,7 +208,7 @@ protected:
|
||||
animation[i] = NULL;
|
||||
|
||||
// Create the cel.
|
||||
base::UniquePtr<Cel> resultCel(new Cel(FrameNumber(i), indexInStock));
|
||||
base::UniquePtr<Cel> resultCel(new Cel(frame_t(i), indexInStock));
|
||||
|
||||
// Add the cel in the layer.
|
||||
api.addCel(resultLayer, resultCel);
|
||||
@ -225,7 +225,7 @@ protected:
|
||||
}
|
||||
|
||||
// Change the number of frames
|
||||
api.setTotalFrames(sprite, FrameNumber(animation.size()));
|
||||
api.setTotalFrames(sprite, frame_t(animation.size()));
|
||||
|
||||
// Set the size of the sprite to the tile size.
|
||||
api.setSpriteSize(sprite, m_rect.w, m_rect.h);
|
||||
|
@ -89,7 +89,7 @@ void MergeDownLayerCommand::onExecute(Context* context)
|
||||
Layer* dst_layer = src_layer->getPrevious();
|
||||
int index;
|
||||
|
||||
for (FrameNumber frpos(0); frpos<sprite->totalFrames(); ++frpos) {
|
||||
for (frame_t frpos = 0; frpos<sprite->totalFrames(); ++frpos) {
|
||||
// Get frames
|
||||
Cel* src_cel = static_cast<LayerImage*>(src_layer)->getCel(frpos);
|
||||
Cel* dst_cel = static_cast<LayerImage*>(dst_layer)->getCel(frpos);
|
||||
|
@ -167,7 +167,7 @@ void NewFileCommand::onExecute(Context* context)
|
||||
(format == IMAGE_INDEXED ? ncolors: 256)));
|
||||
|
||||
if (sprite->pixelFormat() != IMAGE_GRAYSCALE)
|
||||
get_default_palette()->copyColorsTo(sprite->getPalette(FrameNumber(0)));
|
||||
get_default_palette()->copyColorsTo(sprite->palette(frame_t(0)));
|
||||
|
||||
// If the background color isn't transparent, we have to
|
||||
// convert the `Layer 1' in a `Background'
|
||||
@ -178,7 +178,7 @@ void NewFileCommand::onExecute(Context* context)
|
||||
LayerImage* layerImage = static_cast<LayerImage*>(layer);
|
||||
layerImage->configureAsBackground();
|
||||
|
||||
Image* image = layerImage->getCel(FrameNumber(0))->image();
|
||||
Image* image = layerImage->getCel(frame_t(0))->image();
|
||||
doc::clear_image(image,
|
||||
color_utils::color_for_target(color,
|
||||
ColorTarget(
|
||||
|
@ -89,10 +89,10 @@ void NewFrameCommand::onExecute(Context* context)
|
||||
UndoTransaction undoTransaction(writer.context(), "New Frame");
|
||||
switch (m_content) {
|
||||
case Content::CurrentFrame:
|
||||
document->getApi().addFrame(sprite, writer.frame().next());
|
||||
document->getApi().addFrame(sprite, writer.frame()+1);
|
||||
break;
|
||||
case Content::EmptyFrame:
|
||||
document->getApi().addEmptyFrame(sprite, writer.frame().next());
|
||||
document->getApi().addEmptyFrame(sprite, writer.frame()+1);
|
||||
break;
|
||||
}
|
||||
undoTransaction.commit();
|
||||
|
@ -560,7 +560,7 @@ void PaletteEntryEditor::onRampClick(Event& ev)
|
||||
return;
|
||||
|
||||
Palette* src_palette = get_current_palette();
|
||||
Palette* dst_palette = new Palette(FrameNumber(0), 256);
|
||||
Palette* dst_palette = new Palette(frame_t(0), 256);
|
||||
|
||||
src_palette->copyColorsTo(dst_palette);
|
||||
dst_palette->makeHorzRamp(index1, index2);
|
||||
@ -740,8 +740,8 @@ void PaletteEntryEditor::updateCurrentSpritePalette(const char* operationName)
|
||||
Document* document(writer.document());
|
||||
Sprite* sprite(writer.sprite());
|
||||
Palette* newPalette = get_current_palette(); // System current pal
|
||||
FrameNumber frame = writer.frame();
|
||||
Palette* currentSpritePalette = sprite->getPalette(frame); // Sprite current pal
|
||||
frame_t frame = writer.frame();
|
||||
Palette* currentSpritePalette = sprite->palette(frame); // Sprite current pal
|
||||
int from, to;
|
||||
|
||||
// Check differences between current sprite palette and current system palette
|
||||
|
@ -69,7 +69,7 @@ public:
|
||||
|
||||
m_curFrameTick = ui::clock();
|
||||
m_pingPongForward = true;
|
||||
m_nextFrameTime = editor->sprite()->getFrameDuration(editor->frame());
|
||||
m_nextFrameTime = editor->sprite()->frameDuration(editor->frame());
|
||||
|
||||
m_playTimer.Tick.connect(&PlayAniWindow::onPlaybackTick, this);
|
||||
m_playTimer.start();
|
||||
@ -81,14 +81,14 @@ protected:
|
||||
m_nextFrameTime -= (ui::clock() - m_curFrameTick);
|
||||
|
||||
while (m_nextFrameTime <= 0) {
|
||||
FrameNumber frame = calculate_next_frame(
|
||||
frame_t frame = calculate_next_frame(
|
||||
m_editor->sprite(),
|
||||
m_editor->frame(),
|
||||
m_docSettings,
|
||||
m_pingPongForward);
|
||||
|
||||
m_editor->setFrame(frame);
|
||||
m_nextFrameTime += m_editor->sprite()->getFrameDuration(frame);
|
||||
m_nextFrameTime += m_editor->sprite()->frameDuration(frame);
|
||||
invalidate();
|
||||
}
|
||||
|
||||
@ -146,7 +146,7 @@ protected:
|
||||
|
||||
private:
|
||||
Editor* m_editor;
|
||||
FrameNumber m_oldFrame;
|
||||
frame_t m_oldFrame;
|
||||
Editor::EditorFlags m_oldFlags;
|
||||
Document* m_doc;
|
||||
IDocumentSettings* m_docSettings;
|
||||
|
@ -60,7 +60,7 @@ public:
|
||||
, m_editor(editor)
|
||||
, m_doc(editor->document())
|
||||
, m_sprite(editor->sprite())
|
||||
, m_pal(m_sprite->getPalette(editor->frame()))
|
||||
, m_pal(m_sprite->palette(editor->frame()))
|
||||
, m_index_bg_color(-1)
|
||||
, m_doublebuf(Image::create(IMAGE_RGB, ui::display_w(), ui::display_h()))
|
||||
, m_doublesur(she::instance()->createRgbaSurface(ui::display_w(), ui::display_h()))
|
||||
|
@ -70,10 +70,10 @@ void RemoveFrameCommand::onExecute(Context* context)
|
||||
// TODO the range of selected frames should be in the DocumentLocation.
|
||||
Timeline::Range range = App::instance()->getMainWindow()->getTimeline()->range();
|
||||
if (range.enabled()) {
|
||||
for (FrameNumber frame = range.frameEnd(),
|
||||
begin = range.frameBegin().previous();
|
||||
for (frame_t frame = range.frameEnd(),
|
||||
begin = range.frameBegin()-1;
|
||||
frame != begin;
|
||||
frame = frame.previous()) {
|
||||
--frame) {
|
||||
document->getApi().removeFrame(sprite, frame);
|
||||
}
|
||||
}
|
||||
|
@ -44,7 +44,7 @@ protected:
|
||||
void onExecute(Context* context) override;
|
||||
|
||||
Action m_action;
|
||||
FrameNumber m_begin, m_end;
|
||||
frame_t m_begin, m_end;
|
||||
};
|
||||
|
||||
SetLoopSectionCommand::SetLoopSectionCommand()
|
||||
@ -67,8 +67,8 @@ void SetLoopSectionCommand::onLoadParams(Params* params)
|
||||
std::string begin = params->get("begin");
|
||||
std::string end = params->get("end");
|
||||
|
||||
m_begin = FrameNumber(strtol(begin.c_str(), NULL, 10));
|
||||
m_end = FrameNumber(strtol(end.c_str(), NULL, 10));
|
||||
m_begin = frame_t(strtol(begin.c_str(), NULL, 10));
|
||||
m_end = frame_t(strtol(end.c_str(), NULL, 10));
|
||||
}
|
||||
|
||||
bool SetLoopSectionCommand::onEnabled(Context* ctx)
|
||||
@ -86,8 +86,8 @@ void SetLoopSectionCommand::onExecute(Context* ctx)
|
||||
if (!docSets)
|
||||
return;
|
||||
|
||||
FrameNumber begin = m_begin;
|
||||
FrameNumber end = m_end;
|
||||
frame_t begin = m_begin;
|
||||
frame_t end = m_end;
|
||||
bool on = false;
|
||||
|
||||
switch (m_action) {
|
||||
|
@ -96,7 +96,7 @@ void SpritePropertiesCommand::onExecute(Context* context)
|
||||
imgtype_text = "Grayscale";
|
||||
break;
|
||||
case IMAGE_INDEXED:
|
||||
std::sprintf(buf, "Indexed (%d colors)", sprite->getPalette(FrameNumber(0))->size());
|
||||
std::sprintf(buf, "Indexed (%d colors)", sprite->palette(0)->size());
|
||||
imgtype_text = buf;
|
||||
break;
|
||||
default:
|
||||
|
@ -110,8 +110,8 @@ protected:
|
||||
doc::algorithm::fixup_image_transparent_colors(image);
|
||||
doc::algorithm::resize_image(image, new_image,
|
||||
m_resize_method,
|
||||
m_sprite->getPalette(cel->frame()),
|
||||
m_sprite->getRgbMap(cel->frame()));
|
||||
m_sprite->palette(cel->frame()),
|
||||
m_sprite->rgbMap(cel->frame()));
|
||||
|
||||
api.replaceStockImage(m_sprite, cel->imageIndex(), new_image);
|
||||
|
||||
@ -138,8 +138,8 @@ protected:
|
||||
scale_y(m_document->mask()->bounds().y-1), MAX(1, w), MAX(1, h)));
|
||||
algorithm::resize_image(old_bitmap, new_mask->bitmap(),
|
||||
m_resize_method,
|
||||
m_sprite->getPalette(FrameNumber(0)), // Ignored
|
||||
m_sprite->getRgbMap(FrameNumber(0))); // Ignored
|
||||
m_sprite->palette(0), // Ignored
|
||||
m_sprite->rgbMap(0)); // Ignored
|
||||
|
||||
// Reshrink
|
||||
new_mask->intersect(new_mask->bounds());
|
||||
|
@ -89,7 +89,7 @@ void UndoCommand::onExecute(Context* context)
|
||||
|
||||
if (spritePosition != currentPosition) {
|
||||
current_editor->setLayer(sprite->indexToLayer(spritePosition.layerIndex()));
|
||||
current_editor->setFrame(spritePosition.frameNumber());
|
||||
current_editor->setFrame(spritePosition.frame());
|
||||
|
||||
// Draw the current layer/frame (which is not undone yet) so the
|
||||
// user can see the doUndo/doRedo effect.
|
||||
|
@ -297,12 +297,12 @@ bool FilterManagerImpl::skipPixel()
|
||||
|
||||
Palette* FilterManagerImpl::getPalette()
|
||||
{
|
||||
return m_location.sprite()->getPalette(m_location.frame());
|
||||
return m_location.sprite()->palette(m_location.frame());
|
||||
}
|
||||
|
||||
RgbMap* FilterManagerImpl::getRgbMap()
|
||||
{
|
||||
return m_location.sprite()->getRgbMap(m_location.frame());
|
||||
return m_location.sprite()->rgbMap(m_location.frame());
|
||||
}
|
||||
|
||||
void FilterManagerImpl::init(const Layer* layer, Image* image, int offset_x, int offset_y)
|
||||
|
@ -95,7 +95,7 @@ namespace app {
|
||||
Document* document() { return m_location.document(); }
|
||||
Sprite* sprite() { return m_location.sprite(); }
|
||||
Layer* layer() { return m_location.layer(); }
|
||||
FrameNumber frame() { return m_location.frame(); }
|
||||
frame_t frame() { return m_location.frame(); }
|
||||
Image* destinationImage() const { return m_dst; }
|
||||
|
||||
// Updates the current editor to show the progress of the preview.
|
||||
|
@ -35,7 +35,7 @@ namespace app {
|
||||
const DocumentAccessT& document() const { return m_document; }
|
||||
const Sprite* sprite() const { return m_location.sprite(); }
|
||||
const Layer* layer() const { return m_location.layer(); }
|
||||
FrameNumber frame() const { return m_location.frame(); }
|
||||
frame_t frame() const { return m_location.frame(); }
|
||||
const Cel* cel() const { return m_location.cel(); }
|
||||
|
||||
// You cannot change the location directly from a writable ContextAccess anyway.
|
||||
|
@ -125,7 +125,7 @@ void Document::notifyLayerMergedDown(Layer* srcLayer, Layer* targetLayer)
|
||||
notifyObservers<doc::DocumentEvent&>(&doc::DocumentObserver::onLayerMergedDown, ev);
|
||||
}
|
||||
|
||||
void Document::notifyCelMoved(Layer* fromLayer, FrameNumber fromFrame, Layer* toLayer, FrameNumber toFrame)
|
||||
void Document::notifyCelMoved(Layer* fromLayer, frame_t fromFrame, Layer* toLayer, frame_t toFrame)
|
||||
{
|
||||
doc::DocumentEvent ev(this);
|
||||
ev.sprite(fromLayer->sprite());
|
||||
@ -136,7 +136,7 @@ void Document::notifyCelMoved(Layer* fromLayer, FrameNumber fromFrame, Layer* to
|
||||
notifyObservers<doc::DocumentEvent&>(&doc::DocumentObserver::onCelMoved, ev);
|
||||
}
|
||||
|
||||
void Document::notifyCelCopied(Layer* fromLayer, FrameNumber fromFrame, Layer* toLayer, FrameNumber toFrame)
|
||||
void Document::notifyCelCopied(Layer* fromLayer, frame_t fromFrame, Layer* toLayer, frame_t toFrame)
|
||||
{
|
||||
doc::DocumentEvent ev(this);
|
||||
ev.sprite(fromLayer->sprite());
|
||||
@ -246,7 +246,7 @@ void Document::prepareExtraCel(const gfx::Rect& bounds, int opacity)
|
||||
ASSERT(sprite() != NULL);
|
||||
|
||||
if (!m_extraCel)
|
||||
m_extraCel = new Cel(FrameNumber(0), 0); // Ignored fields for this cell (frame, and image index)
|
||||
m_extraCel = new Cel(frame_t(0), 0); // Ignored fields for this cell (frame, and image index)
|
||||
|
||||
m_extraCel->setPosition(bounds.getOrigin());
|
||||
m_extraCel->setOpacity(opacity);
|
||||
@ -397,7 +397,7 @@ Document* Document::duplicate(DuplicateType type) const
|
||||
sourceSprite->pixelFormat(),
|
||||
sourceSprite->width(),
|
||||
sourceSprite->height(),
|
||||
sourceSprite->getPalette(FrameNumber(0))->size()));
|
||||
sourceSprite->palette(frame_t(0))->size()));
|
||||
|
||||
base::UniquePtr<Document> documentCopy(new Document(spriteCopyPtr));
|
||||
Sprite* spriteCopy = spriteCopyPtr.release();
|
||||
@ -405,8 +405,8 @@ Document* Document::duplicate(DuplicateType type) const
|
||||
spriteCopy->setTotalFrames(sourceSprite->totalFrames());
|
||||
|
||||
// Copy frames duration
|
||||
for (FrameNumber i(0); i < sourceSprite->totalFrames(); ++i)
|
||||
spriteCopy->setFrameDuration(i, sourceSprite->getFrameDuration(i));
|
||||
for (frame_t i(0); i < sourceSprite->totalFrames(); ++i)
|
||||
spriteCopy->setFrameDuration(i, sourceSprite->frameDuration(i));
|
||||
|
||||
// Copy color palettes
|
||||
{
|
||||
@ -439,7 +439,7 @@ Document* Document::duplicate(DuplicateType type) const
|
||||
(spriteCopy,
|
||||
sourceSprite->folder(),
|
||||
gfx::Rect(0, 0, sourceSprite->width(), sourceSprite->height()),
|
||||
FrameNumber(0), sourceSprite->lastFrame());
|
||||
frame_t(0), sourceSprite->lastFrame());
|
||||
|
||||
// Add and select the new flat layer
|
||||
spriteCopy->folder()->addLayer(flatLayer);
|
||||
|
@ -26,7 +26,7 @@
|
||||
#include "base/shared_ptr.h"
|
||||
#include "base/unique_ptr.h"
|
||||
#include "doc/document.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/pixel_format.h"
|
||||
#include "gfx/rect.h"
|
||||
#include "gfx/transformation.h"
|
||||
@ -93,8 +93,8 @@ namespace app {
|
||||
void notifySpritePixelsModified(Sprite* sprite, const gfx::Region& region);
|
||||
void notifyExposeSpritePixels(Sprite* sprite, const gfx::Region& region);
|
||||
void notifyLayerMergedDown(Layer* srcLayer, Layer* targetLayer);
|
||||
void notifyCelMoved(Layer* fromLayer, FrameNumber fromFrame, Layer* toLayer, FrameNumber toFrame);
|
||||
void notifyCelCopied(Layer* fromLayer, FrameNumber fromFrame, Layer* toLayer, FrameNumber toFrame);
|
||||
void notifyCelMoved(Layer* fromLayer, frame_t fromFrame, Layer* toLayer, frame_t toFrame);
|
||||
void notifyCelCopied(Layer* fromLayer, frame_t fromFrame, Layer* toLayer, frame_t toFrame);
|
||||
void notifySelectionChanged();
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
@ -141,7 +141,7 @@ void DocumentApi::trimSprite(Sprite* sprite)
|
||||
Image* image = image_wrap.get();
|
||||
render::Render render;
|
||||
|
||||
for (FrameNumber frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
for (frame_t frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
render.renderSprite(image, sprite, frame);
|
||||
|
||||
// TODO configurable (what color pixel to use as "refpixel",
|
||||
@ -165,10 +165,10 @@ void DocumentApi::setPixelFormat(Sprite* sprite, PixelFormat newFormat, Ditherin
|
||||
return;
|
||||
|
||||
// TODO Review this, why we use the palette in frame 0?
|
||||
FrameNumber frame(0);
|
||||
frame_t frame(0);
|
||||
|
||||
// Use the rgbmap for the specified sprite
|
||||
const RgbMap* rgbmap = sprite->getRgbMap(frame);
|
||||
const RgbMap* rgbmap = sprite->rgbMap(frame);
|
||||
|
||||
// Get the list of cels from the background layer (if it
|
||||
// exists). This list will be used to check if each image belong to
|
||||
@ -192,7 +192,7 @@ void DocumentApi::setPixelFormat(Sprite* sprite, PixelFormat newFormat, Ditherin
|
||||
|
||||
new_image = render::convert_pixel_format
|
||||
(old_image, NULL, newFormat, dithering_method, rgbmap,
|
||||
sprite->getPalette(frame),
|
||||
sprite->palette(frame),
|
||||
is_image_from_background);
|
||||
|
||||
replaceStockImage(sprite, c, new_image);
|
||||
@ -232,7 +232,7 @@ void DocumentApi::setPixelFormat(Sprite* sprite, PixelFormat newFormat, Ditherin
|
||||
}
|
||||
|
||||
m_undoers->pushUndoer(new undoers::AddPalette(
|
||||
getObjects(), sprite, FrameNumber(0)));
|
||||
getObjects(), sprite, frame_t(0)));
|
||||
}
|
||||
|
||||
// It's a base::UniquePtr because setPalette'll create a copy of "graypal".
|
||||
@ -243,14 +243,14 @@ void DocumentApi::setPixelFormat(Sprite* sprite, PixelFormat newFormat, Ditherin
|
||||
}
|
||||
}
|
||||
|
||||
void DocumentApi::addFrame(Sprite* sprite, FrameNumber newFrame)
|
||||
void DocumentApi::addFrame(Sprite* sprite, frame_t newFrame)
|
||||
{
|
||||
copyFrame(sprite, newFrame.previous(), newFrame);
|
||||
copyFrame(sprite, newFrame-1, newFrame);
|
||||
}
|
||||
|
||||
void DocumentApi::addEmptyFrame(Sprite* sprite, FrameNumber newFrame)
|
||||
void DocumentApi::addEmptyFrame(Sprite* sprite, frame_t newFrame)
|
||||
{
|
||||
int duration = sprite->getFrameDuration(newFrame.previous());
|
||||
int duration = sprite->frameDuration(newFrame-1);
|
||||
|
||||
// Add the frame in the sprite structure, it adjusts the total
|
||||
// number of frames in the sprite.
|
||||
@ -270,27 +270,27 @@ void DocumentApi::addEmptyFrame(Sprite* sprite, FrameNumber newFrame)
|
||||
m_document->notifyObservers<doc::DocumentEvent&>(&doc::DocumentObserver::onAddFrame, ev);
|
||||
}
|
||||
|
||||
void DocumentApi::addEmptyFramesTo(Sprite* sprite, FrameNumber newFrame)
|
||||
void DocumentApi::addEmptyFramesTo(Sprite* sprite, frame_t newFrame)
|
||||
{
|
||||
while (sprite->totalFrames() <= newFrame)
|
||||
addEmptyFrame(sprite, sprite->totalFrames());
|
||||
}
|
||||
|
||||
void DocumentApi::copyFrame(Sprite* sprite, FrameNumber fromFrame, FrameNumber newFrame)
|
||||
void DocumentApi::copyFrame(Sprite* sprite, frame_t fromFrame, frame_t newFrame)
|
||||
{
|
||||
int duration = sprite->getFrameDuration(fromFrame);
|
||||
int duration = sprite->frameDuration(fromFrame);
|
||||
|
||||
addEmptyFrame(sprite, newFrame);
|
||||
|
||||
if (fromFrame >= newFrame)
|
||||
fromFrame = fromFrame.next();
|
||||
++fromFrame;
|
||||
|
||||
copyFrameForLayer(sprite->folder(), fromFrame, newFrame);
|
||||
|
||||
setFrameDuration(sprite, newFrame, duration);
|
||||
}
|
||||
|
||||
void DocumentApi::displaceFrames(Layer* layer, FrameNumber frame)
|
||||
void DocumentApi::displaceFrames(Layer* layer, frame_t frame)
|
||||
{
|
||||
ASSERT(layer);
|
||||
ASSERT(frame >= 0);
|
||||
@ -303,10 +303,10 @@ void DocumentApi::displaceFrames(Layer* layer, FrameNumber frame)
|
||||
LayerImage* imglayer = static_cast<LayerImage*>(layer);
|
||||
|
||||
// Displace all cels in '>=frame' to the next frame.
|
||||
for (FrameNumber c=sprite->lastFrame(); c>=frame; --c) {
|
||||
for (frame_t c=sprite->lastFrame(); c>=frame; --c) {
|
||||
Cel* cel = imglayer->getCel(c);
|
||||
if (cel)
|
||||
setCelFramePosition(imglayer, cel, cel->frame().next());
|
||||
setCelFramePosition(imglayer, cel, cel->frame()+1);
|
||||
}
|
||||
|
||||
// Add background cel
|
||||
@ -330,7 +330,7 @@ void DocumentApi::displaceFrames(Layer* layer, FrameNumber frame)
|
||||
}
|
||||
}
|
||||
|
||||
void DocumentApi::copyFrameForLayer(Layer* layer, FrameNumber fromFrame, FrameNumber frame)
|
||||
void DocumentApi::copyFrameForLayer(Layer* layer, frame_t fromFrame, frame_t frame)
|
||||
{
|
||||
ASSERT(layer);
|
||||
ASSERT(frame >= 0);
|
||||
@ -355,7 +355,7 @@ void DocumentApi::copyFrameForLayer(Layer* layer, FrameNumber fromFrame, FrameNu
|
||||
}
|
||||
}
|
||||
|
||||
void DocumentApi::removeFrame(Sprite* sprite, FrameNumber frame)
|
||||
void DocumentApi::removeFrame(Sprite* sprite, frame_t frame)
|
||||
{
|
||||
ASSERT(frame >= 0);
|
||||
|
||||
@ -381,7 +381,7 @@ void DocumentApi::removeFrame(Sprite* sprite, FrameNumber frame)
|
||||
|
||||
// Does the hard part of removing a frame: Removes all cels located in
|
||||
// the given frame, and moves all following cels one frame position back.
|
||||
void DocumentApi::removeFrameOfLayer(Layer* layer, FrameNumber frame)
|
||||
void DocumentApi::removeFrameOfLayer(Layer* layer, frame_t frame)
|
||||
{
|
||||
ASSERT(layer);
|
||||
ASSERT(frame >= 0);
|
||||
@ -397,7 +397,7 @@ void DocumentApi::removeFrameOfLayer(Layer* layer, FrameNumber frame)
|
||||
|
||||
for (++frame; frame<sprite->totalFrames(); ++frame)
|
||||
if (Cel* cel = imglayer->getCel(frame))
|
||||
setCelFramePosition(imglayer, cel, cel->frame().previous());
|
||||
setCelFramePosition(imglayer, cel, cel->frame()-1);
|
||||
break;
|
||||
}
|
||||
|
||||
@ -413,7 +413,7 @@ void DocumentApi::removeFrameOfLayer(Layer* layer, FrameNumber frame)
|
||||
}
|
||||
}
|
||||
|
||||
void DocumentApi::setTotalFrames(Sprite* sprite, FrameNumber frames)
|
||||
void DocumentApi::setTotalFrames(Sprite* sprite, frame_t frames)
|
||||
{
|
||||
ASSERT(frames >= 1);
|
||||
|
||||
@ -431,7 +431,7 @@ void DocumentApi::setTotalFrames(Sprite* sprite, FrameNumber frames)
|
||||
m_document->notifyObservers<doc::DocumentEvent&>(&doc::DocumentObserver::onTotalFramesChanged, ev);
|
||||
}
|
||||
|
||||
void DocumentApi::setFrameDuration(Sprite* sprite, FrameNumber frame, int msecs)
|
||||
void DocumentApi::setFrameDuration(Sprite* sprite, frame_t frame, int msecs)
|
||||
{
|
||||
// Add undoers.
|
||||
if (undoEnabled())
|
||||
@ -448,15 +448,15 @@ void DocumentApi::setFrameDuration(Sprite* sprite, FrameNumber frame, int msecs)
|
||||
m_document->notifyObservers<doc::DocumentEvent&>(&doc::DocumentObserver::onFrameDurationChanged, ev);
|
||||
}
|
||||
|
||||
void DocumentApi::setFrameRangeDuration(Sprite* sprite, FrameNumber from, FrameNumber to, int msecs)
|
||||
void DocumentApi::setFrameRangeDuration(Sprite* sprite, frame_t from, frame_t to, int msecs)
|
||||
{
|
||||
ASSERT(from >= FrameNumber(0));
|
||||
ASSERT(from >= frame_t(0));
|
||||
ASSERT(from < to);
|
||||
ASSERT(to <= sprite->lastFrame());
|
||||
|
||||
// Add undoers.
|
||||
if (undoEnabled()) {
|
||||
for (FrameNumber fr(from); fr<=to; ++fr)
|
||||
for (frame_t fr(from); fr<=to; ++fr)
|
||||
m_undoers->pushUndoer(new undoers::SetFrameDuration(
|
||||
getObjects(), sprite, fr));
|
||||
}
|
||||
@ -465,27 +465,27 @@ void DocumentApi::setFrameRangeDuration(Sprite* sprite, FrameNumber from, FrameN
|
||||
sprite->setFrameRangeDuration(from, to, msecs);
|
||||
}
|
||||
|
||||
void DocumentApi::moveFrame(Sprite* sprite, FrameNumber frame, FrameNumber beforeFrame)
|
||||
void DocumentApi::moveFrame(Sprite* sprite, frame_t frame, frame_t beforeFrame)
|
||||
{
|
||||
if (frame != beforeFrame &&
|
||||
frame >= 0 &&
|
||||
frame <= sprite->lastFrame() &&
|
||||
beforeFrame >= 0 &&
|
||||
beforeFrame <= sprite->lastFrame().next()) {
|
||||
beforeFrame <= sprite->lastFrame()+1) {
|
||||
// Change the frame-lengths.
|
||||
int frlen_aux = sprite->getFrameDuration(frame);
|
||||
int frlen_aux = sprite->frameDuration(frame);
|
||||
|
||||
// Moving the frame to the future.
|
||||
if (frame < beforeFrame) {
|
||||
for (FrameNumber c=frame; c<beforeFrame.previous(); ++c)
|
||||
setFrameDuration(sprite, c, sprite->getFrameDuration(c.next()));
|
||||
for (frame_t c=frame; c<beforeFrame-1; ++c)
|
||||
setFrameDuration(sprite, c, sprite->frameDuration(c+1));
|
||||
|
||||
setFrameDuration(sprite, beforeFrame.previous(), frlen_aux);
|
||||
setFrameDuration(sprite, beforeFrame-1, frlen_aux);
|
||||
}
|
||||
// Moving the frame to the past.
|
||||
else if (beforeFrame < frame) {
|
||||
for (FrameNumber c=frame; c>beforeFrame; --c)
|
||||
setFrameDuration(sprite, c, sprite->getFrameDuration(c.previous()));
|
||||
for (frame_t c=frame; c>beforeFrame; --c)
|
||||
setFrameDuration(sprite, c, sprite->frameDuration(c-1));
|
||||
|
||||
setFrameDuration(sprite, beforeFrame, frlen_aux);
|
||||
}
|
||||
@ -495,7 +495,7 @@ void DocumentApi::moveFrame(Sprite* sprite, FrameNumber frame, FrameNumber befor
|
||||
}
|
||||
}
|
||||
|
||||
void DocumentApi::moveFrameLayer(Layer* layer, FrameNumber frame, FrameNumber beforeFrame)
|
||||
void DocumentApi::moveFrameLayer(Layer* layer, frame_t frame, frame_t beforeFrame)
|
||||
{
|
||||
ASSERT(layer);
|
||||
|
||||
@ -512,13 +512,13 @@ void DocumentApi::moveFrameLayer(Layer* layer, FrameNumber frame, FrameNumber be
|
||||
|
||||
for (; it != end; ++it) {
|
||||
Cel* cel = *it;
|
||||
FrameNumber celFrame = cel->frame();
|
||||
FrameNumber newFrame = celFrame;
|
||||
frame_t celFrame = cel->frame();
|
||||
frame_t newFrame = celFrame;
|
||||
|
||||
// fthe frame to the future
|
||||
if (frame < beforeFrame) {
|
||||
if (celFrame == frame) {
|
||||
newFrame = beforeFrame.previous();
|
||||
newFrame = beforeFrame-1;
|
||||
}
|
||||
else if (celFrame > frame &&
|
||||
celFrame < beforeFrame) {
|
||||
@ -604,7 +604,7 @@ void DocumentApi::removeCel(Cel* cel)
|
||||
delete cel;
|
||||
}
|
||||
|
||||
void DocumentApi::setCelFramePosition(LayerImage* layer, Cel* cel, FrameNumber frame)
|
||||
void DocumentApi::setCelFramePosition(LayerImage* layer, Cel* cel, frame_t frame)
|
||||
{
|
||||
ASSERT(cel);
|
||||
ASSERT(frame >= 0);
|
||||
@ -669,7 +669,7 @@ void DocumentApi::cropCel(Sprite* sprite, Cel* cel, int x, int y, int w, int h)
|
||||
setCelPosition(sprite, cel, x, y);
|
||||
}
|
||||
|
||||
void DocumentApi::clearCel(LayerImage* layer, FrameNumber frame)
|
||||
void DocumentApi::clearCel(LayerImage* layer, frame_t frame)
|
||||
{
|
||||
Cel* cel = layer->getCel(frame);
|
||||
if (cel)
|
||||
@ -696,8 +696,8 @@ void DocumentApi::clearCel(Cel* cel)
|
||||
}
|
||||
|
||||
void DocumentApi::moveCel(
|
||||
LayerImage* srcLayer, FrameNumber srcFrame,
|
||||
LayerImage* dstLayer, FrameNumber dstFrame)
|
||||
LayerImage* srcLayer, frame_t srcFrame,
|
||||
LayerImage* dstLayer, frame_t dstFrame)
|
||||
{
|
||||
ASSERT(srcLayer != NULL);
|
||||
ASSERT(dstLayer != NULL);
|
||||
@ -763,8 +763,8 @@ void DocumentApi::moveCel(
|
||||
}
|
||||
|
||||
void DocumentApi::copyCel(
|
||||
LayerImage* srcLayer, FrameNumber srcFrame,
|
||||
LayerImage* dstLayer, FrameNumber dstFrame)
|
||||
LayerImage* srcLayer, frame_t srcFrame,
|
||||
LayerImage* dstLayer, frame_t dstFrame)
|
||||
{
|
||||
ASSERT(srcLayer != NULL);
|
||||
ASSERT(dstLayer != NULL);
|
||||
@ -818,7 +818,7 @@ void DocumentApi::copyCel(
|
||||
}
|
||||
|
||||
void DocumentApi::swapCel(
|
||||
LayerImage* layer, FrameNumber frame1, FrameNumber frame2)
|
||||
LayerImage* layer, frame_t frame1, frame_t frame2)
|
||||
{
|
||||
Sprite* sprite = layer->sprite();
|
||||
ASSERT(sprite != NULL);
|
||||
@ -1019,7 +1019,7 @@ void DocumentApi::backgroundFromLayer(LayerImage* layer)
|
||||
}
|
||||
|
||||
// Fill all empty cels with a flat-image filled with bgcolor
|
||||
for (FrameNumber frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
for (frame_t frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
Cel* cel = layer->getCel(frame);
|
||||
if (!cel) {
|
||||
Image* cel_image = Image::create(sprite->pixelFormat(), sprite->width(), sprite->height());
|
||||
@ -1083,7 +1083,7 @@ void DocumentApi::flattenLayers(Sprite* sprite)
|
||||
color_t bgcolor = bgColor(background);
|
||||
|
||||
// Copy all frames to the background.
|
||||
for (FrameNumber frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
for (frame_t frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
// Clear the image and render this frame.
|
||||
clear_image(image, bgcolor);
|
||||
render.renderSprite(image, sprite, frame);
|
||||
@ -1166,7 +1166,7 @@ int DocumentApi::addImageInStock(Sprite* sprite, Image* image)
|
||||
return imageIndex;
|
||||
}
|
||||
|
||||
Cel* DocumentApi::addImage(LayerImage* layer, FrameNumber frameNumber, Image* image)
|
||||
Cel* DocumentApi::addImage(LayerImage* layer, frame_t frameNumber, Image* image)
|
||||
{
|
||||
int imageIndex = addImageInStock(layer->sprite(), image);
|
||||
|
||||
@ -1338,9 +1338,9 @@ void DocumentApi::deselectMask()
|
||||
m_document->setMaskVisible(false);
|
||||
}
|
||||
|
||||
void DocumentApi::setPalette(Sprite* sprite, FrameNumber frame, Palette* newPalette)
|
||||
void DocumentApi::setPalette(Sprite* sprite, frame_t frame, Palette* newPalette)
|
||||
{
|
||||
Palette* currentSpritePalette = sprite->getPalette(frame); // Sprite current pal
|
||||
Palette* currentSpritePalette = sprite->palette(frame); // Sprite current pal
|
||||
int from, to;
|
||||
|
||||
// Check differences between current sprite palette and current system palette
|
||||
|
@ -24,7 +24,7 @@
|
||||
#include "doc/algorithm/flip_type.h"
|
||||
#include "doc/color.h"
|
||||
#include "doc/dithering_method.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/pixel_format.h"
|
||||
|
||||
namespace doc {
|
||||
@ -67,31 +67,31 @@ namespace app {
|
||||
void setPixelFormat(Sprite* sprite, PixelFormat newFormat, DitheringMethod dithering_method);
|
||||
|
||||
// Frames API
|
||||
void addFrame(Sprite* sprite, FrameNumber newFrame);
|
||||
void addEmptyFrame(Sprite* sprite, FrameNumber newFrame);
|
||||
void addEmptyFramesTo(Sprite* sprite, FrameNumber newFrame);
|
||||
void copyFrame(Sprite* sprite, FrameNumber fromFrame, FrameNumber newFrame);
|
||||
void removeFrame(Sprite* sprite, FrameNumber frame);
|
||||
void setTotalFrames(Sprite* sprite, FrameNumber frames);
|
||||
void setFrameDuration(Sprite* sprite, FrameNumber frame, int msecs);
|
||||
void setFrameRangeDuration(Sprite* sprite, FrameNumber from, FrameNumber to, int msecs);
|
||||
void moveFrame(Sprite* sprite, FrameNumber frame, FrameNumber beforeFrame);
|
||||
void addFrame(Sprite* sprite, frame_t newFrame);
|
||||
void addEmptyFrame(Sprite* sprite, frame_t newFrame);
|
||||
void addEmptyFramesTo(Sprite* sprite, frame_t newFrame);
|
||||
void copyFrame(Sprite* sprite, frame_t fromFrame, frame_t newFrame);
|
||||
void removeFrame(Sprite* sprite, frame_t frame);
|
||||
void setTotalFrames(Sprite* sprite, frame_t frames);
|
||||
void setFrameDuration(Sprite* sprite, frame_t frame, int msecs);
|
||||
void setFrameRangeDuration(Sprite* sprite, frame_t from, frame_t to, int msecs);
|
||||
void moveFrame(Sprite* sprite, frame_t frame, frame_t beforeFrame);
|
||||
|
||||
// Cels API
|
||||
void addCel(LayerImage* layer, Cel* cel);
|
||||
void clearCel(LayerImage* layer, FrameNumber frame);
|
||||
void clearCel(LayerImage* layer, frame_t frame);
|
||||
void clearCel(Cel* cel);
|
||||
void setCelPosition(Sprite* sprite, Cel* cel, int x, int y);
|
||||
void setCelOpacity(Sprite* sprite, Cel* cel, int newOpacity);
|
||||
void cropCel(Sprite* sprite, Cel* cel, int x, int y, int w, int h);
|
||||
void moveCel(
|
||||
LayerImage* srcLayer, FrameNumber srcFrame,
|
||||
LayerImage* dstLayer, FrameNumber dstFrame);
|
||||
LayerImage* srcLayer, frame_t srcFrame,
|
||||
LayerImage* dstLayer, frame_t dstFrame);
|
||||
void copyCel(
|
||||
LayerImage* srcLayer, FrameNumber srcFrame,
|
||||
LayerImage* dstLayer, FrameNumber dstFrame);
|
||||
LayerImage* srcLayer, frame_t srcFrame,
|
||||
LayerImage* dstLayer, frame_t dstFrame);
|
||||
void swapCel(
|
||||
LayerImage* layer, FrameNumber frame1, FrameNumber frame2);
|
||||
LayerImage* layer, frame_t frame1, frame_t frame2);
|
||||
|
||||
// Layers API
|
||||
LayerImage* newLayer(Sprite* sprite);
|
||||
@ -109,7 +109,7 @@ namespace app {
|
||||
void duplicateLayerBefore(Layer* sourceLayer, Layer* beforeLayer);
|
||||
|
||||
// Images stock API
|
||||
Cel* addImage(LayerImage* layer, FrameNumber frameNumber, Image* image);
|
||||
Cel* addImage(LayerImage* layer, frame_t frameNumber, Image* image);
|
||||
int addImageInStock(Sprite* sprite, Image* image);
|
||||
void removeImageFromStock(Sprite* sprite, int imageIndex);
|
||||
void replaceStockImage(Sprite* sprite, int imageIndex, Image* newImage);
|
||||
@ -126,16 +126,16 @@ namespace app {
|
||||
void deselectMask();
|
||||
|
||||
// Palette API
|
||||
void setPalette(Sprite* sprite, FrameNumber frame, Palette* newPalette);
|
||||
void setPalette(Sprite* sprite, frame_t frame, Palette* newPalette);
|
||||
|
||||
private:
|
||||
undo::ObjectsContainer* getObjects() const;
|
||||
void removeCel(Cel* cel);
|
||||
void setCelFramePosition(LayerImage* layer, Cel* cel, FrameNumber frame);
|
||||
void displaceFrames(Layer* layer, FrameNumber frame);
|
||||
void copyFrameForLayer(Layer* layer, FrameNumber fromFrame, FrameNumber frame);
|
||||
void removeFrameOfLayer(Layer* layer, FrameNumber frame);
|
||||
void moveFrameLayer(Layer* layer, FrameNumber frame, FrameNumber beforeFrame);
|
||||
void setCelFramePosition(LayerImage* layer, Cel* cel, frame_t frame);
|
||||
void displaceFrames(Layer* layer, frame_t frame);
|
||||
void copyFrameForLayer(Layer* layer, frame_t fromFrame, frame_t frame);
|
||||
void removeFrameOfLayer(Layer* layer, frame_t frame);
|
||||
void moveFrameLayer(Layer* layer, frame_t frame, frame_t beforeFrame);
|
||||
void configureLayerAsBackground(LayerImage* layer);
|
||||
bool undoEnabled();
|
||||
|
||||
|
@ -37,7 +37,7 @@ TEST(DocumentApi, MoveCel) {
|
||||
LayerImage* layer1 = dynamic_cast<LayerImage*>(sprite->folder()->getFirstLayer());
|
||||
LayerImage* layer2 = new LayerImage(sprite);
|
||||
|
||||
Cel* cel1 = layer1->getCel(FrameNumber(0));
|
||||
Cel* cel1 = layer1->getCel(frame_t(0));
|
||||
cel1->setPosition(2, -2);
|
||||
cel1->setOpacity(128);
|
||||
|
||||
@ -52,12 +52,12 @@ TEST(DocumentApi, MoveCel) {
|
||||
base::UniquePtr<Image> expectedImage(Image::createCopy(image1));
|
||||
|
||||
doc->getApi().moveCel(
|
||||
layer1, FrameNumber(0),
|
||||
layer2, FrameNumber(1));
|
||||
layer1, frame_t(0),
|
||||
layer2, frame_t(1));
|
||||
|
||||
EXPECT_EQ(NULL, layer1->getCel(FrameNumber(0)));
|
||||
EXPECT_EQ(NULL, layer1->getCel(frame_t(0)));
|
||||
|
||||
Cel* cel2 = layer2->getCel(FrameNumber(1));
|
||||
Cel* cel2 = layer2->getCel(frame_t(1));
|
||||
ASSERT_TRUE(cel2 != NULL);
|
||||
|
||||
Image* image2 = cel2->image();
|
||||
|
@ -54,7 +54,7 @@ namespace app {
|
||||
class DocumentExporter::Sample {
|
||||
public:
|
||||
Sample(Document* document, Sprite* sprite, Layer* layer,
|
||||
FrameNumber frame, const std::string& filename) :
|
||||
frame_t frame, const std::string& filename) :
|
||||
m_document(document),
|
||||
m_sprite(sprite),
|
||||
m_layer(layer),
|
||||
@ -65,7 +65,7 @@ public:
|
||||
Document* document() const { return m_document; }
|
||||
Sprite* sprite() const { return m_sprite; }
|
||||
Layer* layer() const { return m_layer; }
|
||||
FrameNumber frame() const { return m_frame; }
|
||||
frame_t frame() const { return m_frame; }
|
||||
std::string filename() const { return m_filename; }
|
||||
const gfx::Size& originalSize() const { return m_originalSize; }
|
||||
const gfx::Rect& trimmedBounds() const { return m_trimmedBounds; }
|
||||
@ -86,7 +86,7 @@ private:
|
||||
Document* m_document;
|
||||
Sprite* m_sprite;
|
||||
Layer* m_layer;
|
||||
FrameNumber m_frame;
|
||||
frame_t m_frame;
|
||||
std::string m_filename;
|
||||
gfx::Size m_originalSize;
|
||||
gfx::Rect m_trimmedBounds;
|
||||
@ -251,7 +251,7 @@ void DocumentExporter::exportSheet()
|
||||
Sprite* texture = textureDocument->sprite();
|
||||
Image* textureImage = static_cast<LayerImage*>(
|
||||
texture->folder()->getFirstLayer())
|
||||
->getCel(FrameNumber(0))->image();
|
||||
->getCel(frame_t(0))->image();
|
||||
|
||||
renderTexture(samples, textureImage);
|
||||
|
||||
@ -275,11 +275,11 @@ void DocumentExporter::captureSamples(Samples& samples)
|
||||
Sprite* sprite = doc->sprite();
|
||||
Layer* layer = item.layer;
|
||||
|
||||
for (FrameNumber frame=FrameNumber(0);
|
||||
for (frame_t frame=frame_t(0);
|
||||
frame<sprite->totalFrames(); ++frame) {
|
||||
std::string filename = doc->filename();
|
||||
|
||||
if (sprite->totalFrames() > FrameNumber(1)) {
|
||||
if (sprite->totalFrames() > frame_t(1)) {
|
||||
std::string path = base::get_file_path(filename);
|
||||
std::string title = base::get_file_title(filename);
|
||||
if (layer) {
|
||||
@ -347,11 +347,11 @@ Document* DocumentExporter::createEmptyTexture(const Samples& samples)
|
||||
pixelFormat = IMAGE_RGB;
|
||||
}
|
||||
else if (palette != NULL
|
||||
&& palette->countDiff(it->sprite()->getPalette(FrameNumber(0)), NULL, NULL) > 0) {
|
||||
&& palette->countDiff(it->sprite()->palette(frame_t(0)), NULL, NULL) > 0) {
|
||||
pixelFormat = IMAGE_RGB;
|
||||
}
|
||||
else
|
||||
palette = it->sprite()->getPalette(FrameNumber(0));
|
||||
palette = it->sprite()->palette(frame_t(0));
|
||||
}
|
||||
|
||||
fullTextureBounds = fullTextureBounds.createUnion(it->inTextureBounds());
|
||||
@ -418,7 +418,7 @@ void DocumentExporter::createDataFile(const Samples& samples, std::ostream& os,
|
||||
<< " \"sourceSize\": { "
|
||||
<< "\"w\": " << srcSize.w << ", "
|
||||
<< "\"h\": " << srcSize.h << " },\n"
|
||||
<< " \"duration\": " << sample.sprite()->getFrameDuration(sample.frame()) << "\n"
|
||||
<< " \"duration\": " << sample.sprite()->frameDuration(sample.frame()) << "\n"
|
||||
<< " }";
|
||||
|
||||
if (++it != samples.end())
|
||||
|
@ -45,7 +45,7 @@ void DocumentLocation::layerIndex(LayerIndex layerIndex)
|
||||
|
||||
Palette* DocumentLocation::palette()
|
||||
{
|
||||
return (m_sprite ? m_sprite->getPalette(m_frame): NULL);
|
||||
return (m_sprite ? m_sprite->palette(m_frame): NULL);
|
||||
}
|
||||
|
||||
const Cel* DocumentLocation::cel() const
|
||||
@ -82,7 +82,7 @@ Image* DocumentLocation::image(int* x, int* y, int* opacity) const
|
||||
|
||||
Palette* DocumentLocation::palette() const
|
||||
{
|
||||
return (m_sprite ? m_sprite->getPalette(m_frame): NULL);
|
||||
return (m_sprite ? m_sprite->palette(m_frame): NULL);
|
||||
}
|
||||
|
||||
} // namespace app
|
||||
|
@ -20,7 +20,7 @@
|
||||
#define APP_DOCUMENT_LOCATION_H_INCLUDED
|
||||
#pragma once
|
||||
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/layer_index.h"
|
||||
|
||||
namespace doc {
|
||||
@ -50,7 +50,7 @@ namespace app {
|
||||
const Document* document() const { return m_document; }
|
||||
const Sprite* sprite() const { return m_sprite; }
|
||||
const Layer* layer() const { return m_layer; }
|
||||
FrameNumber frame() const { return m_frame; }
|
||||
frame_t frame() const { return m_frame; }
|
||||
const Cel* cel() const;
|
||||
|
||||
Document* document() { return m_document; }
|
||||
@ -61,7 +61,7 @@ namespace app {
|
||||
void document(Document* document) { m_document = document; }
|
||||
void sprite(Sprite* sprite) { m_sprite = sprite; }
|
||||
void layer(Layer* layer) { m_layer = layer; }
|
||||
void frame(FrameNumber frame) { m_frame = frame; }
|
||||
void frame(frame_t frame) { m_frame = frame; }
|
||||
|
||||
LayerIndex layerIndex() const;
|
||||
void layerIndex(LayerIndex layerIndex);
|
||||
@ -73,7 +73,7 @@ namespace app {
|
||||
Document* m_document;
|
||||
Sprite* m_sprite;
|
||||
Layer* m_layer;
|
||||
FrameNumber m_frame;
|
||||
frame_t m_frame;
|
||||
};
|
||||
|
||||
} // namespace app
|
||||
|
@ -26,14 +26,14 @@ namespace app {
|
||||
|
||||
using namespace doc;
|
||||
|
||||
void DocumentRange::startRange(LayerIndex layer, FrameNumber frame, Type type)
|
||||
void DocumentRange::startRange(LayerIndex layer, frame_t frame, Type type)
|
||||
{
|
||||
m_type = type;
|
||||
m_layerBegin = m_layerEnd = layer;
|
||||
m_frameBegin = m_frameEnd = frame;
|
||||
}
|
||||
|
||||
void DocumentRange::endRange(LayerIndex layer, FrameNumber frame)
|
||||
void DocumentRange::endRange(LayerIndex layer, frame_t frame)
|
||||
{
|
||||
ASSERT(enabled());
|
||||
m_layerEnd = layer;
|
||||
@ -53,7 +53,7 @@ bool DocumentRange::inRange(LayerIndex layer) const
|
||||
return false;
|
||||
}
|
||||
|
||||
bool DocumentRange::inRange(FrameNumber frame) const
|
||||
bool DocumentRange::inRange(frame_t frame) const
|
||||
{
|
||||
if (enabled())
|
||||
return (frame >= frameBegin() && frame <= frameEnd());
|
||||
@ -61,7 +61,7 @@ bool DocumentRange::inRange(FrameNumber frame) const
|
||||
return false;
|
||||
}
|
||||
|
||||
bool DocumentRange::inRange(LayerIndex layer, FrameNumber frame) const
|
||||
bool DocumentRange::inRange(LayerIndex layer, frame_t frame) const
|
||||
{
|
||||
return inRange(layer) && inRange(frame);
|
||||
}
|
||||
@ -72,18 +72,20 @@ void DocumentRange::setLayers(int layers)
|
||||
else m_layerBegin = m_layerEnd + LayerIndex(layers - 1);
|
||||
}
|
||||
|
||||
void DocumentRange::setFrames(FrameNumber frames)
|
||||
void DocumentRange::setFrames(frame_t frames)
|
||||
{
|
||||
if (m_frameBegin <= m_frameEnd) m_frameEnd = (m_frameBegin + frames).previous();
|
||||
else m_frameBegin = (m_frameEnd + frames).previous();
|
||||
if (m_frameBegin <= m_frameEnd)
|
||||
m_frameEnd = (m_frameBegin + frames) - 1;
|
||||
else
|
||||
m_frameBegin = (m_frameEnd + frames) - 1;
|
||||
}
|
||||
|
||||
void DocumentRange::displace(int layerDelta, int frameDelta)
|
||||
{
|
||||
m_layerBegin += LayerIndex(layerDelta);
|
||||
m_layerEnd += LayerIndex(layerDelta);
|
||||
m_frameBegin += FrameNumber(frameDelta);
|
||||
m_frameEnd += FrameNumber(frameDelta);
|
||||
m_frameBegin += frame_t(frameDelta);
|
||||
m_frameEnd += frame_t(frameDelta);
|
||||
}
|
||||
|
||||
} // namespace app
|
||||
|
@ -20,7 +20,7 @@
|
||||
#define APP_DOCUMENT_RANGE_H_INCLUDED
|
||||
#pragma once
|
||||
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/layer_index.h"
|
||||
|
||||
#include <algorithm>
|
||||
@ -38,21 +38,21 @@ namespace app {
|
||||
bool enabled() const { return m_type != kNone; }
|
||||
LayerIndex layerBegin() const { return std::min(m_layerBegin, m_layerEnd); }
|
||||
LayerIndex layerEnd() const { return std::max(m_layerBegin, m_layerEnd); }
|
||||
FrameNumber frameBegin() const { return std::min(m_frameBegin, m_frameEnd); }
|
||||
FrameNumber frameEnd() const { return std::max(m_frameBegin, m_frameEnd); }
|
||||
frame_t frameBegin() const { return std::min(m_frameBegin, m_frameEnd); }
|
||||
frame_t frameEnd() const { return std::max(m_frameBegin, m_frameEnd); }
|
||||
|
||||
int layers() const { return layerEnd() - layerBegin() + 1; }
|
||||
FrameNumber frames() const { return (frameEnd() - frameBegin()).next(); }
|
||||
frame_t frames() const { return frameEnd() - frameBegin() + 1; }
|
||||
void setLayers(int layers);
|
||||
void setFrames(FrameNumber frames);
|
||||
void setFrames(frame_t frames);
|
||||
void displace(int layerDelta, int frameDelta);
|
||||
|
||||
bool inRange(LayerIndex layer) const;
|
||||
bool inRange(FrameNumber frame) const;
|
||||
bool inRange(LayerIndex layer, FrameNumber frame) const;
|
||||
bool inRange(frame_t frame) const;
|
||||
bool inRange(LayerIndex layer, frame_t frame) const;
|
||||
|
||||
void startRange(LayerIndex layer, FrameNumber frame, Type type);
|
||||
void endRange(LayerIndex layer, FrameNumber frame);
|
||||
void startRange(LayerIndex layer, frame_t frame, Type type);
|
||||
void endRange(LayerIndex layer, frame_t frame);
|
||||
void disableRange();
|
||||
|
||||
bool operator==(const DocumentRange& o) const {
|
||||
@ -65,8 +65,8 @@ namespace app {
|
||||
Type m_type;
|
||||
LayerIndex m_layerBegin;
|
||||
LayerIndex m_layerEnd;
|
||||
FrameNumber m_frameBegin;
|
||||
FrameNumber m_frameEnd;
|
||||
frame_t m_frameBegin;
|
||||
frame_t m_frameEnd;
|
||||
};
|
||||
|
||||
} // namespace app
|
||||
|
@ -106,8 +106,8 @@ static DocumentRange drop_range_op(
|
||||
|
||||
int srcLayerBegin, srcLayerStep, srcLayerEnd;
|
||||
int dstLayerBegin, dstLayerStep;
|
||||
FrameNumber srcFrameBegin, srcFrameStep, srcFrameEnd;
|
||||
FrameNumber dstFrameBegin, dstFrameStep;
|
||||
frame_t srcFrameBegin, srcFrameStep, srcFrameEnd;
|
||||
frame_t dstFrameBegin, dstFrameStep;
|
||||
|
||||
if (to.layerBegin() <= from.layerBegin()) {
|
||||
srcLayerBegin = from.layerBegin();
|
||||
@ -126,22 +126,22 @@ static DocumentRange drop_range_op(
|
||||
|
||||
if (to.frameBegin() <= from.frameBegin()) {
|
||||
srcFrameBegin = from.frameBegin();
|
||||
srcFrameStep = FrameNumber(1);
|
||||
srcFrameEnd = from.frameEnd().next();
|
||||
srcFrameStep = frame_t(1);
|
||||
srcFrameEnd = from.frameEnd()+1;
|
||||
dstFrameBegin = to.frameBegin();
|
||||
dstFrameStep = FrameNumber(1);
|
||||
dstFrameStep = frame_t(1);
|
||||
}
|
||||
else {
|
||||
srcFrameBegin = from.frameEnd();
|
||||
srcFrameStep = FrameNumber(-1);
|
||||
srcFrameEnd = from.frameBegin().previous();
|
||||
srcFrameStep = frame_t(-1);
|
||||
srcFrameEnd = from.frameBegin()-1;
|
||||
dstFrameBegin = to.frameEnd();
|
||||
dstFrameStep = FrameNumber(-1);
|
||||
dstFrameStep = frame_t(-1);
|
||||
}
|
||||
|
||||
for (int srcLayerIdx = srcLayerBegin,
|
||||
dstLayerIdx = dstLayerBegin; srcLayerIdx != srcLayerEnd; ) {
|
||||
for (FrameNumber srcFrame = srcFrameBegin,
|
||||
for (frame_t srcFrame = srcFrameBegin,
|
||||
dstFrame = dstFrameBegin; srcFrame != srcFrameEnd; ) {
|
||||
LayerImage* srcLayer = static_cast<LayerImage*>(layers[srcLayerIdx]);
|
||||
LayerImage* dstLayer = static_cast<LayerImage*>(layers[dstLayerIdx]);
|
||||
@ -164,8 +164,8 @@ static DocumentRange drop_range_op(
|
||||
|
||||
case DocumentRange::kFrames:
|
||||
{
|
||||
FrameNumber srcFrameBegin, srcFrameStep, srcFrameEnd;
|
||||
FrameNumber dstFrameBegin, dstFrameStep;
|
||||
frame_t srcFrameBegin, srcFrameStep, srcFrameEnd;
|
||||
frame_t dstFrameBegin, dstFrameStep;
|
||||
|
||||
switch (op) {
|
||||
|
||||
@ -173,33 +173,33 @@ static DocumentRange drop_range_op(
|
||||
if (place == kDocumentRangeBefore) {
|
||||
if (to.frameBegin() <= from.frameBegin()) {
|
||||
srcFrameBegin = from.frameBegin();
|
||||
srcFrameStep = FrameNumber(1);
|
||||
srcFrameEnd = from.frameEnd().next();
|
||||
srcFrameStep = frame_t(1);
|
||||
srcFrameEnd = from.frameEnd()+1;
|
||||
dstFrameBegin = to.frameBegin();
|
||||
dstFrameStep = FrameNumber(1);
|
||||
dstFrameStep = frame_t(1);
|
||||
}
|
||||
else {
|
||||
srcFrameBegin = from.frameEnd();
|
||||
srcFrameStep = FrameNumber(-1);
|
||||
srcFrameEnd = from.frameBegin().previous();
|
||||
srcFrameStep = frame_t(-1);
|
||||
srcFrameEnd = from.frameBegin()-1;
|
||||
dstFrameBegin = to.frameBegin();
|
||||
dstFrameStep = FrameNumber(-1);
|
||||
dstFrameStep = frame_t(-1);
|
||||
}
|
||||
}
|
||||
else if (place == kDocumentRangeAfter) {
|
||||
if (to.frameEnd() <= from.frameBegin()) {
|
||||
srcFrameBegin = from.frameBegin();
|
||||
srcFrameStep = FrameNumber(1);
|
||||
srcFrameEnd = from.frameEnd().next();
|
||||
srcFrameStep = frame_t(1);
|
||||
srcFrameEnd = from.frameEnd()+1;
|
||||
dstFrameBegin = to.frameEnd();
|
||||
dstFrameStep = FrameNumber(1);
|
||||
dstFrameStep = frame_t(1);
|
||||
}
|
||||
else {
|
||||
srcFrameBegin = from.frameEnd();
|
||||
srcFrameStep = FrameNumber(-1);
|
||||
srcFrameEnd = from.frameBegin().previous();
|
||||
dstFrameBegin = to.frameEnd().next();
|
||||
dstFrameStep = FrameNumber(-1);
|
||||
srcFrameStep = frame_t(-1);
|
||||
srcFrameEnd = from.frameBegin()-1;
|
||||
dstFrameBegin = to.frameEnd()+1;
|
||||
dstFrameStep = frame_t(-1);
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -208,39 +208,39 @@ static DocumentRange drop_range_op(
|
||||
if (place == kDocumentRangeBefore) {
|
||||
if (to.frameBegin() <= from.frameBegin()) {
|
||||
srcFrameBegin = from.frameBegin();
|
||||
srcFrameStep = FrameNumber(2);
|
||||
srcFrameEnd = from.frameBegin().next(2*from.frames());
|
||||
srcFrameStep = frame_t(2);
|
||||
srcFrameEnd = from.frameBegin() + 2*from.frames();
|
||||
dstFrameBegin = to.frameBegin();
|
||||
dstFrameStep = FrameNumber(1);
|
||||
dstFrameStep = frame_t(1);
|
||||
}
|
||||
else {
|
||||
srcFrameBegin = from.frameEnd();
|
||||
srcFrameStep = FrameNumber(-1);
|
||||
srcFrameEnd = from.frameBegin().previous();
|
||||
srcFrameStep = frame_t(-1);
|
||||
srcFrameEnd = from.frameBegin()-1;
|
||||
dstFrameBegin = to.frameBegin();
|
||||
dstFrameStep = FrameNumber(0);
|
||||
dstFrameStep = frame_t(0);
|
||||
}
|
||||
}
|
||||
else if (place == kDocumentRangeAfter) {
|
||||
if (to.frameEnd() <= from.frameBegin()) {
|
||||
srcFrameBegin = from.frameBegin();
|
||||
srcFrameStep = FrameNumber(2);
|
||||
srcFrameEnd = from.frameBegin().next(2*from.frames());
|
||||
dstFrameBegin = to.frameEnd().next();
|
||||
dstFrameStep = FrameNumber(1);
|
||||
srcFrameStep = frame_t(2);
|
||||
srcFrameEnd = from.frameBegin() + 2*from.frames();
|
||||
dstFrameBegin = to.frameEnd()+1;
|
||||
dstFrameStep = frame_t(1);
|
||||
}
|
||||
else {
|
||||
srcFrameBegin = from.frameEnd();
|
||||
srcFrameStep = FrameNumber(-1);
|
||||
srcFrameEnd = from.frameBegin().previous();
|
||||
dstFrameBegin = to.frameEnd().next();
|
||||
dstFrameStep = FrameNumber(0);
|
||||
srcFrameStep = frame_t(-1);
|
||||
srcFrameEnd = from.frameBegin()-1;
|
||||
dstFrameBegin = to.frameEnd()+1;
|
||||
dstFrameStep = frame_t(0);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
for (FrameNumber srcFrame = srcFrameBegin,
|
||||
for (frame_t srcFrame = srcFrameBegin,
|
||||
dstFrame = dstFrameBegin; srcFrame != srcFrameEnd; ) {
|
||||
switch (op) {
|
||||
case Move: api.moveFrame(sprite, srcFrame, dstFrame); break;
|
||||
@ -251,12 +251,12 @@ static DocumentRange drop_range_op(
|
||||
}
|
||||
|
||||
if (place == kDocumentRangeBefore) {
|
||||
resultRange.startRange(LayerIndex::NoLayer, FrameNumber(to.frameBegin()), from.type());
|
||||
resultRange.endRange(LayerIndex::NoLayer, FrameNumber(to.frameBegin()+from.frames()-1));
|
||||
resultRange.startRange(LayerIndex::NoLayer, frame_t(to.frameBegin()), from.type());
|
||||
resultRange.endRange(LayerIndex::NoLayer, frame_t(to.frameBegin()+from.frames()-1));
|
||||
}
|
||||
else if (place == kDocumentRangeAfter) {
|
||||
resultRange.startRange(LayerIndex::NoLayer, FrameNumber(to.frameEnd()+1), from.type());
|
||||
resultRange.endRange(LayerIndex::NoLayer, FrameNumber(to.frameEnd()+1+from.frames()-1));
|
||||
resultRange.startRange(LayerIndex::NoLayer, frame_t(to.frameEnd()+1), from.type());
|
||||
resultRange.endRange(LayerIndex::NoLayer, frame_t(to.frameEnd()+1+from.frames()-1));
|
||||
}
|
||||
|
||||
if (op == Move && from.frameBegin() < to.frameBegin())
|
||||
@ -310,12 +310,12 @@ static DocumentRange drop_range_op(
|
||||
}
|
||||
|
||||
if (place == kDocumentRangeBefore) {
|
||||
resultRange.startRange(LayerIndex(to.layerBegin()), FrameNumber(-1), from.type());
|
||||
resultRange.endRange(LayerIndex(to.layerBegin()+from.layers()-1), FrameNumber(-1));
|
||||
resultRange.startRange(LayerIndex(to.layerBegin()), frame_t(-1), from.type());
|
||||
resultRange.endRange(LayerIndex(to.layerBegin()+from.layers()-1), frame_t(-1));
|
||||
}
|
||||
else if (place == kDocumentRangeAfter) {
|
||||
resultRange.startRange(LayerIndex(to.layerEnd()+1), FrameNumber(-1), from.type());
|
||||
resultRange.endRange(LayerIndex(to.layerEnd()+1+from.layers()-1), FrameNumber(-1));
|
||||
resultRange.startRange(LayerIndex(to.layerEnd()+1), frame_t(-1), from.type());
|
||||
resultRange.endRange(LayerIndex(to.layerEnd()+1+from.layers()-1), frame_t(-1));
|
||||
}
|
||||
|
||||
if (op == Move && from.layerBegin() < to.layerBegin())
|
||||
@ -348,7 +348,7 @@ void reverse_frames(Document* doc, const DocumentRange& range)
|
||||
UndoTransaction undo(writer.context(), "Reverse Frames");
|
||||
DocumentApi api = doc->getApi();
|
||||
Sprite* sprite = doc->sprite();
|
||||
FrameNumber frameBegin, frameEnd;
|
||||
frame_t frameBegin, frameEnd;
|
||||
int layerBegin, layerEnd;
|
||||
bool moveFrames = false;
|
||||
|
||||
@ -365,17 +365,17 @@ void reverse_frames(Document* doc, const DocumentRange& range)
|
||||
moveFrames = true;
|
||||
break;
|
||||
case DocumentRange::kLayers:
|
||||
frameBegin = FrameNumber(0);
|
||||
frameEnd = sprite->totalFrames().previous();
|
||||
frameBegin = frame_t(0);
|
||||
frameEnd = sprite->totalFrames()-1;
|
||||
layerBegin = range.layerBegin();
|
||||
layerEnd = range.layerEnd() + 1;
|
||||
break;
|
||||
}
|
||||
|
||||
if (moveFrames) {
|
||||
for (FrameNumber frameRev = frameEnd.next();
|
||||
for (frame_t frameRev = frameEnd+1;
|
||||
frameRev > frameBegin;
|
||||
frameRev = frameRev.previous()) {
|
||||
--frameRev) {
|
||||
api.moveFrame(sprite, frameBegin, frameRev);
|
||||
}
|
||||
}
|
||||
@ -384,11 +384,10 @@ void reverse_frames(Document* doc, const DocumentRange& range)
|
||||
sprite->getLayersList(layers);
|
||||
|
||||
for (int layerIdx = layerBegin; layerIdx != layerEnd; ++layerIdx) {
|
||||
for (FrameNumber frame = frameBegin,
|
||||
for (frame_t frame = frameBegin,
|
||||
frameRev = frameEnd;
|
||||
frame != FrameNumber((frameBegin+frameEnd)/2).next();
|
||||
frame = frame.next(),
|
||||
frameRev = frameRev.previous()) {
|
||||
frame != (frameBegin+frameEnd)/2+1;
|
||||
++frame, --frameRev) {
|
||||
LayerImage* layer = static_cast<LayerImage*>(layers[layerIdx]);
|
||||
api.swapCel(layer, frame, frameRev);
|
||||
}
|
||||
|
@ -106,25 +106,25 @@ public:
|
||||
layer3->setName("layer3");
|
||||
layer4->setName("layer4");
|
||||
|
||||
sprite->setTotalFrames(FrameNumber(4));
|
||||
sprite->setFrameDuration(FrameNumber(0), 1); // These durations can be used to identify
|
||||
sprite->setFrameDuration(FrameNumber(1), 2); // frames after a move operation
|
||||
sprite->setFrameDuration(FrameNumber(2), 3);
|
||||
sprite->setFrameDuration(FrameNumber(3), 4);
|
||||
sprite->setTotalFrames(frame_t(4));
|
||||
sprite->setFrameDuration(frame_t(0), 1); // These durations can be used to identify
|
||||
sprite->setFrameDuration(frame_t(1), 2); // frames after a move operation
|
||||
sprite->setFrameDuration(frame_t(2), 3);
|
||||
sprite->setFrameDuration(frame_t(3), 4);
|
||||
|
||||
DocumentApi api = doc->getApi();
|
||||
for (int i=0; i<4; i++) {
|
||||
LayerImage* layer = static_cast<LayerImage*>(sprite->indexToLayer(LayerIndex(i)));
|
||||
|
||||
for (int j=0; j<4; j++) {
|
||||
Cel* cel = layer->getCel(FrameNumber(j));
|
||||
Cel* cel = layer->getCel(frame_t(j));
|
||||
Image* image;
|
||||
if (cel)
|
||||
image = cel->image();
|
||||
else {
|
||||
image = Image::create(IMAGE_RGB, 4, 4);
|
||||
int imageIdx = sprite->stock()->addImage(image);
|
||||
cel = new Cel(FrameNumber(j), imageIdx);
|
||||
cel = new Cel(frame_t(j), imageIdx);
|
||||
layer->addCel(cel);
|
||||
}
|
||||
|
||||
@ -156,8 +156,8 @@ protected:
|
||||
if (!expect_cel(expected_layer, expected_frame, layer, frame))
|
||||
return false;
|
||||
|
||||
EXPECT_EQ((expected_frame+1), sprite->getFrameDuration(FrameNumber(frame)));
|
||||
return ((expected_frame+1) == sprite->getFrameDuration(FrameNumber(frame)));
|
||||
EXPECT_EQ((expected_frame+1), sprite->frameDuration(frame_t(frame)));
|
||||
return ((expected_frame+1) == sprite->frameDuration(frame_t(frame)));
|
||||
}
|
||||
|
||||
if (layer >= 0) {
|
||||
@ -176,7 +176,7 @@ protected:
|
||||
|
||||
color_t color = get_pixel(
|
||||
static_cast<LayerImage*>(sprite->indexToLayer(LayerIndex(layer)))
|
||||
->getCel(FrameNumber(frame))->image(),
|
||||
->getCel(frame_t(frame))->image(),
|
||||
expected_layer, expected_frame);
|
||||
|
||||
EXPECT_EQ(expected_color, color);
|
||||
@ -186,7 +186,7 @@ protected:
|
||||
|
||||
bool expect_empty_cel(int layer, int frame) {
|
||||
Cel* cel = static_cast<LayerImage*>(sprite->indexToLayer(LayerIndex(layer)))
|
||||
->getCel(FrameNumber(frame));
|
||||
->getCel(frame_t(frame));
|
||||
|
||||
EXPECT_EQ(NULL, cel);
|
||||
return (cel == NULL);
|
||||
@ -205,15 +205,15 @@ protected:
|
||||
|
||||
inline DocumentRange range(Layer* fromLayer, int fromFrNum, Layer* toLayer, int toFrNum, DocumentRange::Type type) {
|
||||
DocumentRange r;
|
||||
r.startRange(fromLayer->sprite()->layerToIndex(fromLayer), FrameNumber(fromFrNum), type);
|
||||
r.endRange(toLayer->sprite()->layerToIndex(toLayer), FrameNumber(toFrNum));
|
||||
r.startRange(fromLayer->sprite()->layerToIndex(fromLayer), frame_t(fromFrNum), type);
|
||||
r.endRange(toLayer->sprite()->layerToIndex(toLayer), frame_t(toFrNum));
|
||||
return r;
|
||||
}
|
||||
|
||||
inline DocumentRange range(int fromLayer, int fromFrNum, int toLayer, int toFrNum, DocumentRange::Type type) {
|
||||
DocumentRange r;
|
||||
r.startRange(LayerIndex(fromLayer), FrameNumber(fromFrNum), type);
|
||||
r.endRange(LayerIndex(toLayer), FrameNumber(toFrNum));
|
||||
r.startRange(LayerIndex(fromLayer), frame_t(fromFrNum), type);
|
||||
r.endRange(LayerIndex(toLayer), frame_t(toFrNum));
|
||||
return r;
|
||||
}
|
||||
|
||||
|
@ -90,7 +90,7 @@ static void ase_file_prepare_frame_header(FILE* f, ASE_FrameHeader* frame_header
|
||||
static void ase_file_write_frame_header(FILE* f, ASE_FrameHeader* frame_header);
|
||||
|
||||
static void ase_file_write_layers(FILE* f, ASE_FrameHeader* frame_header, Layer* layer);
|
||||
static void ase_file_write_cels(FILE* f, ASE_FrameHeader* frame_header, Sprite* sprite, Layer* layer, FrameNumber frame);
|
||||
static void ase_file_write_cels(FILE* f, ASE_FrameHeader* frame_header, Sprite* sprite, Layer* layer, frame_t frame);
|
||||
|
||||
static void ase_file_read_padding(FILE* f, int bytes);
|
||||
static void ase_file_write_padding(FILE* f, int bytes);
|
||||
@ -100,12 +100,12 @@ static void ase_file_write_string(FILE* f, const std::string& string);
|
||||
static void ase_file_write_start_chunk(FILE* f, ASE_FrameHeader* frame_header, int type, ASE_Chunk* chunk);
|
||||
static void ase_file_write_close_chunk(FILE* f, ASE_Chunk* chunk);
|
||||
|
||||
static Palette* ase_file_read_color_chunk(FILE* f, Sprite* sprite, FrameNumber frame);
|
||||
static Palette* ase_file_read_color2_chunk(FILE* f, Sprite* sprite, FrameNumber frame);
|
||||
static Palette* ase_file_read_color_chunk(FILE* f, Sprite* sprite, frame_t frame);
|
||||
static Palette* ase_file_read_color2_chunk(FILE* f, Sprite* sprite, frame_t frame);
|
||||
static void ase_file_write_color2_chunk(FILE* f, ASE_FrameHeader* frame_header, Palette* pal);
|
||||
static Layer* ase_file_read_layer_chunk(FILE* f, Sprite* sprite, Layer** previous_layer, int* current_level);
|
||||
static void ase_file_write_layer_chunk(FILE* f, ASE_FrameHeader* frame_header, Layer* layer);
|
||||
static Cel* ase_file_read_cel_chunk(FILE* f, Sprite* sprite, FrameNumber frame, PixelFormat pixelFormat, FileOp* fop, ASE_Header* header, size_t chunk_end);
|
||||
static Cel* ase_file_read_cel_chunk(FILE* f, Sprite* sprite, frame_t frame, PixelFormat pixelFormat, FileOp* fop, ASE_Header* header, size_t chunk_end);
|
||||
static void ase_file_write_cel_chunk(FILE* f, ASE_FrameHeader* frame_header, Cel* cel, LayerImage* layer, Sprite* sprite);
|
||||
static Mask* ase_file_read_mask_chunk(FILE* f);
|
||||
#if 0
|
||||
@ -171,7 +171,7 @@ bool AseFormat::onLoad(FileOp* fop)
|
||||
header.width, header.height, header.ncolors));
|
||||
|
||||
// Set frames and speed
|
||||
sprite->setTotalFrames(FrameNumber(header.frames));
|
||||
sprite->setTotalFrames(frame_t(header.frames));
|
||||
sprite->setDurationForAllFrames(header.speed);
|
||||
|
||||
// Set transparent entry
|
||||
@ -182,7 +182,7 @@ bool AseFormat::onLoad(FileOp* fop)
|
||||
int current_level = -1;
|
||||
|
||||
/* read frame by frame to end-of-file */
|
||||
for (FrameNumber frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
for (frame_t frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
/* start frame position */
|
||||
int frame_pos = ftell(f);
|
||||
fop_progress(fop, (float)frame_pos / (float)header.size);
|
||||
@ -212,7 +212,7 @@ bool AseFormat::onLoad(FileOp* fop)
|
||||
/* only for 8 bpp images */
|
||||
case ASE_FILE_CHUNK_FLI_COLOR:
|
||||
case ASE_FILE_CHUNK_FLI_COLOR2: {
|
||||
Palette* prev_pal = sprite->getPalette(frame);
|
||||
Palette* prev_pal = sprite->palette(frame);
|
||||
Palette* pal =
|
||||
chunk_type == ASE_FILE_CHUNK_FLI_COLOR ?
|
||||
ase_file_read_color_chunk(f, sprite, frame):
|
||||
@ -306,19 +306,19 @@ bool AseFormat::onSave(FileOp* fop)
|
||||
ase_file_write_header(f, &header);
|
||||
|
||||
// Write frames
|
||||
for (FrameNumber frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
for (frame_t frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
// Prepare the frame header
|
||||
ASE_FrameHeader frame_header;
|
||||
ase_file_prepare_frame_header(f, &frame_header);
|
||||
|
||||
// Frame duration
|
||||
frame_header.duration = sprite->getFrameDuration(frame);
|
||||
frame_header.duration = sprite->frameDuration(frame);
|
||||
|
||||
// is the first frame or did the palette change?
|
||||
if ((frame == 0 ||
|
||||
sprite->getPalette(frame.previous())->countDiff(sprite->getPalette(frame), NULL, NULL) > 0)) {
|
||||
sprite->palette(frame-1)->countDiff(sprite->palette(frame), NULL, NULL) > 0)) {
|
||||
// Write the color chunk
|
||||
ase_file_write_color2_chunk(f, &frame_header, sprite->getPalette(frame));
|
||||
ase_file_write_color2_chunk(f, &frame_header, sprite->palette(frame));
|
||||
}
|
||||
|
||||
// Write extra chunks in the first frame
|
||||
@ -339,7 +339,7 @@ bool AseFormat::onSave(FileOp* fop)
|
||||
|
||||
// Progress
|
||||
if (sprite->totalFrames() > 1)
|
||||
fop_progress(fop, (float)(frame.next()) / (float)(sprite->totalFrames()));
|
||||
fop_progress(fop, float(frame+1) / float(sprite->totalFrames()));
|
||||
|
||||
if (fop_is_stop(fop))
|
||||
break;
|
||||
@ -400,14 +400,14 @@ static void ase_file_prepare_header(FILE* f, ASE_Header* header, const Sprite* s
|
||||
sprite->pixelFormat() == IMAGE_GRAYSCALE ? 16:
|
||||
sprite->pixelFormat() == IMAGE_INDEXED ? 8: 0);
|
||||
header->flags = 0;
|
||||
header->speed = sprite->getFrameDuration(FrameNumber(0));
|
||||
header->speed = sprite->frameDuration(frame_t(0));
|
||||
header->next = 0;
|
||||
header->frit = 0;
|
||||
header->transparent_index = sprite->transparentColor();
|
||||
header->ignore[0] = 0;
|
||||
header->ignore[1] = 0;
|
||||
header->ignore[2] = 0;
|
||||
header->ncolors = sprite->getPalette(FrameNumber(0))->size();
|
||||
header->ncolors = sprite->palette(frame_t(0))->size();
|
||||
}
|
||||
|
||||
static void ase_file_write_header(FILE* f, ASE_Header* header)
|
||||
@ -495,7 +495,7 @@ static void ase_file_write_layers(FILE* f, ASE_FrameHeader* frame_header, Layer*
|
||||
}
|
||||
}
|
||||
|
||||
static void ase_file_write_cels(FILE* f, ASE_FrameHeader* frame_header, Sprite* sprite, Layer* layer, FrameNumber frame)
|
||||
static void ase_file_write_cels(FILE* f, ASE_FrameHeader* frame_header, Sprite* sprite, Layer* layer, frame_t frame)
|
||||
{
|
||||
if (layer->isImage()) {
|
||||
Cel* cel = static_cast<LayerImage*>(layer)->getCel(frame);
|
||||
@ -572,10 +572,10 @@ static void ase_file_write_close_chunk(FILE* f, ASE_Chunk* chunk)
|
||||
fseek(f, chunk_end, SEEK_SET);
|
||||
}
|
||||
|
||||
static Palette* ase_file_read_color_chunk(FILE* f, Sprite* sprite, FrameNumber frame)
|
||||
static Palette* ase_file_read_color_chunk(FILE* f, Sprite* sprite, frame_t frame)
|
||||
{
|
||||
int i, c, r, g, b, packets, skip, size;
|
||||
Palette* pal = new Palette(*sprite->getPalette(frame));
|
||||
Palette* pal = new Palette(*sprite->palette(frame));
|
||||
pal->setFrame(frame);
|
||||
|
||||
packets = fgetw(f); // Number of packets
|
||||
@ -600,10 +600,10 @@ static Palette* ase_file_read_color_chunk(FILE* f, Sprite* sprite, FrameNumber f
|
||||
return pal;
|
||||
}
|
||||
|
||||
static Palette* ase_file_read_color2_chunk(FILE* f, Sprite* sprite, FrameNumber frame)
|
||||
static Palette* ase_file_read_color2_chunk(FILE* f, Sprite* sprite, frame_t frame)
|
||||
{
|
||||
int i, c, r, g, b, packets, skip, size;
|
||||
Palette* pal = new Palette(*sprite->getPalette(frame));
|
||||
Palette* pal = new Palette(*sprite->palette(frame));
|
||||
pal->setFrame(frame);
|
||||
|
||||
packets = fgetw(f); // Number of packets
|
||||
@ -993,7 +993,7 @@ static void write_compressed_image(FILE* f, Image* image)
|
||||
// Cel Chunk
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
static Cel* ase_file_read_cel_chunk(FILE* f, Sprite* sprite, FrameNumber frame,
|
||||
static Cel* ase_file_read_cel_chunk(FILE* f, Sprite* sprite, frame_t frame,
|
||||
PixelFormat pixelFormat,
|
||||
FileOp* fop, ASE_Header* header, size_t chunk_end)
|
||||
{
|
||||
@ -1057,7 +1057,7 @@ static Cel* ase_file_read_cel_chunk(FILE* f, Sprite* sprite, FrameNumber frame,
|
||||
|
||||
case ASE_FILE_LINK_CEL: {
|
||||
// Read link position
|
||||
FrameNumber link_frame = FrameNumber(fgetw(f));
|
||||
frame_t link_frame = frame_t(fgetw(f));
|
||||
Cel* link = static_cast<LayerImage*>(layer)->getCel(link_frame);
|
||||
|
||||
if (link) {
|
||||
|
@ -374,7 +374,7 @@ FileOp* fop_to_save_document(Context* context, Document* document)
|
||||
width = 1;
|
||||
}
|
||||
|
||||
for (FrameNumber frame(0); frame<fop->document->sprite()->totalFrames(); ++frame) {
|
||||
for (frame_t frame(0); frame<fop->document->sprite()->totalFrames(); ++frame) {
|
||||
// Get the name for this frame
|
||||
char buf[4096];
|
||||
sprintf(buf, "%s%0*d%s", left.c_str(), width, start_from+frame, right.c_str());
|
||||
@ -434,12 +434,12 @@ void fop_operate(FileOp *fop, IFileOpProgress* progress)
|
||||
do { \
|
||||
image_index = fop->document \
|
||||
->sprite() \
|
||||
->stock()->addImage(fop->seq.image); \
|
||||
->stock()->addImage(fop->seq.image); \
|
||||
\
|
||||
fop->seq.last_cel->setImage(image_index); \
|
||||
fop->seq.layer->addCel(fop->seq.last_cel); \
|
||||
\
|
||||
if (fop->document->sprite()->getPalette(frame) \
|
||||
if (fop->document->sprite()->palette(frame) \
|
||||
->countDiff(fop->seq.palette, NULL, NULL) > 0) { \
|
||||
fop->seq.palette->setFrame(frame); \
|
||||
fop->document->sprite()->setPalette(fop->seq.palette, true); \
|
||||
@ -451,8 +451,8 @@ void fop_operate(FileOp *fop, IFileOpProgress* progress)
|
||||
} while (0)
|
||||
|
||||
/* load the sequence */
|
||||
FrameNumber frames(fop->seq.filename_list.size());
|
||||
FrameNumber frame(0);
|
||||
frame_t frames(fop->seq.filename_list.size());
|
||||
frame_t frame(0);
|
||||
old_image = NULL;
|
||||
|
||||
fop->seq.has_alpha = false;
|
||||
@ -565,12 +565,12 @@ void fop_operate(FileOp *fop, IFileOpProgress* progress)
|
||||
|
||||
// For each frame in the sprite.
|
||||
render::Render render;
|
||||
for (FrameNumber frame(0); frame < sprite->totalFrames(); ++frame) {
|
||||
for (frame_t frame(0); frame < sprite->totalFrames(); ++frame) {
|
||||
// Draw the "frame" in "fop->seq.image"
|
||||
render.renderSprite(fop->seq.image, sprite, frame);
|
||||
|
||||
// Setup the palette.
|
||||
sprite->getPalette(frame)->copyColorsTo(fop->seq.palette);
|
||||
sprite->palette(frame)->copyColorsTo(fop->seq.palette);
|
||||
|
||||
// Setup the filename to be used.
|
||||
fop->filename = fop->seq.filename_list[frame];
|
||||
@ -672,11 +672,11 @@ void fop_post_load(FileOp* fop)
|
||||
// Creates a suitable palette for RGB images
|
||||
if (fop->document->sprite()->pixelFormat() == IMAGE_RGB &&
|
||||
fop->document->sprite()->getPalettes().size() <= 1 &&
|
||||
fop->document->sprite()->getPalette(FrameNumber(0))->isBlack()) {
|
||||
fop->document->sprite()->palette(frame_t(0))->isBlack()) {
|
||||
SharedPtr<Palette> palette
|
||||
(render::create_palette_from_rgb(
|
||||
fop->document->sprite(),
|
||||
FrameNumber(0), NULL));
|
||||
frame_t(0), NULL));
|
||||
|
||||
fop->document->sprite()->resetPalettes();
|
||||
fop->document->sprite()->setPalette(palette, false);
|
||||
@ -834,7 +834,7 @@ static FileOp* fop_new(FileOpType type, Context* context)
|
||||
fop->seq.image = NULL;
|
||||
fop->seq.progress_offset = 0.0f;
|
||||
fop->seq.progress_fraction = 0.0f;
|
||||
fop->seq.frame = FrameNumber(0);
|
||||
fop->seq.frame = frame_t(0);
|
||||
fop->seq.layer = NULL;
|
||||
fop->seq.last_cel = NULL;
|
||||
|
||||
@ -843,7 +843,7 @@ static FileOp* fop_new(FileOpType type, Context* context)
|
||||
|
||||
static void fop_prepare_for_sequence(FileOp* fop)
|
||||
{
|
||||
fop->seq.palette = new Palette(FrameNumber(0), 256);
|
||||
fop->seq.palette = new Palette(frame_t(0), 256);
|
||||
fop->seq.format_options.reset();
|
||||
}
|
||||
|
||||
|
@ -21,7 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "base/shared_ptr.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/pixel_format.h"
|
||||
|
||||
#include <stdio.h>
|
||||
@ -100,7 +100,7 @@ namespace app {
|
||||
double progress_offset; // Progress offset from the current frame.
|
||||
double progress_fraction; // Progress fraction for one frame.
|
||||
// To load sequences.
|
||||
FrameNumber frame;
|
||||
frame_t frame;
|
||||
bool has_alpha;
|
||||
LayerImage* layer;
|
||||
Cel* last_cel;
|
||||
|
@ -52,7 +52,7 @@ TEST(File, SeveralSizes)
|
||||
// Random pixels
|
||||
LayerImage* layer = dynamic_cast<LayerImage*>(doc->sprite()->folder()->getFirstLayer());
|
||||
ASSERT_TRUE(layer != NULL);
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
std::srand(w*h);
|
||||
int c = std::rand()%256;
|
||||
for (int y=0; y<h; y++) {
|
||||
@ -76,7 +76,7 @@ TEST(File, SeveralSizes)
|
||||
// Same random pixels (see the seed)
|
||||
LayerImage* layer = dynamic_cast<LayerImage*>(doc->sprite()->folder()->getFirstLayer());
|
||||
ASSERT_TRUE(layer != NULL);
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
std::srand(w*h);
|
||||
int c = std::rand()%256;
|
||||
for (int y=0; y<h; y++) {
|
||||
|
@ -78,8 +78,8 @@ bool FliFormat::onLoad(FileOp* fop)
|
||||
unsigned char omap[768];
|
||||
s_fli_header fli_header;
|
||||
int c, w, h;
|
||||
FrameNumber frpos_in;
|
||||
FrameNumber frpos_out;
|
||||
frame_t frpos_in;
|
||||
frame_t frpos_out;
|
||||
int index = 0;
|
||||
|
||||
// Open the file to read in binary mode
|
||||
@ -93,14 +93,14 @@ bool FliFormat::onLoad(FileOp* fop)
|
||||
return false;
|
||||
}
|
||||
|
||||
/* size by frame */
|
||||
// Size by frame
|
||||
w = fli_header.width;
|
||||
h = fli_header.height;
|
||||
|
||||
// Create the bitmaps
|
||||
base::UniquePtr<Image> bmp(Image::create(IMAGE_INDEXED, w, h));
|
||||
base::UniquePtr<Image> old(Image::create(IMAGE_INDEXED, w, h));
|
||||
base::UniquePtr<Palette> pal(new Palette(FrameNumber(0), 256));
|
||||
base::UniquePtr<Palette> pal(new Palette(frame_t(0), 256));
|
||||
|
||||
// Create the image
|
||||
Sprite* sprite = new Sprite(IMAGE_INDEXED, w, h, 256);
|
||||
@ -109,26 +109,26 @@ bool FliFormat::onLoad(FileOp* fop)
|
||||
layer->configureAsBackground();
|
||||
|
||||
// Set frames and speed
|
||||
sprite->setTotalFrames(FrameNumber(fli_header.frames));
|
||||
sprite->setTotalFrames(frame_t(fli_header.frames));
|
||||
sprite->setDurationForAllFrames(fli_header.speed);
|
||||
|
||||
/* write frame by frame */
|
||||
for (frpos_in = frpos_out = FrameNumber(0);
|
||||
// Write frame by frame
|
||||
for (frpos_in = frpos_out = frame_t(0);
|
||||
frpos_in < sprite->totalFrames();
|
||||
++frpos_in) {
|
||||
/* read the frame */
|
||||
// Read the frame
|
||||
fli_read_frame(f, &fli_header,
|
||||
(unsigned char *)old->getPixelAddress(0, 0), omap,
|
||||
(unsigned char *)bmp->getPixelAddress(0, 0), cmap);
|
||||
|
||||
/* first frame, or the frames changes, or the palette changes */
|
||||
// First frame, or the frames changes, or the palette changes
|
||||
if ((frpos_in == 0) ||
|
||||
(count_diff_between_images(old, bmp))
|
||||
#ifndef USE_LINK /* TODO this should be configurable through a check-box */
|
||||
|| (memcmp(omap, cmap, 768) != 0)
|
||||
#endif
|
||||
) {
|
||||
/* the image changes? */
|
||||
// The image changes?
|
||||
if (frpos_in != 0)
|
||||
++frpos_out;
|
||||
|
||||
@ -139,12 +139,12 @@ bool FliFormat::onLoad(FileOp* fop)
|
||||
Cel* cel = new Cel(frpos_out, index);
|
||||
layer->addCel(cel);
|
||||
|
||||
/* first frame or the palette changes */
|
||||
// First frame or the palette changes
|
||||
if ((frpos_in == 0) || (memcmp(omap, cmap, 768) != 0))
|
||||
SETPAL();
|
||||
}
|
||||
#ifdef USE_LINK
|
||||
/* the palette changes */
|
||||
// The palette changes
|
||||
else if (memcmp(omap, cmap, 768) != 0) {
|
||||
++frpos_out;
|
||||
SETPAL();
|
||||
@ -157,25 +157,25 @@ bool FliFormat::onLoad(FileOp* fop)
|
||||
// The palette and the image don't change: add duration to the last added frame
|
||||
else {
|
||||
sprite->setFrameDuration(frpos_out,
|
||||
sprite->getFrameDuration(frpos_out)+fli_header.speed);
|
||||
sprite->frameDuration(frpos_out)+fli_header.speed);
|
||||
}
|
||||
|
||||
/* update the old image and color-map to the new ones to compare later */
|
||||
// Update the old image and color-map to the new ones to compare later
|
||||
copy_image(old, bmp);
|
||||
memcpy(omap, cmap, 768);
|
||||
|
||||
/* update progress */
|
||||
// Update progress
|
||||
fop_progress(fop, (float)(frpos_in+1) / (float)(sprite->totalFrames()));
|
||||
if (fop_is_stop(fop))
|
||||
break;
|
||||
|
||||
/* just one frame? */
|
||||
// Just one frame?
|
||||
if (fop->oneframe)
|
||||
break;
|
||||
}
|
||||
|
||||
// Update number of frames
|
||||
sprite->setTotalFrames(frpos_out.next());
|
||||
sprite->setTotalFrames(frpos_out+1);
|
||||
|
||||
fop->createDocument(sprite);
|
||||
return true;
|
||||
@ -222,26 +222,26 @@ bool FliFormat::onSave(FileOp* fop)
|
||||
render::Render render;
|
||||
|
||||
// Write frame by frame
|
||||
for (FrameNumber frpos(0);
|
||||
for (frame_t frpos(0);
|
||||
frpos < sprite->totalFrames();
|
||||
++frpos) {
|
||||
/* get color map */
|
||||
pal = sprite->getPalette(frpos);
|
||||
// Get color map
|
||||
pal = sprite->palette(frpos);
|
||||
for (c=0; c<256; c++) {
|
||||
cmap[3*c ] = rgba_getr(pal->getEntry(c));
|
||||
cmap[3*c+1] = rgba_getg(pal->getEntry(c));
|
||||
cmap[3*c+2] = rgba_getb(pal->getEntry(c));
|
||||
}
|
||||
|
||||
/* render the frame in the bitmap */
|
||||
// Render the frame in the bitmap
|
||||
render.renderSprite(bmp, sprite, frpos);
|
||||
|
||||
/* how many times this frame should be written to get the same
|
||||
time that it has in the sprite */
|
||||
times = sprite->getFrameDuration(frpos) / fli_header.speed;
|
||||
// How many times this frame should be written to get the same
|
||||
// time that it has in the sprite
|
||||
times = sprite->frameDuration(frpos) / fli_header.speed;
|
||||
|
||||
for (c=0; c<times; c++) {
|
||||
/* write this frame */
|
||||
// Write this frame
|
||||
if (frpos == 0 && c == 0)
|
||||
fli_write_frame(f, &fli_header, NULL, NULL,
|
||||
(unsigned char *)bmp->getPixelAddress(0, 0), cmap, W_ALL);
|
||||
@ -250,13 +250,13 @@ bool FliFormat::onSave(FileOp* fop)
|
||||
(unsigned char *)old->getPixelAddress(0, 0), omap,
|
||||
(unsigned char *)bmp->getPixelAddress(0, 0), cmap, W_ALL);
|
||||
|
||||
/* update the old image and color-map to the new ones to compare later */
|
||||
// Update the old image and color-map to the new ones to compare later
|
||||
copy_image(old, bmp);
|
||||
memcpy(omap, cmap, 768);
|
||||
}
|
||||
|
||||
/* update progress */
|
||||
fop_progress(fop, (float)(frpos.next()) / (float)(sprite->totalFrames()));
|
||||
// Update progress
|
||||
fop_progress(fop, (float)(frpos+1) / (float)(sprite->totalFrames()));
|
||||
}
|
||||
|
||||
// Write the header and close the file
|
||||
@ -270,8 +270,8 @@ static int get_time_precision(Sprite *sprite)
|
||||
{
|
||||
int precision = 1000;
|
||||
|
||||
for (FrameNumber c(0); c < sprite->totalFrames() && precision > 1; ++c) {
|
||||
int len = sprite->getFrameDuration(c);
|
||||
for (frame_t c(0); c < sprite->totalFrames() && precision > 1; ++c) {
|
||||
int len = sprite->frameDuration(c);
|
||||
|
||||
while (len / precision == 0)
|
||||
precision /= 10;
|
||||
|
@ -157,8 +157,8 @@ bool GifFormat::onLoad(FileOp* fop)
|
||||
data->sprite_w = gif_file->SWidth;
|
||||
data->sprite_h = gif_file->SHeight;
|
||||
|
||||
UniquePtr<Palette> current_palette(new Palette(FrameNumber(0), 256));
|
||||
UniquePtr<Palette> previous_palette(new Palette(FrameNumber(0), 256));
|
||||
UniquePtr<Palette> current_palette(new Palette(frame_t(0), 256));
|
||||
UniquePtr<Palette> previous_palette(new Palette(frame_t(0), 256));
|
||||
|
||||
// If the GIF image has a global palette, it has a valid
|
||||
// background color (so the GIF is not transparent).
|
||||
@ -181,7 +181,7 @@ bool GifFormat::onLoad(FileOp* fop)
|
||||
|
||||
// Scan the content of the GIF file (read record by record)
|
||||
GifRecordType record_type;
|
||||
FrameNumber frame_num(0);
|
||||
frame_t frame_num(0);
|
||||
DisposalMethod disposal_method = DISPOSAL_METHOD_NONE;
|
||||
int transparent_index = -1;
|
||||
int frame_delay = -1;
|
||||
@ -207,8 +207,8 @@ bool GifFormat::onLoad(FileOp* fop)
|
||||
throw Exception("Image %d is out of sprite bounds.\n", (int)frame_num);
|
||||
|
||||
// Add a new frames.
|
||||
if (frame_num >= FrameNumber(data->frames.size()))
|
||||
data->frames.resize(frame_num.next());
|
||||
if (frame_num >= frame_t(data->frames.size()))
|
||||
data->frames.resize(frame_num+1);
|
||||
|
||||
data->frames[frame_num].x = frame_x;
|
||||
data->frames[frame_num].y = frame_y;
|
||||
@ -409,10 +409,10 @@ bool GifFormat::onPostLoad(FileOp* fop)
|
||||
clear_image(previous_image, bgcolor);
|
||||
|
||||
// Add all frames in the sprite.
|
||||
sprite->setTotalFrames(FrameNumber(data->frames.size()));
|
||||
sprite->setTotalFrames(frame_t(data->frames.size()));
|
||||
Palette* current_palette = NULL;
|
||||
|
||||
FrameNumber frame_num(0);
|
||||
frame_t frame_num(0);
|
||||
for (GifFrames::iterator
|
||||
frame_it=data->frames.begin(),
|
||||
frame_end=data->frames.end(); frame_it != frame_end; ++frame_it, ++frame_num) {
|
||||
@ -551,7 +551,7 @@ bool GifFormat::onSave(FileOp* fop)
|
||||
int background_color = (sprite_format == IMAGE_INDEXED ? sprite->transparentColor(): 0);
|
||||
int transparent_index = (has_background ? -1: sprite->transparentColor());
|
||||
|
||||
Palette current_palette = *sprite->getPalette(FrameNumber(0));
|
||||
Palette current_palette = *sprite->palette(frame_t(0));
|
||||
Palette previous_palette(current_palette);
|
||||
RgbMap rgbmap;
|
||||
|
||||
@ -620,7 +620,7 @@ bool GifFormat::onSave(FileOp* fop)
|
||||
gif_options->quantize() == GifOptions::QuantizeAll) {
|
||||
// Feed the optimizer with all rendered frames.
|
||||
render::PaletteOptimizer optimizer;
|
||||
for (FrameNumber frame_num(0); frame_num<sprite->totalFrames(); ++frame_num) {
|
||||
for (frame_t frame_num(0); frame_num<sprite->totalFrames(); ++frame_num) {
|
||||
clear_image(buffer_image, background_color);
|
||||
render.renderSprite(buffer_image, sprite, frame_num);
|
||||
optimizer.feedWithImage(buffer_image);
|
||||
@ -632,7 +632,7 @@ bool GifFormat::onSave(FileOp* fop)
|
||||
rgbmap.regenerate(¤t_palette, transparent_index);
|
||||
}
|
||||
|
||||
for (FrameNumber frame_num(0); frame_num<sprite->totalFrames(); ++frame_num) {
|
||||
for (frame_t frame_num(0); frame_num<sprite->totalFrames(); ++frame_num) {
|
||||
// If the sprite is RGB or Grayscale, we must to convert it to Indexed on the fly.
|
||||
if (sprite_format != IMAGE_INDEXED) {
|
||||
clear_image(buffer_image, background_color);
|
||||
@ -640,7 +640,7 @@ bool GifFormat::onSave(FileOp* fop)
|
||||
|
||||
switch (gif_options->quantize()) {
|
||||
case GifOptions::NoQuantize:
|
||||
sprite->getPalette(frame_num)->copyColorsTo(¤t_palette);
|
||||
sprite->palette(frame_num)->copyColorsTo(¤t_palette);
|
||||
rgbmap.regenerate(¤t_palette, transparent_index);
|
||||
break;
|
||||
case GifOptions::QuantizeEach:
|
||||
@ -718,7 +718,7 @@ bool GifFormat::onSave(FileOp* fop)
|
||||
unsigned char extension_bytes[5];
|
||||
int disposal_method = (sprite->backgroundLayer() ? DISPOSAL_METHOD_DO_NOT_DISPOSE:
|
||||
DISPOSAL_METHOD_RESTORE_BGCOLOR);
|
||||
int frame_delay = sprite->getFrameDuration(frame_num) / 10;
|
||||
int frame_delay = sprite->frameDuration(frame_num) / 10;
|
||||
|
||||
extension_bytes[0] = (((disposal_method & 7) << 2) |
|
||||
(transparent_index >= 0 ? 1: 0));
|
||||
|
@ -54,7 +54,7 @@ TEST_F(GifFormat, Dimensions)
|
||||
LayerImage* layer = dynamic_cast<LayerImage*>(sprite->folder()->getFirstLayer());
|
||||
ASSERT_NE((LayerImage*)NULL, layer);
|
||||
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
clear_image(image, doc->sprite()->transparentColor());
|
||||
|
||||
save_document(&m_ctx, doc);
|
||||
@ -72,7 +72,7 @@ TEST_F(GifFormat, Dimensions)
|
||||
EXPECT_EQ(3, sprite->transparentColor());
|
||||
// TODO instead of 256, this should be 16 as Gif files contains
|
||||
// palettes that are power of two.
|
||||
EXPECT_EQ(256, sprite->getPalette(FrameNumber(0))->size());
|
||||
EXPECT_EQ(256, sprite->palette(frame_t(0))->size());
|
||||
|
||||
doc->close();
|
||||
delete doc;
|
||||
@ -88,7 +88,7 @@ TEST_F(GifFormat, OpaqueIndexed)
|
||||
Sprite* sprite = doc->sprite();
|
||||
doc->setFilename(fn);
|
||||
|
||||
Palette* pal = sprite->getPalette(FrameNumber(0));
|
||||
Palette* pal = sprite->palette(frame_t(0));
|
||||
pal->setEntry(0, rgb(255, 255, 255));
|
||||
pal->setEntry(1, rgb(255, 13, 254));
|
||||
pal->setEntry(2, rgb(129, 255, 32));
|
||||
@ -98,7 +98,7 @@ TEST_F(GifFormat, OpaqueIndexed)
|
||||
layer->setBackground(true);
|
||||
ASSERT_NE((LayerImage*)NULL, layer);
|
||||
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
image->putPixel(0, 0, 0);
|
||||
image->putPixel(0, 1, 1);
|
||||
image->putPixel(1, 0, 2);
|
||||
@ -118,13 +118,13 @@ TEST_F(GifFormat, OpaqueIndexed)
|
||||
ASSERT_NE((LayerImage*)NULL, layer);
|
||||
EXPECT_TRUE(layer->isBackground());
|
||||
|
||||
Palette* pal = sprite->getPalette(FrameNumber(0));
|
||||
Palette* pal = sprite->palette(frame_t(0));
|
||||
EXPECT_EQ(rgb(255, 255, 255), pal->getEntry(0));
|
||||
EXPECT_EQ(rgb(255, 13, 254), pal->getEntry(1));
|
||||
EXPECT_EQ(rgb(129, 255, 32), pal->getEntry(2));
|
||||
EXPECT_EQ(rgb(0, 0, 255), pal->getEntry(3));
|
||||
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
EXPECT_EQ(0, sprite->transparentColor());
|
||||
EXPECT_EQ(0, image->getPixel(0, 0));
|
||||
EXPECT_EQ(1, image->getPixel(0, 1));
|
||||
@ -145,7 +145,7 @@ TEST_F(GifFormat, TransparentIndexed)
|
||||
Sprite* sprite = doc->sprite();
|
||||
doc->setFilename(fn);
|
||||
|
||||
Palette* pal = sprite->getPalette(FrameNumber(0));
|
||||
Palette* pal = sprite->palette(frame_t(0));
|
||||
pal->setEntry(0, rgb(255, 255, 255));
|
||||
pal->setEntry(1, rgb(255, 13, 254));
|
||||
pal->setEntry(2, rgb(129, 255, 32));
|
||||
@ -154,7 +154,7 @@ TEST_F(GifFormat, TransparentIndexed)
|
||||
LayerImage* layer = dynamic_cast<LayerImage*>(sprite->folder()->getFirstLayer());
|
||||
ASSERT_NE((LayerImage*)NULL, layer);
|
||||
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
image->putPixel(0, 0, 0);
|
||||
image->putPixel(0, 1, 1);
|
||||
image->putPixel(1, 0, 2);
|
||||
@ -174,13 +174,13 @@ TEST_F(GifFormat, TransparentIndexed)
|
||||
ASSERT_NE((LayerImage*)NULL, layer);
|
||||
EXPECT_FALSE(layer->isBackground());
|
||||
|
||||
Palette* pal = sprite->getPalette(FrameNumber(0));
|
||||
Palette* pal = sprite->palette(frame_t(0));
|
||||
EXPECT_EQ(rgb(255, 255, 255), pal->getEntry(0));
|
||||
EXPECT_EQ(rgb(255, 13, 254), pal->getEntry(1));
|
||||
EXPECT_EQ(rgb(129, 255, 32), pal->getEntry(2));
|
||||
EXPECT_EQ(rgb(0, 0, 255), pal->getEntry(3));
|
||||
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
EXPECT_EQ(0, sprite->transparentColor());
|
||||
EXPECT_EQ(0, image->getPixel(0, 0));
|
||||
EXPECT_EQ(1, image->getPixel(0, 1));
|
||||
@ -204,7 +204,7 @@ TEST_F(GifFormat, TransparentRgbQuantization)
|
||||
LayerImage* layer = dynamic_cast<LayerImage*>(sprite->folder()->getFirstLayer());
|
||||
ASSERT_NE((LayerImage*)NULL, layer);
|
||||
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
image->putPixel(0, 0, rgba(0, 0, 0, 0));
|
||||
image->putPixel(0, 1, rgb(255, 0, 0));
|
||||
image->putPixel(1, 0, rgb(0, 255, 0));
|
||||
@ -223,8 +223,8 @@ TEST_F(GifFormat, TransparentRgbQuantization)
|
||||
LayerImage* layer = dynamic_cast<LayerImage*>(sprite->folder()->getFirstLayer());
|
||||
ASSERT_NE((LayerImage*)NULL, layer);
|
||||
|
||||
Palette* pal = sprite->getPalette(FrameNumber(0));
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Palette* pal = sprite->palette(frame_t(0));
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
EXPECT_EQ(0, sprite->transparentColor());
|
||||
EXPECT_EQ(0, image->getPixel(0, 0));
|
||||
EXPECT_EQ(rgb(255, 0, 0), pal->getEntry(image->getPixel(0, 1)));
|
||||
@ -250,7 +250,7 @@ TEST_F(GifFormat, OpaqueRgbQuantization)
|
||||
ASSERT_NE((LayerImage*)NULL, layer);
|
||||
EXPECT_NE((LayerImage*)NULL, sprite->backgroundLayer());
|
||||
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
image->putPixel(0, 0, rgb(0, 0, 0));
|
||||
image->putPixel(0, 1, rgb(255, 0, 0));
|
||||
image->putPixel(1, 0, rgb(0, 255, 0));
|
||||
@ -271,8 +271,8 @@ TEST_F(GifFormat, OpaqueRgbQuantization)
|
||||
EXPECT_TRUE(layer->isBackground());
|
||||
EXPECT_EQ(layer, sprite->backgroundLayer());
|
||||
|
||||
Palette* pal = sprite->getPalette(FrameNumber(0));
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Palette* pal = sprite->palette(frame_t(0));
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
EXPECT_EQ(0, sprite->transparentColor());
|
||||
EXPECT_EQ(rgb(0, 0, 0), pal->getEntry(image->getPixel(0, 0)));
|
||||
EXPECT_EQ(rgb(255, 0, 0), pal->getEntry(image->getPixel(0, 1)));
|
||||
@ -299,17 +299,17 @@ TEST_F(GifFormat, OpaqueRgbQuantizationTwoLayers)
|
||||
LayerImage* layer2 = new LayerImage(sprite);
|
||||
sprite->folder()->addLayer(layer2);
|
||||
|
||||
Image* image1 = layer1->getCel(FrameNumber(0))->image();
|
||||
Image* image1 = layer1->getCel(frame_t(0))->image();
|
||||
Image* image2 = Image::create(IMAGE_RGB, 2, 2);
|
||||
int image2Idx = sprite->stock()->addImage(image2);
|
||||
Cel* cel2 = new Cel(FrameNumber(0), image2Idx);
|
||||
Cel* cel2 = new Cel(frame_t(0), image2Idx);
|
||||
layer2->addCel(cel2);
|
||||
|
||||
image1->clear(rgba(255, 255, 255, 255));
|
||||
image2->putPixel(0, 0, rgba(255, 0, 0, 255));
|
||||
image2->putPixel(1, 1, rgba(196, 0, 0, 255));
|
||||
|
||||
Palette* pal = sprite->getPalette(FrameNumber(0));
|
||||
Palette* pal = sprite->palette(frame_t(0));
|
||||
pal->setEntry(0, rgba(255, 255, 255, 255));
|
||||
pal->setEntry(1, rgba(255, 0, 0, 255));
|
||||
|
||||
@ -329,8 +329,8 @@ TEST_F(GifFormat, OpaqueRgbQuantizationTwoLayers)
|
||||
ASSERT_NE((LayerImage*)NULL, layer);
|
||||
ASSERT_TRUE(layer->isBackground());
|
||||
|
||||
Palette* pal = sprite->getPalette(FrameNumber(0));
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Palette* pal = sprite->palette(frame_t(0));
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
EXPECT_EQ(0, sprite->transparentColor());
|
||||
|
||||
EXPECT_EQ(1, image->getPixel(0, 0));
|
||||
|
@ -142,7 +142,7 @@ bool IcoFormat::onLoad(FileOp* fop)
|
||||
// Create the first image/cel
|
||||
Image* image = Image::create(pixelFormat, width, height);
|
||||
int image_index = sprite->stock()->addImage(image);
|
||||
Cel* cel = new Cel(FrameNumber(0), image_index);
|
||||
Cel* cel = new Cel(frame_t(0), image_index);
|
||||
layer->addCel(cel);
|
||||
clear_image(image, 0);
|
||||
|
||||
@ -165,7 +165,7 @@ bool IcoFormat::onLoad(FileOp* fop)
|
||||
|
||||
// Read the palette
|
||||
if (entry.bpp <= 8) {
|
||||
Palette* pal = new Palette(FrameNumber(0), numcolors);
|
||||
Palette* pal = new Palette(frame_t(0), numcolors);
|
||||
|
||||
for (int i=0; i<numcolors; ++i) {
|
||||
int b = fgetc(f);
|
||||
@ -242,7 +242,7 @@ bool IcoFormat::onSave(FileOp* fop)
|
||||
int bpp, bw, bitsw;
|
||||
int size, offset, i;
|
||||
int c, x, y, b, m, v;
|
||||
FrameNumber n, num = sprite->totalFrames();
|
||||
frame_t n, num = sprite->totalFrames();
|
||||
|
||||
FileHandle f(open_file_with_exception(fop->filename, "wb"));
|
||||
|
||||
@ -254,7 +254,7 @@ bool IcoFormat::onSave(FileOp* fop)
|
||||
fputw(num, f); // number of icons
|
||||
|
||||
// Entries
|
||||
for (n=FrameNumber(0); n<num; ++n) {
|
||||
for (n=frame_t(0); n<num; ++n) {
|
||||
bpp = (sprite->pixelFormat() == IMAGE_INDEXED) ? 8 : 24;
|
||||
bw = (((sprite->width() * bpp / 8) + 3) / 4) * 4;
|
||||
bitsw = ((((sprite->width() + 7) / 8) + 3) / 4) * 4;
|
||||
@ -282,7 +282,7 @@ bool IcoFormat::onSave(FileOp* fop)
|
||||
sprite->height()));
|
||||
|
||||
render::Render render;
|
||||
for (n=FrameNumber(0); n<num; ++n) {
|
||||
for (n=frame_t(0); n<num; ++n) {
|
||||
render.renderSprite(image, sprite, n);
|
||||
|
||||
bpp = (sprite->pixelFormat() == IMAGE_INDEXED) ? 8 : 24;
|
||||
@ -308,7 +308,7 @@ bool IcoFormat::onSave(FileOp* fop)
|
||||
|
||||
// PALETTE
|
||||
if (bpp == 8) {
|
||||
Palette *pal = sprite->getPalette(n);
|
||||
Palette *pal = sprite->palette(n);
|
||||
|
||||
fputl(0, f); // color 0 is black, so the XOR mask works
|
||||
|
||||
|
@ -74,9 +74,9 @@ Palette* load_palette(const char *filename)
|
||||
|
||||
if (fop->document &&
|
||||
fop->document->sprite() &&
|
||||
fop->document->sprite()->getPalette(FrameNumber(0))) {
|
||||
fop->document->sprite()->palette(frame_t(0))) {
|
||||
pal = new Palette(
|
||||
*fop->document->sprite()->getPalette(FrameNumber(0)));
|
||||
*fop->document->sprite()->palette(frame_t(0)));
|
||||
|
||||
// TODO remove this line when support for palettes with less
|
||||
// than 256 colors is added.
|
||||
@ -118,7 +118,7 @@ bool save_palette(const char *filename, Palette* pal)
|
||||
doc->sprite()->setPalette(pal, false);
|
||||
|
||||
LayerImage* layer = dynamic_cast<LayerImage*>(sprite->folder()->getFirstLayer());
|
||||
Image* image = layer->getCel(FrameNumber(0))->image();
|
||||
Image* image = layer->getCel(frame_t(0))->image();
|
||||
|
||||
int x, y, c;
|
||||
for (y=c=0; y<16; y++)
|
||||
|
@ -22,7 +22,7 @@
|
||||
|
||||
#include "base/unique_ptr.h"
|
||||
#include "doc/cel.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/image.h"
|
||||
#include "doc/layer.h"
|
||||
#include "doc/sprite.h"
|
||||
@ -34,16 +34,16 @@ namespace app {
|
||||
|
||||
using namespace doc;
|
||||
|
||||
static bool has_cels(const Layer* layer, FrameNumber frame);
|
||||
static bool has_cels(const Layer* layer, frame_t frame);
|
||||
|
||||
LayerImage* create_flatten_layer_copy(Sprite* dstSprite, const Layer* srcLayer,
|
||||
const gfx::Rect& bounds,
|
||||
FrameNumber frmin, FrameNumber frmax)
|
||||
frame_t frmin, frame_t frmax)
|
||||
{
|
||||
base::UniquePtr<LayerImage> flatLayer(new LayerImage(dstSprite));
|
||||
render::Render render;
|
||||
|
||||
for (FrameNumber frame=frmin; frame<=frmax; ++frame) {
|
||||
for (frame_t frame=frmin; frame<=frmax; ++frame) {
|
||||
// Does this frame have cels to render?
|
||||
if (has_cels(srcLayer, frame)) {
|
||||
// Create a new image to render each frame.
|
||||
@ -72,7 +72,7 @@ LayerImage* create_flatten_layer_copy(Sprite* dstSprite, const Layer* srcLayer,
|
||||
|
||||
// Returns true if the "layer" or its children have any cel to render
|
||||
// in the given "frame".
|
||||
static bool has_cels(const Layer* layer, FrameNumber frame)
|
||||
static bool has_cels(const Layer* layer, frame_t frame)
|
||||
{
|
||||
if (!layer->isVisible())
|
||||
return false;
|
||||
|
@ -21,7 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "gfx/rect.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
|
||||
namespace doc {
|
||||
class Sprite;
|
||||
@ -40,7 +40,7 @@ namespace app {
|
||||
// sprite.
|
||||
LayerImage* create_flatten_layer_copy(Sprite* dstSprite, const Layer* srcLayer,
|
||||
const gfx::Rect& bounds,
|
||||
FrameNumber frmin, FrameNumber frmax);
|
||||
frame_t frmin, frame_t frmax);
|
||||
|
||||
} // namespace app
|
||||
|
||||
|
@ -27,17 +27,17 @@
|
||||
|
||||
namespace app {
|
||||
|
||||
doc::FrameNumber calculate_next_frame(
|
||||
doc::frame_t calculate_next_frame(
|
||||
doc::Sprite* sprite,
|
||||
doc::FrameNumber frame,
|
||||
doc::frame_t frame,
|
||||
IDocumentSettings* docSettings,
|
||||
bool& pingPongForward)
|
||||
{
|
||||
FrameNumber first = FrameNumber(0);
|
||||
FrameNumber last = sprite->lastFrame();
|
||||
frame_t first = frame_t(0);
|
||||
frame_t last = sprite->lastFrame();
|
||||
|
||||
if (docSettings->getLoopAnimation()) {
|
||||
FrameNumber loopBegin, loopEnd;
|
||||
frame_t loopBegin, loopEnd;
|
||||
docSettings->getLoopRange(&loopBegin, &loopEnd);
|
||||
loopBegin = MID(first, loopBegin, last);
|
||||
loopEnd = MID(first, loopEnd, last);
|
||||
@ -49,29 +49,33 @@ doc::FrameNumber calculate_next_frame(
|
||||
switch (docSettings->getAnimationDirection()) {
|
||||
|
||||
case IDocumentSettings::AniDir_Normal:
|
||||
frame = frame.next();
|
||||
if (frame > last) frame = first;
|
||||
++frame;
|
||||
if (frame > last)
|
||||
frame = first;
|
||||
break;
|
||||
|
||||
case IDocumentSettings::AniDir_Reverse:
|
||||
frame = frame.previous();
|
||||
if (frame < first) frame = last;
|
||||
--frame;
|
||||
if (frame < first)
|
||||
frame = last;
|
||||
break;
|
||||
|
||||
case IDocumentSettings::AniDir_PingPong:
|
||||
if (pingPongForward) {
|
||||
frame = frame.next();
|
||||
++frame;
|
||||
if (frame > last) {
|
||||
frame = last.previous();
|
||||
if (frame < first) frame = first;
|
||||
frame = last-1;
|
||||
if (frame < first)
|
||||
frame = first;
|
||||
pingPongForward = false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
frame = frame.previous();
|
||||
--frame;
|
||||
if (frame < first) {
|
||||
frame = first.next();
|
||||
if (frame > last) frame = last;
|
||||
frame = first+1;
|
||||
if (frame > last)
|
||||
frame = last;
|
||||
pingPongForward = true;
|
||||
}
|
||||
}
|
||||
|
@ -20,7 +20,7 @@
|
||||
#define APP_HANDLE_ANIDIR_H_INCLUDED
|
||||
#pragma once
|
||||
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
|
||||
namespace doc {
|
||||
class Sprite;
|
||||
@ -30,9 +30,9 @@ namespace app {
|
||||
|
||||
class IDocumentSettings;
|
||||
|
||||
doc::FrameNumber calculate_next_frame(
|
||||
doc::frame_t calculate_next_frame(
|
||||
doc::Sprite* sprite,
|
||||
doc::FrameNumber frame,
|
||||
doc::frame_t frame,
|
||||
IDocumentSettings* docSettings,
|
||||
bool& pingPongForward);
|
||||
|
||||
|
@ -44,8 +44,8 @@ static Palette* ase_current_palette = NULL;
|
||||
|
||||
int init_module_palette()
|
||||
{
|
||||
ase_default_palette = new Palette(FrameNumber(0), 256);
|
||||
ase_current_palette = new Palette(FrameNumber(0), 256);
|
||||
ase_default_palette = new Palette(frame_t(0), 256);
|
||||
ase_current_palette = new Palette(frame_t(0), 256);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -98,7 +98,7 @@ bool set_current_palette(const Palette *_palette, bool forced)
|
||||
|
||||
void set_black_palette()
|
||||
{
|
||||
Palette* p = new Palette(FrameNumber(0), 256);
|
||||
Palette* p = new Palette(frame_t(0), 256);
|
||||
set_current_palette(p, true);
|
||||
delete p;
|
||||
}
|
||||
|
@ -24,7 +24,7 @@
|
||||
#include "filters/tiled_mode.h"
|
||||
#include "gfx/point.h"
|
||||
#include "gfx/rect.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
|
||||
namespace app {
|
||||
class DocumentSettingsObserver;
|
||||
@ -100,11 +100,11 @@ namespace app {
|
||||
};
|
||||
|
||||
virtual bool getLoopAnimation() = 0;
|
||||
virtual void getLoopRange(doc::FrameNumber* begin, doc::FrameNumber* end) = 0;
|
||||
virtual void getLoopRange(doc::frame_t* begin, doc::frame_t* end) = 0;
|
||||
virtual AniDir getAnimationDirection() = 0;
|
||||
|
||||
virtual void setLoopAnimation(bool state) = 0;
|
||||
virtual void setLoopRange(doc::FrameNumber begin, doc::FrameNumber end) = 0;
|
||||
virtual void setLoopRange(doc::frame_t begin, doc::frame_t end) = 0;
|
||||
virtual void setAnimationDirection(AniDir dir) = 0;
|
||||
|
||||
// Observable
|
||||
|
@ -207,11 +207,11 @@ public:
|
||||
// Animation
|
||||
|
||||
virtual bool getLoopAnimation() override;
|
||||
virtual void getLoopRange(doc::FrameNumber* begin, doc::FrameNumber* end) override;
|
||||
virtual void getLoopRange(doc::frame_t* begin, doc::frame_t* end) override;
|
||||
virtual AniDir getAnimationDirection() override;
|
||||
|
||||
virtual void setLoopAnimation(bool state) override;
|
||||
virtual void setLoopRange(doc::FrameNumber begin, doc::FrameNumber end) override;
|
||||
virtual void setLoopRange(doc::frame_t begin, doc::frame_t end) override;
|
||||
virtual void setAnimationDirection(AniDir dir) override;
|
||||
|
||||
virtual void addObserver(DocumentSettingsObserver* observer) override;
|
||||
@ -270,8 +270,8 @@ private:
|
||||
int m_pixelGridOpacity;
|
||||
bool m_pixelGridAutoOpacity;
|
||||
bool m_isLoop;
|
||||
doc::FrameNumber m_loopBegin;
|
||||
doc::FrameNumber m_loopEnd;
|
||||
doc::frame_t m_loopBegin;
|
||||
doc::frame_t m_loopEnd;
|
||||
AniDir m_aniDir;
|
||||
};
|
||||
|
||||
@ -800,7 +800,7 @@ bool UIDocumentSettingsImpl::getLoopAnimation()
|
||||
return m_isLoop;
|
||||
}
|
||||
|
||||
void UIDocumentSettingsImpl::getLoopRange(doc::FrameNumber* begin, doc::FrameNumber* end)
|
||||
void UIDocumentSettingsImpl::getLoopRange(doc::frame_t* begin, doc::frame_t* end)
|
||||
{
|
||||
*begin = m_loopBegin;
|
||||
*end = m_loopEnd;
|
||||
@ -817,7 +817,7 @@ void UIDocumentSettingsImpl::setLoopAnimation(bool state)
|
||||
redrawDocumentViews();
|
||||
}
|
||||
|
||||
void UIDocumentSettingsImpl::setLoopRange(doc::FrameNumber begin, doc::FrameNumber end)
|
||||
void UIDocumentSettingsImpl::setLoopRange(doc::frame_t begin, doc::frame_t end)
|
||||
{
|
||||
m_loopBegin = begin;
|
||||
m_loopEnd = end;
|
||||
|
@ -50,7 +50,7 @@ namespace app {
|
||||
location->document(doc);
|
||||
location->sprite(doc->sprite());
|
||||
location->layer(doc->sprite()->folder()->getFirstLayer());
|
||||
location->frame(FrameNumber(0));
|
||||
location->frame(0);
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -77,7 +77,7 @@ private:
|
||||
|
||||
if (!fop_is_stop(m_fop) && sprite) {
|
||||
// The palette to convert the Image
|
||||
m_palette.reset(new Palette(*sprite->getPalette(FrameNumber(0))));
|
||||
m_palette.reset(new Palette(*sprite->palette(frame_t(0))));
|
||||
|
||||
// Render first frame of the sprite in 'image'
|
||||
base::UniquePtr<Image> image(Image::create(
|
||||
@ -86,7 +86,7 @@ private:
|
||||
AppRender render;
|
||||
render.setupBackground(NULL, image->pixelFormat());
|
||||
render.setBgType(render::BgType::CHECKED);
|
||||
render.renderSprite(image, sprite, FrameNumber(0));
|
||||
render.renderSprite(image, sprite, frame_t(0));
|
||||
|
||||
// Calculate the thumbnail size
|
||||
int thumb_w = MAX_THUMBNAIL_SIZE * image->width() / MAX(image->width(), image->height());
|
||||
|
@ -22,7 +22,7 @@
|
||||
|
||||
#include "app/settings/selection_mode.h"
|
||||
#include "app/tools/trace_policy.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "filters/tiled_mode.h"
|
||||
#include "gfx/point.h"
|
||||
|
||||
@ -88,7 +88,7 @@ namespace app {
|
||||
virtual Layer* getLayer() = 0;
|
||||
|
||||
// Returns the frame where we're paiting
|
||||
virtual FrameNumber getFrame() = 0;
|
||||
virtual frame_t getFrame() = 0;
|
||||
|
||||
// Should return an image where we can read pixels (readonly image)
|
||||
virtual const Image* getSrcImage() = 0;
|
||||
|
@ -287,12 +287,12 @@ void ColorSelector::onFixWarningClick(ui::Event& ev)
|
||||
}
|
||||
|
||||
if (document) {
|
||||
FrameNumber frame = writer.frame();
|
||||
frame_t frame = writer.frame();
|
||||
|
||||
UndoTransaction undoTransaction(writer.context(), "Add palette entry", undo::ModifyDocument);
|
||||
undoTransaction.pushUndoer
|
||||
(new undoers::SetPaletteColors(undoTransaction.getObjects(),
|
||||
sprite, sprite->getPalette(frame),
|
||||
sprite, sprite->palette(frame),
|
||||
frame, index, index));
|
||||
|
||||
sprite->setPalette(newPalette, false);
|
||||
|
@ -86,7 +86,7 @@ public:
|
||||
}
|
||||
|
||||
void setBrushSettings(IBrushSettings* brushSettings) {
|
||||
base::UniquePtr<Palette> palette(new Palette(FrameNumber(0), 2));
|
||||
base::UniquePtr<Palette> palette(new Palette(frame_t(0), 2));
|
||||
palette->setEntry(0, doc::rgba(0, 0, 0, 0));
|
||||
palette->setEntry(1, doc::rgba(0, 0, 0, 255));
|
||||
|
||||
|
@ -73,7 +73,7 @@ public:
|
||||
void onAfterFrameChanged(Editor* editor) override {
|
||||
App::instance()->getMainWindow()->getMiniEditor()->updateUsingEditor(this);
|
||||
|
||||
set_current_palette(editor->sprite()->getPalette(editor->frame()), true);
|
||||
set_current_palette(editor->sprite()->palette(editor->frame()), true);
|
||||
}
|
||||
|
||||
// EditorCustomizationDelegate implementation
|
||||
@ -276,7 +276,7 @@ void DocumentView::onAddFrame(doc::DocumentEvent& ev)
|
||||
if (current_editor == m_editor)
|
||||
m_editor->setFrame(ev.frame());
|
||||
else if (m_editor->frame() > ev.frame())
|
||||
m_editor->setFrame(m_editor->frame().next());
|
||||
m_editor->setFrame(m_editor->frame()+1);
|
||||
}
|
||||
|
||||
void DocumentView::onRemoveFrame(doc::DocumentEvent& ev)
|
||||
@ -284,7 +284,7 @@ void DocumentView::onRemoveFrame(doc::DocumentEvent& ev)
|
||||
// Adjust current frame of all editors that are in a frame more
|
||||
// advanced that the removed one.
|
||||
if (m_editor->frame() > ev.frame()) {
|
||||
m_editor->setFrame(m_editor->frame().previous());
|
||||
m_editor->setFrame(m_editor->frame()-1);
|
||||
}
|
||||
// If the editor was in the previous "last frame" (current value of
|
||||
// totalFrames()), we've to adjust it to the new last frame
|
||||
|
@ -152,7 +152,7 @@ Editor::Editor(Document* document, EditorFlags flags)
|
||||
, m_document(document)
|
||||
, m_sprite(m_document->sprite())
|
||||
, m_layer(m_sprite->folder()->getFirstLayer())
|
||||
, m_frame(FrameNumber(0))
|
||||
, m_frame(frame_t(0))
|
||||
, m_zoom(1, 1)
|
||||
, m_cursorThick(0)
|
||||
, m_cursorScreen(0, 0)
|
||||
@ -267,7 +267,7 @@ void Editor::setLayer(const Layer* layer)
|
||||
updateStatusBar();
|
||||
}
|
||||
|
||||
void Editor::setFrame(FrameNumber frame)
|
||||
void Editor::setFrame(frame_t frame)
|
||||
{
|
||||
if (m_frame != frame) {
|
||||
m_observers.notifyBeforeFrameChanged(this);
|
||||
@ -444,7 +444,7 @@ void Editor::drawOneSpriteUnclippedRect(ui::Graphics* g, const gfx::Rect& sprite
|
||||
// Convert the render to a she::Surface
|
||||
she::Surface* tmp(she::instance()->createRgbaSurface(rc.w, rc.h));
|
||||
if (tmp->nativeHandle()) {
|
||||
convert_image_to_surface(rendered, m_sprite->getPalette(m_frame),
|
||||
convert_image_to_surface(rendered, m_sprite->palette(m_frame),
|
||||
tmp, 0, 0, 0, 0, rc.w, rc.h);
|
||||
g->blit(tmp, 0, 0, dest_x, dest_y, rc.w, rc.h);
|
||||
}
|
||||
|
@ -30,7 +30,7 @@
|
||||
#include "app/ui/editor/editor_states_history.h"
|
||||
#include "base/connection.h"
|
||||
#include "doc/document_observer.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/image_buffer.h"
|
||||
#include "gfx/fwd.h"
|
||||
#include "render/zoom.h"
|
||||
@ -116,13 +116,13 @@ namespace app {
|
||||
Document* document() { return m_document; }
|
||||
Sprite* sprite() { return m_sprite; }
|
||||
Layer* layer() { return m_layer; }
|
||||
FrameNumber frame() { return m_frame; }
|
||||
frame_t frame() { return m_frame; }
|
||||
|
||||
void getDocumentLocation(DocumentLocation* location) const;
|
||||
DocumentLocation getDocumentLocation() const;
|
||||
|
||||
void setLayer(const Layer* layer);
|
||||
void setFrame(FrameNumber frame);
|
||||
void setFrame(frame_t frame);
|
||||
|
||||
const render::Zoom& zoom() const { return m_zoom; }
|
||||
int offsetX() const { return m_offset_x; }
|
||||
@ -270,7 +270,7 @@ namespace app {
|
||||
Document* m_document; // Active document in the editor
|
||||
Sprite* m_sprite; // Active sprite in the editor
|
||||
Layer* m_layer; // Active layer in the editor
|
||||
FrameNumber m_frame; // Active frame in the editor
|
||||
frame_t m_frame; // Active frame in the editor
|
||||
render::Zoom m_zoom; // Zoom in the editor
|
||||
|
||||
// Drawing cursor
|
||||
|
@ -359,7 +359,7 @@ bool MovingPixelsState::onKeyDown(Editor* editor, KeyMessage* msg)
|
||||
gfx::Point origin;
|
||||
base::UniquePtr<Image> floatingImage(m_pixelsMovement->getDraggedImageCopy(origin));
|
||||
clipboard::copy_image(floatingImage.get(),
|
||||
document->sprite()->getPalette(editor->frame()),
|
||||
document->sprite()->palette(editor->frame()),
|
||||
origin);
|
||||
}
|
||||
|
||||
|
@ -535,7 +535,7 @@ bool StandbyState::onUpdateStatusBar(Editor* editor)
|
||||
(mask ? mask->bounds().w: sprite->width()),
|
||||
(mask ? mask->bounds().h: sprite->height()),
|
||||
editor->frame()+1,
|
||||
sprite->getFrameDuration(editor->frame()));
|
||||
sprite->frameDuration(editor->frame()));
|
||||
}
|
||||
|
||||
return true;
|
||||
|
@ -64,7 +64,7 @@ class ToolLoopImpl : public tools::ToolLoop,
|
||||
Document* m_document;
|
||||
Sprite* m_sprite;
|
||||
Layer* m_layer;
|
||||
FrameNumber m_frame;
|
||||
frame_t m_frame;
|
||||
bool m_filled;
|
||||
bool m_previewFilled;
|
||||
int m_sprayWidth;
|
||||
@ -236,7 +236,7 @@ public:
|
||||
Document* getDocument() override { return m_document; }
|
||||
Sprite* sprite() override { return m_sprite; }
|
||||
Layer* getLayer() override { return m_layer; }
|
||||
FrameNumber getFrame() override { return m_frame; }
|
||||
frame_t getFrame() override { return m_frame; }
|
||||
|
||||
const Image* getSrcImage() override { return m_expandCelCanvas.getSourceCanvas(); }
|
||||
Image* getDstImage() override { return m_expandCelCanvas.getDestCanvas(); }
|
||||
@ -256,7 +256,7 @@ public:
|
||||
return m_expandCelCanvas.copyValidDestToSourceCanvas(rgn);
|
||||
}
|
||||
|
||||
RgbMap* getRgbMap() override { return m_sprite->getRgbMap(m_frame); }
|
||||
RgbMap* getRgbMap() override { return m_sprite->rgbMap(m_frame); }
|
||||
bool useMask() override { return m_useMask; }
|
||||
Mask* getMask() override { return m_mask; }
|
||||
gfx::Point getMaskOrigin() override { return m_maskOrigin; }
|
||||
|
@ -208,7 +208,7 @@ void MiniEditorWindow::onPlayClicked()
|
||||
if (m_playButton->isPlaying()) {
|
||||
Editor* miniEditor = (m_docView ? m_docView->getEditor(): NULL);
|
||||
if (miniEditor && miniEditor->document() != NULL)
|
||||
m_nextFrameTime = miniEditor->sprite()->getFrameDuration(miniEditor->frame());
|
||||
m_nextFrameTime = miniEditor->sprite()->frameDuration(miniEditor->frame());
|
||||
else
|
||||
m_nextFrameTime = -1;
|
||||
|
||||
@ -284,7 +284,7 @@ void MiniEditorWindow::onPlaybackTick()
|
||||
m_nextFrameTime -= (ui::clock() - m_curFrameTick);
|
||||
|
||||
while (m_nextFrameTime <= 0) {
|
||||
FrameNumber frame = calculate_next_frame(
|
||||
frame_t frame = calculate_next_frame(
|
||||
sprite,
|
||||
miniEditor->frame(),
|
||||
docSettings,
|
||||
@ -292,7 +292,7 @@ void MiniEditorWindow::onPlaybackTick()
|
||||
|
||||
miniEditor->setFrame(frame);
|
||||
|
||||
m_nextFrameTime += miniEditor->sprite()->getFrameDuration(frame);
|
||||
m_nextFrameTime += miniEditor->sprite()->frameDuration(frame);
|
||||
}
|
||||
|
||||
m_curFrameTick = ui::clock();
|
||||
|
@ -263,7 +263,7 @@ void Timeline::setLayer(Layer* layer)
|
||||
m_editor->setLayer(m_layer);
|
||||
}
|
||||
|
||||
void Timeline::setFrame(FrameNumber frame)
|
||||
void Timeline::setFrame(frame_t frame)
|
||||
{
|
||||
ASSERT(m_editor != NULL);
|
||||
// ASSERT(frame >= 0 && frame < m_sprite->totalFrames());
|
||||
@ -271,7 +271,7 @@ void Timeline::setFrame(FrameNumber frame)
|
||||
if (frame < 0)
|
||||
frame = firstFrame();
|
||||
else if (frame >= m_sprite->totalFrames())
|
||||
frame = FrameNumber(m_sprite->totalFrames()-1);
|
||||
frame = frame_t(m_sprite->totalFrames()-1);
|
||||
|
||||
m_frame = frame;
|
||||
invalidate();
|
||||
@ -392,7 +392,7 @@ bool Timeline::onProcessMessage(Message* msg)
|
||||
bool selectCel = (mouseMsg->left()
|
||||
|| !isLayerActive(m_clk_layer)
|
||||
|| !isFrameActive(m_clk_frame));
|
||||
FrameNumber old_frame = m_frame;
|
||||
frame_t old_frame = m_frame;
|
||||
|
||||
// Select the new clicked-part.
|
||||
if (old_layer != m_clk_layer
|
||||
@ -428,7 +428,7 @@ bool Timeline::onProcessMessage(Message* msg)
|
||||
|
||||
int hot_part;
|
||||
LayerIndex hot_layer;
|
||||
FrameNumber hot_frame;
|
||||
frame_t hot_frame;
|
||||
gfx::Point mousePos = static_cast<MouseMessage*>(msg)->position()
|
||||
- getBounds().getOrigin();
|
||||
|
||||
@ -807,7 +807,7 @@ void Timeline::onPaint(ui::PaintEvent& ev)
|
||||
const DocumentReader documentReader(m_document);
|
||||
|
||||
LayerIndex layer, first_layer, last_layer;
|
||||
FrameNumber frame, first_frame, last_frame;
|
||||
frame_t frame, first_frame, last_frame;
|
||||
|
||||
getDrawableLayers(g, &first_layer, &last_layer);
|
||||
getDrawableFrames(g, &first_frame, &last_frame);
|
||||
@ -953,7 +953,7 @@ void Timeline::onRemoveFrame(doc::DocumentEvent& ev)
|
||||
// Adjust current frame of all editors that are in a frame more
|
||||
// advanced that the removed one.
|
||||
if (getFrame() > ev.frame()) {
|
||||
setFrame(getFrame().previous());
|
||||
setFrame(getFrame()-1);
|
||||
}
|
||||
// If the editor was in the previous "last frame" (current value of
|
||||
// totalFrames()), we've to adjust it to the new last frame
|
||||
@ -1048,11 +1048,11 @@ void Timeline::getDrawableLayers(ui::Graphics* g, LayerIndex* first_layer, Layer
|
||||
*last_layer = j;
|
||||
}
|
||||
|
||||
void Timeline::getDrawableFrames(ui::Graphics* g, FrameNumber* first_frame, FrameNumber* last_frame)
|
||||
void Timeline::getDrawableFrames(ui::Graphics* g, frame_t* first_frame, frame_t* last_frame)
|
||||
{
|
||||
*first_frame = FrameNumber((m_separator_w + m_scroll_x) / FRMSIZE);
|
||||
*first_frame = frame_t((m_separator_w + m_scroll_x) / FRMSIZE);
|
||||
*last_frame = *first_frame
|
||||
+ FrameNumber((getClientBounds().w - m_separator_w) / FRMSIZE);
|
||||
+ frame_t((getClientBounds().w - m_separator_w) / FRMSIZE);
|
||||
}
|
||||
|
||||
void Timeline::drawPart(ui::Graphics* g, const gfx::Rect& bounds,
|
||||
@ -1127,7 +1127,7 @@ void Timeline::drawHeader(ui::Graphics* g)
|
||||
NULL, m_timelineBoxStyle, false, false, false);
|
||||
}
|
||||
|
||||
void Timeline::drawHeaderFrame(ui::Graphics* g, FrameNumber frame)
|
||||
void Timeline::drawHeaderFrame(ui::Graphics* g, frame_t frame)
|
||||
{
|
||||
bool is_active = isFrameActive(frame);
|
||||
bool is_hover = (m_hot_part == A_PART_HEADER_FRAME && m_hot_frame == frame);
|
||||
@ -1191,7 +1191,7 @@ void Timeline::drawLayer(ui::Graphics* g, LayerIndex layerIdx)
|
||||
}
|
||||
}
|
||||
|
||||
void Timeline::drawCel(ui::Graphics* g, LayerIndex layerIndex, FrameNumber frame, Cel* cel)
|
||||
void Timeline::drawCel(ui::Graphics* g, LayerIndex layerIndex, frame_t frame, Cel* cel)
|
||||
{
|
||||
Image* image = (cel ? cel->image(): NULL);
|
||||
bool is_hover = (m_hot_part == A_PART_CEL &&
|
||||
@ -1221,8 +1221,8 @@ void Timeline::drawCel(ui::Graphics* g, LayerIndex layerIndex, FrameNumber frame
|
||||
// option is to use a thread to calculate differences, but I
|
||||
// think it's too much for just UI stuff.
|
||||
Layer* layer = m_layers[layerIndex];
|
||||
Cel* left = (layer->isImage() ? static_cast<LayerImage*>(layer)->getCel(frame.previous()): NULL);
|
||||
Cel* right = (layer->isImage() ? static_cast<LayerImage*>(layer)->getCel(frame.next()): NULL);
|
||||
Cel* left = (layer->isImage() ? static_cast<LayerImage*>(layer)->getCel(frame-1): NULL);
|
||||
Cel* right = (layer->isImage() ? static_cast<LayerImage*>(layer)->getCel(frame+1): NULL);
|
||||
Image* leftImg = (left ? m_sprite->stock()->getImage(left->getImage()): NULL);
|
||||
Image* rightImg = (right ? m_sprite->stock()->getImage(right->getImage()): NULL);
|
||||
bool fromLeft = (leftImg && count_diff_between_images(image, leftImg) == 0);
|
||||
@ -1248,7 +1248,7 @@ void Timeline::drawLoopRange(ui::Graphics* g)
|
||||
if (!docSettings->getLoopAnimation())
|
||||
return;
|
||||
|
||||
FrameNumber begin, end;
|
||||
frame_t begin, end;
|
||||
docSettings->getLoopRange(&begin, &end);
|
||||
if (begin > end)
|
||||
return;
|
||||
@ -1384,8 +1384,8 @@ gfx::Rect Timeline::getOnionskinFramesBounds() const
|
||||
ISettings* settings = UIContext::instance()->settings();
|
||||
IDocumentSettings* docSettings = settings->getDocumentSettings(m_document);
|
||||
if (docSettings->getUseOnionskin()) {
|
||||
FrameNumber firstFrame = m_frame.previous(docSettings->getOnionskinPrevFrames());
|
||||
FrameNumber lastFrame = m_frame.next(docSettings->getOnionskinNextFrames());
|
||||
frame_t firstFrame = m_frame - docSettings->getOnionskinPrevFrames();
|
||||
frame_t lastFrame = m_frame + docSettings->getOnionskinNextFrames();
|
||||
|
||||
if (firstFrame < this->firstFrame())
|
||||
firstFrame = this->firstFrame();
|
||||
@ -1409,7 +1409,7 @@ gfx::Rect Timeline::getCelsBounds() const
|
||||
return rc;
|
||||
}
|
||||
|
||||
gfx::Rect Timeline::getPartBounds(int part, LayerIndex layer, FrameNumber frame) const
|
||||
gfx::Rect Timeline::getPartBounds(int part, LayerIndex layer, frame_t frame) const
|
||||
{
|
||||
const gfx::Rect bounds = getClientBounds();
|
||||
|
||||
@ -1479,7 +1479,7 @@ gfx::Rect Timeline::getPartBounds(int part, LayerIndex layer, FrameNumber frame)
|
||||
break;
|
||||
|
||||
case A_PART_CEL:
|
||||
if (validLayer(layer) && frame >= FrameNumber(0)) {
|
||||
if (validLayer(layer) && frame >= frame_t(0)) {
|
||||
return gfx::Rect(
|
||||
m_separator_x + m_separator_w - 1 + FRMSIZE*frame - m_scroll_x,
|
||||
HDRSIZE + LAYSIZE*(lastLayer()-layer) - m_scroll_y,
|
||||
@ -1521,7 +1521,7 @@ gfx::Rect Timeline::getRangeBounds(const Range& range) const
|
||||
return rc;
|
||||
}
|
||||
|
||||
void Timeline::invalidatePart(int part, LayerIndex layer, FrameNumber frame)
|
||||
void Timeline::invalidatePart(int part, LayerIndex layer, frame_t frame)
|
||||
{
|
||||
invalidateRect(getPartBounds(part, layer, frame).offset(getOrigin()));
|
||||
}
|
||||
@ -1547,18 +1547,18 @@ void Timeline::updateHotByMousePos(ui::Message* msg, const gfx::Point& mousePos)
|
||||
{
|
||||
int hot_part;
|
||||
LayerIndex hot_layer;
|
||||
FrameNumber hot_frame;
|
||||
frame_t hot_frame;
|
||||
updateHot(msg, mousePos, hot_part, hot_layer, hot_frame);
|
||||
|
||||
if (hasMouseOver())
|
||||
setCursor(msg, mousePos);
|
||||
}
|
||||
|
||||
void Timeline::updateHot(ui::Message* msg, const gfx::Point& mousePos, int& hot_part, LayerIndex& hot_layer, FrameNumber& hot_frame)
|
||||
void Timeline::updateHot(ui::Message* msg, const gfx::Point& mousePos, int& hot_part, LayerIndex& hot_layer, frame_t& hot_frame)
|
||||
{
|
||||
hot_part = A_PART_NOTHING;
|
||||
hot_layer = LayerIndex::NoLayer;
|
||||
hot_frame = FrameNumber((mousePos.x
|
||||
hot_frame = frame_t((mousePos.x
|
||||
- m_separator_x
|
||||
- m_separator_w
|
||||
+ m_scroll_x) / FRMSIZE);
|
||||
@ -1575,7 +1575,7 @@ void Timeline::updateHot(ui::Message* msg, const gfx::Point& mousePos, int& hot_
|
||||
- HDRSIZE
|
||||
+ m_scroll_y) / LAYSIZE);
|
||||
|
||||
hot_frame = FrameNumber((mousePos.x
|
||||
hot_frame = frame_t((mousePos.x
|
||||
- m_separator_x
|
||||
- m_separator_w
|
||||
+ m_scroll_x) / FRMSIZE);
|
||||
@ -1589,7 +1589,7 @@ void Timeline::updateHot(ui::Message* msg, const gfx::Point& mousePos, int& hot_
|
||||
}
|
||||
else {
|
||||
if (hot_layer > lastLayer()) hot_layer = LayerIndex::NoLayer;
|
||||
if (hot_frame > lastFrame()) hot_frame = FrameNumber(-1);
|
||||
if (hot_frame > lastFrame()) hot_frame = frame_t(-1);
|
||||
}
|
||||
|
||||
// Is the mouse over onionskin handles?
|
||||
@ -1657,7 +1657,7 @@ void Timeline::updateHot(ui::Message* msg, const gfx::Point& mousePos, int& hot_
|
||||
hotThis(hot_part, hot_layer, hot_frame);
|
||||
}
|
||||
|
||||
void Timeline::hotThis(int hot_part, LayerIndex hot_layer, FrameNumber hot_frame)
|
||||
void Timeline::hotThis(int hot_part, LayerIndex hot_layer, frame_t hot_frame)
|
||||
{
|
||||
// If the part, layer or frame change.
|
||||
if (hot_part != m_hot_part ||
|
||||
@ -1698,11 +1698,11 @@ void Timeline::updateStatusBar(ui::Message* msg)
|
||||
case Range::kFrames:
|
||||
if (validFrame(m_hot_frame)) {
|
||||
if (m_dropTarget.hhit == DropTarget::Before) {
|
||||
sb->setStatusText(0, "%s before frame %d", verb, (int)m_dropRange.frameBegin().next());
|
||||
sb->setStatusText(0, "%s before frame %d", verb, int(m_dropRange.frameBegin()+1));
|
||||
return;
|
||||
}
|
||||
else if (m_dropTarget.hhit == DropTarget::After) {
|
||||
sb->setStatusText(0, "%s after frame %d", verb, (int)m_dropRange.frameEnd().next());
|
||||
sb->setStatusText(0, "%s after frame %d", verb, int(m_dropRange.frameEnd()+1));
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -1780,7 +1780,7 @@ void Timeline::updateStatusBar(ui::Message* msg)
|
||||
sb->setStatusText(0,
|
||||
"Frame %d [%d msecs]",
|
||||
(int)m_hot_frame+1,
|
||||
m_sprite->getFrameDuration(m_hot_frame));
|
||||
m_sprite->frameDuration(m_hot_frame));
|
||||
return;
|
||||
}
|
||||
break;
|
||||
@ -1801,7 +1801,7 @@ void Timeline::updateStatusBar(ui::Message* msg)
|
||||
sb->clearText();
|
||||
}
|
||||
|
||||
void Timeline::centerCel(LayerIndex layer, FrameNumber frame)
|
||||
void Timeline::centerCel(LayerIndex layer, frame_t frame)
|
||||
{
|
||||
int target_x = (getBounds().x + m_separator_x + m_separator_w + getBounds().x2())/2 - FRMSIZE/2;
|
||||
int target_y = (getBounds().y + HDRSIZE + getBounds().y2())/2 - LAYSIZE/2;
|
||||
@ -1811,7 +1811,7 @@ void Timeline::centerCel(LayerIndex layer, FrameNumber frame)
|
||||
setScroll(scroll_x, scroll_y);
|
||||
}
|
||||
|
||||
void Timeline::showCel(LayerIndex layer, FrameNumber frame)
|
||||
void Timeline::showCel(LayerIndex layer, frame_t frame)
|
||||
{
|
||||
int scroll_x, scroll_y;
|
||||
int x1, y1, x2, y2;
|
||||
@ -1926,7 +1926,7 @@ bool Timeline::isLayerActive(LayerIndex layerIndex) const
|
||||
return m_range.inRange(layerIndex);
|
||||
}
|
||||
|
||||
bool Timeline::isFrameActive(FrameNumber frame) const
|
||||
bool Timeline::isFrameActive(frame_t frame) const
|
||||
{
|
||||
if (frame == m_frame)
|
||||
return true;
|
||||
@ -1952,7 +1952,7 @@ void Timeline::dropRange(DropOp op)
|
||||
}
|
||||
|
||||
int activeRelativeLayer = getLayerIndex(m_layer) - m_range.layerBegin();
|
||||
FrameNumber activeRelativeFrame = m_frame - m_range.frameBegin();
|
||||
frame_t activeRelativeFrame = m_frame - m_range.frameBegin();
|
||||
|
||||
try {
|
||||
if (copy)
|
||||
@ -1965,7 +1965,7 @@ void Timeline::dropRange(DropOp op)
|
||||
m_range = newFromRange;
|
||||
if (m_range.layerBegin() >= LayerIndex(0))
|
||||
setLayer(m_layers[m_range.layerBegin() + activeRelativeLayer]);
|
||||
if (m_range.frameBegin() >= FrameNumber(0))
|
||||
if (m_range.frameBegin() >= frame_t(0))
|
||||
setFrame(m_range.frameBegin() + activeRelativeFrame);
|
||||
}
|
||||
catch (const std::exception& e) {
|
||||
@ -1995,10 +1995,10 @@ void Timeline::updateDropRange(const gfx::Point& pt)
|
||||
switch (m_range.type()) {
|
||||
|
||||
case Range::kCels: {
|
||||
FrameNumber dx = m_hot_frame - m_clk_frame;
|
||||
frame_t dx = m_hot_frame - m_clk_frame;
|
||||
LayerIndex dy = m_hot_layer - m_clk_layer;
|
||||
LayerIndex layerIdx;
|
||||
FrameNumber frame;
|
||||
frame_t frame;
|
||||
|
||||
layerIdx = dy+m_range.layerBegin();
|
||||
layerIdx = MID(firstLayer(), layerIdx, LayerIndex(m_layers.size() - m_range.layers()));
|
||||
@ -2009,17 +2009,17 @@ void Timeline::updateDropRange(const gfx::Point& pt)
|
||||
m_dropRange.startRange(layerIdx, frame, m_range.type());
|
||||
m_dropRange.endRange(
|
||||
layerIdx+LayerIndex(m_range.layers()-1),
|
||||
(frame+m_range.frames()).previous());
|
||||
frame+m_range.frames()-1);
|
||||
break;
|
||||
}
|
||||
|
||||
case Range::kFrames: {
|
||||
FrameNumber frame = m_hot_frame;
|
||||
FrameNumber frameEnd = frame;
|
||||
frame_t frame = m_hot_frame;
|
||||
frame_t frameEnd = frame;
|
||||
|
||||
if (frame >= m_range.frameBegin() && frame <= m_range.frameEnd()) {
|
||||
frame = m_range.frameBegin();
|
||||
frameEnd = (frame + m_range.frames()).previous();
|
||||
frameEnd = frame + m_range.frames() - 1;
|
||||
}
|
||||
|
||||
LayerIndex layerIdx = getLayerIndex(m_layer);
|
||||
|
@ -26,7 +26,7 @@
|
||||
#include "base/connection.h"
|
||||
#include "doc/document_observer.h"
|
||||
#include "doc/documents_observer.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/layer_index.h"
|
||||
#include "doc/sprite.h"
|
||||
#include "ui/timer.h"
|
||||
@ -82,10 +82,10 @@ namespace app {
|
||||
|
||||
Sprite* sprite() { return m_sprite; }
|
||||
Layer* getLayer() { return m_layer; }
|
||||
FrameNumber getFrame() { return m_frame; }
|
||||
frame_t getFrame() { return m_frame; }
|
||||
|
||||
void setLayer(Layer* layer);
|
||||
void setFrame(FrameNumber frame);
|
||||
void setFrame(frame_t frame);
|
||||
|
||||
State getState() const { return m_state; }
|
||||
bool isMovingCel() const;
|
||||
@ -134,7 +134,7 @@ namespace app {
|
||||
VHit vhit;
|
||||
Layer* layer;
|
||||
LayerIndex layerIdx;
|
||||
FrameNumber frame;
|
||||
frame_t frame;
|
||||
int xpos, ypos;
|
||||
};
|
||||
|
||||
@ -145,38 +145,38 @@ namespace app {
|
||||
void detachDocument();
|
||||
void setCursor(ui::Message* msg, const gfx::Point& mousePos);
|
||||
void getDrawableLayers(ui::Graphics* g, LayerIndex* first_layer, LayerIndex* last_layer);
|
||||
void getDrawableFrames(ui::Graphics* g, FrameNumber* first_frame, FrameNumber* last_frame);
|
||||
void getDrawableFrames(ui::Graphics* g, frame_t* first_frame, frame_t* last_frame);
|
||||
void drawPart(ui::Graphics* g, const gfx::Rect& bounds,
|
||||
const char* text, skin::Style* style,
|
||||
bool is_active = false, bool is_hover = false, bool is_clicked = false);
|
||||
void drawHeader(ui::Graphics* g);
|
||||
void drawHeaderFrame(ui::Graphics* g, FrameNumber frame);
|
||||
void drawHeaderFrame(ui::Graphics* g, frame_t frame);
|
||||
void drawLayer(ui::Graphics* g, LayerIndex layerIdx);
|
||||
void drawCel(ui::Graphics* g, LayerIndex layerIdx, FrameNumber frame, Cel* cel);
|
||||
void drawCel(ui::Graphics* g, LayerIndex layerIdx, frame_t frame, Cel* cel);
|
||||
void drawLoopRange(ui::Graphics* g);
|
||||
void drawRangeOutline(ui::Graphics* g);
|
||||
void drawPaddings(ui::Graphics* g);
|
||||
bool drawPart(ui::Graphics* g, int part, LayerIndex layer, FrameNumber frame);
|
||||
bool drawPart(ui::Graphics* g, int part, LayerIndex layer, frame_t frame);
|
||||
void drawClipboardRange(ui::Graphics* g);
|
||||
gfx::Rect getLayerHeadersBounds() const;
|
||||
gfx::Rect getFrameHeadersBounds() const;
|
||||
gfx::Rect getOnionskinFramesBounds() const;
|
||||
gfx::Rect getCelsBounds() const;
|
||||
gfx::Rect getPartBounds(int part, LayerIndex layer = LayerIndex(0), FrameNumber frame = FrameNumber(0)) const;
|
||||
gfx::Rect getPartBounds(int part, LayerIndex layer = LayerIndex(0), frame_t frame = frame_t(0)) const;
|
||||
gfx::Rect getRangeBounds(const Range& range) const;
|
||||
void invalidatePart(int part, LayerIndex layer, FrameNumber frame);
|
||||
void invalidatePart(int part, LayerIndex layer, frame_t frame);
|
||||
void regenerateLayers();
|
||||
void updateHotByMousePos(ui::Message* msg, const gfx::Point& mousePos);
|
||||
void updateHot(ui::Message* msg, const gfx::Point& mousePos, int& hot_part, LayerIndex& hot_layer, FrameNumber& hot_frame);
|
||||
void hotThis(int hot_part, LayerIndex hot_layer, FrameNumber hot_frame);
|
||||
void centerCel(LayerIndex layer, FrameNumber frame);
|
||||
void showCel(LayerIndex layer, FrameNumber frame);
|
||||
void updateHot(ui::Message* msg, const gfx::Point& mousePos, int& hot_part, LayerIndex& hot_layer, frame_t& hot_frame);
|
||||
void hotThis(int hot_part, LayerIndex hot_layer, frame_t hot_frame);
|
||||
void centerCel(LayerIndex layer, frame_t frame);
|
||||
void showCel(LayerIndex layer, frame_t frame);
|
||||
void showCurrentCel();
|
||||
void cleanClk();
|
||||
void setScroll(int x, int y);
|
||||
LayerIndex getLayerIndex(const Layer* layer) const;
|
||||
bool isLayerActive(LayerIndex layerIdx) const;
|
||||
bool isFrameActive(FrameNumber frame) const;
|
||||
bool isFrameActive(frame_t frame) const;
|
||||
void updateStatusBar(ui::Message* msg);
|
||||
void updateDropRange(const gfx::Point& pt);
|
||||
void clearClipboardRange();
|
||||
@ -189,11 +189,11 @@ namespace app {
|
||||
// The layer of the top.
|
||||
LayerIndex lastLayer() const { return LayerIndex(m_layers.size()-1); }
|
||||
|
||||
FrameNumber firstFrame() const { return FrameNumber(0); }
|
||||
FrameNumber lastFrame() const { return m_sprite->lastFrame(); }
|
||||
frame_t firstFrame() const { return frame_t(0); }
|
||||
frame_t lastFrame() const { return m_sprite->lastFrame(); }
|
||||
|
||||
bool validLayer(LayerIndex layer) const { return layer >= firstLayer() && layer <= lastLayer(); }
|
||||
bool validFrame(FrameNumber frame) const { return frame >= firstFrame() && frame <= lastFrame(); }
|
||||
bool validFrame(frame_t frame) const { return frame >= firstFrame() && frame <= lastFrame(); }
|
||||
|
||||
skin::Style* m_timelineStyle;
|
||||
skin::Style* m_timelineBoxStyle;
|
||||
@ -224,7 +224,7 @@ namespace app {
|
||||
Document* m_document;
|
||||
Sprite* m_sprite;
|
||||
Layer* m_layer;
|
||||
FrameNumber m_frame;
|
||||
frame_t m_frame;
|
||||
Range m_range;
|
||||
Range m_dropRange;
|
||||
State m_state;
|
||||
@ -237,12 +237,12 @@ namespace app {
|
||||
// The 'hot' part is where the mouse is on top of
|
||||
int m_hot_part;
|
||||
LayerIndex m_hot_layer;
|
||||
FrameNumber m_hot_frame;
|
||||
frame_t m_hot_frame;
|
||||
DropTarget m_dropTarget;
|
||||
// The 'clk' part is where the mouse's button was pressed (maybe for a drag & drop operation)
|
||||
int m_clk_part;
|
||||
LayerIndex m_clk_layer;
|
||||
FrameNumber m_clk_frame;
|
||||
frame_t m_clk_frame;
|
||||
// Absolute mouse positions for scrolling.
|
||||
gfx::Point m_oldPos;
|
||||
// Configure timeline
|
||||
|
@ -217,7 +217,7 @@ void UIContext::onGetActiveLocation(DocumentLocation* location) const
|
||||
location->document(doc);
|
||||
location->sprite(doc->sprite());
|
||||
location->layer(doc->sprite()->indexToLayer(LayerIndex(0)));
|
||||
location->frame(FrameNumber(0));
|
||||
location->frame(0);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -35,7 +35,7 @@ namespace undoers {
|
||||
|
||||
using namespace undo;
|
||||
|
||||
AddFrame::AddFrame(ObjectsContainer* objects, Document* document, Sprite* sprite, FrameNumber frame)
|
||||
AddFrame::AddFrame(ObjectsContainer* objects, Document* document, Sprite* sprite, frame_t frame)
|
||||
: m_documentId(objects->addObject(document))
|
||||
, m_spriteId(objects->addObject(sprite))
|
||||
, m_frame(frame)
|
||||
|
@ -21,7 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "app/undoers/undoer_base.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "undo/object_id.h"
|
||||
|
||||
namespace doc {
|
||||
@ -37,7 +37,7 @@ namespace app {
|
||||
|
||||
class AddFrame : public UndoerBase {
|
||||
public:
|
||||
AddFrame(ObjectsContainer* objects, Document* document, Sprite* sprite, FrameNumber frame);
|
||||
AddFrame(ObjectsContainer* objects, Document* document, Sprite* sprite, frame_t frame);
|
||||
|
||||
void dispose() override;
|
||||
size_t getMemSize() const override { return sizeof(*this); }
|
||||
@ -46,7 +46,7 @@ namespace app {
|
||||
private:
|
||||
undo::ObjectId m_documentId;
|
||||
undo::ObjectId m_spriteId;
|
||||
FrameNumber m_frame;
|
||||
frame_t m_frame;
|
||||
};
|
||||
|
||||
} // namespace undoers
|
||||
|
@ -32,7 +32,7 @@ namespace undoers {
|
||||
|
||||
using namespace undo;
|
||||
|
||||
AddPalette::AddPalette(ObjectsContainer* objects, Sprite* sprite, FrameNumber paletteFrame)
|
||||
AddPalette::AddPalette(ObjectsContainer* objects, Sprite* sprite, frame_t paletteFrame)
|
||||
: m_spriteId(objects->addObject(sprite))
|
||||
, m_paletteFrame(paletteFrame)
|
||||
{
|
||||
@ -46,9 +46,9 @@ void AddPalette::dispose()
|
||||
void AddPalette::revert(ObjectsContainer* objects, UndoersCollector* redoers)
|
||||
{
|
||||
Sprite* sprite = objects->getObjectT<Sprite>(m_spriteId);
|
||||
Palette* palette = sprite->getPalette(FrameNumber(m_paletteFrame));
|
||||
Palette* palette = sprite->palette(frame_t(m_paletteFrame));
|
||||
|
||||
redoers->pushUndoer(new RemovePalette(objects, sprite, FrameNumber(m_paletteFrame)));
|
||||
redoers->pushUndoer(new RemovePalette(objects, sprite, frame_t(m_paletteFrame)));
|
||||
|
||||
sprite->deletePalette(palette);
|
||||
}
|
||||
|
@ -21,7 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "app/undoers/undoer_base.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "undo/object_id.h"
|
||||
|
||||
namespace doc {
|
||||
@ -35,7 +35,7 @@ namespace app {
|
||||
|
||||
class AddPalette : public UndoerBase {
|
||||
public:
|
||||
AddPalette(ObjectsContainer* objects, Sprite* sprite, FrameNumber palette_frame);
|
||||
AddPalette(ObjectsContainer* objects, Sprite* sprite, frame_t palette_frame);
|
||||
|
||||
void dispose() override;
|
||||
size_t getMemSize() const override { return sizeof(*this); }
|
||||
@ -43,7 +43,7 @@ namespace app {
|
||||
|
||||
private:
|
||||
undo::ObjectId m_spriteId;
|
||||
FrameNumber m_paletteFrame;
|
||||
frame_t m_paletteFrame;
|
||||
};
|
||||
|
||||
} // namespace undoers
|
||||
|
@ -35,7 +35,7 @@ using namespace doc;
|
||||
using namespace undo;
|
||||
|
||||
RemapPalette::RemapPalette(ObjectsContainer* objects, Sprite* sprite,
|
||||
FrameNumber frameFrom, FrameNumber frameTo,
|
||||
frame_t frameFrom, frame_t frameTo,
|
||||
const std::vector<uint8_t>& mapping)
|
||||
: m_spriteId(objects->addObject(sprite))
|
||||
, m_frameFrom(frameFrom)
|
||||
|
@ -21,7 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "app/undoers/undoer_base.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "undo/object_id.h"
|
||||
|
||||
#include <vector>
|
||||
@ -38,7 +38,7 @@ namespace app {
|
||||
class RemapPalette : public UndoerBase {
|
||||
public:
|
||||
RemapPalette(ObjectsContainer* objects, Sprite* sprite,
|
||||
FrameNumber frameFrom, FrameNumber frameTo,
|
||||
frame_t frameFrom, frame_t frameTo,
|
||||
const std::vector<uint8_t>& mapping);
|
||||
|
||||
void dispose() override;
|
||||
@ -47,8 +47,8 @@ namespace app {
|
||||
|
||||
private:
|
||||
undo::ObjectId m_spriteId;
|
||||
FrameNumber m_frameFrom;
|
||||
FrameNumber m_frameTo;
|
||||
frame_t m_frameFrom;
|
||||
frame_t m_frameTo;
|
||||
std::vector<uint8_t> m_mapping;
|
||||
};
|
||||
|
||||
|
@ -36,11 +36,11 @@ namespace undoers {
|
||||
using namespace doc;
|
||||
using namespace undo;
|
||||
|
||||
RemoveFrame::RemoveFrame(undo::ObjectsContainer* objects, Document* document, Sprite* sprite, FrameNumber frame)
|
||||
RemoveFrame::RemoveFrame(undo::ObjectsContainer* objects, Document* document, Sprite* sprite, frame_t frame)
|
||||
: m_documentId(objects->addObject(document))
|
||||
, m_spriteId(objects->addObject(sprite))
|
||||
, m_frame(frame)
|
||||
, m_frameDuration(sprite->getFrameDuration(frame))
|
||||
, m_frameDuration(sprite->frameDuration(frame))
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -21,7 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "app/undoers/undoer_base.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "undo/object_id.h"
|
||||
|
||||
#include <sstream>
|
||||
@ -39,7 +39,7 @@ namespace app {
|
||||
|
||||
class RemoveFrame : public UndoerBase {
|
||||
public:
|
||||
RemoveFrame(ObjectsContainer* objects, Document* document, Sprite* sprite, FrameNumber frame);
|
||||
RemoveFrame(ObjectsContainer* objects, Document* document, Sprite* sprite, frame_t frame);
|
||||
|
||||
void dispose() override;
|
||||
size_t getMemSize() const override { return sizeof(*this); }
|
||||
@ -48,7 +48,7 @@ namespace app {
|
||||
private:
|
||||
undo::ObjectId m_documentId;
|
||||
undo::ObjectId m_spriteId;
|
||||
FrameNumber m_frame;
|
||||
frame_t m_frame;
|
||||
int m_frameDuration;
|
||||
};
|
||||
|
||||
|
@ -35,10 +35,10 @@ namespace undoers {
|
||||
|
||||
using namespace undo;
|
||||
|
||||
RemovePalette::RemovePalette(ObjectsContainer* objects, Sprite* sprite, FrameNumber paletteFrame)
|
||||
RemovePalette::RemovePalette(ObjectsContainer* objects, Sprite* sprite, frame_t paletteFrame)
|
||||
: m_spriteId(objects->addObject(sprite))
|
||||
{
|
||||
doc::write_palette(m_stream, sprite->getPalette(paletteFrame));
|
||||
doc::write_palette(m_stream, sprite->palette(paletteFrame));
|
||||
}
|
||||
|
||||
void RemovePalette::dispose()
|
||||
|
@ -21,7 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "app/undoers/undoer_base.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "undo/object_id.h"
|
||||
|
||||
#include <sstream>
|
||||
@ -37,7 +37,7 @@ namespace app {
|
||||
|
||||
class RemovePalette : public UndoerBase {
|
||||
public:
|
||||
RemovePalette(ObjectsContainer* objects, Sprite* sprite, FrameNumber paletteFrame);
|
||||
RemovePalette(ObjectsContainer* objects, Sprite* sprite, frame_t paletteFrame);
|
||||
|
||||
void dispose() override;
|
||||
size_t getMemSize() const override { return sizeof(*this) + getStreamSize(); }
|
||||
|
@ -21,7 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "app/undoers/undoer_base.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "undo/object_id.h"
|
||||
|
||||
namespace doc {
|
||||
@ -45,7 +45,7 @@ namespace app {
|
||||
private:
|
||||
undo::ObjectId m_layerId;
|
||||
undo::ObjectId m_celId;
|
||||
FrameNumber m_frame;
|
||||
frame_t m_frame;
|
||||
};
|
||||
|
||||
} // namespace undoers
|
||||
|
@ -31,13 +31,13 @@ namespace undoers {
|
||||
|
||||
using namespace undo;
|
||||
|
||||
SetFrameDuration::SetFrameDuration(ObjectsContainer* objects, Sprite* sprite, FrameNumber frame)
|
||||
SetFrameDuration::SetFrameDuration(ObjectsContainer* objects, Sprite* sprite, frame_t frame)
|
||||
: m_spriteId(objects->addObject(sprite))
|
||||
, m_frame(frame)
|
||||
{
|
||||
ASSERT(frame >= 0 && frame < sprite->totalFrames());
|
||||
|
||||
m_duration = sprite->getFrameDuration(frame);
|
||||
m_duration = sprite->frameDuration(frame);
|
||||
}
|
||||
|
||||
void SetFrameDuration::dispose()
|
||||
|
@ -21,7 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "app/undoers/undoer_base.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "undo/object_id.h"
|
||||
|
||||
namespace doc {
|
||||
@ -35,7 +35,7 @@ namespace app {
|
||||
|
||||
class SetFrameDuration : public UndoerBase {
|
||||
public:
|
||||
SetFrameDuration(ObjectsContainer* objects, Sprite* sprite, FrameNumber frame);
|
||||
SetFrameDuration(ObjectsContainer* objects, Sprite* sprite, frame_t frame);
|
||||
|
||||
void dispose() override;
|
||||
size_t getMemSize() const override { return sizeof(*this); }
|
||||
@ -43,7 +43,7 @@ namespace app {
|
||||
|
||||
private:
|
||||
undo::ObjectId m_spriteId;
|
||||
FrameNumber m_frame;
|
||||
frame_t m_frame;
|
||||
uint32_t m_duration;
|
||||
};
|
||||
|
||||
|
@ -35,7 +35,7 @@ namespace undoers {
|
||||
using namespace undo;
|
||||
using namespace base::serialization::little_endian;
|
||||
|
||||
SetPaletteColors::SetPaletteColors(ObjectsContainer* objects, Sprite* sprite, Palette* palette, FrameNumber frame, int from, int to)
|
||||
SetPaletteColors::SetPaletteColors(ObjectsContainer* objects, Sprite* sprite, Palette* palette, frame_t frame, int from, int to)
|
||||
: m_spriteId(objects->addObject(sprite))
|
||||
, m_frame(frame)
|
||||
, m_from(from)
|
||||
@ -54,7 +54,7 @@ void SetPaletteColors::dispose()
|
||||
void SetPaletteColors::revert(ObjectsContainer* objects, UndoersCollector* redoers)
|
||||
{
|
||||
Sprite* sprite = objects->getObjectT<Sprite>(m_spriteId);
|
||||
Palette* palette = sprite->getPalette(m_frame);
|
||||
Palette* palette = sprite->palette(m_frame);
|
||||
|
||||
if (palette == NULL)
|
||||
throw UndoException("Palette not found when restoring colors");
|
||||
|
@ -21,7 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "app/undoers/undoer_base.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "undo/object_id.h"
|
||||
|
||||
#include <sstream>
|
||||
@ -38,7 +38,7 @@ namespace app {
|
||||
|
||||
class SetPaletteColors : public UndoerBase {
|
||||
public:
|
||||
SetPaletteColors(ObjectsContainer* objects, Sprite* sprite, Palette* palette, FrameNumber frame, int from, int to);
|
||||
SetPaletteColors(ObjectsContainer* objects, Sprite* sprite, Palette* palette, frame_t frame, int from, int to);
|
||||
|
||||
void dispose() override;
|
||||
size_t getMemSize() const override { return sizeof(*this) + getStreamSize(); }
|
||||
@ -50,7 +50,7 @@ namespace app {
|
||||
}
|
||||
|
||||
undo::ObjectId m_spriteId;
|
||||
FrameNumber m_frame;
|
||||
frame_t m_frame;
|
||||
uint8_t m_from;
|
||||
uint8_t m_to;
|
||||
std::stringstream m_stream;
|
||||
|
@ -21,7 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "app/undoers/undoer_base.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "undo/object_id.h"
|
||||
|
||||
#include <sstream>
|
||||
@ -48,7 +48,7 @@ namespace app {
|
||||
private:
|
||||
undo::ObjectId m_documentId;
|
||||
undo::ObjectId m_spriteId;
|
||||
FrameNumber m_totalFrames;
|
||||
frame_t m_totalFrames;
|
||||
};
|
||||
|
||||
} // namespace undoers
|
||||
|
@ -141,7 +141,7 @@ static bool copy_from_document(const DocumentLocation& location)
|
||||
|
||||
clipboard_pos = document->mask()->bounds().getOrigin();
|
||||
|
||||
const Palette* pal = document->sprite()->getPalette(location.frame());
|
||||
const Palette* pal = document->sprite()->palette(location.frame());
|
||||
set_clipboard_image(image, pal ? new Palette(*pal): NULL, true);
|
||||
return true;
|
||||
}
|
||||
@ -262,7 +262,7 @@ void clipboard::paste()
|
||||
if (clipboard_image == NULL)
|
||||
return;
|
||||
|
||||
Palette* dst_palette = dstSpr->getPalette(editor->frame());
|
||||
Palette* dst_palette = dstSpr->palette(editor->frame());
|
||||
|
||||
// Source image (clipboard or a converted copy to the destination 'imgtype')
|
||||
Image* src_image;
|
||||
@ -274,7 +274,7 @@ void clipboard::paste()
|
||||
src_image = clipboard_image;
|
||||
}
|
||||
else {
|
||||
RgbMap* dst_rgbmap = dstSpr->getRgbMap(editor->frame());
|
||||
RgbMap* dst_rgbmap = dstSpr->rgbMap(editor->frame());
|
||||
|
||||
src_image = render::convert_pixel_format(
|
||||
clipboard_image, NULL, dstSpr->pixelFormat(),
|
||||
@ -309,8 +309,8 @@ void clipboard::paste()
|
||||
|
||||
UndoTransaction undoTransaction(UIContext::instance(), "Paste Cels");
|
||||
|
||||
FrameNumber dstFrame = editor->frame();
|
||||
for (FrameNumber frame = srcRange.frameBegin(); frame <= srcRange.frameEnd(); ++frame) {
|
||||
frame_t dstFrame = editor->frame();
|
||||
for (frame_t frame = srcRange.frameBegin(); frame <= srcRange.frameEnd(); ++frame) {
|
||||
if (dstFrame == dstSpr->totalFrames())
|
||||
api.addFrame(dstSpr, dstFrame);
|
||||
|
||||
@ -334,7 +334,7 @@ void clipboard::paste()
|
||||
}
|
||||
}
|
||||
|
||||
dstFrame = dstFrame.next();
|
||||
++dstFrame;
|
||||
}
|
||||
|
||||
undoTransaction.commit();
|
||||
@ -344,9 +344,9 @@ void clipboard::paste()
|
||||
|
||||
case DocumentRange::kFrames: {
|
||||
UndoTransaction undoTransaction(UIContext::instance(), "Paste Frames");
|
||||
FrameNumber dstFrame = FrameNumber(editor->frame() + 1);
|
||||
frame_t dstFrame = frame_t(editor->frame() + 1);
|
||||
|
||||
for (FrameNumber frame = srcRange.frameBegin(); frame <= srcRange.frameEnd(); ++frame) {
|
||||
for (frame_t frame = srcRange.frameBegin(); frame <= srcRange.frameEnd(); ++frame) {
|
||||
api.addFrame(dstSpr, dstFrame);
|
||||
|
||||
for (LayerIndex
|
||||
@ -362,7 +362,7 @@ void clipboard::paste()
|
||||
}
|
||||
}
|
||||
|
||||
dstFrame = dstFrame.next();
|
||||
++dstFrame;
|
||||
}
|
||||
|
||||
undoTransaction.commit();
|
||||
@ -377,7 +377,7 @@ void clipboard::paste()
|
||||
UndoTransaction undoTransaction(UIContext::instance(), "Paste Layers");
|
||||
|
||||
// Expand frames of dstDoc if it's needed.
|
||||
FrameNumber maxFrame(0);
|
||||
frame_t maxFrame(0);
|
||||
for (LayerIndex i = srcRange.layerBegin();
|
||||
i <= srcRange.layerEnd() &&
|
||||
i < LayerIndex(srcLayers.size()); ++i) {
|
||||
@ -385,8 +385,8 @@ void clipboard::paste()
|
||||
if (lastCel && maxFrame < lastCel->frame())
|
||||
maxFrame = lastCel->frame();
|
||||
}
|
||||
if (dstSpr->totalFrames() < maxFrame.next())
|
||||
api.setTotalFrames(dstSpr, maxFrame.next());
|
||||
if (dstSpr->totalFrames() < maxFrame+1)
|
||||
api.setTotalFrames(dstSpr, maxFrame+1);
|
||||
|
||||
for (LayerIndex i = srcRange.layerBegin(); i <= srcRange.layerEnd(); ++i) {
|
||||
LayerImage* newLayer = new LayerImage(dstSpr);
|
||||
|
@ -299,7 +299,7 @@ static void get_win32_clipboard_bitmap(Image*& image, Palette*& palette)
|
||||
// 8 BPP
|
||||
case 8: {
|
||||
int colors = bi->bmiHeader.biClrUsed > 0 ? bi->bmiHeader.biClrUsed: 256;
|
||||
palette = new Palette(FrameNumber(0), colors);
|
||||
palette = new Palette(frame_t(0), colors);
|
||||
for (int c=0; c<colors; ++c) {
|
||||
palette->setEntry(c, rgba(bi->bmiColors[c].rgbRed,
|
||||
bi->bmiColors[c].rgbGreen,
|
||||
|
@ -71,7 +71,7 @@ Image* load_pic_file(const char* filename, int* x, int* y, Palette** palette)
|
||||
|
||||
// Read palette (RGB in 0-63)
|
||||
if (palette) {
|
||||
*palette = new Palette(FrameNumber(0), Palette::MaxColors);
|
||||
*palette = new Palette(frame_t(0), Palette::MaxColors);
|
||||
}
|
||||
for (c=0; c<256; c++) {
|
||||
r = std::fgetc(f);
|
||||
|
@ -42,10 +42,10 @@ CelList get_cels_in_range(Sprite* sprite, const DocumentRange& range)
|
||||
|
||||
LayerImage* layerImage = static_cast<LayerImage*>(layer);
|
||||
|
||||
for (FrameNumber frame = range.frameEnd(),
|
||||
begin = range.frameBegin().previous();
|
||||
for (frame_t frame = range.frameEnd(),
|
||||
begin = range.frameBegin()-1;
|
||||
frame != begin;
|
||||
frame = frame.previous()) {
|
||||
--frame) {
|
||||
Cel* cel = layerImage->getCel(frame);
|
||||
if (cel)
|
||||
cels.push_back(cel);
|
||||
|
@ -18,7 +18,7 @@
|
||||
|
||||
namespace doc {
|
||||
|
||||
Cel::Cel(FrameNumber frame, int image)
|
||||
Cel::Cel(frame_t frame, int image)
|
||||
: Object(ObjectType::Cel)
|
||||
, m_layer(NULL)
|
||||
, m_frame(frame)
|
||||
|
@ -8,7 +8,7 @@
|
||||
#define DOC_CEL_H_INCLUDED
|
||||
#pragma once
|
||||
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/object.h"
|
||||
#include "gfx/fwd.h"
|
||||
#include "gfx/point.h"
|
||||
@ -21,11 +21,11 @@ namespace doc {
|
||||
|
||||
class Cel : public Object {
|
||||
public:
|
||||
Cel(FrameNumber frame, int image);
|
||||
Cel(frame_t frame, int image);
|
||||
Cel(const Cel& cel);
|
||||
virtual ~Cel();
|
||||
|
||||
FrameNumber frame() const { return m_frame; }
|
||||
frame_t frame() const { return m_frame; }
|
||||
int imageIndex() const { return m_image; }
|
||||
int x() const { return m_position.x; }
|
||||
int y() const { return m_position.y; }
|
||||
@ -40,7 +40,7 @@ namespace doc {
|
||||
// You should change the frame only if the cel isn't member of a
|
||||
// layer. If the cel is already in a layer, you should use
|
||||
// LayerImage::moveCel() member function.
|
||||
void setFrame(FrameNumber frame) { m_frame = frame; }
|
||||
void setFrame(frame_t frame) { m_frame = frame; }
|
||||
void setImage(int image) { m_image = image; }
|
||||
void setPosition(int x, int y) {
|
||||
m_position.x = x;
|
||||
@ -59,10 +59,10 @@ namespace doc {
|
||||
|
||||
private:
|
||||
LayerImage* m_layer;
|
||||
FrameNumber m_frame; // Frame position
|
||||
int m_image; // Image index of stock
|
||||
gfx::Point m_position; // X/Y screen position
|
||||
int m_opacity; // Opacity level
|
||||
frame_t m_frame; // Frame position
|
||||
int m_image; // Image index of stock
|
||||
gfx::Point m_position; // X/Y screen position
|
||||
int m_opacity; // Opacity level
|
||||
};
|
||||
|
||||
} // namespace doc
|
||||
|
@ -46,7 +46,7 @@ Cel* read_cel(std::istream& is)
|
||||
{
|
||||
// ObjectId cel_id = read32();
|
||||
|
||||
FrameNumber frame(read16(is));
|
||||
frame_t frame(read16(is));
|
||||
int imageIndex = read16(is);
|
||||
int x = (int16_t)read16(is);
|
||||
int y = (int16_t)read16(is);
|
||||
|
@ -8,7 +8,7 @@
|
||||
#define DOC_COLOR_SCALES_H_INCLUDED
|
||||
#pragma once
|
||||
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/object.h"
|
||||
|
||||
#include <vector>
|
||||
|
@ -15,7 +15,7 @@
|
||||
#include "doc/color_scales.h"
|
||||
#include "doc/dirty.h"
|
||||
#include "doc/document.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/image.h"
|
||||
#include "doc/image_bits.h"
|
||||
#include "doc/layer.h"
|
||||
|
@ -9,7 +9,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "gfx/region.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
|
||||
namespace doc {
|
||||
class Cel;
|
||||
@ -45,7 +45,7 @@ namespace doc {
|
||||
Cel* cel() const { return m_cel; }
|
||||
Image* image() const { return m_image; }
|
||||
int imageIndex() const { return m_imageIndex; }
|
||||
FrameNumber frame() const { return m_frame; }
|
||||
frame_t frame() const { return m_frame; }
|
||||
const gfx::Region& region() const { return m_region; }
|
||||
|
||||
void sprite(Sprite* sprite) { m_sprite = sprite; }
|
||||
@ -53,15 +53,15 @@ namespace doc {
|
||||
void cel(Cel* cel) { m_cel = cel; }
|
||||
void image(Image* image) { m_image = image; }
|
||||
void imageIndex(int imageIndex) { m_imageIndex = imageIndex; }
|
||||
void frame(FrameNumber frame) { m_frame = frame; }
|
||||
void frame(frame_t frame) { m_frame = frame; }
|
||||
void region(const gfx::Region& rgn) { m_region = rgn; }
|
||||
|
||||
// Destination of the operation.
|
||||
Layer* targetLayer() const { return m_targetLayer; }
|
||||
FrameNumber targetFrame() const { return m_targetFrame; }
|
||||
frame_t targetFrame() const { return m_targetFrame; }
|
||||
|
||||
void targetLayer(Layer* layer) { m_targetLayer = layer; }
|
||||
void targetFrame(FrameNumber frame) { m_targetFrame = frame; }
|
||||
void targetFrame(frame_t frame) { m_targetFrame = frame; }
|
||||
|
||||
private:
|
||||
Document* m_document;
|
||||
@ -70,13 +70,13 @@ namespace doc {
|
||||
Cel* m_cel;
|
||||
Image* m_image;
|
||||
int m_imageIndex;
|
||||
FrameNumber m_frame;
|
||||
frame_t m_frame;
|
||||
gfx::Region m_region;
|
||||
|
||||
// For copy/move commands, the m_layer/m_frame are source of the
|
||||
// operation, and these are the destination of the operation.
|
||||
Layer* m_targetLayer;
|
||||
FrameNumber m_targetFrame;
|
||||
frame_t m_targetFrame;
|
||||
};
|
||||
|
||||
} // namespace app
|
||||
|
@ -48,7 +48,7 @@ Palette* load_col_file(const char* filename)
|
||||
|
||||
// Animator format
|
||||
if (!pro) {
|
||||
pal = new Palette(FrameNumber(0), 256);
|
||||
pal = new Palette(frame_t(0), 256);
|
||||
|
||||
for (c=0; c<256; c++) {
|
||||
r = fgetc(f);
|
||||
@ -76,7 +76,7 @@ Palette* load_col_file(const char* filename)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
pal = new Palette(FrameNumber(0), MIN(d.quot, 256));
|
||||
pal = new Palette(frame_t(0), MIN(d.quot, 256));
|
||||
|
||||
for (c=0; c<pal->size(); c++) {
|
||||
r = fgetc(f);
|
||||
|
@ -34,7 +34,7 @@ Palette* load_gpl_file(const char *filename)
|
||||
base::trim_string(line, line);
|
||||
if (line != "GIMP Palette") return NULL;
|
||||
|
||||
base::UniquePtr<Palette> pal(new Palette(FrameNumber(0), 0));
|
||||
base::UniquePtr<Palette> pal(new Palette(frame_t(0), 0));
|
||||
|
||||
while (std::getline(f, line)) {
|
||||
// Trim line.
|
||||
|
17
src/doc/frame.h
Normal file
17
src/doc/frame.h
Normal file
@ -0,0 +1,17 @@
|
||||
// Aseprite Document Library
|
||||
// Copyright (c) 2001-2014 David Capello
|
||||
//
|
||||
// This file is released under the terms of the MIT license.
|
||||
// Read LICENSE.txt for more information.
|
||||
|
||||
#ifndef DOC_FRAME_H_INCLUDED
|
||||
#define DOC_FRAME_H_INCLUDED
|
||||
#pragma once
|
||||
|
||||
namespace doc {
|
||||
|
||||
typedef int frame_t;
|
||||
|
||||
} // namespace doc
|
||||
|
||||
#endif
|
@ -1,54 +0,0 @@
|
||||
// Aseprite Document Library
|
||||
// Copyright (c) 2001-2014 David Capello
|
||||
//
|
||||
// This file is released under the terms of the MIT license.
|
||||
// Read LICENSE.txt for more information.
|
||||
|
||||
#ifndef DOC_FRAME_NUMBER_H_INCLUDED
|
||||
#define DOC_FRAME_NUMBER_H_INCLUDED
|
||||
#pragma once
|
||||
|
||||
namespace doc {
|
||||
|
||||
typedef int frame_t;
|
||||
|
||||
class FrameNumber {
|
||||
public:
|
||||
FrameNumber() : m_value(0) { }
|
||||
explicit FrameNumber(int value) : m_value(value) { }
|
||||
|
||||
FrameNumber next(int i = 1) const { return FrameNumber(m_value+i); };
|
||||
FrameNumber previous(int i = 1) const { return FrameNumber(m_value-i); };
|
||||
|
||||
operator int() { return m_value; }
|
||||
operator const int() const { return m_value; }
|
||||
|
||||
FrameNumber& operator=(const FrameNumber& o) { m_value = o.m_value; return *this; }
|
||||
FrameNumber& operator++() { ++m_value; return *this; }
|
||||
FrameNumber& operator--() { --m_value; return *this; }
|
||||
FrameNumber operator++(int) { FrameNumber old(*this); ++m_value; return old; }
|
||||
FrameNumber operator--(int) { FrameNumber old(*this); --m_value; return old; }
|
||||
FrameNumber& operator+=(const FrameNumber& o) { m_value += o.m_value; return *this; }
|
||||
FrameNumber& operator-=(const FrameNumber& o) { m_value -= o.m_value; return *this; }
|
||||
bool operator<(const FrameNumber& o) const { return m_value < o.m_value; }
|
||||
bool operator>(const FrameNumber& o) const { return m_value > o.m_value; }
|
||||
bool operator<=(const FrameNumber& o) const { return m_value <= o.m_value; }
|
||||
bool operator>=(const FrameNumber& o) const { return m_value >= o.m_value; }
|
||||
bool operator==(const FrameNumber& o) const { return m_value == o.m_value; }
|
||||
bool operator!=(const FrameNumber& o) const { return m_value != o.m_value; }
|
||||
|
||||
private:
|
||||
int m_value;
|
||||
};
|
||||
|
||||
inline FrameNumber operator+(const FrameNumber& x, const FrameNumber& y) {
|
||||
return FrameNumber((int)x + (int)y);
|
||||
}
|
||||
|
||||
inline FrameNumber operator-(const FrameNumber& x, const FrameNumber& y) {
|
||||
return FrameNumber((int)x - (int)y);
|
||||
}
|
||||
|
||||
} // namespace doc
|
||||
|
||||
#endif
|
@ -19,7 +19,7 @@
|
||||
namespace doc {
|
||||
|
||||
ImagesCollector::ImagesCollector(Layer* layer,
|
||||
FrameNumber frame,
|
||||
frame_t frame,
|
||||
bool allFrames,
|
||||
bool forEdit)
|
||||
: m_allFrames(allFrames)
|
||||
@ -28,7 +28,7 @@ ImagesCollector::ImagesCollector(Layer* layer,
|
||||
collectFromLayer(layer, frame);
|
||||
}
|
||||
|
||||
void ImagesCollector::collectFromLayer(Layer* layer, FrameNumber frame)
|
||||
void ImagesCollector::collectFromLayer(Layer* layer, frame_t frame)
|
||||
{
|
||||
const Sprite* sprite = layer->sprite();
|
||||
|
||||
@ -42,7 +42,7 @@ void ImagesCollector::collectFromLayer(Layer* layer, FrameNumber frame)
|
||||
|
||||
case ObjectType::LayerImage: {
|
||||
if (m_allFrames) {
|
||||
for (FrameNumber frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
for (frame_t frame(0); frame<sprite->totalFrames(); ++frame) {
|
||||
Cel* cel = static_cast<LayerImage*>(layer)->getCel(frame);
|
||||
if (cel != NULL)
|
||||
collectImage(layer, cel);
|
||||
|
@ -8,7 +8,7 @@
|
||||
#define DOC_IMAGES_REF_H_INCLUDED
|
||||
#pragma once
|
||||
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
|
||||
#include <list>
|
||||
|
||||
@ -50,7 +50,7 @@ namespace doc {
|
||||
// * forEdit: True if you will modify the images (it is used to avoid
|
||||
// returning images from layers which are read-only/write-locked).
|
||||
ImagesCollector(Layer* layer,
|
||||
FrameNumber frame,
|
||||
frame_t frame,
|
||||
bool allFrames,
|
||||
bool forEdit);
|
||||
|
||||
@ -61,7 +61,7 @@ namespace doc {
|
||||
bool empty() const { return m_items.empty(); }
|
||||
|
||||
private:
|
||||
void collectFromLayer(Layer* layer, FrameNumber frame);
|
||||
void collectFromLayer(Layer* layer, frame_t frame);
|
||||
void collectImage(Layer* layer, Cel* cel);
|
||||
|
||||
Items m_items;
|
||||
|
@ -131,7 +131,7 @@ void LayerImage::destroyAllCels()
|
||||
|
||||
Cel* LayerImage::cel(frame_t frame) const
|
||||
{
|
||||
return const_cast<Cel*>(getCel(FrameNumber(frame)));
|
||||
return const_cast<Cel*>(getCel(frame_t(frame)));
|
||||
}
|
||||
|
||||
void LayerImage::getCels(CelList& cels) const
|
||||
@ -181,14 +181,14 @@ void LayerImage::removeCel(Cel *cel)
|
||||
m_cels.erase(it);
|
||||
}
|
||||
|
||||
void LayerImage::moveCel(Cel* cel, FrameNumber frame)
|
||||
void LayerImage::moveCel(Cel* cel, frame_t frame)
|
||||
{
|
||||
removeCel(cel);
|
||||
cel->setFrame(frame);
|
||||
addCel(cel);
|
||||
}
|
||||
|
||||
const Cel* LayerImage::getCel(FrameNumber frame) const
|
||||
const Cel* LayerImage::getCel(frame_t frame) const
|
||||
{
|
||||
CelConstIterator it = getCelBegin();
|
||||
CelConstIterator end = getCelEnd();
|
||||
@ -202,7 +202,7 @@ const Cel* LayerImage::getCel(FrameNumber frame) const
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Cel* LayerImage::getCel(FrameNumber frame)
|
||||
Cel* LayerImage::getCel(frame_t frame)
|
||||
{
|
||||
return const_cast<Cel*>(static_cast<const LayerImage*>(this)->getCel(frame));
|
||||
}
|
||||
|
@ -10,7 +10,7 @@
|
||||
|
||||
#include "doc/blend.h"
|
||||
#include "doc/cel_list.h"
|
||||
#include "doc/frame_number.h"
|
||||
#include "doc/frame.h"
|
||||
#include "doc/layer_list.h"
|
||||
#include "doc/object.h"
|
||||
|
||||
@ -114,9 +114,9 @@ namespace doc {
|
||||
|
||||
void addCel(Cel *cel);
|
||||
void removeCel(Cel *cel);
|
||||
void moveCel(Cel *cel, FrameNumber frame);
|
||||
const Cel* getCel(FrameNumber frame) const;
|
||||
Cel* getCel(FrameNumber frame);
|
||||
void moveCel(Cel *cel, frame_t frame);
|
||||
const Cel* getCel(frame_t frame) const;
|
||||
Cel* getCel(frame_t frame);
|
||||
Cel* cel(frame_t frame) const override;
|
||||
void getCels(CelList& cels) const override;
|
||||
Cel* getLastCel() const;
|
||||
|
@ -20,7 +20,7 @@ namespace doc {
|
||||
|
||||
using namespace gfx;
|
||||
|
||||
Palette::Palette(FrameNumber frame, int ncolors)
|
||||
Palette::Palette(frame_t frame, int ncolors)
|
||||
: Object(ObjectType::Palette)
|
||||
{
|
||||
ASSERT(ncolors >= 0 && ncolors <= MaxColors);
|
||||
@ -46,7 +46,7 @@ Palette::~Palette()
|
||||
|
||||
Palette* Palette::createGrayscale()
|
||||
{
|
||||
Palette* graypal = new Palette(FrameNumber(0), MaxColors);
|
||||
Palette* graypal = new Palette(frame_t(0), MaxColors);
|
||||
for (int c=0; c<MaxColors; c++)
|
||||
graypal->setEntry(c, rgba(c, c, c, 255));
|
||||
return graypal;
|
||||
@ -75,7 +75,7 @@ void Palette::addEntry(color_t color)
|
||||
setEntry(size()-1, color);
|
||||
}
|
||||
|
||||
void Palette::setFrame(FrameNumber frame)
|
||||
void Palette::setFrame(frame_t frame)
|
||||
{
|
||||
ASSERT(frame >= 0);
|
||||
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user