[aseprite] 121/308: Add possibility to save brush type/size/angle, fg/bg colors, ink type/opacity, shade, etc. into brush slots
Tobias Hansen
thansen at moszumanska.debian.org
Tue Mar 8 02:44:59 UTC 2016
This is an automated email from the git hooks/post-receive script.
thansen pushed a commit to branch master
in repository aseprite.
commit 0cdc71bf05b47af0f66447082b31422b462909c5
Author: David Capello <davidcapello at gmail.com>
Date: Wed Dec 16 17:27:04 2015 -0300
Add possibility to save brush type/size/angle, fg/bg colors, ink type/opacity, shade, etc. into brush slots
Fix #904
---
data/pref.xml | 11 ++++
src/app/app_brushes.cpp | 44 +++++--------
src/app/app_brushes.h | 51 ++++-----------
src/app/brush_slot.h | 104 +++++++++++++++++++++++++++++
src/app/commands/cmd_new_brush.cpp | 3 +-
src/app/ui/brush_popup.cpp | 130 +++++++++++++++++++++++++++++++------
src/app/ui/brush_popup.h | 4 +-
src/app/ui/context_bar.cpp | 122 ++++++++++++++++++++++++++--------
src/app/ui/context_bar.h | 2 +
9 files changed, 355 insertions(+), 116 deletions(-)
diff --git a/data/pref.xml b/data/pref.xml
index aea4a04..1cd907d 100644
--- a/data/pref.xml
+++ b/data/pref.xml
@@ -128,6 +128,17 @@
<section id="brush">
<option id="pattern" type="doc::BrushPattern" default="doc::BrushPattern::DEFAULT" />
</section>
+ <section id="save_brush">
+ <option id="brush_type" type="bool" default="true" />
+ <option id="brush_size" type="bool" default="true" />
+ <option id="brush_angle" type="bool" default="true" />
+ <option id="fg_color" type="bool" default="false" />
+ <option id="bg_color" type="bool" default="false" />
+ <option id="ink_type" type="bool" default="true" />
+ <option id="ink_opacity" type="bool" default="true" />
+ <option id="shade" type="bool" default="true" />
+ <option id="pixel_perfect" type="bool" default="false" />
+ </section>
<section id="selection">
<option id="mode" type="app::tools::SelectionMode" default="app::tools::SelectionMode::DEFAULT" />
<option id="pivot_visibility" type="bool" default="false" />
diff --git a/src/app/app_brushes.cpp b/src/app/app_brushes.cpp
index 0cdba53..715433f 100644
--- a/src/app/app_brushes.cpp
+++ b/src/app/app_brushes.cpp
@@ -22,27 +22,27 @@ AppBrushes::AppBrushes()
m_standard.push_back(BrushRef(new Brush(kLineBrushType, 7, 44)));
}
-AppBrushes::slot_id AppBrushes::addCustomBrush(const BrushRef& brush)
+AppBrushes::slot_id AppBrushes::addBrushSlot(const BrushSlot& brush)
{
// Use an empty slot
for (size_t i=0; i<m_slots.size(); ++i) {
if (!m_slots[i].locked() ||
!m_slots[i].brush()) {
- m_slots[i].setBrush(brush);
+ m_slots[i] = brush;
return i+1;
}
}
- m_slots.push_back(BrushSlot(brush));
+ m_slots.push_back(brush);
ItemsChange();
- return (int)m_slots.size(); // Returns the slot
+ return slot_id(m_slots.size()); // Returns the slot
}
-void AppBrushes::removeCustomBrush(slot_id slot)
+void AppBrushes::removeBrushSlot(slot_id slot)
{
--slot;
if (slot >= 0 && slot < (int)m_slots.size()) {
- m_slots[slot].setBrush(BrushRef(nullptr));
+ m_slots[slot] = BrushSlot();
// Erase empty trailing slots
while (!m_slots.empty() &&
@@ -53,7 +53,7 @@ void AppBrushes::removeCustomBrush(slot_id slot)
}
}
-void AppBrushes::removeAllCustomBrushes()
+void AppBrushes::removeAllBrushSlots()
{
while (!m_slots.empty())
m_slots.erase(--m_slots.end());
@@ -61,40 +61,32 @@ void AppBrushes::removeAllCustomBrushes()
ItemsChange();
}
-bool AppBrushes::hasCustomBrush(slot_id slot) const
+bool AppBrushes::hasBrushSlot(slot_id slot) const
{
--slot;
return (slot >= 0 && slot < (int)m_slots.size() &&
- m_slots[slot].brush());
+ !m_slots[slot].isEmpty());
}
-BrushRef AppBrushes::getCustomBrush(slot_id slot) const
+BrushSlot AppBrushes::getBrushSlot(slot_id slot) const
{
--slot;
if (slot >= 0 && slot < (int)m_slots.size())
- return m_slots[slot].brush();
+ return m_slots[slot];
else
- return BrushRef();
+ return BrushSlot();
}
-void AppBrushes::setCustomBrush(slot_id slot, const doc::BrushRef& brush)
+void AppBrushes::setBrushSlot(slot_id slot, const BrushSlot& brush)
{
--slot;
if (slot >= 0 && slot < (int)m_slots.size()) {
- m_slots[slot].setBrush(brush);
+ m_slots[slot] = brush;
ItemsChange();
}
}
-Brushes AppBrushes::getCustomBrushes()
-{
- Brushes brushes;
- for (const auto& slot : m_slots)
- brushes.push_back(slot.brush());
- return brushes;
-}
-
-void AppBrushes::lockCustomBrush(slot_id slot)
+void AppBrushes::lockBrushSlot(slot_id slot)
{
--slot;
if (slot >= 0 && slot < (int)m_slots.size() &&
@@ -103,7 +95,7 @@ void AppBrushes::lockCustomBrush(slot_id slot)
}
}
-void AppBrushes::unlockCustomBrush(slot_id slot)
+void AppBrushes::unlockBrushSlot(slot_id slot)
{
--slot;
if (slot >= 0 && slot < (int)m_slots.size() &&
@@ -112,11 +104,11 @@ void AppBrushes::unlockCustomBrush(slot_id slot)
}
}
-bool AppBrushes::isCustomBrushLocked(slot_id slot) const
+bool AppBrushes::isBrushSlotLocked(slot_id slot) const
{
--slot;
if (slot >= 0 && slot < (int)m_slots.size() &&
- m_slots[slot].brush()) {
+ !m_slots[slot].isEmpty()) {
return m_slots[slot].locked();
}
else
diff --git a/src/app/app_brushes.h b/src/app/app_brushes.h
index aa01103..dc451c2 100644
--- a/src/app/app_brushes.h
+++ b/src/app/app_brushes.h
@@ -9,8 +9,8 @@
#define APP_APP_BRUSHES_H_INCLUDED
#pragma once
+#include "app/brush_slot.h"
#include "base/signal.h"
-#include "doc/brush.h"
#include "doc/brushes.h"
#include <vector>
@@ -21,55 +21,28 @@ namespace app {
public:
// Number of slot (a range from 1 to AppBrushes::size() inclusive)
typedef int slot_id;
+ typedef std::vector<BrushSlot> BrushSlots;
AppBrushes();
// Adds a new brush and returns the slot number where the brush
// is now available.
- slot_id addCustomBrush(const doc::BrushRef& brush);
- void removeCustomBrush(slot_id slot);
- void removeAllCustomBrushes();
- bool hasCustomBrush(slot_id slot) const;
+ slot_id addBrushSlot(const BrushSlot& brush);
+ void removeBrushSlot(slot_id slot);
+ void removeAllBrushSlots();
+ bool hasBrushSlot(slot_id slot) const;
const doc::Brushes& getStandardBrushes() { return m_standard; }
- doc::BrushRef getCustomBrush(slot_id slot) const;
- void setCustomBrush(slot_id slot, const doc::BrushRef& brush);
- doc::Brushes getCustomBrushes();
+ BrushSlot getBrushSlot(slot_id slot) const;
+ void setBrushSlot(slot_id slot, const BrushSlot& brush);
+ const BrushSlots& getBrushSlots() const { return m_slots; }
- void lockCustomBrush(slot_id slot);
- void unlockCustomBrush(slot_id slot);
- bool isCustomBrushLocked(slot_id slot) const;
+ void lockBrushSlot(slot_id slot);
+ void unlockBrushSlot(slot_id slot);
+ bool isBrushSlotLocked(slot_id slot) const;
base::Signal0<void> ItemsChange;
private:
- // Custom brush slot
- class BrushSlot {
- public:
- BrushSlot(const doc::BrushRef& brush)
- : m_locked(false)
- , m_brush(brush) {
- }
-
- // True if this is a standard brush.
- bool standard() const { return m_standard; }
-
- // True if the user locked the brush using the shortcut key to
- // access it.
- bool locked() const { return m_locked; }
- void setLocked(bool locked) { m_locked = locked; }
-
- // Can be null if the user deletes the brush.
- doc::BrushRef brush() const { return m_brush; }
- void setBrush(const doc::BrushRef& brush) { m_brush = brush; }
-
- private:
- bool m_standard;
- bool m_locked;
- doc::BrushRef m_brush;
- };
-
- typedef std::vector<BrushSlot> BrushSlots;
-
doc::Brushes m_standard;
BrushSlots m_slots;
};
diff --git a/src/app/brush_slot.h b/src/app/brush_slot.h
new file mode 100644
index 0000000..c76041f
--- /dev/null
+++ b/src/app/brush_slot.h
@@ -0,0 +1,104 @@
+// Aseprite
+// Copyright (C) 2001-2015 David Capello
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License version 2 as
+// published by the Free Software Foundation.
+
+#ifndef APP_BRUSH_SLOT_H_INCLUDED
+#define APP_BRUSH_SLOT_H_INCLUDED
+#pragma once
+
+#include "app/color.h"
+#include "app/shade.h"
+#include "app/tools/ink_type.h"
+#include "doc/brush.h"
+
+namespace app {
+
+// Custom brush slot
+class BrushSlot {
+public:
+ enum class Flags {
+ Locked = 0x0001,
+ BrushType = 0x0002,
+ BrushSize = 0x0004,
+ BrushAngle = 0x0008,
+ FgColor = 0x0010,
+ BgColor = 0x0020,
+ InkType = 0x0040,
+ InkOpacity = 0x0080,
+ Shade = 0x0100,
+ PixelPerfect = 0x0200
+ };
+
+ BrushSlot(Flags flags = Flags(0),
+ const doc::BrushRef& brush = doc::BrushRef(nullptr),
+ const app::Color& fgColor = app::Color::fromMask(),
+ const app::Color& bgColor = app::Color::fromMask(),
+ tools::InkType inkType = tools::InkType::DEFAULT,
+ int inkOpacity = 255,
+ const Shade& shade = Shade(),
+ bool pixelPerfect = false)
+ : m_flags(flags)
+ , m_brush(brush)
+ , m_fgColor(fgColor)
+ , m_bgColor(bgColor)
+ , m_inkType(inkType)
+ , m_inkOpacity(inkOpacity)
+ , m_shade(shade)
+ , m_pixelPerfect(pixelPerfect) {
+ }
+
+ bool isEmpty() const {
+ return int(m_flags) == 0;
+ }
+
+ bool hasFlag(Flags flag) const {
+ return ((int(m_flags) & int(flag)) == int(flag));
+ }
+
+ bool hasBrush() const {
+ return
+ (brush() &&
+ (hasFlag(Flags::BrushType) ||
+ hasFlag(Flags::BrushSize) ||
+ hasFlag(Flags::BrushAngle)));
+ }
+
+ // Can be null if the user deletes the brush.
+ doc::BrushRef brush() const { return m_brush; }
+ app::Color fgColor() const { return m_fgColor; }
+ app::Color bgColor() const { return m_bgColor; }
+ tools::InkType inkType() const { return m_inkType; }
+ int inkOpacity() const { return m_inkOpacity; }
+ const Shade& shade() const { return m_shade; }
+ bool pixelPerfect() const { return m_pixelPerfect; }
+
+ // True if the user locked the brush using the shortcut key to
+ // access it.
+ bool locked() const {
+ return hasFlag(Flags::Locked);
+ }
+
+ void setLocked(bool locked) {
+ if (locked)
+ m_flags = static_cast<Flags>(int(m_flags) | int(Flags::Locked));
+ else
+ m_flags = static_cast<Flags>(int(m_flags) & ~int(Flags::Locked));
+ }
+
+private:
+ Flags m_flags;
+ doc::BrushRef m_brush;
+ app::Color m_fgColor;
+ app::Color m_bgColor;
+ tools::InkType m_inkType;
+ int m_inkOpacity;
+ Shade m_shade;
+ bool m_pixelPerfect;
+};
+
+} // namespace app
+
+#endif
diff --git a/src/app/commands/cmd_new_brush.cpp b/src/app/commands/cmd_new_brush.cpp
index d082d0a..1657703 100644
--- a/src/app/commands/cmd_new_brush.cpp
+++ b/src/app/commands/cmd_new_brush.cpp
@@ -150,7 +150,8 @@ void NewBrushCommand::createBrush(const Site& site, const Mask* mask)
brush->setPatternOrigin(mask->bounds().origin());
ContextBar* ctxBar = App::instance()->getMainWindow()->getContextBar();
- auto slot = App::instance()->brushes().addCustomBrush(brush);
+ int slot = App::instance()->brushes().addBrushSlot(
+ BrushSlot(BrushSlot::Flags::BrushType, brush));
ctxBar->setActiveBrush(brush);
// Get the shortcut for this brush and show it to the user
diff --git a/src/app/ui/brush_popup.cpp b/src/app/ui/brush_popup.cpp
index 3eec4aa..0efa988 100644
--- a/src/app/ui/brush_popup.cpp
+++ b/src/app/ui/brush_popup.cpp
@@ -13,10 +13,12 @@
#include "app/app.h"
#include "app/app_brushes.h"
+#include "app/brush_slot.h"
#include "app/commands/command.h"
#include "app/commands/commands.h"
#include "app/modules/gui.h"
#include "app/modules/palettes.h"
+#include "app/pref/preferences.h"
#include "app/ui/app_menuitem.h"
#include "app/ui/button_set.h"
#include "app/ui/keyboard_shortcuts.h"
@@ -69,16 +71,18 @@ void show_popup_menu(PopupWindow* popupWindow, Menu* popupMenu,
class SelectBrushItem : public ButtonSet::Item {
public:
- SelectBrushItem(BrushPopupDelegate* delegate, const BrushRef& brush, int slot = -1)
+ SelectBrushItem(BrushPopupDelegate* delegate, const BrushSlot& brush, int slot = -1)
: m_delegate(delegate)
, m_brush(brush)
, m_slot(slot) {
- SkinPartPtr icon(new SkinPart);
- icon->setBitmap(0, BrushPopup::createSurfaceForBrush(brush));
- setIcon(icon);
+ if (m_brush.hasBrush()) {
+ SkinPartPtr icon(new SkinPart);
+ icon->setBitmap(0, BrushPopup::createSurfaceForBrush(m_brush.brush()));
+ setIcon(icon);
+ }
}
- const BrushRef& brush() const {
+ const BrushSlot& brush() const {
return m_brush;
}
@@ -87,14 +91,14 @@ private:
void onClick() override {
if (m_slot >= 0)
m_delegate->onSelectBrushSlot(m_slot);
- else
- m_delegate->onSelectBrush(m_brush);
+ else if (m_brush.hasBrush())
+ m_delegate->onSelectBrush(m_brush.brush());
}
private:
BrushPopupDelegate* m_delegate;
- BrushRef m_brush;
+ BrushSlot m_brush;
int m_slot;
};
@@ -162,9 +166,9 @@ private:
void onSaveBrush() {
AppBrushes& brushes = App::instance()->brushes();
- brushes.setCustomBrush(
- m_slot, m_delegate->onCreateBrushFromActivePreferences());
- brushes.lockCustomBrush(m_slot);
+ brushes.setBrushSlot(
+ m_slot, m_delegate->onCreateBrushSlotFromActivePreferences());
+ brushes.lockBrushSlot(m_slot);
}
void onLockBrush() {
@@ -198,14 +202,95 @@ public:
private:
void onClick() override {
AppBrushes& brushes = App::instance()->brushes();
- auto slot = brushes.addCustomBrush(
- m_delegate->onCreateBrushFromActivePreferences());
- brushes.lockCustomBrush(slot);
+ auto slot = brushes.addBrushSlot(
+ m_delegate->onCreateBrushSlotFromActivePreferences());
+ brushes.lockBrushSlot(slot);
}
BrushPopupDelegate* m_delegate;
};
+class NewBrushOptionsItem : public ButtonSet::Item {
+public:
+ NewBrushOptionsItem() {
+ setIcon(SkinTheme::instance()->parts.iconArrowDown(), true);
+ }
+
+private:
+ void onClick() override {
+ Menu menu;
+
+ menu.addChild(new Separator("Parameters to Save", HORIZONTAL));
+
+ Grid* grid = new Grid(2, false);
+ ButtonSet* brushParams = new ButtonSet(3);
+ ButtonSet::Item* brushType = brushParams->addItem("Type");
+ ButtonSet::Item* brushSize = brushParams->addItem("Size");
+ ButtonSet::Item* brushAngle = brushParams->addItem("Angle");
+ brushParams->setMultipleSelection(true);
+
+ ButtonSet* colorParams = new ButtonSet(2);
+ ButtonSet::Item* fgColor = colorParams->addItem("Foreground");
+ ButtonSet::Item* bgColor = colorParams->addItem("Background");
+ colorParams->setMultipleSelection(true);
+
+ ButtonSet* inkParams = new ButtonSet(2);
+ ButtonSet::Item* inkType = inkParams->addItem("Type");
+ ButtonSet::Item* inkOpacity = inkParams->addItem("Opacity");
+ inkParams->setMultipleSelection(true);
+
+ ButtonSet* extrasParams = new ButtonSet(2);
+ ButtonSet::Item* shade = extrasParams->addItem("Shade");
+ ButtonSet::Item* pixelPerfect = extrasParams->addItem("Pixel-Perfect");
+ extrasParams->setMultipleSelection(true);
+
+ grid->addChildInCell(new Label("Brush:"), 1, 1, 0);
+ grid->addChildInCell(brushParams, 1, 1, 0);
+ grid->addChildInCell(new Label("Color:"), 1, 1, 0);
+ grid->addChildInCell(colorParams, 1, 1, 0);
+ grid->addChildInCell(new Label("Ink:"), 1, 1, 0);
+ grid->addChildInCell(inkParams, 1, 1, 0);
+ grid->addChildInCell(new Label("Extras:"), 1, 1, 0);
+ grid->addChildInCell(extrasParams, 1, 1, 0);
+ menu.addChild(grid);
+
+ // Load preferences
+ auto& saveBrush = Preferences::instance().saveBrush;
+ brushType->setSelected(saveBrush.brushType());
+ brushSize->setSelected(saveBrush.brushSize());
+ brushAngle->setSelected(saveBrush.brushAngle());
+ fgColor->setSelected(saveBrush.fgColor());
+ bgColor->setSelected(saveBrush.bgColor());
+ inkType->setSelected(saveBrush.inkType());
+ inkOpacity->setSelected(saveBrush.inkOpacity());
+ shade->setSelected(saveBrush.shade());
+ pixelPerfect->setSelected(saveBrush.pixelPerfect());
+
+ show_popup_menu(static_cast<PopupWindow*>(window()), &menu,
+ gfx::Point(origin().x, origin().y+bounds().h));
+
+ // Save preferences
+ if (saveBrush.brushType() != brushType->isSelected())
+ saveBrush.brushType(brushType->isSelected());
+ if (saveBrush.brushSize() != brushSize->isSelected())
+ saveBrush.brushSize(brushSize->isSelected());
+ if (saveBrush.brushAngle() != brushAngle->isSelected())
+ saveBrush.brushAngle(brushAngle->isSelected());
+ if (saveBrush.fgColor() != fgColor->isSelected())
+ saveBrush.fgColor(fgColor->isSelected());
+ if (saveBrush.bgColor() != bgColor->isSelected())
+ saveBrush.bgColor(bgColor->isSelected());
+ if (saveBrush.inkType() != inkType->isSelected())
+ saveBrush.inkType(inkType->isSelected());
+ if (saveBrush.inkOpacity() != inkOpacity->isSelected())
+ saveBrush.inkOpacity(inkOpacity->isSelected());
+ if (saveBrush.shade() != shade->isSelected())
+ saveBrush.shade(shade->isSelected());
+ if (saveBrush.pixelPerfect() != pixelPerfect->isSelected())
+ saveBrush.pixelPerfect(pixelPerfect->isSelected());
+ }
+};
+
} // anonymous namespace
BrushPopup::BrushPopup(BrushPopupDelegate* delegate)
@@ -232,7 +317,9 @@ BrushPopup::BrushPopup(BrushPopupDelegate* delegate)
const doc::Brushes& brushes = App::instance()->brushes().getStandardBrushes();
for (const auto& brush : brushes)
- m_standardBrushes.addItem(new SelectBrushItem(m_delegate, brush));
+ m_standardBrushes.addItem(
+ new SelectBrushItem(
+ m_delegate, BrushSlot(BrushSlot::Flags::BrushType, brush)));
m_standardBrushes.setTransparent(true);
m_standardBrushes.setBgColor(gfx::ColorNone);
@@ -247,10 +334,10 @@ void BrushPopup::setBrush(Brush* brush)
SelectBrushItem* item = static_cast<SelectBrushItem*>(child);
// Same type and same image
- if (item->brush() &&
- item->brush()->type() == brush->type() &&
+ if (item->brush().hasBrush() &&
+ item->brush().brush()->type() == brush->type() &&
(brush->type() != kImageBrushType ||
- item->brush()->image() == brush->image())) {
+ item->brush().brush()->image() == brush->image())) {
m_standardBrushes.setSelectedItem(item);
return;
}
@@ -259,7 +346,7 @@ void BrushPopup::setBrush(Brush* brush)
void BrushPopup::regenerate(const gfx::Rect& box)
{
- const doc::Brushes& brushes = App::instance()->brushes().getCustomBrushes();
+ auto& brushSlots = App::instance()->brushes().getBrushSlots();
if (m_customBrushes) {
// As BrushPopup::regenerate() can be called when a
@@ -274,7 +361,7 @@ void BrushPopup::regenerate(const gfx::Rect& box)
auto& parts = SkinTheme::instance()->parts;
int slot = 0;
- for (const auto& brush : brushes) {
+ for (const auto& brush : brushSlots) {
++slot;
// Get shortcut
@@ -293,7 +380,8 @@ void BrushPopup::regenerate(const gfx::Rect& box)
m_customBrushes->addItem(new BrushOptionsItem(this, m_delegate, slot));
}
- m_customBrushes->addItem(new NewCustomBrushItem(m_delegate), 3, 1);
+ m_customBrushes->addItem(new NewCustomBrushItem(m_delegate), 2, 1);
+ m_customBrushes->addItem(new NewBrushOptionsItem);
m_customBrushes->setExpansive(true);
m_box.addChild(m_customBrushes);
diff --git a/src/app/ui/brush_popup.h b/src/app/ui/brush_popup.h
index f7a2356..fd10980 100644
--- a/src/app/ui/brush_popup.h
+++ b/src/app/ui/brush_popup.h
@@ -18,10 +18,12 @@
namespace app {
+ class BrushSlot;
+
class BrushPopupDelegate {
public:
virtual ~BrushPopupDelegate() { }
- virtual doc::BrushRef onCreateBrushFromActivePreferences() = 0;
+ virtual BrushSlot onCreateBrushSlotFromActivePreferences() = 0;
virtual void onSelectBrush(const doc::BrushRef& brush) = 0;
virtual void onSelectBrushSlot(int slot) = 0;
virtual void onDeleteBrushSlot(int slot) = 0;
diff --git a/src/app/ui/context_bar.cpp b/src/app/ui/context_bar.cpp
index 044bd56..b5904dc 100644
--- a/src/app/ui/context_bar.cpp
+++ b/src/app/ui/context_bar.cpp
@@ -123,11 +123,34 @@ protected:
}
// BrushPopupDelegate impl
- BrushRef onCreateBrushFromActivePreferences() {
- return ContextBar::createBrushFromPreferences();
- }
-
- void onSelectBrush(const BrushRef& brush) {
+ BrushSlot onCreateBrushSlotFromActivePreferences() override {
+ auto& pref = Preferences::instance();
+ auto& saveBrush = pref.saveBrush;
+ auto& toolPref = pref.tool(App::instance()->activeTool());
+
+ int flags = 0;
+ if (saveBrush.brushType()) flags |= int(BrushSlot::Flags::BrushType);
+ if (saveBrush.brushSize()) flags |= int(BrushSlot::Flags::BrushSize);
+ if (saveBrush.brushAngle()) flags |= int(BrushSlot::Flags::BrushAngle);
+ if (saveBrush.fgColor()) flags |= int(BrushSlot::Flags::FgColor);
+ if (saveBrush.bgColor()) flags |= int(BrushSlot::Flags::BgColor);
+ if (saveBrush.inkType()) flags |= int(BrushSlot::Flags::InkType);
+ if (saveBrush.inkOpacity()) flags |= int(BrushSlot::Flags::InkOpacity);
+ if (saveBrush.shade()) flags |= int(BrushSlot::Flags::Shade);
+ if (saveBrush.pixelPerfect()) flags |= int(BrushSlot::Flags::PixelPerfect);
+
+ return BrushSlot(
+ BrushSlot::Flags(flags),
+ ContextBar::createBrushFromPreferences(),
+ pref.colorBar.fgColor(),
+ pref.colorBar.bgColor(),
+ toolPref.ink(),
+ toolPref.opacity(),
+ m_owner->getShade(),
+ toolPref.freehandAlgorithm() == tools::FreehandAlgorithm::PIXEL_PERFECT);
+ }
+
+ void onSelectBrush(const BrushRef& brush) override {
if (brush->type() == kImageBrushType)
m_owner->setActiveBrush(brush);
else {
@@ -141,41 +164,28 @@ protected:
}
}
- void onSelectBrushSlot(int slot) {
- doc::BrushRef brush = App::instance()->brushes().getCustomBrush(slot);
-
- // Is this an empty custom brush slot?
- if (!brush)
- return;
-
- Tool* tool = App::instance()->activeTool();
- ToolPreferences::Brush& brushPref = Preferences::instance().tool(tool).brush;
-
- brushPref.type(static_cast<app::gen::BrushType>(brush->type()));
- brushPref.size(brush->size());
- brushPref.angle(brush->angle());
-
- m_owner->setActiveBrush(brush);
+ void onSelectBrushSlot(int slot) override {
+ m_owner->setActiveBrushBySlot(slot);
}
void onDeleteBrushSlot(int slot) override {
- m_brushes.removeCustomBrush(slot);
+ m_brushes.removeBrushSlot(slot);
}
void onDeleteAllBrushes() override {
- m_brushes.removeAllCustomBrushes();
+ m_brushes.removeAllBrushSlots();
}
bool onIsBrushSlotLocked(int slot) const override {
- return m_brushes.isCustomBrushLocked(slot);
+ return m_brushes.isBrushSlotLocked(slot);
}
void onLockBrushSlot(int slot) override {
- m_brushes.lockCustomBrush(slot);
+ m_brushes.lockBrushSlot(slot);
}
void onUnlockBrushSlot(int slot) override {
- m_brushes.unlockCustomBrush(slot);
+ m_brushes.unlockBrushSlot(slot);
}
private:
@@ -723,6 +733,14 @@ public:
return m_shade.createShadeRemap(left);
}
+ Shade getShade() const {
+ return m_shade.getShade();
+ }
+
+ void setShade(const Shade& shade) {
+ m_shade.setShade(shade);
+ }
+
private:
void onShowMenu() {
loadShades();
@@ -1663,10 +1681,53 @@ void ContextBar::updateAutoSelectLayer(bool state)
void ContextBar::setActiveBrushBySlot(int slot)
{
AppBrushes& brushes = App::instance()->brushes();
+ BrushSlot brush = brushes.getBrushSlot(slot);
+ if (!brush.isEmpty()) {
+ brushes.lockBrushSlot(slot);
- if (brushes.hasCustomBrush(slot)) {
- brushes.lockCustomBrush(slot);
- setActiveBrush(brushes.getCustomBrush(slot));
+ Tool* tool = App::instance()->activeTool();
+ Preferences& pref = Preferences::instance();
+ ToolPreferences& toolPref = pref.tool(tool);
+ ToolPreferences::Brush& brushPref = toolPref.brush;
+
+ if (brush.brush()) {
+ if (brush.brush()->type() == doc::kImageBrushType) {
+ setActiveBrush(brush.brush());
+ }
+ else {
+ setActiveBrush(ContextBar::createBrushFromPreferences());
+
+ if (brush.hasFlag(BrushSlot::Flags::BrushType))
+ brushPref.type(static_cast<app::gen::BrushType>(brush.brush()->type()));
+
+ if (brush.hasFlag(BrushSlot::Flags::BrushSize))
+ brushPref.size(brush.brush()->size());
+
+ if (brush.hasFlag(BrushSlot::Flags::BrushAngle))
+ brushPref.angle(brush.brush()->angle());
+ }
+ }
+
+ if (brush.hasFlag(BrushSlot::Flags::FgColor))
+ pref.colorBar.fgColor(brush.fgColor());
+
+ if (brush.hasFlag(BrushSlot::Flags::BgColor))
+ pref.colorBar.bgColor(brush.bgColor());
+
+ if (brush.hasFlag(BrushSlot::Flags::InkType))
+ setInkType(brush.inkType());
+
+ if (brush.hasFlag(BrushSlot::Flags::InkOpacity))
+ toolPref.opacity(brush.inkOpacity());
+
+ if (brush.hasFlag(BrushSlot::Flags::Shade))
+ m_inkShades->setShade(brush.shade());
+
+ if (brush.hasFlag(BrushSlot::Flags::PixelPerfect))
+ toolPref.freehandAlgorithm(
+ (brush.pixelPerfect() ?
+ tools::FreehandAlgorithm::PIXEL_PERFECT:
+ tools::FreehandAlgorithm::REGULAR));
}
else {
updateForTool(App::instance()->activeTool());
@@ -1717,6 +1778,11 @@ doc::BrushRef ContextBar::createBrushFromPreferences(ToolPreferences::Brush* bru
return brush;
}
+Shade ContextBar::getShade() const
+{
+ return m_inkShades->getShade();
+}
+
doc::Remap* ContextBar::createShadeRemap(bool left)
{
return m_inkShades->createShadeRemap(left);
diff --git a/src/app/ui/context_bar.h b/src/app/ui/context_bar.h
index 0d30e45..df0082c 100644
--- a/src/app/ui/context_bar.h
+++ b/src/app/ui/context_bar.h
@@ -10,6 +10,7 @@
#pragma once
#include "app/pref/preferences.h"
+#include "app/shade.h"
#include "app/tools/ink_type.h"
#include "app/tools/selection_mode.h"
#include "app/ui/context_bar_observer.h"
@@ -61,6 +62,7 @@ namespace app {
doc::Remap* createShadeRemap(bool left);
void reverseShadeColors();
+ Shade getShade() const;
void setInkType(tools::InkType type);
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-games/aseprite.git
More information about the Pkg-games-commits
mailing list