void ContextFlags::update(Context* context)
{
Site site = context->activeSite();
Document* document = static_cast<Document*>(site.document());
m_flags = 0;
if (document) {
m_flags |= HasActiveDocument;
if (document->lock(Document::ReadLock, 0)) {
m_flags |= ActiveDocumentIsReadable;
if (document->isMaskVisible())
m_flags |= HasVisibleMask;
Sprite* sprite = site.sprite();
if (sprite) {
m_flags |= HasActiveSprite;
if (sprite->backgroundLayer())
m_flags |= HasBackgroundLayer;
Layer* layer = site.layer();
if (layer) {
m_flags |= HasActiveLayer;
if (layer->isBackground())
m_flags |= ActiveLayerIsBackground;
if (layer->isVisible())
m_flags |= ActiveLayerIsVisible;
if (layer->isEditable())
m_flags |= ActiveLayerIsEditable;
if (layer->isImage()) {
m_flags |= ActiveLayerIsImage;
Cel* cel = layer->cel(site.frame());
if (cel) {
m_flags |= HasActiveCel;
if (cel->image())
m_flags |= HasActiveImage;
}
}
}
}
if (document->lockToWrite(0))
m_flags |= ActiveDocumentIsWritable;
document->unlock();
}
}
}
void GotoPreviousLayerCommand::onExecute(Context* context)
{
const ContextReader reader(context);
const Sprite* sprite = reader.sprite();
Site site = *reader.site();
if (site.layerIndex() > 0)
site.layerIndex(site.layerIndex().previous());
else
site.layerIndex(LayerIndex(sprite->countLayers()-1));
// Flash the current layer
ASSERT(current_editor != NULL && "Current editor cannot be null when we have a current sprite");
current_editor->setLayer(site.layer());
current_editor->flashCurrentLayer();
updateStatusBar(site);
}
void ReplaceColorCommand::onExecute(Context* context)
{
Site site = context->activeSite();
ReplaceColorFilterWrapper filter(site.layer());
filter.setFrom(get_config_color(ConfigSection, "Color1", ColorBar::instance()->getFgColor()));
filter.setTo(get_config_color(ConfigSection, "Color2", ColorBar::instance()->getBgColor()));
filter.setTolerance(get_config_int(ConfigSection, "Tolerance", 0));
FilterManagerImpl filterMgr(context, &filter);
filterMgr.setTarget(TARGET_RED_CHANNEL |
TARGET_GREEN_CHANNEL |
TARGET_BLUE_CHANNEL |
TARGET_GRAY_CHANNEL |
TARGET_ALPHA_CHANNEL);
ReplaceColorWindow window(filter, filterMgr);
if (window.doModal()) {
set_config_color(ConfigSection, "From", filter.getFrom());
set_config_color(ConfigSection, "To", filter.getTo());
set_config_int(ConfigSection, "Tolerance", filter.getTolerance());
}
}
void FlipCommand::onExecute(Context* context)
{
ContextWriter writer(context);
Document* document = writer.document();
Sprite* sprite = writer.sprite();
{
Transaction transaction(writer.context(),
m_flipMask ?
(m_flipType == doc::algorithm::FlipHorizontal ?
"Flip Horizontal":
"Flip Vertical"):
(m_flipType == doc::algorithm::FlipHorizontal ?
"Flip Canvas Horizontal":
"Flip Canvas Vertical"));
DocumentApi api = document->getApi(transaction);
CelList cels;
if (m_flipMask) {
auto range = App::instance()->timeline()->range();
if (range.enabled())
cels = get_unique_cels(sprite, range);
else if (writer.cel())
cels.push_back(writer.cel());
}
else {
for (Cel* cel : sprite->uniqueCels())
cels.push_back(cel);
}
Mask* mask = document->mask();
if (m_flipMask && document->isMaskVisible()) {
Site site = *writer.site();
for (Cel* cel : cels) {
site.frame(cel->frame());
site.layer(cel->layer());
int x, y;
Image* image = site.image(&x, &y);
if (!image)
continue;
// When the mask is inside the cel, we can try to flip the
// pixels inside the image.
if (cel->bounds().contains(mask->bounds())) {
gfx::Rect flipBounds = mask->bounds();
flipBounds.offset(-x, -y);
flipBounds &= image->bounds();
if (flipBounds.isEmpty())
continue;
if (mask->bitmap() && !mask->isRectangular())
transaction.execute(new cmd::FlipMaskedCel(cel, m_flipType));
else
api.flipImage(image, flipBounds, m_flipType);
if (cel->layer()->isTransparent())
transaction.execute(new cmd::TrimCel(cel));
}
// When the mask is bigger than the cel bounds, we have to
// expand the cel, make the flip, and shrink it again.
else {
gfx::Rect flipBounds = (sprite->bounds() & mask->bounds());
if (flipBounds.isEmpty())
continue;
ExpandCelCanvas expand(
site, cel->layer(),
TiledMode::NONE, transaction,
ExpandCelCanvas::None);
expand.validateDestCanvas(gfx::Region(flipBounds));
if (mask->bitmap() && !mask->isRectangular())
doc::algorithm::flip_image_with_mask(
expand.getDestCanvas(), mask, m_flipType,
document->bgColor(cel->layer()));
else
doc::algorithm::flip_image(
expand.getDestCanvas(),
flipBounds, m_flipType);
expand.commit();
}
}
}
else {
for (Cel* cel : cels) {
Image* image = cel->image();
api.setCelPosition
(sprite, cel,
(m_flipType == doc::algorithm::FlipHorizontal ?
sprite->width() - image->width() - cel->x():
cel->x()),
(m_flipType == doc::algorithm::FlipVertical ?
sprite->height() - image->height() - cel->y():
cel->y()));
api.flipImage(image, image->bounds(), m_flipType);
}
}
// Flip the mask.
Image* maskBitmap = mask->bitmap();
if (maskBitmap) {
transaction.execute(new cmd::FlipMask(document, m_flipType));
// Flip the mask position because the
if (!m_flipMask)
transaction.execute(
new cmd::SetMaskPosition(
document,
gfx::Point(
(m_flipType == doc::algorithm::FlipHorizontal ?
sprite->width() - mask->bounds().x2():
mask->bounds().x),
(m_flipType == doc::algorithm::FlipVertical ?
sprite->height() - mask->bounds().y2():
mask->bounds().y))));
document->generateMaskBoundaries();
}
transaction.commit();
}
update_screen_for_document(document);
}
bool StandbyState::onMouseDown(Editor* editor, MouseMessage* msg)
{
if (editor->hasCapture())
return true;
UIContext* context = UIContext::instance();
tools::Ink* clickedInk = editor->getCurrentEditorInk();
Site site;
editor->getSite(&site);
app::Document* document = static_cast<app::Document*>(site.document());
Layer* layer = site.layer();
// When an editor is clicked the current view is changed.
context->setActiveView(editor->getDocumentView());
// Start scroll loop
if (checkForScroll(editor, msg) || checkForZoom(editor, msg))
return true;
// Move cel X,Y coordinates
if (clickedInk->isCelMovement()) {
// Handle "Auto Select Layer"
if (editor->isAutoSelectLayer()) {
gfx::Point cursor = editor->screenToEditor(msg->position());
ColorPicker picker;
picker.pickColor(site, cursor, ColorPicker::FromComposition);
if (layer != picker.layer()) {
layer = picker.layer();
if (layer) {
editor->setLayer(layer);
editor->flashCurrentLayer();
}
}
}
if ((layer) &&
(layer->type() == ObjectType::LayerImage)) {
// TODO we should be able to move the `Background' with tiled mode
if (layer->isBackground()) {
StatusBar::instance()->showTip(1000,
"The background layer cannot be moved");
}
else if (!layer->isVisible()) {
StatusBar::instance()->showTip(1000,
"Layer '%s' is hidden", layer->name().c_str());
}
else if (!layer->isMovable() || !layer->isEditable()) {
StatusBar::instance()->showTip(1000,
"Layer '%s' is locked", layer->name().c_str());
}
else {
// Change to MovingCelState
editor->setState(EditorStatePtr(new MovingCelState(editor, msg)));
}
}
return true;
}
// Call the eyedropper command
if (clickedInk->isEyedropper()) {
callEyedropper(editor);
return true;
}
if (clickedInk->isSelection()) {
// Transform selected pixels
if (document->isMaskVisible() && m_decorator->getTransformHandles(editor)) {
TransformHandles* transfHandles = m_decorator->getTransformHandles(editor);
// Get the handle covered by the mouse.
HandleType handle = transfHandles->getHandleAtPoint(editor,
msg->position(),
document->getTransformation());
if (handle != NoHandle) {
int x, y, opacity;
Image* image = site.image(&x, &y, &opacity);
if (layer && image) {
if (!layer->isEditable()) {
StatusBar::instance()->showTip(1000,
"Layer '%s' is locked", layer->name().c_str());
return true;
}
// Change to MovingPixelsState
transformSelection(editor, msg, handle);
}
return true;
}
}
// Move selected pixels
if (layer && editor->isInsideSelection() && msg->left()) {
if (!layer->isEditable()) {
StatusBar::instance()->showTip(1000,
"Layer '%s' is locked", layer->name().c_str());
return true;
}
// Change to MovingPixelsState
transformSelection(editor, msg, MoveHandle);
return true;
}
}
// Start the Tool-Loop
if (layer) {
tools::ToolLoop* toolLoop = create_tool_loop(editor, context);
if (toolLoop) {
EditorStatePtr newState(new DrawingState(toolLoop));
editor->setState(newState);
static_cast<DrawingState*>(newState.get())
->initToolLoop(editor, msg);
}
return true;
}
return true;
}
bool StandbyState::onMouseDown(Editor* editor, MouseMessage* msg)
{
if (editor->hasCapture())
return true;
UIContext* context = UIContext::instance();
tools::Ink* clickedInk = editor->getCurrentEditorInk();
Site site;
editor->getSite(&site);
app::Document* document = static_cast<app::Document*>(site.document());
Layer* layer = site.layer();
// When an editor is clicked the current view is changed.
context->setActiveView(editor->getDocumentView());
// Start scroll loop
if (checkForScroll(editor, msg) || checkForZoom(editor, msg))
return true;
// Move cel X,Y coordinates
if (clickedInk->isCelMovement()) {
// Handle "Auto Select Layer"
if (editor->isAutoSelectLayer()) {
gfx::Point cursor = editor->screenToEditor(msg->position());
ColorPicker picker;
picker.pickColor(site, cursor, ColorPicker::FromComposition);
DocumentRange range = App::instance()->getMainWindow()->getTimeline()->range();
// Change layer only when the layer is diffrent from current one, and
// the range we selected is not with multiple cels.
bool layerChanged = (layer != picker.layer());
bool rangeEnabled = range.enabled();
bool rangeSingleCel = ((range.type() == DocumentRange::kCels) &&
(range.layers() == 1) && (range.frames() == 1));
if (layerChanged && (!rangeEnabled || rangeSingleCel)) {
layer = picker.layer();
if (layer) {
editor->setLayer(layer);
editor->flashCurrentLayer();
}
}
}
if ((layer) &&
(layer->type() == ObjectType::LayerImage)) {
// TODO we should be able to move the `Background' with tiled mode
if (layer->isBackground()) {
StatusBar::instance()->showTip(1000,
"The background layer cannot be moved");
}
else if (!layer->isVisible()) {
StatusBar::instance()->showTip(1000,
"Layer '%s' is hidden", layer->name().c_str());
}
else if (!layer->isMovable() || !layer->isEditable()) {
StatusBar::instance()->showTip(1000,
"Layer '%s' is locked", layer->name().c_str());
}
else if (!layer->cel(editor->frame())) {
StatusBar::instance()->showTip(1000,
"Cel is empty, nothing to move");
}
else {
// Change to MovingCelState
editor->setState(EditorStatePtr(new MovingCelState(editor, msg)));
}
}
return true;
}
// Call the eyedropper command
if (clickedInk->isEyedropper()) {
editor->captureMouse();
callEyedropper(editor);
return true;
}
if (clickedInk->isSelection()) {
// Transform selected pixels
if (editor->isActive() &&
document->isMaskVisible() &&
m_decorator->getTransformHandles(editor)) {
TransformHandles* transfHandles = m_decorator->getTransformHandles(editor);
// Get the handle covered by the mouse.
HandleType handle = transfHandles->getHandleAtPoint(editor,
msg->position(),
document->getTransformation());
if (handle != NoHandle) {
int x, y, opacity;
Image* image = site.image(&x, &y, &opacity);
if (layer && image) {
if (!layer->isEditable()) {
StatusBar::instance()->showTip(1000,
"Layer '%s' is locked", layer->name().c_str());
return true;
}
// Change to MovingPixelsState
transformSelection(editor, msg, handle);
}
return true;
}
}
// Move selected pixels
if (layer && editor->isInsideSelection() && msg->left()) {
if (!layer->isEditable()) {
StatusBar::instance()->showTip(1000,
"Layer '%s' is locked", layer->name().c_str());
return true;
}
// Change to MovingPixelsState
transformSelection(editor, msg, MoveHandle);
return true;
}
}
// Move symmetry
gfx::Rect box1, box2;
if (m_decorator->getSymmetryHandles(editor, box1, box2) &&
(box1.contains(msg->position()) ||
box2.contains(msg->position()))) {
auto& symmetry = Preferences::instance().document(editor->document()).symmetry;
auto mode = symmetry.mode();
bool horz = (mode == app::gen::SymmetryMode::HORIZONTAL);
auto& axis = (horz ? symmetry.xAxis:
symmetry.yAxis);
editor->setState(
EditorStatePtr(new MovingSymmetryState(editor, msg,
mode, axis)));
return true;
}
// Start the Tool-Loop
if (layer) {
tools::ToolLoop* toolLoop = create_tool_loop(editor, context);
if (toolLoop) {
EditorStatePtr newState(new DrawingState(toolLoop));
editor->setState(newState);
static_cast<DrawingState*>(newState.get())
->initToolLoop(editor, msg);
}
return true;
}
return true;
}
void updateStatusBar(Site& site) {
if (site.layer() != NULL)
StatusBar::instance()
->setStatusText(1000, "Layer `%s' selected",
site.layer()->name().c_str());
}
SpritePosition CmdTransaction::calcSpritePosition() const
{
Site site = context()->activeSite();
return SpritePosition(site.layer(), site.frame());
}
ExpandCelCanvas::ExpandCelCanvas(Site site,
TiledMode tiledMode, Transaction& transaction, Flags flags)
: m_document(static_cast<app::Document*>(site.document()))
, m_sprite(site.sprite())
, m_layer(site.layer())
, m_cel(NULL)
, m_celImage(NULL)
, m_celCreated(false)
, m_flags(flags)
, m_srcImage(NULL)
, m_dstImage(NULL)
, m_closed(false)
, m_committed(false)
, m_transaction(transaction)
{
ASSERT(!singleton);
singleton = this;
create_buffers();
if (m_layer->isImage()) {
m_cel = m_layer->cel(site.frame());
if (m_cel)
m_celImage = m_cel->imageRef();
}
// Create a new cel
if (m_cel == NULL) {
m_celCreated = true;
m_cel = new Cel(site.frame(), ImageRef(NULL));
}
m_origCelPos = m_cel->position();
// Region to draw
gfx::Rect celBounds(
m_cel->x(),
m_cel->y(),
m_celImage ? m_celImage->width(): m_sprite->width(),
m_celImage ? m_celImage->height(): m_sprite->height());
gfx::Rect spriteBounds(0, 0,
m_sprite->width(),
m_sprite->height());
if (tiledMode == TiledMode::NONE) { // Non-tiled
m_bounds = celBounds.createUnion(spriteBounds);
}
else { // Tiled
m_bounds = spriteBounds;
}
// We have to adjust the cel position to match the m_dstImage
// position (the new m_dstImage will be used in RenderEngine to
// draw this cel).
m_cel->setPosition(m_bounds.x, m_bounds.y);
if (m_celCreated) {
getDestCanvas();
m_cel->data()->setImage(m_dstImage);
static_cast<LayerImage*>(m_layer)->addCel(m_cel);
}
}
PixelsMovement::PixelsMovement(
Context* context,
Site site,
const Image* moveThis,
const Mask* mask,
const char* operationName)
: m_reader(context)
, m_site(site)
, m_document(static_cast<app::Document*>(site.document()))
, m_sprite(site.sprite())
, m_layer(site.layer())
, m_transaction(context, operationName)
, m_setMaskCmd(nullptr)
, m_isDragging(false)
, m_adjustPivot(false)
, m_handle(NoHandle)
, m_originalImage(Image::createCopy(moveThis))
, m_opaque(false)
, m_maskColor(m_sprite->transparentColor())
{
gfx::Transformation transform(mask->bounds());
set_pivot_from_preferences(transform);
m_initialData = transform;
m_currentData = transform;
m_initialMask = new Mask(*mask);
m_currentMask = new Mask(*mask);
m_pivotVisConn =
Preferences::instance().selection.pivotVisibility.AfterChange.connect(
base::Bind<void>(&PixelsMovement::onPivotChange, this));
m_pivotPosConn =
Preferences::instance().selection.pivotPosition.AfterChange.connect(
base::Bind<void>(&PixelsMovement::onPivotChange, this));
m_rotAlgoConn =
Preferences::instance().selection.rotationAlgorithm.AfterChange.connect(
base::Bind<void>(&PixelsMovement::onRotationAlgorithmChange, this));
// The extra cel must be null, because if it's not null, it means
// that someone else is using it (e.g. the editor brush preview),
// and its owner could destroy our new "extra cel".
ASSERT(!m_document->extraCel());
redrawExtraImage();
redrawCurrentMask();
// If the mask isn't in the document (e.g. it's from Paste command),
// we've to replace the document mask and generate its boundaries.
//
// This is really tricky. PixelsMovement is used in two situations:
// 1) When the current selection is transformed, and
// 2) when the user pastes the clipboard content.
//
// In the first case, the current document selection is used. And a
// cutMask() command could be called after PixelsMovement ctor. We
// need the following stack of Cmd instances in the Transaction:
// - cmd::ClearMask: clears the old mask)
// - cmd::SetMask (m_setMaskCmd): replaces the old mask with a new mask
// The new mask in m_setMaskCmd is replaced each time the mask is modified.
//
// In the second case, the mask isn't in the document, is a new mask
// used to paste the pixels, so we've to replace the document mask.
// The Transaction contains just a:
// - cmd::SetMask
//
// The main point here is that cmd::SetMask must be the last item in
// the Transaction using the mask (because we use cmd::SetMask::setNewMask()).
//
// TODO Simplify this code in some way or make explicit both usages
if (mask != m_document->mask()) {
updateDocumentMask();
update_screen_for_document(m_document);
}
}
void UndoCommand::onExecute(Context* context)
{
ContextWriter writer(context);
Doc* document(writer.document());
DocUndo* undo = document->undoHistory();
#ifdef ENABLE_UI
Sprite* sprite = document->sprite();
SpritePosition spritePosition;
const bool gotoModified =
(Preferences::instance().undo.gotoModified() &&
context->isUIAvailable() && current_editor);
if (gotoModified) {
SpritePosition currentPosition(writer.site()->layer(),
writer.site()->frame());
if (m_type == Undo)
spritePosition = undo->nextUndoSpritePosition();
else
spritePosition = undo->nextRedoSpritePosition();
if (spritePosition != currentPosition) {
Layer* selectLayer = spritePosition.layer();
if (selectLayer)
current_editor->setLayer(selectLayer);
current_editor->setFrame(spritePosition.frame());
// Draw the current layer/frame (which is not undone yet) so the
// user can see the doUndo/doRedo effect.
current_editor->drawSpriteClipped(
gfx::Region(gfx::Rect(0, 0, sprite->width(), sprite->height())));
current_editor->manager()->flipDisplay();
base::this_thread::sleep_for(0.01);
}
}
// Get the stream to deserialize the document range after executing
// the undo/redo action. We cannot yet deserialize the document
// range because there could be inexistent layers.
std::istream* docRangeStream;
if (m_type == Undo)
docRangeStream = undo->nextUndoDocRange();
else
docRangeStream = undo->nextRedoDocRange();
StatusBar* statusbar = StatusBar::instance();
if (statusbar) {
std::string msg;
if (m_type == Undo)
msg = "Undid " + undo->nextUndoLabel();
else
msg = "Redid " + undo->nextRedoLabel();
if (Preferences::instance().undo.showTooltip())
statusbar->showTip(1000, msg.c_str());
else
statusbar->setStatusText(0, msg.c_str());
}
#endif // ENABLE_UI
// Effectively undo/redo.
if (m_type == Undo)
undo->undo();
else
undo->redo();
#ifdef ENABLE_UI
// After redo/undo, we retry to change the current SpritePosition
// (because new frames/layers could be added, positions that we
// weren't able to reach before the undo).
if (gotoModified) {
Site newSite = context->activeSite();
SpritePosition currentPosition(
newSite.layer(),
newSite.frame());
if (spritePosition != currentPosition) {
Layer* selectLayer = spritePosition.layer();
if (selectLayer)
current_editor->setLayer(selectLayer);
current_editor->setFrame(spritePosition.frame());
}
}
// Update timeline range. We've to deserialize the DocRange at
// this point when objects (possible layers) are re-created after
// the undo and we can deserialize them.
if (docRangeStream) {
Timeline* timeline = App::instance()->timeline();
if (timeline) {
DocRange docRange;
if (docRange.read(*docRangeStream))
timeline->setRange(docRange);
}
}
#endif // ENABLE_UI
document->generateMaskBoundaries();
document->setExtraCel(ExtraCelRef(nullptr));
#ifdef ENABLE_UI
update_screen_for_document(document);
#endif
set_current_palette(writer.palette(), false);
}